icom-wlan-node 0.2.5 → 0.2.7

package/README.md

@@ -117,6 +117,7 @@ await rig.setPtt(false);
   - **Audio TX**: `setPtt(on: boolean)`, `sendAudioFloat32()`, `sendAudioPcm16()`
   - **Rig Control**: `setFrequency()`, `setMode()`, `setConnectorDataMode()`, `setConnectorWLanLevel()`
   - **Rig Query**: `readOperatingFrequency()`, `readOperatingMode()`, `readTransmitFrequency()`, `readTransceiverState()`, `readBandEdges()`
+  - **Antenna Tuner**: `readTunerStatus()`, `setTunerEnabled()`, `startManualTune()`
   - **Meters (RX)**: `readSquelchStatus()`, `readAudioSquelch()`, `readOvfStatus()`, `getLevelMeter()`
   - **Meters (TX)**: `readSWR()`, `readALC()`, `readPowerLevel()`, `readCompLevel()`
   - **Power Supply**: `readVoltage()`, `readCurrent()`
@@ -262,7 +263,7 @@ The library exposes common CI‑V operations as friendly methods. Addresses are
 - `readSquelchStatus(options?: QueryOptions) => Promise<{ raw: number; isOpen: boolean } | null>` — Squelch gate state (CI-V 0x15/0x01)
 - `readAudioSquelch(options?: QueryOptions) => Promise<{ raw: number; isOpen: boolean } | null>` — Audio squelch state (CI-V 0x15/0x05)
 - `readOvfStatus(options?: QueryOptions) => Promise<{ raw: number; isOverload: boolean } | null>` — ADC overload detection (CI-V 0x15/0x07)
-- `getLevelMeter(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` — S-meter level (CI-V 0x15/0x02)
+- `getLevelMeter(options?: QueryOptions) => Promise<{ raw: number; percent: number; sUnits: number; dbAboveS9?: number; dBm: number; formatted: string } | null>` — S-meter (signal strength) with physical units (CI-V 0x15/0x02)
 
 **Transmission Meters** (require PTT on):
 - `readSWR(options?: QueryOptions) => Promise<{ raw: number; swr: number; alert: boolean } | null>` — SWR meter (CI-V 0x15/0x12)
@@ -330,7 +331,8 @@ if (ovf) {
 
 const sMeter = await rig.getLevelMeter({ timeout: 2000 });
 if (sMeter) {
-  console.log(`S-Meter: ${sMeter.percent.toFixed(1)}%`);
+  console.log(`S-Meter: ${sMeter.formatted} (${sMeter.sUnits.toFixed(1)} S-units, ${sMeter.dBm.toFixed(1)} dBm)`);
+  // Example output: "S-Meter: S9+10dB (9.9 S-units, -63.1 dBm)"
 }
 
 // Read power supply monitoring
@@ -420,3 +422,29 @@ ICOM_IP=192.168.31.253 ICOM_PORT=50001 ICOM_USER=icom ICOM_PASS=icomicom npm tes
 ## License
 
 MIT
+#### Antenna Tuner (ATU)
+
+- `readTunerStatus(options?: QueryOptions) => Promise<{ raw: number; state: 'OFF'|'ON'|'TUNING' } | null>` — 读取天调状态（CI‑V 0x1A/0x00）
+- `setTunerEnabled(enabled: boolean) => Promise<void>` — 开启/关闭内置天调（CI‑V 0x1A/0x01 00/01）
+- `startManualTune() => Promise<void>` — 触发一次手动调谐（相当于 [TUNE] 键，CI‑V 0x1A/0x02/0x00）
+
+示例：
+
+```ts
+// 读取天调状态
+const atu = await rig.readTunerStatus({ timeout: 2000 });
+if (atu) console.log('ATU:', atu.state); // OFF / ON / TUNING
+
+// 启用内置天调
+await rig.setTunerEnabled(true);
+
+// 触发一次手动调谐
+await rig.startManualTune();
+
+// 可选：轮询状态直到结束
+let status;
+do {
+  await new Promise(r => setTimeout(r, 300));
+  status = await rig.readTunerStatus({ timeout: 1000 });
+} while (status && status.state === 'TUNING');
+```

package/dist/rig/IcomConstants.d.ts

@@ -135,6 +135,28 @@ export declare const METER_CALIBRATION: {
             readonly amps: 4;
         };
     };
