icom-wlan-node 0.2.0 → 0.2.1

package/README.md

@@ -111,15 +111,16 @@ await rig.setPtt(false);
   - `reconnectAttempting(ReconnectAttemptInfo)` — reconnect attempt started
   - `reconnectFailed(ReconnectFailedInfo)` — reconnect attempt failed
 - Methods
-  - `connect()` / `disconnect()` — connects control + CIV + audio sub‑sessions; resolves when all ready
-  - `sendCiv(buf: Buffer)` — send a raw CI‑V frame
-  - `setPtt(on: boolean)` — key/unkey; also manages TX meter polling and audio tailing
-  - `sendAudioFloat32(samples: Float32Array, addLeadingBuffer?: boolean)` / `sendAudioPcm16(samples: Int16Array)`
-  - `getConnectionPhase()` — returns current ConnectionPhase (IDLE, CONNECTING, CONNECTED, DISCONNECTING, RECONNECTING)
-  - `getConnectionMetrics()` — returns detailed ConnectionMetrics (phase, uptime, session states, etc.)
-  - `getConnectionState()` — returns per‑session ConnectionState (control, civ, audio)
-  - `isAnySessionDisconnected()` — returns true if any session is disconnected
-  - `configureMonitoring(config)` — configure connection monitoring and auto‑reconnect behavior
+  - **Connection**: `connect()` / `disconnect()` — connects control + CIV + audio sub‑sessions; resolves when all ready
+  - **Raw CI‑V**: `sendCiv(buf: Buffer)` — send a raw CI‑V frame
+  - **Audio TX**: `setPtt(on: boolean)`, `sendAudioFloat32()`, `sendAudioPcm16()`
+  - **Rig Control**: `setFrequency()`, `setMode()`, `setConnectorDataMode()`, `setConnectorWLanLevel()`
+  - **Rig Query**: `readOperatingFrequency()`, `readOperatingMode()`, `readTransmitFrequency()`, `readTransceiverState()`, `readBandEdges()`
+  - **Meters (RX)**: `readSquelchStatus()`, `readAudioSquelch()`, `readOvfStatus()`, `getLevelMeter()`
+  - **Meters (TX)**: `readSWR()`, `readALC()`, `readPowerLevel()`, `readCompLevel()`
+  - **Power Supply**: `readVoltage()`, `readCurrent()`
+  - **Audio Config**: `getConnectorWLanLevel()`
+  - **Connection Monitoring**: `getConnectionPhase()`, `getConnectionMetrics()`, `getConnectionState()`, `isAnySessionDisconnected()`, `configureMonitoring()`
 
 ### Connection Management & Auto-Reconnect
 
@@ -250,10 +251,24 @@ The library exposes common CI‑V operations as friendly methods. Addresses are
 
 #### Meters & Levels
 
