hamlib 0.1.4 → 0.1.6

package/Readme.md

@@ -4,6 +4,7 @@ A comprehensive Node.js wrapper for [Hamlib](https://hamlib.github.io/) - contro
 
 ## 🚀 Features
 
+- **Async/Await Support**: All operations are asynchronous and non-blocking for optimal performance
 - **Built-in Methods**: Complete radio control API including memory channels, RIT/XIT, scanning, levels, functions, and more
 - **303+ Supported Radios**: Works with Yaesu, Icom, Kenwood, Elecraft, FlexRadio, and many more
 - **Multi-platform**: Pre-built binaries for Windows x64, Linux x64/ARM64, macOS ARM64
@@ -11,6 +12,25 @@ A comprehensive Node.js wrapper for [Hamlib](https://hamlib.github.io/) - contro
 - **TypeScript Support**: Full type definitions and IntelliSense
 - **Modern JavaScript**: CommonJS and ES Modules support
 
+## ⚡ Async Operations
+
+**All radio control operations are asynchronous** to prevent blocking the Node.js event loop during I/O operations:
+
+```javascript
+// ✅ Correct - Using async/await
+await rig.setFrequency(144390000);
+const frequency = await rig.getFrequency();
+
+// ✅ Correct - Using Promises
+rig.setFrequency(144390000)
+  .then(() => rig.getFrequency())
+  .then(freq => console.log('Frequency:', freq))
+  .catch(err => console.error('Error:', err));
+
+// ❌ Incorrect - Operations are no longer synchronous
+// rig.setFrequency(144390000); // This won't work as expected
+```
+
 ## 📦 Quick Start
 
 ```bash
@@ -20,25 +40,29 @@ npm install node-hamlib
 ```javascript
 const { HamLib } = require('node-hamlib');
 
-// Find your radio model
-const rigs = HamLib.getSupportedRigs();
-console.log('Supported radios:', rigs.length);
+async function controlRadio() {
+  // Find your radio model
+  const rigs = HamLib.getSupportedRigs();
+  console.log('Supported radios:', rigs.length);
 
-// Connect to radio
-const rig = new HamLib(1035, '/dev/ttyUSB0'); // FT-991A
-rig.open();
+  // Connect to radio
+  const rig = new HamLib(1035, '/dev/ttyUSB0'); // FT-991A
+  await rig.open();
 
-// Basic control
-rig.setFrequency(144390000); // 144.39 MHz
-rig.setMode('FM');
-rig.setPtt(true);
+  // Basic control
+  await rig.setFrequency(144390000); // 144.39 MHz
+  await rig.setMode('FM');
+  await rig.setPtt(true);
 
-// Get status
-console.log('Frequency:', rig.getFrequency());
-console.log('Mode:', rig.getMode());
-console.log('Signal:', rig.getStrength());
+  // Get status
+  console.log('Frequency:', await rig.getFrequency());
+  console.log('Mode:', await rig.getMode());
+  console.log('Signal:', await rig.getStrength());
 
-rig.close();
+  await rig.close();
+}
+
+controlRadio().catch(console.error);
 ```
 
 ## 📡 Complete API Reference
@@ -74,9 +98,9 @@ const rig = new HamLib(1035, 'localhost:4532');      // rigctld
 #### `open()` / `close()` / `destroy()`
 Connection control
 ```javascript
-rig.open();              // Open connection
-rig.close();             // Close (can reopen)
-rig.destroy();           // Destroy permanently
+await rig.open();        // Open connection
+await rig.close();       // Close (can reopen)
+await rig.destroy();     // Destroy permanently
 ```
 
 #### `getConnectionInfo()`
@@ -93,22 +117,22 @@ console.log('Status:', info.status);
 #### Frequency Control
 ```javascript
 // Set frequency (Hz)
-rig.setFrequency(144390000);
-rig.setFrequency(144390000, 'VFO-A');
+await rig.setFrequency(144390000);
+await rig.setFrequency(144390000, 'VFO-A');
 
 // Get frequency
-const freq = rig.getFrequency();
-const freqA = rig.getFrequency('VFO-A');
+const freq = await rig.getFrequency();
+const freqA = await rig.getFrequency('VFO-A');
 ```
 
 #### Mode Control
 ```javascript
 // Set mode
-rig.setMode('FM');
-rig.setMode('USB', 'wide');
+await rig.setMode('FM');
+await rig.setMode('USB', 'wide');
 
 // Get mode
-const mode = rig.getMode();
+const mode = await rig.getMode();
 console.log('Mode:', mode.mode);
 console.log('Bandwidth:', mode.bandwidth);
 ```
@@ -116,22 +140,22 @@ console.log('Bandwidth:', mode.bandwidth);
 #### VFO Control
 ```javascript
 // Set VFO
-rig.setVfo('VFO-A');
-rig.setVfo('VFO-B');
+await rig.setVfo('VFO-A');
+await rig.setVfo('VFO-B');
 
 // Get current VFO
-const vfo = rig.getVfo();
+const vfo = await rig.getVfo();
 ```
 
 #### PTT Control
 ```javascript
-rig.setPtt(true);   // Transmit
-rig.setPtt(false);  // Receive
+await rig.setPtt(true);   // Transmit
+await rig.setPtt(false);  // Receive
 ```
 
 #### Signal Monitoring
 ```javascript
-const strength = rig.getStrength();
+const strength = await rig.getStrength();
 console.log('Signal strength:', strength);
 ```
 
@@ -284,6 +308,109 @@ rig.setAntenna(2);            // Select antenna 2
 const antenna = rig.getAntenna();
 ```
 
+### ⚙️ Serial Port Configuration
+
+#### `getSupportedSerialConfigs()`
+Get available serial configuration options
+```javascript
+const configs = rig.getSupportedSerialConfigs();
+console.log('Data bits:', configs.serial.data_bits);     // ['5', '6', '7', '8']
+console.log('Stop bits:', configs.serial.stop_bits);     // ['1', '2']
+console.log('Parity:', configs.serial.serial_parity);    // ['None', 'Even', 'Odd']
+console.log('Handshake:', configs.serial.serial_handshake); // ['None', 'Hardware', 'Software']
+console.log('PTT types:', configs.ptt_type);             // ['RIG', 'DTR', 'RTS', 'PARALLEL', ...]
+console.log('DCD types:', configs.dcd_type);             // ['RIG', 'DSR', 'CTS', 'CD', ...]
+```
+
+#### `setSerialConfig(param, value)` / `getSerialConfig(param)`
+Configure serial port parameters
+```javascript
+// Basic serial configuration (most common)
+rig.setSerialConfig('data_bits', '8');        // 8 data bits
+rig.setSerialConfig('stop_bits', '1');        // 1 stop bit
+rig.setSerialConfig('serial_parity', 'None'); // No parity
+rig.setSerialConfig('serial_handshake', 'None'); // No flow control
+
+// Hardware flow control (if supported)
+rig.setSerialConfig('serial_handshake', 'Hardware');
+
+// Control line states
+rig.setSerialConfig('rts_state', 'ON');       // Set RTS high
+rig.setSerialConfig('dtr_state', 'OFF');      // Set DTR low
+
+// Get current configuration
+const dataBits = rig.getSerialConfig('data_bits');
+const parity = rig.getSerialConfig('serial_parity');
+```
+
+#### `setPttType(type)` / `getPttType()`
+Configure PTT (Push-to-Talk) method
+```javascript
+// Use CAT command for PTT (recommended)
+rig.setPttType('RIG');
+
+// Use DTR line for PTT (legacy interfaces)
+rig.setPttType('DTR');
+
+// Use RTS line for PTT (alternative)
+rig.setPttType('RTS');
+
+// Disable PTT control
+rig.setPttType('NONE');
+
+// Get current PTT type
+const pttType = rig.getPttType();
+console.log('PTT method:', pttType);
+```
+
+#### `setDcdType(type)` / `getDcdType()`
+Configure DCD (Data Carrier Detect) method
+```javascript
+// Use CAT command for DCD (software squelch)
+rig.setDcdType('RIG');
+
+// Use DSR line for DCD (hardware squelch)
+rig.setDcdType('DSR');
+
+// Use CTS line for DCD (alternative)
+rig.setDcdType('CTS');
+
+// Get current DCD type
+const dcdType = rig.getDcdType();
+console.log('DCD method:', dcdType);
+```
+
+#### Common Serial Configurations
+
+**Yaesu Radios:**
+```javascript
+rig.setSerialConfig('data_bits', '8');
+rig.setSerialConfig('stop_bits', '1');
+rig.setSerialConfig('serial_parity', 'None');
+rig.setSerialConfig('serial_handshake', 'None');
+rig.setPttType('RIG');  // Use CAT command
+// Baud rate: 4800/9600 (set in constructor)
+```
+
+**Kenwood Radios:**
+```javascript
+rig.setSerialConfig('data_bits', '8');
+rig.setSerialConfig('stop_bits', '2');        // Note: 2 stop bits
+rig.setSerialConfig('serial_parity', 'None');
+rig.setSerialConfig('serial_handshake', 'None');
+rig.setPttType('RIG');
+// Baud rate: 9600
+```
+
+**Legacy Interface (DTR/RTS PTT):**
+```javascript
+rig.setSerialConfig('data_bits', '8');
+rig.setSerialConfig('stop_bits', '1');
+rig.setSerialConfig('serial_parity', 'None');
+rig.setPttType('DTR');                        // Use DTR for PTT
+rig.setDcdType('DSR');                        // Use DSR for squelch
+```
+
 ## 🎯 Complete Example
 
 ```javascript
@@ -303,39 +430,48 @@ async function radioControl() {
   const rig = new HamLib(ft991a.rigModel, '/dev/ttyUSB0');
   
   try {
-    rig.open();
+    await rig.open();
     console.log('Connected to', rig.getConnectionInfo().port);
     
     // Set up radio
-    rig.setFrequency(144390000);
-    rig.setMode('FM');
-    rig.setLevel('RFPOWER', 0.5);
-    rig.setFunction('NB', true);
+    await rig.setFrequency(144390000);
+    await rig.setMode('FM');
+    await rig.setLevel('RFPOWER', 0.5);
+    await rig.setFunction('NB', true);
     
     // Store memory channel
-    rig.setMemoryChannel(1, {
+    await rig.setMemoryChannel(1, {
       frequency: 144390000,
       mode: 'FM',
       description: 'Local Repeater'
     });
     
     // Monitor signal
-    setInterval(() => {
-      const freq = rig.getFrequency();
-      const mode = rig.getMode();
-      const strength = rig.getStrength();
-      
-      console.log(`${freq/1000000} MHz ${mode.mode} S:${strength}`);
+    const monitorInterval = setInterval(async () => {
+      try {
+        const freq = await rig.getFrequency();
+        const mode = await rig.getMode();
+        const strength = await rig.getStrength();
+        
+        console.log(`${freq/1000000} MHz ${mode.mode} S:${strength}`);
+      } catch (err) {
+        console.error('Monitor error:', err.message);
+      }
     }, 1000);
     
+    // Stop monitoring after 30 seconds
+    setTimeout(() => {
+      clearInterval(monitorInterval);
+    }, 30000);
+    
   } catch (error) {
     console.error('Error:', error.message);
   } finally {
-    rig.close();
+    await rig.close();
   }
 }
 
-radioControl();
+radioControl().catch(console.error);
 ```
 
 ## 📋 Supported Radios

package/index.d.ts

@@ -142,6 +142,47 @@ type VfoOperationType = 'CPY' | 'XCHG' | 'FROM_VFO' | 'TO_VFO' | 'MCL' | 'UP' |
                         'DOWN' | 'BAND_UP' | 'BAND_DOWN' | 'LEFT' | 'RIGHT' | 
                         'TUNE' | 'TOGGLE';
 
+/**
+ * Serial configuration parameter names
+ */
+type SerialConfigParam = 'data_bits' | 'stop_bits' | 'serial_parity' | 'serial_handshake' | 
+                        'rts_state' | 'dtr_state';
+
+/**
+ * PTT (Push-to-Talk) types
+ */
+type PttType = 'RIG' | 'DTR' | 'RTS' | 'PARALLEL' | 'CM108' | 'GPIO' | 'GPION' | 'NONE';
+
+/**
+ * DCD (Data Carrier Detect) types
+ */
+type DcdType = 'RIG' | 'DSR' | 'CTS' | 'CD' | 'PARALLEL' | 'CM108' | 'GPIO' | 'GPION' | 'NONE';
+
+/**
+ * Serial configuration options interface
+ */
+interface SerialConfigOptions {
+  /** Serial port basic parameters */
+  serial: {
+    /** Data bits options */
+    data_bits: string[];
+    /** Stop bits options */
+    stop_bits: string[];
+    /** Parity options */
+    serial_parity: string[];
+    /** Handshake options */
+    serial_handshake: string[];
+    /** RTS state options */
+    rts_state: string[];
+    /** DTR state options */
+    dtr_state: string[];
+  };
+  /** PTT type options */
+  ptt_type: string[];
+  /** DCD type options */
+  dcd_type: string[];
+}
+
 /**
  * HamLib class - for controlling amateur radio devices
  */
@@ -183,25 +224,25 @@ declare class HamLib {
    * Must be called before other operations
    * @throws Throws error when connection fails
    */
-  open(): void;
+  open(): Promise<number>;
 
   /**
    * Set VFO (Variable Frequency Oscillator)
    * @param vfo VFO identifier, typically 'VFO-A' or 'VFO-B'
    * @throws Throws error when device doesn't support or operation fails
    */
-  setVfo(vfo: VFO): void;
+  setVfo(vfo: VFO): Promise<number>;
 
   /**
    * Set frequency
    * @param frequency Frequency value in hertz
    * @param vfo Optional VFO to set frequency on ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
    * @example
-   * rig.setFrequency(144390000); // Set to 144.39MHz on current VFO
-   * rig.setFrequency(144390000, 'VFO-A'); // Set to 144.39MHz on VFO-A
-   * rig.setFrequency(144390000, 'VFO-B'); // Set to 144.39MHz on VFO-B
+   * await rig.setFrequency(144390000); // Set to 144.39MHz on current VFO
+   * await rig.setFrequency(144390000, 'VFO-A'); // Set to 144.39MHz on VFO-A
+   * await rig.setFrequency(144390000, 'VFO-B'); // Set to 144.39MHz on VFO-B
    */
-  setFrequency(frequency: number, vfo?: VFO): void;
+  setFrequency(frequency: number, vfo?: VFO): Promise<number>;
 
   /**
    * Set radio mode
@@ -209,60 +250,60 @@ declare class HamLib {
    * @param bandwidth Optional bandwidth setting ('narrow', 'wide', or default)
    * @note Operates on the current VFO (RIG_VFO_CURR)
    * @example
-   * rig.setMode('USB');
-   * rig.setMode('FM', 'narrow');
+   * await rig.setMode('USB');
+   * await rig.setMode('FM', 'narrow');
    */
-  setMode(mode: RadioMode, bandwidth?: 'narrow' | 'wide'): void;
+  setMode(mode: RadioMode, bandwidth?: 'narrow' | 'wide'): Promise<number>;
 
   /**
    * Set PTT (Push-to-Talk) status
    * @param state true to enable PTT, false to disable PTT
    * @note Operates on the current VFO (RIG_VFO_CURR)
    */
-  setPtt(state: boolean): void;
+  setPtt(state: boolean): Promise<number>;
 
   /**
    * Get current VFO
    * @returns Current VFO identifier
    */
-  getVfo(): string;
+  getVfo(): Promise<string>;
 
   /**
    * Get current frequency
    * @param vfo Optional VFO to get frequency from ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
    * @returns Current frequency value in hertz
    * @example
-   * rig.getFrequency(); // Get frequency from current VFO
-   * rig.getFrequency('VFO-A'); // Get frequency from VFO-A
-   * rig.getFrequency('VFO-B'); // Get frequency from VFO-B
+   * await rig.getFrequency(); // Get frequency from current VFO
+   * await rig.getFrequency('VFO-A'); // Get frequency from VFO-A
+   * await rig.getFrequency('VFO-B'); // Get frequency from VFO-B
    */
-  getFrequency(vfo?: VFO): number;
+  getFrequency(vfo?: VFO): Promise<number>;
 
   /**
    * Get current radio mode
    * @returns Object containing mode and bandwidth information
    * @note Operates on the current VFO (RIG_VFO_CURR)
    */
-  getMode(): ModeInfo;
+  getMode(): Promise<ModeInfo>;
 
   /**
    * Get current signal strength
    * @returns Signal strength value
    * @note Operates on the current VFO (RIG_VFO_CURR)
    */
-  getStrength(): number;
+  getStrength(): Promise<number>;
 
   /**
    * Close connection to device
    * Does not destroy object, can re-establish connection by calling open()
    */
-  close(): void;
+  close(): Promise<number>;
 
   /**
    * Destroy connection to device
    * Should delete object reference after calling to enable garbage collection
    */
-  destroy(): void;
+  destroy(): Promise<number>;
 
   /**
    * Get connection information
@@ -444,6 +485,89 @@ declare class HamLib {
    * @returns Current antenna number
    */
   getAntenna(): number;
+
+  // Serial Port Configuration
+
+  /**
+   * Set serial port configuration parameter
+   * @param paramName Parameter name ('data_bits', 'stop_bits', 'serial_parity', 'serial_handshake', 'rts_state', 'dtr_state')
+   * @param paramValue Parameter value
+   * @example
+   * // Set data bits to 8
+   * hamlib.setSerialConfig('data_bits', '8');
+   * 
+   * // Set parity to even
+   * hamlib.setSerialConfig('serial_parity', 'Even');
+   * 
+   * // Set handshake to hardware
+   * hamlib.setSerialConfig('serial_handshake', 'Hardware');
+   */
+  setSerialConfig(paramName: SerialConfigParam, paramValue: string): void;
+
+  /**
+   * Get serial port configuration parameter
+   * @param paramName Parameter name to retrieve
+   * @returns Parameter value
+   * @example
+   * // Get current data bits setting
+   * const dataBits = hamlib.getSerialConfig('data_bits');
+   * 
+   * // Get current parity setting
+   * const parity = hamlib.getSerialConfig('serial_parity');
+   */
+  getSerialConfig(paramName: SerialConfigParam): string;
+
+  /**
+   * Set PTT (Push-to-Talk) type
+   * @param pttType PTT type ('RIG', 'DTR', 'RTS', 'PARALLEL', 'CM108', 'GPIO', 'GPION', 'NONE')
+   * @example
+   * // Use DTR line for PTT
+   * hamlib.setPttType('DTR');
+   * 
+   * // Use RTS line for PTT
+   * hamlib.setPttType('RTS');
+   * 
+   * // Use CAT command for PTT
+   * hamlib.setPttType('RIG');
+   */
+  setPttType(pttType: PttType): void;
+
+  /**
+   * Get current PTT type
+   * @returns Current PTT type
+   */
+  getPttType(): string;
+
+  /**
+   * Set DCD (Data Carrier Detect) type
+   * @param dcdType DCD type ('RIG', 'DSR', 'CTS', 'CD', 'PARALLEL', 'CM108', 'GPIO', 'GPION', 'NONE')
+   * @example
+   * // Use DSR line for DCD
+   * hamlib.setDcdType('DSR');
+   * 
+   * // Use CTS line for DCD
+   * hamlib.setDcdType('CTS');
+   * 
+   * // Use CAT command for DCD
+   * hamlib.setDcdType('RIG');
+   */
+  setDcdType(dcdType: DcdType): void;
+
+  /**
+   * Get current DCD type
+   * @returns Current DCD type
+   */
+  getDcdType(): string;
+
+  /**
+   * Get supported serial configuration options
+   * @returns Object containing all supported configuration parameters and their possible values
+   * @example
+   * const configs = hamlib.getSupportedSerialConfigs();
+   * console.log('Supported data bits:', configs.serial.data_bits);
+   * console.log('Supported PTT types:', configs.ptt_type);
+   */
+  getSupportedSerialConfigs(): SerialConfigOptions;
 }
 
 /**
@@ -456,7 +580,7 @@ declare const nodeHamlib: {
 // Export types for use elsewhere
 export { ConnectionInfo, ModeInfo, SupportedRigInfo, VFO, RadioMode, MemoryChannelData, 
          MemoryChannelInfo, SplitModeInfo, SplitStatusInfo, LevelType, FunctionType, 
-         ScanType, VfoOperationType, HamLib };
+         ScanType, VfoOperationType, SerialConfigParam, PttType, DcdType, SerialConfigOptions, HamLib };
 
 // Support both CommonJS and ES module exports
 export = nodeHamlib;