+    /**
+     * S-meter (CI-V 0x15/0x02) calibration points
+     * Per-model calibration for signal strength meter
+     */
+    readonly SMETER: {
+        /**
+         * IC-705 S-meter calibration (from official CI-V reference manual)
+         * - raw=0 → S0
+         * - raw=120 → S9
+         * - raw=241 → S9+60dB
+         */
+        readonly 'IC-705': {
+            /** S0 reference point */
+            readonly S0: 0;
+            /** S9 reference point */
+            readonly S9: 120;
+            /** S9+60dB reference point */
+            readonly S9_PLUS_60DB: 241;
+            /** HF standard: S9 ≈ -73dBm (used for dBm estimation) */
+            readonly HF_S9_DBM: -73;
+        };
+    };
 };
 /**
  * Convert raw power level to percentage

package/dist/rig/IcomConstants.js

@@ -147,6 +147,29 @@ exports.METER_CALIBRATION = {
         LOW: { raw: 121, amps: 2.0 },
         /** High current reference: 4A (raw=241) */
         HIGH: { raw: 241, amps: 4.0 }
+    },
+    /**
+     * S-meter (CI-V 0x15/0x02) calibration points
+     * Per-model calibration for signal strength meter
+     */
+    SMETER: {
+        /**
+         * IC-705 S-meter calibration (from official CI-V reference manual)
+         * - raw=0 → S0
+         * - raw=120 → S9
+         * - raw=241 → S9+60dB
+         */
+        'IC-705': {
+            /** S0 reference point */
+            S0: 0,
+            /** S9 reference point */
+            S9: 120,
+            /** S9+60dB reference point */
+            S9_PLUS_60DB: 241,
+            /** HF standard: S9 ≈ -73dBm (used for dBm estimation) */
+            HF_S9_DBM: -73
+        }
+        // Future: Add other ICOM models here
     }
 };
 /**

package/dist/rig/IcomControl.d.ts

@@ -1,4 +1,4 @@
-import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading, SquelchStatusReading, AudioSquelchReading, OvfStatusReading, PowerLevelReading, CompLevelReading, VoltageReading, CurrentReading, ConnectionState, ConnectionMonitorConfig, ConnectionPhase, ConnectionMetrics, DisconnectReason, DisconnectOptions } from '../types';
+import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading, SquelchStatusReading, AudioSquelchReading, OvfStatusReading, PowerLevelReading, CompLevelReading, VoltageReading, CurrentReading, ConnectionState, ConnectionMonitorConfig, ConnectionPhase, ConnectionMetrics, DisconnectReason, DisconnectOptions, TunerStatusReading } from '../types';
 import { IcomCiv } from './IcomCiv';
 import { IcomAudio } from './IcomAudio';
 export declare class IcomControl {
@@ -160,8 +160,21 @@ export declare class IcomControl {
      */
     getConnectorWLanLevel(options?: QueryOptions): Promise<WlanLevelReading | null>;
     /**
-     * Read generic level meter (CI-V 0x15/0x02), raw 0-255.
-     * Many rigs return two bytes and the low byte is the level.
+     * Read S-meter (signal strength) level (CI-V 0x15/0x02)
+     * Returns complete reading with S-units, dB, and dBm conversion
+     *
+     * @param options - Query options (timeout)
+     * @returns S-meter reading with physical units, or null if timeout
+     *
+     * @example
+     * ```typescript
+     * const reading = await rig.getLevelMeter();
+     * if (reading) {
+     *   console.log(reading.formatted);  // "S9+10dB"
+     *   console.log(reading.sUnits);     // 9.99
+     *   console.log(reading.dBm);        // -63.08
+     * }
+     * ```
      */
     getLevelMeter(options?: QueryOptions): Promise<LevelMeterReading | null>;
     /**
@@ -177,6 +190,25 @@ export declare class IcomControl {
      * await rig.setConnectorDataMode('WLAN');
      */
     setConnectorDataMode(mode: ConnectorDataMode | number): Promise<void>;
