knx.ts 1.0.0

package/dist/connection/KNXService.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNXService = void 0;
+const events_1 = require("events");
+const dgram_1 = __importDefault(require("dgram"));
+const KNXnetIPHeader_1 = require("../core/KNXnetIPHeader");
+const KNXnetIPStructures_1 = require("../core/KNXnetIPStructures");
+const KNXnetIPEnum_1 = require("../core/enum/KNXnetIPEnum");
+const localIp_1 = require("../utils/localIp");
+const KNXDataEncode_1 = require("../core/data/KNXDataEncode");
+const CEMI_1 = require("../core/CEMI");
+const ControlField_1 = require("../core/ControlField");
+const ControlFieldExtended_1 = require("../core/ControlFieldExtended");
+const TPDU_1 = require("../core/layers/data/TPDU");
+const TPCI_1 = require("../core/layers/interfaces/TPCI");
+const APDU_1 = require("../core/layers/data/APDU");
+const APCI_1 = require("../core/layers/interfaces/APCI");
+const APCIEnum_1 = require("../core/enum/APCIEnum");
+const Logger_1 = require("../utils/Logger");
+const KNXnetIPServer_1 = require("./KNXnetIPServer");
+const KNXHelper_1 = require("../utils/KNXHelper");
+const InvalidKnxAddresExeption_1 = require("../errors/InvalidKnxAddresExeption");
+class KNXService extends events_1.EventEmitter {
+    socket = null;
+    options;
+    _transport = "UDP";
+    logger;
+    constructor(options = {}) {
+        super();
+        this.options = {
+            ip: "224.0.23.12",
+            port: 3671,
+            localIp: (0, localIp_1.getLocalIP)(),
+            localPort: 0,
+            ...options,
+        };
+        if (this.options.logOptions) {
+            (0, Logger_1.setupLogger)(this.options.logOptions);
+        }
+        this.logger = Logger_1.knxLogger;
+    }
+    /**
+     * Send a GroupValue_Write telegram to a group address.
+     * @param destination The group address (e.g., "1/1/1")
+     * @param value The value to write.
+     * @param dpt Optional Datapoint Type to help with encoding.
+     */
+    async write(destination, dpt, value) {
+        let data;
+        let isShort = false;
+        // data validation
+        if (dpt !== undefined) {
+            data = KNXDataEncode_1.KnxDataEncoder.encodeThis(dpt, value);
+            isShort = KNXDataEncode_1.KnxDataEncoder.isShortDpt(dpt);
+        }
+        else if (typeof value === "boolean") {
+            data = Buffer.from([value ? 1 : 0]);
+            isShort = true;
+        }
+        else if (Buffer.isBuffer(value)) {
+            data = value;
+            isShort = data.length === 1 && data[0] <= 0x3f;
+        }
+        else if (typeof value === "number") {
+            data = Buffer.from([value]);
+            isShort = value <= 0x3f;
+        }
+        else {
+            throw new Error("Cannot encode value without DPT or basic type (boolean/number/Buffer)");
+        }
+        let cf2Value = 0;
+        if (KNXHelper_1.KNXHelper.isValidGroupAddress(destination)) {
+            cf2Value = 0xe0;
+        }
+        else if (KNXHelper_1.KNXHelper.isValidIndividualAddress(destination)) {
+            cf2Value = 0x60;
+        }
+        else {
+            throw new InvalidKnxAddresExeption_1.InvalidKnxAddressException(`This address ${destination} is not valid`);
+        }
+        const cf1 = new ControlField_1.ControlField(0xbc);
+        const cf2 = new ControlFieldExtended_1.ExtendedControlField(cf2Value);
+        const tpdu = new TPDU_1.TPDU(new TPCI_1.TPCI(TPCI_1.TPCIType.T_DATA_GROUP_PDU), new APDU_1.APDU(new TPCI_1.TPCI(TPCI_1.TPCIType.T_DATA_GROUP_PDU), new APCI_1.APCI(APCIEnum_1.APCIEnum.A_GroupValue_Write_Protocol_Data_Unit), data, isShort), data);
+        const cemi = new CEMI_1.CEMI.DataLinkLayerCEMI["L_Data.req"](null, cf1, cf2, this instanceof KNXnetIPServer_1.KNXnetIPServer ? this.individualAddress : "0.0.0", destination, tpdu);
+        this.logger.debug({ service: cemi.constructor.name }, "Sending GroupValue_Write");
+        return this.send(cemi);
+    }
+    /**
+     * Send a GroupValue_Read telegram to a group address.
+     * @param destination The group address (e.g., "1/1/1")
+     */
+    async read(destination) {
+        const cf1 = new ControlField_1.ControlField(0xbc);
+        const cf2 = new ControlFieldExtended_1.ExtendedControlField(0xe0);
+        const tpdu = new TPDU_1.TPDU(new TPCI_1.TPCI(TPCI_1.TPCIType.T_DATA_GROUP_PDU), new APDU_1.APDU(new TPCI_1.TPCI(TPCI_1.TPCIType.T_DATA_GROUP_PDU), new APCI_1.APCI(APCIEnum_1.APCIEnum.A_GroupValue_Read_Protocol_Data_Unit), Buffer.alloc(0)), Buffer.alloc(0));
+        const cemi = new CEMI_1.CEMI.DataLinkLayerCEMI["L_Data.req"](null, cf1, cf2, "0.0.0", destination, tpdu);
+        return this.send(cemi);
+    }
+    /**
+     * Discovery Process (Search Request)
+     */
+    static async discover(timeout = 3000, localIp) {
+        return new Promise((resolve, reject) => {
+            const socket = dgram_1.default.createSocket("udp4");
+            const devices = [];
+            const _localIp = localIp || (0, localIp_1.getLocalIP)();
+            socket.on("message", (msg, rinfo) => {
+                try {
+                    const header = KNXnetIPHeader_1.KNXnetIPHeader.fromBuffer(msg);
+                    if (header.serviceType === KNXnetIPEnum_1.KNXnetIPServiceType.SEARCH_RESPONSE) {
+                        const hpaiData = msg.subarray(6, 14);
+                        const hpai = KNXnetIPStructures_1.HPAI.fromBuffer(hpaiData);
+                        // Parse DIBs starting from byte 14
+                        const dibs = [];
+                        let offset = 14;
+                        while (offset < msg.length) {
+                            const dibLen = msg.readUInt8(offset);
+                            if (offset + dibLen > msg.length)
+                                break;
+                            const dibBuffer = msg.subarray(offset, offset + dibLen);
+                            dibs.push(KNXnetIPStructures_1.DIB.fromBuffer(dibBuffer));
+                            offset += dibLen;
+                        }
+                        devices.push({
+                            ip: hpai.ipAddress,
+                            port: hpai.port,
+                            dibs,
+                        });
+                    }
+                }
+                catch (e) {
+                    // Ignore malformed packets
+                }
+            });
+            socket.bind(() => {
+                const localHPAI = new KNXnetIPStructures_1.HPAI(KNXnetIPEnum_1.HostProtocolCode.IPV4_UDP, _localIp, socket.address().port);
+                const header = new KNXnetIPHeader_1.KNXnetIPHeader(KNXnetIPEnum_1.KNXnetIPServiceType.SEARCH_REQUEST, 0);
+                const hpaiBuffer = localHPAI.toBuffer();
+                header.totalLength = header.toBuffer().length + hpaiBuffer.length;
+                const packet = Buffer.concat([header.toBuffer(), hpaiBuffer]);
+                // Send to Multicast Address
+                socket.send(packet, 3671, "224.0.23.12");
+                setTimeout(() => {
+                    socket.close();
+                    resolve(devices);
+                }, timeout);
+            });
+        });
+    }
+    /**
+     * Extended Discovery Process (Search Request Extended)
+     * Allows searching with filters (SRPs).
+     */
+    static async discoverExtended(srps, timeout = 3000, localIp) {
+        return new Promise((resolve, reject) => {
+            const socket = dgram_1.default.createSocket("udp4");
+            const devices = [];
+            const _localIp = localIp || (0, localIp_1.getLocalIP)();
+            socket.on("message", (msg, rinfo) => {
+                try {
+                    const header = KNXnetIPHeader_1.KNXnetIPHeader.fromBuffer(msg);
+                    if (header.serviceType === KNXnetIPEnum_1.KNXnetIPServiceType.SEARCH_RESPONSE ||
+                        header.serviceType === KNXnetIPEnum_1.KNXnetIPServiceType.SEARCH_RESPONSE_EXTENDED) {
+                        // Extract IP/Port from HPAI
+                        const hpai = KNXnetIPStructures_1.HPAI.fromBuffer(msg.subarray(6, 14));
+                        const dibs = [];
+                        let offset = 14;
+                        while (offset < msg.length) {
+                            const dibLen = msg.readUInt8(offset);
+                            if (dibLen === 0)
+                                break;
+                            dibs.push(KNXnetIPStructures_1.DIB.fromBuffer(msg.subarray(offset, offset + dibLen)));
+                            offset += dibLen;
+                        }
+                        devices.push({ ip: hpai.ipAddress, port: hpai.port, dibs });
+                    }
+                }
+                catch (e) { }
+            });
+            socket.bind(() => {
+                const localHPAI = new KNXnetIPStructures_1.HPAI(KNXnetIPEnum_1.HostProtocolCode.IPV4_UDP, _localIp, socket.address().port);
+                const header = new KNXnetIPHeader_1.KNXnetIPHeader(KNXnetIPEnum_1.KNXnetIPServiceType.SEARCH_REQUEST_EXTENDED, 0);
+                const hpaiBuf = localHPAI.toBuffer();
+                const srpBufs = srps.map((s) => s.toBuffer());
+                const body = Buffer.concat([hpaiBuf, ...srpBufs]);
+                header.totalLength = 6 + body.length;
+                socket.send(Buffer.concat([header.toBuffer(), body]), 3671, "224.0.23.12");
+                setTimeout(() => {
+                    socket.close();
+                    resolve(devices);
+                }, timeout);
+            });
+        });
+    }
+    /**
+     * Description Request (Self Description)   * Queries a specific device for its capabilities.
+     */
+    async describe() {
+        return new Promise((resolve, reject) => {
+            // Description is usually connectionless via UDP on the Control Endpoint
+            const descSocket = dgram_1.default.createSocket("udp4");
+            const targetIp = this.options.ip;
+            const targetPort = this.options.port;
+            const timeout = setTimeout(() => {
+                descSocket.close();
+                reject(new Error("Description request timed out"));
+            }, 2000);
+            descSocket.on("message", (msg) => {
+                try {
+                    const header = KNXnetIPHeader_1.KNXnetIPHeader.fromBuffer(msg);
+                    if (header.serviceType === KNXnetIPEnum_1.KNXnetIPServiceType.DESCRIPTION_RESPONSE) {
+                        clearTimeout(timeout);
+                        // Similar parsing logic as Discovery
+                        const dibs = [];
+                        let offset = 6; // Header length
+                        while (offset < msg.length) {
+                            const dibLen = msg.readUInt8(offset);
+                            const dibBuffer = msg.subarray(offset, offset + dibLen);
+                            dibs.push(KNXnetIPStructures_1.DIB.fromBuffer(dibBuffer));
+                            offset += dibLen;
+                        }
+                        descSocket.close();
+                        resolve({ dibs });
+                    }
+                }
+                catch (e) { }
+            });
+            descSocket.bind(() => {
+                const localHPAI = new KNXnetIPStructures_1.HPAI(KNXnetIPEnum_1.HostProtocolCode.IPV4_UDP, this.options.localIp, descSocket.address().port);
+                const header = new KNXnetIPHeader_1.KNXnetIPHeader(KNXnetIPEnum_1.KNXnetIPServiceType.DESCRIPTION_REQUEST, 0);
+                const hpaiBuffer = localHPAI.toBuffer();
+                header.totalLength = 6 + hpaiBuffer.length;
+                const packet = Buffer.concat([header.toBuffer(), hpaiBuffer]);
+                descSocket.send(packet, targetPort, targetIp);
+            });
+        });
+    }
+}
+exports.KNXService = KNXService;

