icom-wlan-node 0.2.5 → 0.2.6

package/README.md

@@ -262,7 +262,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 +330,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

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

@@ -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>;
     /**

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

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)

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.6",
   "description": "Icom WLAN (CI‑V, audio) protocol implementation for Node.js/TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",