+    /**
+     * ==============================
+     * Antenna Tuner (ATU) Operations
+     * ==============================
+     */
+    /**
+     * Read antenna tuner status (CI-V 0x1A/0x00)
+     * 00=OFF, 01=ON, 02=TUNING
+     */
+    readTunerStatus(options?: QueryOptions): Promise<TunerStatusReading | null>;
+    /**
+     * Enable or disable internal antenna tuner (CI-V 0x1A/0x01)
+     * @param enabled true to enable, false to disable
+     */
+    setTunerEnabled(enabled: boolean): Promise<void>;
+    /**
+     * Start a manual tuning cycle (same as [TUNE] key) (CI-V 0x1A/0x02/0x00)
+     */
+    startManualTune(): Promise<void>;
     /**
      * Read squelch status (noise/signal gate state)
      * @param options - Query options (timeout in ms, default 3000)

package/dist/rig/IcomControl.js

@@ -45,6 +45,7 @@ const IcomRigCommands_1 = require("./IcomRigCommands");
 const IcomConstants_1 = require("./IcomConstants");
 const bcd_1 = require("../utils/bcd");
 const errors_1 = require("../utils/errors");
+const smeter_1 = require("../utils/smeter");
 class IcomControl {
     constructor(options) {
         this.ev = new events_1.EventEmitter();
@@ -756,8 +757,21 @@ class IcomControl {
         };
     }
     /**
-     * Read generic level meter (CI-V 0x15/0x02), raw 0-255.
-     * Many rigs return two bytes and the low byte is the level.
+     * Read S-meter (signal strength) level (CI-V 0x15/0x02)
+     * Returns complete reading with S-units, dB, and dBm conversion
+     *
+     * @param options - Query options (timeout)
+     * @returns S-meter reading with physical units, or null if timeout
+     *
+     * @example
+     * ```typescript
+     * const reading = await rig.getLevelMeter();
+     * if (reading) {
+     *   console.log(reading.formatted);  // "S9+10dB"
+     *   console.log(reading.sUnits);     // 9.99
+     *   console.log(reading.dBm);        // -63.08
+     * }
+     * ```
      */
     async getLevelMeter(options) {
         const timeoutMs = options?.timeout ?? 3000;
@@ -771,10 +785,9 @@ class IcomControl {
         if (data.length === 0)
             return null;
         const raw = data[data.length - 1] & 0xff; // use low byte as 0-255 level
-        return {
-            raw,
-            percent: (raw / 255) * 100
-        };
+        // Convert raw value to S-meter reading with physical units
+        // Uses IC-705 calibration by default (can be extended to support other models)
+        return (0, smeter_1.rawToSMeter)(raw, 'IC-705');
     }
     /**
      * Set WLAN connector audio level
@@ -798,6 +811,47 @@ class IcomControl {
         const modeCode = typeof mode === 'string' ? (0, IcomConstants_1.getConnectorModeCode)(mode) : mode;
         this.sendCiv(IcomRigCommands_1.IcomRigCommands.setConnectorDataMode(ctrAddr, rigAddr, modeCode));
     }
+    /**
+     * ==============================
+     * Antenna Tuner (ATU) Operations
+     * ==============================
+     */
+    /**
+     * Read antenna tuner status (CI-V 0x1A/0x00)
+     * 00=OFF, 01=ON, 02=TUNING
+     */
+    async readTunerStatus(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getTunerStatus(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x1a, [0x00], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        // Expect FE FE [ctr] [rig] 0x1A 0x00 [status] FD
+        const raw = resp.length > 6 ? (resp[6] & 0xff) : undefined;
+        if (raw === undefined)
+            return null;
+        const state = raw === 0x00 ? 'OFF' : raw === 0x01 ? 'ON' : raw === 0x02 ? 'TUNING' : 'OFF';
+        return { raw, state };
+    }
+    /**
+     * Enable or disable internal antenna tuner (CI-V 0x1A/0x01)
+     * @param enabled true to enable, false to disable
+     */
+    async setTunerEnabled(enabled) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setTunerEnabled(ctrAddr, rigAddr, enabled));
+    }
+    /**
+     * Start a manual tuning cycle (same as [TUNE] key) (CI-V 0x1A/0x02/0x00)
+     */
+    async startManualTune() {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.startManualTune(ctrAddr, rigAddr));
+    }
     /**
      * Read squelch status (noise/signal gate state)
      * @param options - Query options (timeout in ms, default 3000)

package/dist/rig/IcomRigCommands.d.ts

@@ -21,4 +21,7 @@ export declare const IcomRigCommands: {
     getCompLevel(ctrAddr: number, rigAddr: number): Buffer;
     getVoltage(ctrAddr: number, rigAddr: number): Buffer;
     getCurrent(ctrAddr: number, rigAddr: number): Buffer;
+    getTunerStatus(ctrAddr: number, rigAddr: number): Buffer;
+    setTunerEnabled(ctrAddr: number, rigAddr: number, on: boolean): Buffer;
+    startManualTune(ctrAddr: number, rigAddr: number): Buffer;
 };

package/dist/rig/IcomRigCommands.js

@@ -97,5 +97,20 @@ exports.IcomRigCommands = {
     getCurrent(ctrAddr, rigAddr) {
         // FE FE [rig] [ctr] 0x15 0x16 FD
         return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x16, 0xfd]);
+    },
+    // =====================
+    // Antenna Tuner (ATU)
+    // =====================
+    getTunerStatus(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x1A 0x00 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x00, 0xfd]);
+    },
+    setTunerEnabled(ctrAddr, rigAddr, on) {
+        // FE FE [rig] [ctr] 0x1A 0x01 [00|01] FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x01, on ? 0x01 : 0x00, 0xfd]);
+    },
+    startManualTune(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x1A 0x02 0x00 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x02, 0x00, 0xfd]);
     }
 };

package/dist/types.d.ts

@@ -153,14 +153,27 @@ export interface WlanLevelReading {
     percent: number;
 }
 /**
- * Generic level meter (0-255) reading
- * For CI-V 0x15/0x02 experimental level meter
+ * S-meter (signal strength) level reading
+ * For CI-V 0x15/0x02 command
+ *
+ * Calibration (IC-705):
+ * - raw=0 → S0
+ * - raw=120 → S9
+ * - raw=241 → S9+60dB
  */
 export interface LevelMeterReading {
-    /** Raw 0-255 value */
+    /** Raw 0-255 BCD value */
     raw: number;
     /** Percentage (0-100%) */
     percent: number;
+    /** S-unit value (0-9+), supports decimal (e.g., 4.5 = S4.5) */
+    sUnits: number;
+    /** dB above S9 (only when >S9, e.g., 20 means S9+20dB) */
+    dbAboveS9?: number;
+    /** Estimated absolute power in dBm (based on HF standard S9 ≈ -73dBm) */
+    dBm: number;
+    /** Human-readable formatted string (e.g., "S4", "S9+20dB") */
+    formatted: string;
 }
 /**
  * Squelch status reading (CI-V 0x15/0x01)
@@ -241,6 +254,20 @@ export interface CurrentReading {
     /** Current in amperes */
     amps: number;
 }