-- `readSWR(options?: QueryOptions) => Promise<{ raw: number; swr: number; alert: boolean } | null>`
-- `readALC(options?: QueryOptions) => Promise<{ raw: number; percent: number; alert: boolean } | null>`
-- `getConnectorWLanLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>`
-- `getLevelMeter(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>`
+**Reception Meters** (available anytime):
+- `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)
+
+**Transmission Meters** (require PTT on):
+- `readSWR(options?: QueryOptions) => Promise<{ raw: number; swr: number; alert: boolean } | null>` — SWR meter (CI-V 0x15/0x12)
+- `readALC(options?: QueryOptions) => Promise<{ raw: number; percent: number; alert: boolean } | null>` — ALC meter (CI-V 0x15/0x13)
+- `readPowerLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` — Output power level (CI-V 0x15/0x11)
+- `readCompLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` — Voice compression level (CI-V 0x15/0x14)
+
+**Power Supply Monitoring**:
+- `readVoltage(options?: QueryOptions) => Promise<{ raw: number; volts: number } | null>` — Supply voltage (CI-V 0x15/0x15)
+- `readCurrent(options?: QueryOptions) => Promise<{ raw: number; amps: number } | null>` — Supply current draw (CI-V 0x15/0x16)
+
+**Audio Configuration**:
+- `getConnectorWLanLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` — Get WLAN audio level (CI-V 0x1A/0x05/0x01/0x17)
 - `setConnectorWLanLevel(level: number)` — Set WLAN audio level (0-255)
 
 #### Connector Settings
@@ -290,20 +305,75 @@ for (let n = 0; n < 10; n++) {
 }
 await rig.setPtt(false);
 
-// Read meters and connector settings
+// Read reception meters (available anytime)
+const squelch = await rig.readSquelchStatus({ timeout: 2000 });
+if (squelch) {
+  console.log(`Squelch: ${squelch.isOpen ? 'OPEN' : 'CLOSED'}`);
+}
+
+const audioSq = await rig.readAudioSquelch({ timeout: 2000 });
+if (audioSq) {
+  console.log(`Audio Squelch: ${audioSq.isOpen ? 'OPEN' : 'CLOSED'}`);
+}
+
+const ovf = await rig.readOvfStatus({ timeout: 2000 });
+if (ovf) {
+  console.log(`ADC: ${ovf.isOverload ? '⚠️ OVERLOAD' : '✓ OK'}`);
+}
+
+const sMeter = await rig.getLevelMeter({ timeout: 2000 });
+if (sMeter) {
+  console.log(`S-Meter: ${sMeter.percent.toFixed(1)}%`);
+}
+
+// Read power supply monitoring
+const voltage = await rig.readVoltage({ timeout: 2000 });
+if (voltage) {
+  console.log(`Voltage: ${voltage.volts.toFixed(2)}V`);
+}
+
+const current = await rig.readCurrent({ timeout: 2000 });
+if (current) {
+  console.log(`Current: ${current.amps.toFixed(2)}A`);
+}
+
+// Read transmission meters (requires PTT on)
+await rig.setPtt(true);
+await new Promise(r => setTimeout(r, 200)); // Wait for meters to stabilize
+
 const swr = await rig.readSWR({ timeout: 2000 });
+if (swr) {
+  console.log(`SWR: ${swr.swr.toFixed(2)} ${swr.alert ? '⚠️ HIGH' : '✓'}`);
+}
+
 const alc = await rig.readALC({ timeout: 2000 });
+if (alc) {
+  console.log(`ALC: ${alc.percent.toFixed(1)}% ${alc.alert ? '⚠️ HIGH' : '✓'}`);
+}
+
+const power = await rig.readPowerLevel({ timeout: 2000 });
+if (power) {
+  console.log(`Power: ${power.percent.toFixed(1)}%`);
+}
+
+const comp = await rig.readCompLevel({ timeout: 2000 });
+if (comp) {
+  console.log(`COMP: ${comp.percent.toFixed(1)}%`);
+}
+
+await rig.setPtt(false);
+
+// Configure WLAN connector
 const wlanLevel = await rig.getConnectorWLanLevel({ timeout: 2000 });
+if (wlanLevel) {
+  console.log(`WLAN Level: ${wlanLevel.percent.toFixed(1)}%`);
+}
 
 // Set connector to WLAN mode using string constant
 await rig.setConnectorDataMode('WLAN');
 // Or numeric: await rig.setConnectorDataMode(0x03);
 
 await rig.setConnectorWLanLevel(120); // Set WLAN audio level
-
-if (wlanLevel) {
-  console.log(`WLAN Level: ${wlanLevel.percent.toFixed(1)}%`);
-}
 ```
 
 ## Design Notes

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export * from './types';
 export { IcomControl } from './rig/IcomControl';
