icom-wlan-node 0.1.1 → 0.2.1

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/transport/UdpClient.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UdpClient = void 0;
 const dgram_1 = __importDefault(require("dgram"));
 const events_1 = require("events");
+const debug_1 = require("../utils/debug");
 class UdpClient extends events_1.EventEmitter {
     constructor() {
         super(...arguments);
@@ -13,8 +14,11 @@ class UdpClient extends events_1.EventEmitter {
     }
     get localPort() { return this._localPort; }
     open(localPort) {
-        if (this.socket)
+        if (this.socket) {
+            (0, debug_1.dbgV)(`[UDP] Socket already open on port ${this._localPort}, skipping`);
             return;
+        }
+        (0, debug_1.dbgV)(`[UDP] Opening socket on port ${localPort ?? 0}`);
         this.socket = dgram_1.default.createSocket('udp4');
         const sock = this.socket;
         sock.on('message', (msg, rinfo) => this.emit('data', rinfo, Buffer.from(msg)));
@@ -23,8 +27,10 @@ class UdpClient extends events_1.EventEmitter {
             if (!sock)
                 return;
             const addr = sock.address();
-            if (typeof addr === 'object')
+            if (typeof addr === 'object') {
                 this._localPort = addr.port;
+                (0, debug_1.dbgV)(`[UDP] Socket bound to port ${this._localPort}`);
+            }
         });
     }
     close() {
@@ -39,9 +45,17 @@ class UdpClient extends events_1.EventEmitter {
         }
     }
     send(buf, ip, port) {
-        if (!this.socket)
+        if (!this.socket) {
+            console.error('[UDP] ERROR: Cannot send - socket not initialized!');
             throw new Error('UDP socket not opened');
-        this.socket.send(buf, port, ip);
+        }
+        (0, debug_1.dbgV)(`[UDP] send to ${ip}:${port}, ${buf.length} bytes from port ${this._localPort}`);
+        this.socket.send(buf, port, ip, (err) => {
+            if (err) {
+                console.error(`[UDP] send error: ${err.message}`);
+                this.emit('error', err);
+            }
+        });
     }
 }
 exports.UdpClient = UdpClient;

package/dist/types.d.ts