+/**
+ * Antenna tuner state (IC-705 CI-V 0x1A/0x00)
+ * 00=OFF, 01=ON, 02=TUNING
+ */
+export type TunerState = 'OFF' | 'ON' | 'TUNING';
+/**
+ * Antenna tuner status reading
+ */
+export interface TunerStatusReading {
+    /** Raw status code (0x00, 0x01, 0x02) */
+    raw: number;
+    /** Parsed state name */
+    state: TunerState;
+}
 /**
  * Connection state enumeration
  * Represents the current state of a UDP session

package/dist/utils/smeter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * S-meter (signal strength meter) conversion utilities
+ * Converts raw BCD values from CI-V 0x15/0x02 to physical S-units and dBm
+ */
+import { LevelMeterReading } from '../types';
+/**
+ * Convert raw S-meter BCD value to complete reading with S-units, dB, and dBm
+ *
+ * @param raw - Raw BCD value (0-255) from CI-V 0x15/0x02
+ * @param model - Radio model name (default: 'IC-705')
+ * @returns Complete LevelMeterReading with all calculated fields
+ *
+ * @example
+ * ```typescript
+ * const reading = rawToSMeter(140, 'IC-705');
+ * console.log(reading);
+ * // {
+ * //   raw: 140,
+ * //   percent: 54.9,
+ * //   sUnits: 9.99,
+ * //   dbAboveS9: 9.92,
+ * //   dBm: -63.08,
+ * //   formatted: "S9+10dB"
+ * // }
+ * ```
+ */
+export declare function rawToSMeter(raw: number, model?: string): LevelMeterReading;