-export { MODE_MAP, CONNECTOR_MODE_MAP, DEFAULT_CONTROLLER_ADDR, METER_THRESHOLDS, getModeCode, getConnectorModeCode, getModeString, getConnectorModeString, getFilterString } from './rig/IcomConstants';
+export { MODE_MAP, CONNECTOR_MODE_MAP, DEFAULT_CONTROLLER_ADDR, METER_THRESHOLDS, METER_CALIBRATION, getModeCode, getConnectorModeCode, getModeString, getConnectorModeString, getFilterString, rawToPowerPercent, rawToVoltage, rawToCurrent } from './rig/IcomConstants';
 export { parseTwoByteBcd, intToTwoByteBcd } from './utils/bcd';
 export { IcomRigCommands } from './rig/IcomRigCommands';
 export { AUDIO_RATE } from './rig/IcomAudio';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUDIO_RATE = exports.IcomRigCommands = exports.intToTwoByteBcd = exports.parseTwoByteBcd = exports.getFilterString = exports.getConnectorModeString = exports.getModeString = exports.getConnectorModeCode = exports.getModeCode = exports.METER_THRESHOLDS = exports.DEFAULT_CONTROLLER_ADDR = exports.CONNECTOR_MODE_MAP = exports.MODE_MAP = exports.IcomControl = void 0;
+exports.AUDIO_RATE = exports.IcomRigCommands = exports.intToTwoByteBcd = exports.parseTwoByteBcd = exports.rawToCurrent = exports.rawToVoltage = exports.rawToPowerPercent = exports.getFilterString = exports.getConnectorModeString = exports.getModeString = exports.getConnectorModeCode = exports.getModeCode = exports.METER_CALIBRATION = exports.METER_THRESHOLDS = exports.DEFAULT_CONTROLLER_ADDR = exports.CONNECTOR_MODE_MAP = exports.MODE_MAP = exports.IcomControl = void 0;
 // Export types (includes ConnectionPhase, ConnectionMetrics, etc.)
 __exportStar(require("./types"), exports);
 // Export main class
