icom-wlan-node 0.1.1 → 0.2.1

package/README.md

@@ -106,37 +106,190 @@ await rig.setPtt(false);
   - `civFrame(Buffer)` — one complete CI‑V frame (FE FE ... FD)
   - `audio({ pcm16: Buffer })` — audio frames
   - `error(Error)` — UDP errors
+  - `connectionLost(ConnectionLostInfo)` — session timeout detected
+  - `connectionRestored(ConnectionRestoredInfo)` — reconnected successfully
+  - `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)`
+  - **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
+
+The library features a robust state machine for connection lifecycle management with automatic reconnection support.
+
+#### Connection State Machine
+
+```ts
+ConnectionPhase: IDLE → CONNECTING → CONNECTED → DISCONNECTING
+                   ↓                      ↓
+                RECONNECTING ←────────────┘
+```
+
+#### Basic Usage
+
+```ts
+// Connect (idempotent - safe to call multiple times)
+await rig.connect();
+
+// Query connection phase
+const phase = rig.getConnectionPhase(); // 'IDLE' | 'CONNECTING' | 'CONNECTED' | ...
+
+// Get detailed metrics
+const metrics = rig.getConnectionMetrics();
+console.log(metrics.phase);       // Current phase
+console.log(metrics.uptime);      // Milliseconds since connected
+console.log(metrics.sessions);    // Per-session states {control, civ, audio}
+
+// Disconnect (also idempotent)
+await rig.disconnect();
+```
+
+#### Connection Monitoring Events
+
+```ts
+// Connection lost (any session timeout)
+rig.events.on('connectionLost', (info) => {
+  console.error(`Lost: ${info.sessionType}, idle: ${info.timeSinceLastData}ms`);
+});
+
+// Connection restored after reconnect
+rig.events.on('connectionRestored', (info) => {
+  console.log(`Restored after ${info.downtime}ms downtime`);
+});
+
+// Reconnect attempt started
+rig.events.on('reconnectAttempting', (info) => {
+  console.log(`Reconnect attempt #${info.attemptNumber}, delay: ${info.delay}ms`);
+});
+
+// Reconnect attempt failed
+rig.events.on('reconnectFailed', (info) => {
+  console.error(`Attempt #${info.attemptNumber} failed: ${info.error}`);
+  if (!info.willRetry) console.error('Giving up - max retries reached');
+});
+```
+
+#### Auto-Reconnect Configuration
+
+```ts
+rig.configureMonitoring({
+  timeout: 8000,              // Session timeout: 8s (default: 5s)
+  checkInterval: 1000,        // Check every 1s (default: 1s)
+  autoReconnect: true,        // Enable auto-reconnect (default: false)
+  maxReconnectAttempts: 10,   // Max retries (default: undefined = infinite)
+  reconnectBaseDelay: 2000,   // Base delay: 2s (default: 2s)
+  reconnectMaxDelay: 30000    // Max delay: 30s (default: 30s, uses exponential backoff)
+});
+```
+
+**Exponential Backoff**: Delays are `baseDelay × 2^(attempt-1)`, capped at `maxDelay`.
+Example: 2s → 4s → 8s → 16s → 30s (capped) → 30s ...
+
+#### Error Handling
+
+**Common Errors**:
+
+```ts
+try {
+  await rig.connect();
+} catch (err) {
+  if (err.message.includes('timeout')) {
+    // Connection timeout (no response from radio)
+  } else if (err.message.includes('Login failed')) {
+    // Authentication error (check userName/password)
+  } else if (err.message.includes('Radio reported connected=false')) {
+    // Radio rejected connection (may be busy with another client)
+  } else if (err.message.includes('Cannot connect while disconnecting')) {
+    // Invalid state transition (wait for disconnect to complete)
+  }
+}
+
+// Listen for UDP errors
+rig.events.on('error', (err) => {
+  console.error('UDP error:', err.message);
+  // Network issues, invalid packets, etc.
+});
+```
+
+**Connection States to Handle**:
+- **CONNECTING**: Wait or show "connecting..." UI
+- **CONNECTED**: Normal operation
+- **RECONNECTING**: Show "reconnecting..." UI, disable TX
+- **DISCONNECTING**: Cleanup in progress
+- **IDLE**: Not connected
 
 ### High‑Level API
 
 The library exposes common CI‑V operations as friendly methods. Addresses are handled internally (`ctrAddr=0xe0`, `rigAddr` discovered via capabilities).
 
-- `setFrequency(hz: number)`
-- `setMode(mode: IcomMode | number, { dataMode?: boolean })`
-- `setPtt(on: boolean)`
+#### Rig Control
+
+- `setFrequency(hz: number)` — Set operating frequency in Hz
+- `setMode(mode: IcomMode | number, options?: { dataMode?: boolean })` — Set mode (supports string or numeric code)
+- `setPtt(on: boolean)` — Key/unkey transmitter
+
+**Supported Modes** (IcomMode string constants):
+- `'LSB'`, `'USB'`, `'AM'`, `'CW'`, `'RTTY'`, `'FM'`, `'WFM'`, `'CW_R'`, `'RTTY_R'`, `'DV'`
+- Or use numeric codes: `0x00` (LSB), `0x01` (USB), `0x02` (AM), etc.
+
+#### Rig Query
+
 - `readOperatingFrequency(options?: QueryOptions) => Promise<number|null>`
 - `readOperatingMode(options?: QueryOptions) => Promise<{ mode: number; filter?: number; modeName?: string; filterName?: string } | null>`
 - `readTransmitFrequency(options?: QueryOptions) => Promise<number|null>`
 - `readTransceiverState(options?: QueryOptions) => Promise<'TX' | 'RX' | 'UNKNOWN' | null>`
 - `readBandEdges(options?: QueryOptions) => Promise<Buffer|null>`
-- `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>`
-- `setConnectorWLanLevel(level: number)`
-- `setConnectorDataMode(mode: ConnectorDataMode | number)`
 
-Examples:
+#### Meters & Levels
+
+**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
+
+- `setConnectorDataMode(mode: ConnectorDataMode | number)` — Set data routing mode (supports string or numeric)
+
+**Supported Connector Modes** (ConnectorDataMode string constants):
+- `'MIC'` (0x00), `'ACC'` (0x01), `'USB'` (0x02), `'WLAN'` (0x03)
+
+#### Examples
 
 ```ts