package/dist/utils/smeter.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * S-meter (signal strength meter) conversion utilities
+ * Converts raw BCD values from CI-V 0x15/0x02 to physical S-units and dBm
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawToSMeter = rawToSMeter;
+const IcomConstants_1 = require("../rig/IcomConstants");
+/**
+ * Get S-meter calibration constants for a specific radio model
+ * @param model - Radio model name (e.g., 'IC-705')
+ * @returns Calibration constants, defaults to IC-705 if model not found
+ */
+function getCalibration(model = 'IC-705') {
+    const cal = IcomConstants_1.METER_CALIBRATION.SMETER[model];
+    if (!cal) {
+        // Default to IC-705 if model not found
+        console.warn(`S-meter calibration for model '${model}' not found, using IC-705 defaults`);
+        return IcomConstants_1.METER_CALIBRATION.SMETER['IC-705'];
+    }
+    return cal;
+}
+/**
+ * Convert raw S-meter value to S-units (0-9+)
+ * Uses linear interpolation based on calibration points
+ *
+ * @param raw - Raw BCD value (0-255)
+ * @param cal - Calibration constants
+ * @returns S-unit value (0-9+, supports decimals)
+ */
+function rawToSUnits(raw, cal) {
+    // Clamp to valid range
+    if (raw <= cal.S0)
+        return 0;
+    if (raw >= cal.S9_PLUS_60DB) {
+        // Maximum S9+60dB = S9 + 60dB/6dB per S-unit = S9 + 10 S-units = S19
+        return 9 + 60 / 6;
+    }
+    // Linear interpolation
+    if (raw <= cal.S9) {
+        // S0 to S9: linear from 0 to 9
+        return (raw - cal.S0) * 9.0 / (cal.S9 - cal.S0);
+    }
+    else {
+        // Above S9: each S-unit = 6dB
+        const dbAboveS9 = (raw - cal.S9) * 60.0 / (cal.S9_PLUS_60DB - cal.S9);
+        return 9 + dbAboveS9 / 6.0;
+    }
+}
+/**
+ * Convert raw S-meter value to dB above S9
+ * Only meaningful when raw > S9 threshold
+ *
+ * @param raw - Raw BCD value (0-255)
+ * @param cal - Calibration constants
+ * @returns dB above S9, or undefined if below S9
+ */
+function rawToDbAboveS9(raw, cal) {
+    if (raw <= cal.S9) {
+        return undefined; // Below S9, no "dB above S9" concept
+    }
+    // Linear interpolation: S9 to S9+60dB
+    const dbAboveS9 = (raw - cal.S9) * 60.0 / (cal.S9_PLUS_60DB - cal.S9);
+    return Math.max(0, dbAboveS9); // Clamp to non-negative
+}
+/**
+ * Estimate absolute power in dBm
+ * Based on HF standard: S9 ≈ -73dBm
+ * NOTE: This is an estimation and may vary by band, filter, and device settings
+ *
+ * @param sUnits - S-unit value
+ * @param cal - Calibration constants
+ * @returns Estimated power in dBm
+ */
+function estimateDpm(sUnits, cal) {
+    // Each S-unit below S9 = 6dB
+    // Each dB above S9 = 1dB
+    const dbRelativeToS9 = (sUnits - 9) * 6.0;
+    return cal.HF_S9_DBM + dbRelativeToS9;
+}
+/**
+ * Format S-meter reading as human-readable string
+ * Examples: "S0", "S4", "S9", "S9+10dB", "S9+60dB"
+ *
+ * @param sUnits - S-unit value
+ * @param dbAboveS9 - dB above S9 (if any)
+ * @returns Formatted string
+ */
+function formatSMeter(sUnits, dbAboveS9) {
+    if (dbAboveS9 !== undefined && dbAboveS9 > 0) {
+        // Above S9: show as "S9+XdB"
+        const roundedDb = Math.round(dbAboveS9);
+        return `S9+${roundedDb}dB`;
+    }
+    else {
+        // S0-S9: show as "SX"
+        const roundedS = Math.floor(sUnits);
+        return `S${roundedS}`;
+    }
+}
+/**
+ * Convert raw S-meter BCD value to complete reading with S-units, dB, and dBm
+ *
+ * @param raw - Raw BCD value (0-255) from CI-V 0x15/0x02
+ * @param model - Radio model name (default: 'IC-705')
+ * @returns Complete LevelMeterReading with all calculated fields
+ *
+ * @example
+ * ```typescript
+ * const reading = rawToSMeter(140, 'IC-705');
+ * console.log(reading);
+ * // {
+ * //   raw: 140,
+ * //   percent: 54.9,
+ * //   sUnits: 9.99,
+ * //   dbAboveS9: 9.92,
+ * //   dBm: -63.08,
+ * //   formatted: "S9+10dB"
+ * // }
+ * ```
+ */
+function rawToSMeter(raw, model = 'IC-705') {
+    const cal = getCalibration(model);
+    // Calculate all fields
+    const sUnits = rawToSUnits(raw, cal);
+    const dbAboveS9 = rawToDbAboveS9(raw, cal);
+    const dBm = estimateDpm(sUnits, cal);
+    const formatted = formatSMeter(sUnits, dbAboveS9);
+    const percent = (raw / 255) * 100;
+    return {
+        raw,
+        percent: Math.round(percent * 10) / 10, // Round to 1 decimal place
+        sUnits: Math.round(sUnits * 100) / 100, // Round to 2 decimal places
+        dbAboveS9: dbAboveS9 !== undefined ? Math.round(dbAboveS9 * 100) / 100 : undefined,
+        dBm: Math.round(dBm * 100) / 100, // Round to 2 decimal places
+        formatted
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icom-wlan-node",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Icom WLAN (CI‑V, audio) protocol implementation for Node.js/TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",