knx.ts 1.0.2 → 1.0.4

package/dist/connection/KNXTunneling.js

@@ -11,6 +11,7 @@ const KNXnetIPHeader_1 = require("../core/KNXnetIPHeader");
 const KNXnetIPStructures_1 = require("../core/KNXnetIPStructures");
 const KNXnetIPEnum_1 = require("../core/enum/KNXnetIPEnum");
 const CEMI_1 = require("../core/CEMI");
+const KNXHelper_1 = require("../utils/KNXHelper");
 /**
  * Handles KNXnet/IP Tunneling connections for point-to-point communication with a KNX gateway.
  * This class manages the connection state, sequence numbering for reliable delivery,
@@ -22,7 +23,7 @@ class KNXTunneling extends KNXService_1.KNXService {
     rxSequenceNumber = 0;
     isConnected = false;
     tcpBuffer = Buffer.alloc(0);
-    assignedAddress = 0; // Assigned Individual Address
+    individualAddress = "1.0.1"; // Assigned Individual Address
     // Heartbeat
     heartbeatTimer = null;
     heartbeatFailures = 0;
@@ -39,8 +40,7 @@ class KNXTunneling extends KNXService_1.KNXService {
         super(options);
         this._transport = options.transport || "UDP";
         if (!this.options.connectionType) {
-            this.options.connectionType =
-                KNXnetIPEnum_1.ConnectionType.TUNNEL_CONNECTION;
+            this.options.connectionType = KNXnetIPEnum_1.ConnectionType.TUNNEL_CONNECTION;
         }
         this.MAX_QUEUE_SIZE = options.maxQueueSize || 100;
         this.logger = this.logger.child({ module: "TunnelClient" });
@@ -69,7 +69,7 @@ class KNXTunneling extends KNXService_1.KNXService {
                 this.removeListener("connected", successListener);
                 reject(err);
             };
-            const successListener = (info) => {
+            const successListener = () => {
                 this.removeListener("error", errorListener); // Limpiamos el listener de error temporal
                 resolve();
             };
@@ -117,23 +117,14 @@ class KNXTunneling extends KNXService_1.KNXService {
         });
     }
     sendConnectRequest() {
-        const localPort = this._transport === "UDP"
-            ? this.socket.address().port
-            : this.socket.localPort;
+        const localPort = this._transport === "UDP" ? this.socket.address().port : this.socket.localPort;
         const useRouteBack = this.options.useRouteBack;
-        const hpai = new KNXnetIPStructures_1.HPAI(this._transport === "TCP"
-            ? KNXnetIPEnum_1.HostProtocolCode.IPV4_TCP
-            : KNXnetIPEnum_1.HostProtocolCode.IPV4_UDP, useRouteBack ? "0.0.0.0" : this.options.localIp, useRouteBack ? 0 : localPort);
-        // @ts-ignore
+        const hpai = new KNXnetIPStructures_1.HPAI(this._transport === "TCP" ? KNXnetIPEnum_1.HostProtocolCode.IPV4_TCP : KNXnetIPEnum_1.HostProtocolCode.IPV4_UDP, useRouteBack ? "0.0.0.0" : this.options.localIp, useRouteBack ? 0 : localPort);
         const cri = new KNXnetIPStructures_1.CRI(this.options.connectionType);
         const header = new KNXnetIPHeader_1.KNXnetIPHeader(KNXnetIPEnum_1.KNXnetIPServiceType.CONNECT_REQUEST, 0);
         // CORRECCIÓN
         // Estructura: HPAI (Control) -> HPAI (Data) -> CRI
-        const body = Buffer.concat([
-            hpai.toBuffer(),
-            hpai.toBuffer(),
-            cri.toBuffer(),
-        ]);
+        const body = Buffer.concat([hpai.toBuffer(), hpai.toBuffer(), cri.toBuffer()]);
         header.totalLength = 6 + body.length;
         this.sendRaw(Buffer.concat([header.toBuffer(), body]));
     }
@@ -143,14 +134,9 @@ class KNXTunneling extends KNXService_1.KNXService {
                 ? this.socket.address().port
                 : this.socket.localPort;
             const useRouteBack = this.options.useRouteBack;
-            const hpai = new KNXnetIPStructures_1.HPAI(this._transport === "TCP"
-                ? KNXnetIPEnum_1.HostProtocolCode.IPV4_TCP
-                : KNXnetIPEnum_1.HostProtocolCode.IPV4_UDP, useRouteBack ? "0.0.0.0" : this.options.localIp, useRouteBack ? 0 : localPort);
+            const hpai = new KNXnetIPStructures_1.HPAI(this._transport === "TCP" ? KNXnetIPEnum_1.HostProtocolCode.IPV4_TCP : KNXnetIPEnum_1.HostProtocolCode.IPV4_UDP, useRouteBack ? "0.0.0.0" : this.options.localIp, useRouteBack ? 0 : localPort);
             const header = new KNXnetIPHeader_1.KNXnetIPHeader(KNXnetIPEnum_1.KNXnetIPServiceType.DISCONNECT_REQUEST, 0);
-            const body = Buffer.concat([
-                Buffer.from([this.channelId, 0x00]),
-                hpai.toBuffer(),
-            ]);
+            const body = Buffer.concat([Buffer.from([this.channelId, 0x00]), hpai.toBuffer()]);
             header.totalLength = 6 + body.length;
             this.sendRaw(Buffer.concat([header.toBuffer(), body]));
             // Graceful disconnect: Wait for response or timeout (1s)
@@ -186,9 +172,9 @@ class KNXTunneling extends KNXService_1.KNXService {
         if (this.msgQueue.length >= this.MAX_QUEUE_SIZE) {
             throw new Error("Outgoing queue full");
         }
+        this.emit("send", cemi);
         const cemiBuffer = Buffer.isBuffer(cemi) ? cemi : cemi.toBuffer();
-        const isDeviceMgmt = this.options.connectionType ===
-            KNXnetIPEnum_1.ConnectionType.DEVICE_MGMT_CONNECTION;
+        const isDeviceMgmt = this.options.connectionType === KNXnetIPEnum_1.ConnectionType.DEVICE_MGMT_CONNECTION;
         const serviceType = isDeviceMgmt
             ? KNXnetIPEnum_1.KNXnetIPServiceType.DEVICE_CONFIGURATION_REQUEST
             : KNXnetIPEnum_1.KNXnetIPServiceType.TUNNELLING_REQUEST;
@@ -204,12 +190,7 @@ class KNXTunneling extends KNXService_1.KNXService {
         const msg = this.msgQueue.shift();
         this.activeRequest = msg;
         const header = new KNXnetIPHeader_1.KNXnetIPHeader(msg.serviceType, 0);
-        const connHeader = Buffer.from([
-            0x04,
-            this.channelId,
-            this.sequenceNumber,
-            0x00,
-        ]);
+        const connHeader = Buffer.from([0x04, this.channelId, this.sequenceNumber, 0x00]);
         header.totalLength = 6 + connHeader.length + msg.packet.length;
         const packet = Buffer.concat([header.toBuffer(), connHeader, msg.packet]);
         this.pendingAck = {
@@ -228,12 +209,7 @@ class KNXTunneling extends KNXService_1.KNXService {
             this.pendingAck.retryCount++;
             const msg = this.pendingAck.currentMsg;
             const header = new KNXnetIPHeader_1.KNXnetIPHeader(msg.serviceType, 0);
-            const connHeader = Buffer.from([
-                0x04,
-                this.channelId,
-                this.pendingAck.seq,
-                0x00,
-            ]);
+            const connHeader = Buffer.from([0x04, this.channelId, this.pendingAck.seq, 0x00]);
             header.totalLength = 6 + connHeader.length + msg.packet.length;
             const packet = Buffer.concat([header.toBuffer(), connHeader, msg.packet]);
             this.logger.warn(`ACK timeout for seq ${this.pendingAck.seq}, retrying (1/1)...`);
@@ -277,7 +253,7 @@ class KNXTunneling extends KNXService_1.KNXService {
             const header = KNXnetIPHeader_1.KNXnetIPHeader.fromBuffer(msg);
             const body = msg.subarray(6);
             switch (header.serviceType) {
-                case KNXnetIPEnum_1.KNXnetIPServiceType.CONNECT_RESPONSE:
+                case KNXnetIPEnum_1.KNXnetIPServiceType.CONNECT_RESPONSE: {
                     const status = body[1];
                     if (status === KNXnetIPEnum_1.KNXnetIPErrorCodes.E_NO_ERROR) {
                         this.channelId = body[0];
@@ -287,10 +263,10 @@ class KNXTunneling extends KNXService_1.KNXService {
                         // Parse CRD
                         if (body.length >= 14) {
                             const crd = KNXnetIPStructures_1.CRD.fromBuffer(body.subarray(10));
-                            this.assignedAddress = crd.knxAddress;
+                            this.individualAddress = KNXHelper_1.KNXHelper.GetAddress(crd.knxAddress, ".");
                             this.emit("connected", {
                                 channelId: this.channelId,
-                                assignedAddress: crd.knxAddress,
+                                individualAddress: this.individualAddress,
                             });
                         }
                         else {
@@ -302,6 +278,7 @@ class KNXTunneling extends KNXService_1.KNXService {
                         this.emit("error", new Error(`Connect Error: 0x${status.toString(16)}`));
                     }
                     break;
+                }
                 case KNXnetIPEnum_1.KNXnetIPServiceType.CONNECTIONSTATE_RESPONSE:
                     if (body[0] === this.channelId) {
                         if (body[1] === KNXnetIPEnum_1.KNXnetIPErrorCodes.E_NO_ERROR) {
@@ -324,10 +301,7 @@ class KNXTunneling extends KNXService_1.KNXService {
                 case KNXnetIPEnum_1.KNXnetIPServiceType.CONNECTIONSTATE_REQUEST:
                     if (body[0] === this.channelId) {
                         const respHeader = new KNXnetIPHeader_1.KNXnetIPHeader(KNXnetIPEnum_1.KNXnetIPServiceType.CONNECTIONSTATE_RESPONSE, 0);
-                        const respBody = Buffer.from([
-                            this.channelId,
-                            KNXnetIPEnum_1.KNXnetIPErrorCodes.E_NO_ERROR,
-                        ]);
+                        const respBody = Buffer.from([this.channelId, KNXnetIPEnum_1.KNXnetIPErrorCodes.E_NO_ERROR]);
                         respHeader.totalLength = 6 + respBody.length;
                         this.sendRaw(Buffer.concat([respHeader.toBuffer(), respBody]));
                     }
@@ -370,12 +344,8 @@ class KNXTunneling extends KNXService_1.KNXService {
                     break;
                 case KNXnetIPEnum_1.KNXnetIPServiceType.TUNNELLING_FEATURE_RESPONSE:
                     // Body: ConnHeader(4) + FeatureID(1) + ReturnCode(1) + Value(n)
-                    if (this.isSending &&
-                        this.activeRequest?.responseType ===
-                            KNXnetIPEnum_1.KNXnetIPServiceType.TUNNELLING_FEATURE_RESPONSE) {
-                        if (body[0] === 0x04 &&
-                            body[1] === this.channelId &&
-                            body[2] === this.sequenceNumber) {
+                    if (this.isSending && this.activeRequest?.responseType === KNXnetIPEnum_1.KNXnetIPServiceType.TUNNELLING_FEATURE_RESPONSE) {
+                        if (body[0] === 0x04 && body[1] === this.channelId && body[2] === this.sequenceNumber) {
                             const returnCode = body[5];
                             const val = body.subarray(6);
                             const resolve = this.activeRequest.resolve;
@@ -427,9 +397,15 @@ class KNXTunneling extends KNXService_1.KNXService {
                 const data = body.subarray(len);
                 const cemi = CEMI_1.CEMI.fromBuffer(data);
                 this.emit("indication", cemi);
+                if (!("destinationAddress" in cemi))
+                    return;
+                this.emit(cemi.destinationAddress, cemi);
                 this.emit("raw_indication", data);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (e) {
+                /* empty */
             }