package/dist/connection/KNXTunneling.d.ts

@@ -0,0 +1,44 @@
+import { KNXService } from "./KNXService";
+import { ServiceMessage } from "../@types/interfaces/ServiceMessage";
+import { KNXTunnelingOptions } from "../@types/interfaces/connection";
+/**
+ * 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,
+ * heartbeat monitoring (ConnectionState), and message queuing over both UDP and TCP transports.
+ */
+export declare class KNXTunneling extends KNXService {
+    private channelId;
+    private sequenceNumber;
+    private rxSequenceNumber;
+    private isConnected;
+    private tcpBuffer;
+    assignedAddress: number;
+    private heartbeatTimer;
+    private heartbeatFailures;
+    private heartbeatRetryTimer;
+    private msgQueue;
+    private isSending;
+    private pendingAck;
+    private activeRequest;
+    private readonly MAX_QUEUE_SIZE;
+    private disconnectTimeout;
+    constructor(options: KNXTunnelingOptions);
+    connect(): Promise<void>;
+    private connectUDP;
+    private connectTCP;
+    private sendConnectRequest;
+    disconnect(): void;
+    private closeSocket;
+    send(cemi: ServiceMessage | Buffer): Promise<void>;
+    private processQueue;
+    private handleAckTimeout;
+    getFeature(featureId: number): Promise<Buffer>;
+    private handleMessage;
+    private handleRequest;
+    private sendAck;
+    private sendRaw;
+    private startHeartbeat;
+    private sendHeartbeatRequest;
+    private handleHeartbeatTimeout;
+    private stopHeartbeat;
+}