-// Set frequency and mode (USB-D)
+// Set frequency and mode using string constants
 await rig.setFrequency(14074000);
-await rig.setMode(0x01, { dataMode: true }); // USB=0x01, data mode
+await rig.setMode('USB', { dataMode: true }); // USB-D for FT8
+
+// Or use numeric codes
+await rig.setMode(0x01, { dataMode: true }); // USB=0x01
+
+// Set LSB mode
+await rig.setMode('LSB');
 
 // Query current frequency (Hz)
 const hz = await rig.readOperatingFrequency({ timeout: 3000 });
@@ -152,17 +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 });
-const wlanLevel = await rig.getConnectorWLanLevel({ timeout: 2000 });
-const level = await rig.getLevelMeter({ timeout: 1500 });
-await rig.setConnectorWLanLevel(0x0120);
-await rig.setConnectorDataMode(0x01); // e.g., DATA
+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)}%`);
+}
 
-if (level) {
-  console.log(`Generic Level Meter: raw=${level.raw} (${level.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
 ```
 
 ## Design Notes

package/dist/core/Session.d.ts

@@ -1,4 +1,5 @@
 import { UdpClient } from '../transport/UdpClient';
+import { SessionType } from '../types';
 export interface SessionOptions {
     ip: string;
     port: number;
@@ -19,10 +20,12 @@ export declare class Session {
     lastSentTime: number;
     lastReceivedTime: number;
     private address;
+    private handlers;
     private txHistory;
     private areYouThereTimer?;
     private pingTimer?;
     private destroyed;
+    sessionType?: SessionType;
     constructor(address: SessionOptions, handlers: SessionHandlers);
     open(): void;
     close(): void;
@@ -40,4 +43,10 @@ export declare class Session {
     stopPing(): void;
     stopTimers(): void;
     setRemote(ip: string, port: number): void;
+    /**
+     * Reset session state to initial values
+     * Call this before reconnecting to ensure clean state
+     * (especially important after radio restart)
+     */
+    resetState(): void;
 }

package/dist/core/Session.js

@@ -19,21 +19,24 @@ class Session {
         this.txHistory = new Map();
         this.destroyed = false;
         this.address = address;
+        this.handlers = handlers;
         this.udp.on('data', (rinfo, data) => {
             if (this.destroyed)
                 return;
             this.lastReceivedTime = Date.now();
             try {
-                // Peek type directly to avoid late requires during teardown
-                const t = data.length >= 6 ? data.readUInt16LE(4) : -1;
-                (0, debug_1.dbgV)(`RX port=${this.localPort} from ${rinfo.address}:${rinfo.port} len=${data.length} type=${t >= 0 ? '0x' + t.toString(16) : 'n/a'}`);
+                const type = data.length >= 6 ? data.readUInt16LE(4) : -1;
+                (0, debug_1.dbgV)(`RX port=${this.localPort} from ${rinfo.address}:${rinfo.port} len=${data.length} type=${type >= 0 ? '0x' + type.toString(16) : 'n/a'}`);
             }
             catch { }
             handlers.onData(data);
         });
         this.udp.on('error', handlers.onSendError);
     }
-    open() { this.udp.open(); }
+    open() {
+        this.destroyed = false; // Reset destroyed flag to allow sending data after reconnection
+        this.udp.open();
+    }
     close() {
         this.stopTimers();
         this.destroyed = true;
@@ -78,8 +81,9 @@ class Session {
     } }
     startAreYouThere() {
         this.stopAreYouThere();
+        (0, debug_1.dbg)(`Starting AreYouThere timer for ${this.address.ip}:${this.address.port}`);
         this.areYouThereTimer = setInterval(() => {
-            (0, debug_1.dbgV)(`AYT -> ${this.address.ip}:${this.address.port} localId=${this.localId}`);
+            (0, debug_1.dbg)(`AYT -> ${this.address.ip}:${this.address.port} localId=${this.localId}`);
             this.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.ARE_YOU_THERE, 0, this.localId, 0));
         }, 500);
     }
@@ -101,5 +105,30 @@ class Session {
     setRemote(ip, port) {
         this.address = { ip, port };
     }
+    /**
+     * Reset session state to initial values
+     * Call this before reconnecting to ensure clean state
+     * (especially important after radio restart)
+     */
+    resetState() {
+        // Reset destroyed flag to ensure session is usable after state reset
+        this.destroyed = false;
+        // Generate new IDs
+        this.localId = Date.now() >>> 0;
+        this.remoteId = 0;
+        // Reset sequence numbers
+        this.trackedSeq = 1;
+        this.pingSeq = 0;
+        this.innerSeq = 0x30;
+        // Reset tokens
+        this.rigToken = 0;
+        this.localToken = (Date.now() & 0xffff) >>> 0;
+        // Reset timestamps
+        this.lastSentTime = Date.now();
+        this.lastReceivedTime = Date.now();
+        // Clear history
+        this.txHistory.clear();
+        (0, debug_1.dbgV)(`Session state reset: localId=${this.localId}, localToken=${this.localToken}`);
+    }
 }
 exports.Session = Session;

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,8 +14,8 @@ 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;
-// Export types
+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
 var IcomControl_1 = require("./rig/IcomControl");
@@ -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/IcomCiv.js

@@ -12,9 +12,14 @@ class IcomCiv {
     }
     start() {
         this.stop();
-        // keep-alive open/close
+        // CIV session watchdog: Keep-alive mechanism to maintain CIV connection
+        // Matches FT8CN's startCivDataTimer() implementation:
+        // - Checks every 500ms if CIV session is receiving data
+        // - If no data received for >2000ms, sends OpenClose(true) to re-establish connection
+        // - This prevents silent disconnection where radio stops responding without error
         this.openTimer = setInterval(() => {
             if (Date.now() - this.sess.lastReceivedTime > 2000) {
+                (0, debug_1.dbg)('CIV watchdog: No data for >2s, sending OpenClose to keep alive');
                 this.sendOpenClose(true);
             }
         }, 500);

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);
+}