@@ -26,11 +26,15 @@ Object.defineProperty(exports, "MODE_MAP", { enumerable: true, get: function ()
 Object.defineProperty(exports, "CONNECTOR_MODE_MAP", { enumerable: true, get: function () { return IcomConstants_1.CONNECTOR_MODE_MAP; } });
 Object.defineProperty(exports, "DEFAULT_CONTROLLER_ADDR", { enumerable: true, get: function () { return IcomConstants_1.DEFAULT_CONTROLLER_ADDR; } });
 Object.defineProperty(exports, "METER_THRESHOLDS", { enumerable: true, get: function () { return IcomConstants_1.METER_THRESHOLDS; } });
+Object.defineProperty(exports, "METER_CALIBRATION", { enumerable: true, get: function () { return IcomConstants_1.METER_CALIBRATION; } });
 Object.defineProperty(exports, "getModeCode", { enumerable: true, get: function () { return IcomConstants_1.getModeCode; } });
 Object.defineProperty(exports, "getConnectorModeCode", { enumerable: true, get: function () { return IcomConstants_1.getConnectorModeCode; } });
 Object.defineProperty(exports, "getModeString", { enumerable: true, get: function () { return IcomConstants_1.getModeString; } });
 Object.defineProperty(exports, "getConnectorModeString", { enumerable: true, get: function () { return IcomConstants_1.getConnectorModeString; } });
 Object.defineProperty(exports, "getFilterString", { enumerable: true, get: function () { return IcomConstants_1.getFilterString; } });
+Object.defineProperty(exports, "rawToPowerPercent", { enumerable: true, get: function () { return IcomConstants_1.rawToPowerPercent; } });
+Object.defineProperty(exports, "rawToVoltage", { enumerable: true, get: function () { return IcomConstants_1.rawToVoltage; } });
+Object.defineProperty(exports, "rawToCurrent", { enumerable: true, get: function () { return IcomConstants_1.rawToCurrent; } });
 // Export BCD utilities
 var bcd_1 = require("./utils/bcd");
 Object.defineProperty(exports, "parseTwoByteBcd", { enumerable: true, get: function () { return bcd_1.parseTwoByteBcd; } });

package/dist/rig/IcomConstants.d.ts

@@ -82,3 +82,75 @@ export declare const METER_THRESHOLDS: {
  * Matches FT8CN's IComPacketTypes.METER_TIMER_PERIOD_MS
  */
 export declare const METER_TIMER_PERIOD_MS = 500;
+/**
+ * Meter calibration constants for physical unit conversion
+ * Based on IC-705 official CI-V reference manual
+ */
+export declare const METER_CALIBRATION: {
+    /**
+     * Power level (CI-V 0x15/0x11) calibration points
+     * Used for converting raw BCD to percentage
+     */
+    readonly POWER: {
+        /** 50% power reference point */
+        readonly HALF: {
+            readonly raw: 323;
+            readonly percent: 50;
+        };
+        /** 100% power reference point */
+        readonly FULL: {
+            readonly raw: 531;
+            readonly percent: 100;
+        };
+    };
+    /**
+     * Voltage (CI-V 0x15/0x15) calibration points
+     * Used for converting raw BCD to volts
+     */
+    readonly VOLTAGE: {
+        /** Low voltage reference: 5V */
+        readonly LOW: {
+            readonly raw: 117;
+            readonly volts: 5;
+        };
+        /** High voltage reference: 16V */
+        readonly HIGH: {
+            readonly raw: 577;
+            readonly volts: 16;
+        };
+    };
+    /**
+     * Current (CI-V 0x15/0x16) calibration points
+     * Used for converting raw BCD to amperes
+     */
+    readonly CURRENT: {
+        /** Low current reference: 2A */
+        readonly LOW: {
+            readonly raw: 289;
+            readonly amps: 2;
+        };
+        /** High current reference: 4A */
+        readonly HIGH: {
+            readonly raw: 577;
+            readonly amps: 4;
+        };
+    };
+};
+/**
+ * Convert raw power level to percentage
+ * @param raw - Raw BCD value (0-255)
+ * @returns Power percentage (0-100%)
+ */
+export declare function rawToPowerPercent(raw: number): number;
+/**
+ * Convert raw voltage reading to volts
+ * @param raw - Raw BCD value (0-255)
+ * @returns Voltage in volts
+ */
+export declare function rawToVoltage(raw: number): number;
+/**
+ * Convert raw current reading to amperes
+ * @param raw - Raw BCD value (0-255)
+ * @returns Current in amperes
+ */
+export declare function rawToCurrent(raw: number): number;

package/dist/rig/IcomConstants.js

@@ -4,12 +4,15 @@
  * Based on FT8CN's IcomRigConstant.java
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.METER_TIMER_PERIOD_MS = exports.METER_THRESHOLDS = exports.DEFAULT_CONTROLLER_ADDR = exports.CONNECTOR_MODE_MAP = exports.MODE_MAP = void 0;
+exports.METER_CALIBRATION = exports.METER_TIMER_PERIOD_MS = exports.METER_THRESHOLDS = exports.DEFAULT_CONTROLLER_ADDR = exports.CONNECTOR_MODE_MAP = exports.MODE_MAP = void 0;
 exports.getModeCode = getModeCode;
 exports.getConnectorModeCode = getConnectorModeCode;
 exports.getModeString = getModeString;
 exports.getConnectorModeString = getConnectorModeString;
 exports.getFilterString = getFilterString;
+exports.rawToPowerPercent = rawToPowerPercent;
+exports.rawToVoltage = rawToVoltage;
+exports.rawToCurrent = rawToCurrent;
 /**
  * Operating modes supported by ICOM radios
  * LSB:0, USB:1, AM:2, CW:3, RTTY:4, FM:5, WFM:6, CW_R:7, RTTY_R:8, DV:17
@@ -110,3 +113,81 @@ exports.METER_THRESHOLDS = {
  * Matches FT8CN's IComPacketTypes.METER_TIMER_PERIOD_MS
  */
 exports.METER_TIMER_PERIOD_MS = 500;
+/**
+ * Meter calibration constants for physical unit conversion
+ * Based on IC-705 official CI-V reference manual
+ */
+exports.METER_CALIBRATION = {
+    /**
+     * Power level (CI-V 0x15/0x11) calibration points
+     * Used for converting raw BCD to percentage
+     */
+    POWER: {
+        /** 50% power reference point */
+        HALF: { raw: 0x0143, percent: 50 },
+        /** 100% power reference point */
+        FULL: { raw: 0x0213, percent: 100 }
+    },
+    /**
+     * Voltage (CI-V 0x15/0x15) calibration points
+     * Used for converting raw BCD to volts
+     */
+    VOLTAGE: {
+        /** Low voltage reference: 5V */
+        LOW: { raw: 0x0075, volts: 5.0 },
+        /** High voltage reference: 16V */
+        HIGH: { raw: 0x0241, volts: 16.0 }
+    },
+    /**
+     * Current (CI-V 0x15/0x16) calibration points
+     * Used for converting raw BCD to amperes
+     */
+    CURRENT: {
+        /** Low current reference: 2A */
+        LOW: { raw: 0x0121, amps: 2.0 },
+        /** High current reference: 4A */
+        HIGH: { raw: 0x0241, amps: 4.0 }
+    }
+};
+/**
+ * Linear interpolation helper for meter value conversion
+ * @param raw - Raw BCD value
+ * @param x1 - Lower calibration point (raw value)
+ * @param y1 - Lower calibration point (physical value)
+ * @param x2 - Upper calibration point (raw value)
+ * @param y2 - Upper calibration point (physical value)
+ * @returns Interpolated physical value
+ */
+function linearInterpolate(raw, x1, y1, x2, y2) {
+    // Clamp to range
+    if (raw <= x1)
+        return y1;
+    if (raw >= x2)
+        return y2;
+    // Linear interpolation: y = y1 + (raw - x1) * (y2 - y1) / (x2 - x1)
+    return y1 + ((raw - x1) * (y2 - y1)) / (x2 - x1);
+}
+/**
+ * Convert raw power level to percentage
+ * @param raw - Raw BCD value (0-255)
+ * @returns Power percentage (0-100%)
+ */
+function rawToPowerPercent(raw) {
+    return linearInterpolate(raw, exports.METER_CALIBRATION.POWER.HALF.raw, exports.METER_CALIBRATION.POWER.HALF.percent, exports.METER_CALIBRATION.POWER.FULL.raw, exports.METER_CALIBRATION.POWER.FULL.percent);
+}
+/**
+ * Convert raw voltage reading to volts
+ * @param raw - Raw BCD value (0-255)
+ * @returns Voltage in volts
+ */
+function rawToVoltage(raw) {
+    return linearInterpolate(raw, exports.METER_CALIBRATION.VOLTAGE.LOW.raw, exports.METER_CALIBRATION.VOLTAGE.LOW.volts, exports.METER_CALIBRATION.VOLTAGE.HIGH.raw, exports.METER_CALIBRATION.VOLTAGE.HIGH.volts);
+}
+/**
+ * Convert raw current reading to amperes
+ * @param raw - Raw BCD value (0-255)
+ * @returns Current in amperes
+ */
+function rawToCurrent(raw) {
+    return linearInterpolate(raw, exports.METER_CALIBRATION.CURRENT.LOW.raw, exports.METER_CALIBRATION.CURRENT.LOW.amps, exports.METER_CALIBRATION.CURRENT.HIGH.raw, exports.METER_CALIBRATION.CURRENT.HIGH.amps);
+}

package/dist/rig/IcomControl.d.ts

@@ -1,4 +1,4 @@
-import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading, ConnectionState, ConnectionMonitorConfig, ConnectionPhase, ConnectionMetrics } from '../types';
+import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading, SquelchStatusReading, AudioSquelchReading, OvfStatusReading, PowerLevelReading, CompLevelReading, VoltageReading, CurrentReading, ConnectionState, ConnectionMonitorConfig, ConnectionPhase, ConnectionMetrics } from '../types';
 import { IcomCiv } from './IcomCiv';
 import { IcomAudio } from './IcomAudio';
 export declare class IcomControl {
@@ -172,6 +172,83 @@ export declare class IcomControl {
      * await rig.setConnectorDataMode('WLAN');
      */
     setConnectorDataMode(mode: ConnectorDataMode | number): Promise<void>;
+    /**
+     * Read squelch status (noise/signal gate state)
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Squelch status with raw value and boolean state
+     * @example
+     * const status = await rig.readSquelchStatus({ timeout: 2000 });
+     * if (status) {
+     *   console.log(`Squelch: ${status.isOpen ? 'OPEN' : 'CLOSED'}`);
+     * }
+     */
+    readSquelchStatus(options?: QueryOptions): Promise<SquelchStatusReading | null>;
+    /**
+     * Read audio squelch state
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Audio squelch status with raw value and boolean state
+     * @example
+     * const squelch = await rig.readAudioSquelch({ timeout: 2000 });
+     * if (squelch) {
+     *   console.log(`Audio Squelch: ${squelch.isOpen ? 'OPEN' : 'CLOSED'}`);
+     * }
+     */
+    readAudioSquelch(options?: QueryOptions): Promise<AudioSquelchReading | null>;
+    /**
+     * Read OVF (ADC overload) status
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns OVF status with raw value and boolean overload flag
+     * @example
+     * const ovf = await rig.readOvfStatus({ timeout: 2000 });
+     * if (ovf) {
+     *   console.log(`ADC: ${ovf.isOverload ? '⚠️ OVERLOAD' : '✓ OK'}`);
+     * }
+     */
+    readOvfStatus(options?: QueryOptions): Promise<OvfStatusReading | null>;
+    /**
+     * Read power output level during transmission
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Power level with raw value and percentage
+     * @example
+     * const power = await rig.readPowerLevel({ timeout: 2000 });
+     * if (power) {
+     *   console.log(`Power: ${power.percent.toFixed(1)}%`);
+     * }
+     */
+    readPowerLevel(options?: QueryOptions): Promise<PowerLevelReading | null>;
+    /**
+     * Read COMP (voice compression) level during transmission
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Compression level with raw value and percentage
+     * @example
+     * const comp = await rig.readCompLevel({ timeout: 2000 });
+     * if (comp) {
+     *   console.log(`COMP: ${comp.percent.toFixed(1)}%`);
+     * }
+     */
+    readCompLevel(options?: QueryOptions): Promise<CompLevelReading | null>;
+    /**
+     * Read power supply voltage
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Voltage reading with raw value and volts
+     * @example
+     * const voltage = await rig.readVoltage({ timeout: 2000 });
+     * if (voltage) {
+     *   console.log(`Voltage: ${voltage.volts.toFixed(2)}V`);
+     * }
+     */
+    readVoltage(options?: QueryOptions): Promise<VoltageReading | null>;
+    /**
+     * Read power supply current draw
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Current reading with raw value and amperes
+     * @example
+     * const current = await rig.readCurrent({ timeout: 2000 });
+     * if (current) {
+     *   console.log(`Current: ${current.amps.toFixed(2)}A`);
+     * }
+     */
+    readCurrent(options?: QueryOptions): Promise<CurrentReading | null>;
     private static isReplyOf;
     /**
      * Extract meter data from CI-V response frame

package/dist/rig/IcomControl.js

@@ -732,6 +732,174 @@ class IcomControl {
         const modeCode = typeof mode === 'string' ? (0, IcomConstants_1.getConnectorModeCode)(mode) : mode;
         this.sendCiv(IcomRigCommands_1.IcomRigCommands.setConnectorDataMode(ctrAddr, rigAddr, modeCode));
     }
+    /**
+     * Read squelch status (noise/signal gate state)
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Squelch status with raw value and boolean state
+     * @example
+     * const status = await rig.readSquelchStatus({ timeout: 2000 });
+     * if (status) {
+     *   console.log(`Squelch: ${status.isOpen ? 'OPEN' : 'CLOSED'}`);
+     * }
+     */
+    async readSquelchStatus(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getSquelchStatus(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isMeterReply(frame, 0x01, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractMeterData(resp);
+        if (raw === null)
+            return null;
+        return {
+            raw,
+            isOpen: raw === 0x0001
+        };
+    }
+    /**
+     * Read audio squelch state
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Audio squelch status with raw value and boolean state
+     * @example
+     * const squelch = await rig.readAudioSquelch({ timeout: 2000 });
+     * if (squelch) {
+     *   console.log(`Audio Squelch: ${squelch.isOpen ? 'OPEN' : 'CLOSED'}`);
+     * }
+     */
+    async readAudioSquelch(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getAudioSquelch(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isMeterReply(frame, 0x05, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractMeterData(resp);
+        if (raw === null)
+            return null;
+        return {
+            raw,
+            isOpen: raw === 0x0001
+        };
+    }
+    /**
+     * Read OVF (ADC overload) status
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns OVF status with raw value and boolean overload flag
+     * @example
+     * const ovf = await rig.readOvfStatus({ timeout: 2000 });
+     * if (ovf) {
+     *   console.log(`ADC: ${ovf.isOverload ? '⚠️ OVERLOAD' : '✓ OK'}`);
+     * }
+     */
+    async readOvfStatus(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getOvfStatus(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isMeterReply(frame, 0x07, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractMeterData(resp);
+        if (raw === null)
+            return null;
+        return {
+            raw,
+            isOverload: raw === 0x0001
+        };
+    }
+    /**
+     * Read power output level during transmission
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Power level with raw value and percentage
+     * @example
+     * const power = await rig.readPowerLevel({ timeout: 2000 });
+     * if (power) {
+     *   console.log(`Power: ${power.percent.toFixed(1)}%`);
+     * }
+     */
+    async readPowerLevel(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getPowerLevel(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isMeterReply(frame, 0x11, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractMeterData(resp);
+        if (raw === null)
+            return null;
+        return {
+            raw,
+            percent: (0, IcomConstants_1.rawToPowerPercent)(raw)
+        };
+    }
+    /**
+     * Read COMP (voice compression) level during transmission
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Compression level with raw value and percentage
+     * @example
+     * const comp = await rig.readCompLevel({ timeout: 2000 });
+     * if (comp) {
+     *   console.log(`COMP: ${comp.percent.toFixed(1)}%`);
+     * }
+     */
+    async readCompLevel(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getCompLevel(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isMeterReply(frame, 0x14, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractMeterData(resp);
+        if (raw === null)
+            return null;
+        return {
+            raw,
+            percent: (raw / 255) * 100
+        };
+    }
+    /**
+     * Read power supply voltage
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Voltage reading with raw value and volts
+     * @example
+     * const voltage = await rig.readVoltage({ timeout: 2000 });
+     * if (voltage) {
+     *   console.log(`Voltage: ${voltage.volts.toFixed(2)}V`);
+     * }
+     */
+    async readVoltage(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getVoltage(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isMeterReply(frame, 0x15, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractMeterData(resp);
+        if (raw === null)
+            return null;
+        return {
+            raw,
+            volts: (0, IcomConstants_1.rawToVoltage)(raw)
+        };
+    }
+    /**
+     * Read power supply current draw
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Current reading with raw value and amperes
+     * @example
+     * const current = await rig.readCurrent({ timeout: 2000 });
+     * if (current) {
+     *   console.log(`Current: ${current.amps.toFixed(2)}A`);
+     * }
+     */
+    async readCurrent(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getCurrent(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isMeterReply(frame, 0x16, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractMeterData(resp);
+        if (raw === null)
+            return null;
+        return {
+            raw,
+            amps: (0, IcomConstants_1.rawToCurrent)(raw)
+        };
+    }
     static isReplyOf(frame, cmd, ctrAddr, rigAddr) {
         // typical reply FE FE [ctr] [rig] cmd ... FD
         return frame.length >= 7 && frame[0] === 0xfe && frame[1] === 0xfe && frame[4] === (cmd & 0xff);

package/dist/rig/IcomRigCommands.d.ts

@@ -14,4 +14,11 @@ export declare const IcomRigCommands: {
     getConnectorWLanLevel(ctrAddr: number, rigAddr: number): Buffer;
     setConnectorWLanLevel(ctrAddr: number, rigAddr: number, level: number): Buffer;
     setConnectorDataMode(ctrAddr: number, rigAddr: number, mode: number): Buffer;
+    getSquelchStatus(ctrAddr: number, rigAddr: number): Buffer;
+    getAudioSquelch(ctrAddr: number, rigAddr: number): Buffer;
+    getOvfStatus(ctrAddr: number, rigAddr: number): Buffer;
+    getPowerLevel(ctrAddr: number, rigAddr: number): Buffer;
+    getCompLevel(ctrAddr: number, rigAddr: number): Buffer;
+    getVoltage(ctrAddr: number, rigAddr: number): Buffer;
+    getCurrent(ctrAddr: number, rigAddr: number): Buffer;
 };

package/dist/rig/IcomRigCommands.js

@@ -69,5 +69,33 @@ exports.IcomRigCommands = {
     setConnectorDataMode(ctrAddr, rigAddr, mode) {
         // FE FE [rig] [ctr] 0x1A 0x05 0x01 0x19 [mode] FD
         return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x05, 0x01, 0x19, mode & 0xff, 0xfd]);
+    },
+    getSquelchStatus(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x15 0x01 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x01, 0xfd]);
+    },
+    getAudioSquelch(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x15 0x05 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x05, 0xfd]);
+    },
+    getOvfStatus(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x15 0x07 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x07, 0xfd]);
+    },
+    getPowerLevel(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x15 0x11 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x11, 0xfd]);
+    },
+    getCompLevel(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x15 0x14 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x14, 0xfd]);
+    },
+    getVoltage(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x15 0x15 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x15, 0xfd]);
+    },
+    getCurrent(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x15 0x16 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x16, 0xfd]);
     }
 };

package/dist/types.d.ts

@@ -162,6 +162,85 @@ export interface LevelMeterReading {
     /** Percentage (0-100%) */
     percent: number;
 }
+/**
+ * Squelch status reading (CI-V 0x15/0x01)
+ * Indicates whether noise/signal squelch gate is open or closed
+ */
+export interface SquelchStatusReading {
+    /** Raw BCD value (0 or 1) */
+    raw: number;
+    /** True if squelch is open (signal present), false if closed (no signal) */
+    isOpen: boolean;
+}
+/**
+ * Audio squelch reading (CI-V 0x15/0x05)
+ * Indicates audio squelch state
+ */
+export interface AudioSquelchReading {
+    /** Raw BCD value (0 or 1) */
+    raw: number;
+    /** True if audio squelch is open, false if closed */
+    isOpen: boolean;
+}
+/**
+ * OVF (ADC overload) status reading (CI-V 0x15/0x07)
+ * Indicates whether the ADC (analog-to-digital converter) is overloading
+ */
+export interface OvfStatusReading {
+    /** Raw BCD value (0 or 1) */
+    raw: number;
+    /** True if ADC is overloading, false if normal */
+    isOverload: boolean;
+}
+/**
+ * Power output level reading (CI-V 0x15/0x11)
+ * Represents transmitter output power level
+ */
+export interface PowerLevelReading {
+    /**
+     * Raw BCD value (0-255)
+     * Calibration: 0143≈50%, 0213≈100%
+     */
+    raw: number;
+    /** Percentage of maximum power (0-100%) */
+    percent: number;
+}
+/**
+ * COMP (voice compression) level reading (CI-V 0x15/0x14)
+ * Represents speech compressor level during transmission
+ */
+export interface CompLevelReading {
+    /** Raw BCD value (0-255) */
+    raw: number;
+    /** Percentage of maximum compression (0-100%) */
+    percent: number;
+}
+/**
+ * Voltage reading (CI-V 0x15/0x15)
+ * Represents power supply voltage
+ */
+export interface VoltageReading {
+    /**
+     * Raw BCD value (0-255)
+     * Calibration: 0075≈5V, 0241≈16V
+     */
+    raw: number;
+    /** Voltage in volts */
+    volts: number;
+}
+/**
+ * Current reading (CI-V 0x15/0x16)
+ * Represents power supply current draw
+ */
+export interface CurrentReading {
+    /**
+     * Raw BCD value (0-255)
+     * Calibration: 0121≈2A, 0241≈4A
+     */
+    raw: number;
+    /** Current in amperes */
+    amps: number;
+}
 /**
  * Connection state enumeration
  * Represents the current state of a UDP session

package/package.json

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