@@ -41,6 +41,10 @@ export interface IcomRigEvents {
     civFrame: (frame: Buffer) => void;
     audio: (frame: AudioFrame) => void;
     error: (err: Error) => void;
+    connectionLost: (info: ConnectionLostInfo) => void;
+    connectionRestored: (info: ConnectionRestoredInfo) => void;
+    reconnectAttempting: (info: ReconnectAttemptInfo) => void;
+    reconnectFailed: (info: ReconnectFailedInfo) => void;
 }
 export interface Disposable {
     dispose(): void;
@@ -158,3 +162,253 @@ 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
+ */
+export declare enum ConnectionState {
+    /** Connection is active and receiving data */
+    CONNECTED = "CONNECTED",
+    /** Connection has been lost (timeout detected) */
+    DISCONNECTED = "DISCONNECTED",
+    /** Attempting to restore connection */
+    RECONNECTING = "RECONNECTING"
+}
+/**
+ * Connection phase state machine
+ * Represents the high-level connection lifecycle state
+ */
+export declare enum ConnectionPhase {
+    /** Initial state or fully disconnected */
+    IDLE = "IDLE",
+    /** Establishing connection (AreYouThere, Login, sub-sessions) */
+    CONNECTING = "CONNECTING",
+    /** All sessions established and ready */
+    CONNECTED = "CONNECTED",
+    /** Actively disconnecting */
+    DISCONNECTING = "DISCONNECTING",
+    /** Attempting to reconnect after connection loss */
+    RECONNECTING = "RECONNECTING"
+}
+/**
+ * Connection session tracking information
+ * Used to prevent race conditions and track connection lifecycle
+ */
+export interface ConnectionSession {
+    /** Current connection phase */
+    phase: ConnectionPhase;
+    /** Unique session ID to prevent race conditions */
+    sessionId: number;
+    /** When this connection session started */
+    startTime: number;
+    /** When the connection was last lost (for downtime calculation) */
+    lastDisconnectTime?: number;
+}
+/**
+ * Connection metrics for observability
+ */
+export interface ConnectionMetrics {
+    /** Current connection phase */
+    phase: ConnectionPhase;
+    /** Current session ID */
+    sessionId: number;
+    /** Total uptime in milliseconds (since last successful connect) */
+    uptime: number;
+    /** Individual session states */
+    sessions: {
+        control: ConnectionState;
+        civ: ConnectionState;
+        audio: ConnectionState;
+    };
+    /** Last disconnect timestamp (if any) */
+    lastDisconnectTime?: number;
+    /** Whether currently reconnecting */
+    isReconnecting: boolean;
+}
+/**
+ * UDP session type identifier
+ */
+export declare enum SessionType {
+    /** Main control session (login, status, token management) */
+    CONTROL = "CONTROL",
+    /** CI-V command session */
+    CIV = "CIV",
+    /** Audio streaming session */
+    AUDIO = "AUDIO"
+}
+/**
+ * Information about a connection loss event
+ */
+export interface ConnectionLostInfo {
+    /** Which session lost connection */
+    sessionType: SessionType;
+    /** Reason for disconnection */
+    reason: string;
+    /** Time since last received data (ms) */
+    timeSinceLastData: number;
+    /** Timestamp when the event occurred */
+    timestamp: number;
+}
+/**
+ * Information about a connection restored event
+ */
+export interface ConnectionRestoredInfo {
+    /** Which session was restored */
+    sessionType: SessionType;
+    /** How long the connection was down (ms) */
+    downtime: number;
+    /** Timestamp when the connection was restored */
+    timestamp: number;
+}
+/**
+ * Information about a reconnection attempt
+ */
+export interface ReconnectAttemptInfo {
+    /** Which session is attempting to reconnect */
+    sessionType: SessionType;
+    /** Current attempt number (1-based) */
+    attemptNumber: number;
+    /** Delay before this attempt (ms) */
+    delay: number;
+    /** Timestamp of this attempt */
+    timestamp: number;
+    /** Whether this is a full reconnect (all sessions) */
+    fullReconnect: boolean;
+}
+/**
+ * Information about a failed reconnection attempt
+ */
+export interface ReconnectFailedInfo {
+    /** Which session failed to reconnect */
+    sessionType: SessionType;
+    /** Attempt number that failed */
+    attemptNumber: number;
+    /** Error that caused the failure */
+    error: string;
+    /** Timestamp of the failure */
+    timestamp: number;
+    /** Whether this was a full reconnect attempt */
+    fullReconnect: boolean;
+    /** Whether we will retry */
+    willRetry: boolean;
+    /** Next retry delay (ms), if retrying */
+    nextRetryDelay?: number;
+}
+/**
+ * Configuration for connection monitoring
+ */
+export interface ConnectionMonitorConfig {
+    /**
+     * Timeout threshold in milliseconds
+     * If no data received within this period, connection is considered lost
+     * Default: 5000ms (5 seconds)
+     */
+    timeout?: number;
+    /**
+     * How often to check for timeout (ms)
+     * Default: 1000ms (1 second)
+     */
+    checkInterval?: number;
+    /**
+     * Enable automatic reconnection attempts
+     * Default: false
+     */
+    autoReconnect?: boolean;
+    /**
+     * Maximum number of reconnection attempts
+     * Set to undefined for infinite retries
+     * Default: undefined (infinite retries)
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Base delay between reconnection attempts (ms)
+     * Uses exponential backoff: attempt N uses delay * 2^(N-1)
+     * Default: 2000ms (2 seconds)
+     */
+    reconnectBaseDelay?: number;
+    /**
+     * Maximum delay between reconnection attempts (ms)
+     * Caps the exponential backoff
+     * Default: 30000ms (30 seconds)
+     */
+    reconnectMaxDelay?: number;
+}

package/dist/types.js

@@ -1,2 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionType = exports.ConnectionPhase = exports.ConnectionState = void 0;
+// ============================================================================
+// Connection Monitoring Types
+// ============================================================================
+/**
+ * Connection state enumeration
+ * Represents the current state of a UDP session
+ */
+var ConnectionState;
+(function (ConnectionState) {
+    /** Connection is active and receiving data */
+    ConnectionState["CONNECTED"] = "CONNECTED";
+    /** Connection has been lost (timeout detected) */
+    ConnectionState["DISCONNECTED"] = "DISCONNECTED";
+    /** Attempting to restore connection */
+    ConnectionState["RECONNECTING"] = "RECONNECTING";
+})(ConnectionState || (exports.ConnectionState = ConnectionState = {}));
+/**
+ * Connection phase state machine
+ * Represents the high-level connection lifecycle state
+ */
+var ConnectionPhase;
+(function (ConnectionPhase) {
+    /** Initial state or fully disconnected */
+    ConnectionPhase["IDLE"] = "IDLE";
+    /** Establishing connection (AreYouThere, Login, sub-sessions) */
+    ConnectionPhase["CONNECTING"] = "CONNECTING";
+    /** All sessions established and ready */
+    ConnectionPhase["CONNECTED"] = "CONNECTED";
+    /** Actively disconnecting */
+    ConnectionPhase["DISCONNECTING"] = "DISCONNECTING";
+    /** Attempting to reconnect after connection loss */
+    ConnectionPhase["RECONNECTING"] = "RECONNECTING";
+})(ConnectionPhase || (exports.ConnectionPhase = ConnectionPhase = {}));
+/**
+ * UDP session type identifier
+ */
+var SessionType;
+(function (SessionType) {
+    /** Main control session (login, status, token management) */
+    SessionType["CONTROL"] = "CONTROL";
+    /** CI-V command session */
+    SessionType["CIV"] = "CIV";
+    /** Audio streaming session */
+    SessionType["AUDIO"] = "AUDIO";
+})(SessionType || (exports.SessionType = SessionType = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icom-wlan-node",
-  "version": "0.1.1",
+  "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",