-            catch (e) { }
         }
         else if (seq === ((this.rxSequenceNumber - 1) & 0xff)) {
             // Duplicate frame, send ACK again but don't process
@@ -450,7 +426,11 @@ class KNXTunneling extends KNXService_1.KNXService {
         if (!this.socket)
             return;
         if (this._transport === "UDP") {
-            this.socket.send(buffer, this.options.port, this.options.ip);
+            this.socket.send(buffer, this.options.port, this.options.ip, (err) => {
+                if (err) {
+                    this.emit("error", err);
+                }
+            });
         }
         else {
             this.socket.write(buffer);
@@ -466,18 +446,11 @@ class KNXTunneling extends KNXService_1.KNXService {
         }, 60000);
     }
     sendHeartbeatRequest() {
-        const localPort = this._transport === "UDP"
-            ? this.socket.address().port
-            : this.socket.localPort;
+        const localPort = this._transport === "UDP" ? this.socket.address().port : this.socket.localPort;
         const useRouteBack = this.options.useRouteBack;
-        const hpai = new KNXnetIPStructures_1.HPAI(this._transport === "TCP"
-            ? KNXnetIPEnum_1.HostProtocolCode.IPV4_TCP
-            : KNXnetIPEnum_1.HostProtocolCode.IPV4_UDP, useRouteBack ? "0.0.0.0" : this.options.localIp, useRouteBack ? 0 : localPort);
+        const hpai = new KNXnetIPStructures_1.HPAI(this._transport === "TCP" ? KNXnetIPEnum_1.HostProtocolCode.IPV4_TCP : KNXnetIPEnum_1.HostProtocolCode.IPV4_UDP, useRouteBack ? "0.0.0.0" : this.options.localIp, useRouteBack ? 0 : localPort);
         const header = new KNXnetIPHeader_1.KNXnetIPHeader(KNXnetIPEnum_1.KNXnetIPServiceType.CONNECTIONSTATE_REQUEST, 0);
-        const body = Buffer.concat([
-            Buffer.from([this.channelId, 0x00]),
-            hpai.toBuffer(),
-        ]);
+        const body = Buffer.concat([Buffer.from([this.channelId, 0x00]), hpai.toBuffer()]);
         header.totalLength = 6 + body.length;
         this.sendRaw(Buffer.concat([header.toBuffer(), body]));
         // Check timeout in 10s (spec recommendation)

package/dist/connection/KNXUSBConnection.d.ts

@@ -0,0 +1,20 @@
+import { KNXService } from "./KNXService";
+import { CEMIInstance } from "../core/CEMI";
+import { KNXUSBOptions } from "../@types/interfaces/connection";
+export declare class KNXUSBConnection extends KNXService<KNXUSBOptions> {
+    private device;
+    private isConnected;
+    private busConnected;
+    private supportedEmiType;
+    constructor(options: KNXUSBOptions);
+    connect(): Promise<void>;
+    disconnect(): void;
+    private initializeDevice;
+    private discoverEmiType;
+    private sendUSBTransfer;
+    private sendHIDReport;
+    send(data: Buffer | CEMIInstance): Promise<void>;
+    private handleData;
+    private processTransferFrame;
+    private handleError;
+}

package/dist/connection/KNXUSBConnection.js

@@ -0,0 +1,358 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNXUSBConnection = void 0;
+const hid = __importStar(require("node-hid"));
+const KNXService_1 = require("./KNXService");
+const CEMIAdapter_1 = require("../utils/CEMIAdapter");
+const CEMI_1 = require("../core/CEMI");
+class KNXUSBConnection extends KNXService_1.KNXService {
+    device = null;
+    isConnected = false;
+    busConnected = false;
+    supportedEmiType = 0x03;
+    constructor(options) {
+        super(options);
+        this.logger = this.logger.child({ module: "KNXUSBConnection" });
+    }
+    async connect() {
+        if (this.isConnected)
+            return;
+        return new Promise((resolve, reject) => {
+            try {
+                const options = this.options;
+                let devicePath = options.path;
+                if (!devicePath) {
+                    const devices = hid.devices();
+                    const knxDevice = devices.find((d) => (options.vendorId &&
+                        d.vendorId === options.vendorId &&
+                        options.productId &&
+                        d.productId === options.productId) ||
+                        d.vendorId === 0x28c2 || // Zennio
+                        d.vendorId === 0x145c || // ABB/Busch-Jaeger
+                        d.vendorId === 0x10a6 || // MDT
+                        d.vendorId === 0x135e || // Siemens
+                        d.vendorId === 0x0e77 || // Weinzierl/Siemens
+                        d.vendorId === 0x147b || // Weinzierl
+                        d.vendorId === 0x16d0 || // MCS
+                        (d.product && d.product.toLowerCase().includes("knx")));
+                    if (!knxDevice || !knxDevice.path) {
+                        throw new Error("No KNX USB device found");
+                    }
+                    devicePath = knxDevice.path;
+                }
+                this.logger.info(`Opening KNX USB device at ${devicePath}`);
+                this.device = new hid.HID(devicePath);
+                this.device.on("data", (data) => {
+                    this.handleData(data);
+                });
+                this.device.on("error", (err) => this.handleError(err));
+                this.isConnected = true;
+                this.busConnected = false;
+                this.initializeDevice()
+                    .then(() => {
+                    this.emit("connected");
+                    resolve();
+                })
+                    .catch((err) => {
+                    this.logger.error("Failed to initialize KNX USB: " + err);
+                    this.disconnect();
+                    reject(err);
+                });
+            }
+            catch (err) {
+                this.logger.error("Failed to connect to KNX USB: " + err);
+                reject(err);
+            }
+        });
+    }
+    disconnect() {
+        if (!this.isConnected || !this.device)
+            return;
+        try {
+            this.device.close();
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            // Ignore close errors
+        }
+        finally {
+            this.device = null;
+            this.isConnected = false;
+            this.busConnected = false;
+            this.emit("disconnected");
+        }
+    }
+    async initializeDevice() {
+        // 1. Discover supported EMI types FIRST before sending any resets that might lock up older interfaces
+        // knxd implementation uses up to 5 retries for EMI discovery
+        await this.discoverEmiType();
+        // 2. Set active EMI type to the discovered type
+        // protocolId: 0x0f (BusAccessServerFeatureService)
+        // emiId: 0x03 (service device feature set), feature: 0x05, value: this.supportedEmiType
+        await this.sendUSBTransfer(0x0f, 0x03, Buffer.from([0x05, this.supportedEmiType]));
+        await new Promise((r) => setTimeout(r, 100));
+        if (this.supportedEmiType === 0x03) {
+            // 3. cEMI Specific Initialization
+            // Send Reset Request (M_RESET_REQ = 0xF1)
+            await this.sendUSBTransfer(0x01, 0x03, Buffer.from([0xf1]));
+            await new Promise((r) => setTimeout(r, 100));
+            // Set Comm Mode (PID_COMM_MODE)
+            // M_PROP_WRITE_REQ (0xF6), ObjType (0x0008), ObjInst (0x01), PropId (0x34), Elements (1) + StartIdx (1) -> 0x1001, Mode: 0x00 (DataLinkLayer)
+            const commModeBuf = Buffer.from([
+                0xf6, // M_PROP_WRITE_REQ
+                0x00,
+                0x08, // Interface Object
+                0x01, // Object Instance
+                0x34, // Property ID (52)
+                0x10,
+                0x01, // Elements + Start Index
+                0x00, // Data (DataLinkLayer, 0x00)
+            ]);
+            await this.sendUSBTransfer(0x01, 0x03, commModeBuf);
+            await new Promise((r) => setTimeout(r, 100));
+        }
+    }
+    async discoverEmiType() {
+        return new Promise((resolve) => {
+            let attempts = 0;
+            let timeout;
+            const attemptDiscovery = () => {
+                attempts++;
+                this.sendUSBTransfer(0x0f, 0x01, Buffer.from([0x01])).catch((e) => {
+                    this.logger.error("Error sending EMI discovery: " + e);
+                });
+                timeout = setTimeout(() => {
+                    if (attempts < 5) {
+                        attemptDiscovery();
+                    }
+                    else {
+                        this.removeListener("emi_discovery", onDiscovery);
+                        this.logger.warn("EMI discovery timeout, defaulting to cEMI");
+                        this.supportedEmiType = 0x03;
+                        resolve();
+                    }
+                }, 1000); // 1 second timeout for each retry like knxd
+            };
+            const onDiscovery = (version) => {
+                clearTimeout(timeout);
+                this.supportedEmiType = version;
+                this.logger.info(`Discovered EMI version: ${version === 0x03 ? "cEMI" : version === 0x01 ? "EMI1" : "EMI2"}`);
+                resolve();
+            };
+            this.once("emi_discovery", onDiscovery);
+            attemptDiscovery();
+        });
+    }
+    async sendUSBTransfer(protocolId, emiId, data) {
+        if (!this.device)
+            throw new Error("Device offline");
+        const header = Buffer.alloc(8);
+        header[0] = 0x00; // protocol version
+        header[1] = 0x08; // header length
+        header.writeUInt16BE(data.length, 2); // body length
+        header[4] = protocolId;
+        header[5] = emiId;
+        header.writeUInt16BE(0x0000, 6); // manufacturer code
+        const body = Buffer.concat([header, data]);
+        this.sendHIDReport(body);
+    }
+    sendHIDReport(data) {
+        if (!this.device)
+            return;
+        if (data.length > 61) {
+            this.logger.error("KNX USB: Frame too long for single packet, and knxd logic does not support fragmentation");
+            return;
+        }
+        // knxd perfectly sizes each USB send to exactly 64 bytes padded with 0
+        const report = Buffer.alloc(64);
+        report[0] = 0x01; // Report ID
+        report[1] = 0x13; // Sequence=1, Type=3 (single-frame packet)
+        report[2] = data.length;
+        data.copy(report, 3);
+        try {
+            this.device.write(report);
+        }
+        catch (e) {
+            this.logger.error("Failed to write to KNX USB device: " + e);
+            this.handleError(e);
+        }
+    }
+    async send(data) {
+        if (!this.isConnected || !this.device) {
+            throw new Error("KNX USB device offline");
+        }
+        try {
+            let frame;
+            if (this.supportedEmiType === 0x03) {
+                if (Buffer.isBuffer(data)) {
+                    frame = data;
+                }
+                else {
+                    frame = data.toBuffer();
+                }
+            }
+            else {
+                // EMI1 / EMI2 mode
+                let emiMsg = null;
+                if (Buffer.isBuffer(data)) {
+                    frame = data;
+                }
+                else {
+                    this.logger.debug("Converting cEMI to EMI");
+                    emiMsg = CEMIAdapter_1.CEMIAdapter.cemiToEmi(data);
+                }
+                if (emiMsg) {
+                    frame = emiMsg.toBuffer();
+                }
+            }
+            if (frame) {
+                this.emit("send", frame);
+                await this.sendUSBTransfer(0x01, this.supportedEmiType, frame);
+            }
+        }
+        catch (err) {
+            this.logger.error("Error sending to USB:" + err);
+            throw err;
+        }
+    }
+    handleData(data) {
+        if (data.length < 3 || data[0] !== 0x01)
+            return;
+        // knxd strictly processes single-frame packets
+        if ((data[1] & 0x0f) !== 0x03)
+            return;
+        // Connection State Check based on knxd USBLowLevelDriver logic
+        const wanted = Buffer.from([0x01, 0x13, 0x0a, 0x00, 0x08, 0x00, 0x02, 0x0f, 0x04, 0x00, 0x00, 0x03]);
+        if (data.length >= 12 && data.subarray(0, 12).equals(wanted)) {
+            const isConnectedToBus = (data[12] & 0x01) === 1;
+            if (isConnectedToBus) {
+                if (!this.busConnected) {
+                    this.busConnected = true;
+                    this.logger.info("KNX Bus Connected");
+                    this.emit("bus_connected");
+                }
+            }
+            else {
+                if (this.busConnected) {
+                    this.busConnected = false;
+                    this.logger.error("KNX Bus Disconnected");
+                    this.emit("bus_disconnected");
+                }
+            }
+            return;
+        }
+        const bodyLength = data[2];
+        if (3 + bodyLength > data.length)
+            return;
+        const body = data.subarray(3, 3 + bodyLength);
+        this.processTransferFrame(body);
+    }
+    processTransferFrame(buffer) {
+        if (buffer.length < 8)
+            return;
+        const headerLength = buffer[1];
+        const bodyLength = buffer.readUInt16BE(2);
+        const protocolId = buffer[4];
+        const emiId = buffer[5];
+        if (headerLength !== 0x08 || buffer.length < headerLength + bodyLength)
+            return;
+        const bodyStart = headerLength;
+        const payload = buffer.subarray(bodyStart, bodyStart + bodyLength);
+        if (protocolId === 0x0f && emiId === 0x02 && payload.length >= 3 && payload[0] === 0x01) {
+            // EMI Discovery response, implementing exact knxd fallback logic
+            const bitmask = payload[2];
+            let version = 0x03; // fallback to cEMI
+            if (bitmask & 0x02)
+                version = 0x02; // vEMI2
+            else if (bitmask & 0x01)
+                version = 0x01; // vEMI1
+            else if (bitmask & 0x04)
+                version = 0x03; // vCEMI
+            else {
+                this.logger.warn(`EMI version bitmask 0x${bitmask.toString(16)} not recognized, defaulting to cEMI`);
+                version = 0x03;
+            }
+            this.emit("emi_discovery", version);
+            return;
+        }
+        if (protocolId === 0x01 && emiId === this.supportedEmiType) {
+            if (payload.length > 0) {
+                if (this.supportedEmiType === 0x03) {
+                    // cEMI
+                    try {
+                        const cemiMsg = CEMI_1.CEMI.fromBuffer(payload);
+                        if (cemiMsg) {
+                            this.emit("indication", cemiMsg);
+                            this.emit("raw_indication", payload);
+                            try {
+                                const emiMsg = CEMIAdapter_1.CEMIAdapter.cemiToEmi(cemiMsg);
+                                if (emiMsg)
+                                    this.emit("indication_emi", emiMsg);
+                                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                            }
+                            catch (e) {
+                                /* empty */
+                            }
+                        }
+                    }
+                    catch (e) {
+                        this.logger.debug(`Error parsing incoming USB cEMI data: ${e.message}`);
+                    }
+                }
+                else {
+                    // EMI1 / EMI2
+                    try {
+                        const cemiMsg = CEMIAdapter_1.CEMIAdapter.emiToCemi(payload);
+                        if (cemiMsg) {
+                            this.emit("indication", cemiMsg);
+                            this.emit("raw_indication", payload);
+                        }
+                    }
+                    catch (e) {
+                        this.logger.debug(`Error parsing incoming USB EMI data: ${e.message}`);
+                    }
+                }
+            }
+        }
+    }
+    handleError(err) {
+        this.logger.error("KNX USB Error:", err);
+        this.isConnected = false;
+        this.busConnected = false;
+        this.emit("error", err);
+    }
+}
+exports.KNXUSBConnection = KNXUSBConnection;

package/dist/connection/KNXnetIPServer.d.ts

@@ -1,14 +1,14 @@
 import { KNXService } from "./KNXService";
-import { ServiceMessage } from "../@types/interfaces/ServiceMessage";
-import { KNXnetIPServerOptions } from "../@types/interfaces/connection";
+import { CEMIInstance } from "../core/CEMI";
+import { KNXDiscoveredDevice, KNXnetIPServerOptions } from "../@types/interfaces/connection";
 /**
-  * Implements a KNXnet/IP Server (Gateway) that supports Routing and Tunneling protocols.
-  * This class handles device discovery (Search/Description), manages multiple concurrent
-  * tunneling connections, and bridges communication between IP multicast (Routing) and
-  * point-to-point (Tunneling) clients. It includes implementation for flow control
-  * (RoutingBusy), rate limiting, and echo cancellation.
-  */
-export declare class KNXnetIPServer extends KNXService {
+ * Implements a KNXnet/IP Server (Gateway) that supports Routing and Tunneling protocols.
+ * This class handles device discovery (Search/Description), manages multiple concurrent
+ * tunneling connections, and bridges communication between IP multicast (Routing) and
+ * point-to-point (Tunneling) clients. It includes implementation for flow control
+ * (RoutingBusy), rate limiting, and echo cancellation.
+ */
+export declare class KNXnetIPServer extends KNXService<KNXnetIPServerOptions> {
     private isRoutingBusy;
     private routingBusyTimer;
     private msgQueue;
@@ -20,6 +20,8 @@ export declare class KNXnetIPServer extends KNXService {
     private decrementInterval;
     private serverIAInt;
     private _tunnelConnections;
+    isCacheDelegated: boolean;
+    isEventsDelegated: boolean;
     private readonly MAX_QUEUE_SIZE;
     private readonly BUSY_THRESHOLD;
     private readonly HEARTBEAT_TIMEOUT;
@@ -27,14 +29,29 @@ export declare class KNXnetIPServer extends KNXService {
     private MAX_PENDING_REQUESTS_PER_CLIENT;
     private maxTunnelConnections;
     private clientAddrsStartInt;
-    private externalManager;
     constructor(options: KNXnetIPServerOptions);
-    get individualAddress(): string;
     connect(): Promise<void>;
     disconnect(): void;
+    /**
+     * Discovers KNXnet/IP devices on the network by sending SEARCH_REQUEST and SEARCH_REQUEST_EXTENDED
+     * multicasts to 224.0.23.12:3671. Returns an array of discovered devices with their properties.
+     *
+     * @param timeout Wait time in milliseconds for responses
+     * @param useExtended Whether to send SEARCH_REQUEST_EXTENDED alongside SEARCH_REQUEST
+     * @returns Promise resolving to an array of discovered devices
+     */
+    static discover(ipLocal?: string, ipMulticast?: string, port?: number, timeout?: number, useExtended?: boolean): Promise<KNXDiscoveredDevice[]>;
     private resolveRouteBack;
     private clearTimers;
-    send(data: Buffer | ServiceMessage): Promise<void>;
+    /**
+     * Send a CEMI message or buffer CEMI to the bus.
+     * @param data The CEMI message or buffer to send.
+     */
+    send(data: Buffer | CEMIInstance): Promise<void>;
+    /**
+     * Send a raw CEMI buffer to the bus.
+     * @param cemiBuffer The CEMI buffer to send.
+     */
     sendRaw(cemiBuffer: Buffer): Promise<void>;
     private enqueuePacket;
     private sendLostMessage;