knx.ts 1.0.2 → 1.0.4

package/dist/connection/Router.d.ts

@@ -1,40 +1,33 @@
 import { EventEmitter } from "events";
 import { KNXService } from "./KNXService";
-import { ExternalManagerOptions } from "../@types/interfaces/connection";
+import { RouterConnOptions } from "../@types/interfaces/connection";
+import { CEMIInstance } from "../core/CEMI";
+import { KnxDataEncoder } from "../core/data/KNXDataEncode";
+import { AllDpts } from "../@types/types/AllDpts";
 /**
- * Router: A high-performance, robust Learning Bridge.
- * Architecture strictly follows knxd/src/libserver/router.cpp patterns:
- * 1. Loop Prevention via signature tracking AND Repeat Flag analysis.
- * 2. IA Learning & Selective Routing.
- * 3. Source Address Patching & Sanitization.
- * 4. Client Address Pool Management (KNXnet/IP Tunneling).
+ * Router: A robust, high-performance learning bridge.
+ * The architecture is based on the patterns in the knxd repository at knxd/src/libserver/router.cpp:
+ * 1. Loop prevention through destination address tracking.
+ * 2. AI learning and selective routing.
+ * 3. Source address correction and sanitization.
+ * 4. Address filtering between KNXnetIP and other connections, and vice versa.
  */
 export declare class Router extends EventEmitter {
-    private links;
-    private addressTable;
-    private recentSignatures;
+    readonly links: Map<string, KNXService>;
+    readonly addressTable: Map<string, {
+        link: KNXService;
+        key: string;
+    }>;
+    private recentDestinationAddress;
     private readonly MAX_SIGNATURES_SIZE;
-    private routerAddress;
-    private clientAddrsStart;
-    private clientAddrsCount;
-    private clientAddrsUsed;
+    routerAddress: string;
     private logger;
-    constructor(options: ExternalManagerOptions & {
-        routerAddress?: string;
-        clientAddrs?: string;
-    });
-    /**
-     * Allocates a free physical address for a tunneling client.
-     */
-    getClientAddress(): string | null;
-    /**
-     * Releases an allocated physical address when a client disconnects.
-     */
-    releaseClientAddress(addr: string): void;
-    private addrToInt;
-    private intToAddr;
-    registerLink(link: KNXService): void;
-    unregisterLink(link: KNXService): void;
+    private gcInterval;
+    readonly toIPFilter: RouterConnOptions["toIpFilter"];
+    readonly toLocalFilter: RouterConnOptions["toLocalFilter"];
+    constructor(options: RouterConnOptions);
+    registerLink(key: string, link: KNXService): void;
+    unregisterLink(key: string | "TPUART" | "KNXUSB"): void;
     /**
      * Main entry point for any packet received from any link.
      * Based on knxd's Router::recv_L_Data and Router::trigger_cb logic.
@@ -42,8 +35,35 @@ export declare class Router extends EventEmitter {
     private processIncoming;
     private learnAddress;
     private route;
-    private getSignature;
-    private gcSignatures;
+    /**
+     * Evaluates if a message should be sent to a link based on configured filters.
+     * Logic: Skip if the policy is "discard all" and the address matches.
+     * Otherwise, send if the address is in the filter list or no filter exists.
+     */
+    private evaluateFilter;
+    private evaluateLocalFilter;
+    private evaluateIpFilter;
+    /**
+     * Sends data to a link with error handling.
+     */
+    private sendToLink;
+    /**
+     * Broadcasts a CEMI message to all registered links.
+     */
+    send(cemi: CEMIInstance): Promise<void>;
+    /**
+     * Send a GroupValue_Read telegram to a group address to all registered links.
+     * @param destination The group address (e.g., "1/1/1")
+     */
+    read(destination: string): Promise<void>;
+    /**
+     * 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.
+     */
+    write<T extends (typeof KnxDataEncoder.dptEnum)[number] | string | null>(destination: string, dpt: T, value: AllDpts<T>): Promise<void>;
+    private gcDestinationAddress;
     connect(): Promise<void>;
     disconnect(): void;
 }

package/dist/connection/Router.js

@@ -4,126 +4,114 @@ exports.Router = void 0;
 const events_1 = require("events");
 const TPUART_1 = require("./TPUART");
 const KNXTunneling_1 = require("./KNXTunneling");
+const KNXUSBConnection_1 = require("./KNXUSBConnection");
 const Logger_1 = require("../utils/Logger");
+const CEMI_1 = require("../core/CEMI");
+const KNXnetIPServer_1 = require("./KNXnetIPServer");
+const GroupAddressCache_1 = require("../core/cache/GroupAddressCache");
+const KNXDataEncode_1 = require("../core/data/KNXDataEncode");
+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");
 /**
- * Router: A high-performance, robust Learning Bridge.
- * Architecture strictly follows knxd/src/libserver/router.cpp patterns:
- * 1. Loop Prevention via signature tracking AND Repeat Flag analysis.
- * 2. IA Learning & Selective Routing.
- * 3. Source Address Patching & Sanitization.
- * 4. Client Address Pool Management (KNXnet/IP Tunneling).
+ * Router: A robust, high-performance learning bridge.
+ * The architecture is based on the patterns in the knxd repository at knxd/src/libserver/router.cpp:
+ * 1. Loop prevention through destination address tracking.
+ * 2. AI learning and selective routing.
+ * 3. Source address correction and sanitization.
+ * 4. Address filtering between KNXnetIP and other connections, and vice versa.
  */
 class Router extends events_1.EventEmitter {
-    links = new Set();
+    links = new Map();
     addressTable = new Map();
     // knxd 'ignore' list: prevents infinite loops across different physical paths
     // Only ignores frames if they are marked as repeated in the KNX Control Field.
-    recentSignatures = new Map();
+    recentDestinationAddress = new Map();
     MAX_SIGNATURES_SIZE = 10000;
     routerAddress = "15.15.0"; // Default, should be configurable
-    // Dynamic address pool for clients (like KNXnet/IP Tunneling)
-    clientAddrsStart = null;
-    clientAddrsCount = 0;
-    clientAddrsUsed = [];
     logger;
+    gcInterval;
+    toIPFilter = {};
+    toLocalFilter = {};
     constructor(options) {
         super();
-        if (options.logOptions) {
-            (0, Logger_1.setupLogger)(options.logOptions);
-        }
         this.logger = Logger_1.knxLogger.child({ module: "Router" });
         if (options.routerAddress)
             this.routerAddress = options.routerAddress;
-        // Parse client addrs e.g. "15.15.10:10"
-        if (options.clientAddrs) {
-            const parts = options.clientAddrs.split(":");
-            if (parts.length === 2) {
-                this.clientAddrsStart = parts[0];
-                this.clientAddrsCount = parseInt(parts[1], 10);
-                this.clientAddrsUsed = new Array(this.clientAddrsCount).fill(false);
-            }
+        if (options.toIpFilter) {
+            this.toIPFilter = options.toIpFilter;
         }
-        if (options.tpuart)
-            this.registerLink(new TPUART_1.TPUARTConnection(options.tpuart));
-        if (options.tunneling)
-            options.tunneling.forEach((c) => this.registerLink(new KNXTunneling_1.KNXTunneling(c)));
-        this.logger.info(`Router initialized at ${this.routerAddress}`);
-        // Periodically clean the signature cache (knxd pattern)
-        setInterval(() => this.gcSignatures(), 1000);
-    }
-    /**
-     * Allocates a free physical address for a tunneling client.
-     */
-    getClientAddress() {
-        if (!this.clientAddrsStart || this.clientAddrsCount === 0)
-            return null;
-        const startInt = this.addrToInt(this.clientAddrsStart);
-        for (let i = 0; i < this.clientAddrsCount; i++) {
-            if (!this.clientAddrsUsed[i]) {
-                this.clientAddrsUsed[i] = true;
-                return this.intToAddr(startInt + i);
-            }
+        if (options.toLocalFilter) {
+            this.toLocalFilter = options.toLocalFilter;
         }
-        return null; // Pool exhausted
-    }
-    /**
-     * Releases an allocated physical address when a client disconnects.
-     */
-    releaseClientAddress(addr) {
-        if (!this.clientAddrsStart || this.clientAddrsCount === 0)
-            return;
-        const startInt = this.addrToInt(this.clientAddrsStart);
-        const addrInt = this.addrToInt(addr);
-        const index = addrInt - startInt;
-        if (index >= 0 && index < this.clientAddrsCount) {
-            this.clientAddrsUsed[index] = false;
+        if (options.knxNetIpServer) {
+            options.knxNetIpServer.individualAddress = this.routerAddress;
+            const ipServer = new KNXnetIPServer_1.KNXnetIPServer(options.knxNetIpServer);
+            ipServer.isCacheDelegated = true;
+            ipServer.isEventsDelegated = true;
+            this.registerLink(`IP KNXnet/IP Server: ${ipServer.options.localIp}:${ipServer.options.port}`, ipServer);
         }
+        if (options.tpuart) {
+            options.tpuart.individualAddress = this.routerAddress;
+            this.registerLink("TPUART", new TPUART_1.TPUARTConnection(options.tpuart));
+        }
+        if (options.tunneling) {
+            options.tunneling.forEach((c) => {
+                // * Tunneling doesn't support individualAddress, is assigned by the tunnel connection
+                // c.individualAddress = this.routerAddress;
+                this.registerLink(`IP Tunneling: ${c.ip}:${c.port}`, new KNXTunneling_1.KNXTunneling(c));
+            });
+        }
+        if (options.usb) {
+            options.usb.individualAddress = this.routerAddress;
+            this.registerLink("KNXUSB", new KNXUSBConnection_1.KNXUSBConnection(options.usb));
+        }
+        this.logger.info(`Router initialized at ${this.routerAddress}`);
+        // Periodically clean the signature cache (knxd pattern)
+        this.gcInterval = setInterval(() => this.gcDestinationAddress(), 1000);
     }
-    addrToInt(addr) {
-        const [a, b, c] = addr.split(".").map(Number);
-        return ((a & 0x0f) << 12) | ((b & 0x0f) << 8) | (c & 0xff);
-    }
-    intToAddr(val) {
-        return `${(val >> 12) & 0x0f}.${(val >> 8) & 0x0f}.${val & 0xff}`;
-    }
-    registerLink(link) {
-        if (this.links.has(link))
+    registerLink(key, link) {
+        if (this.links.has(key))
             return;
-        this.links.add(link);
-        this.logger.info(`Link registered: ${link.constructor.name}`);
+        this.links.set(key, link);
+        this.logger.info(`Link registered: ${key}`);
         link.on("indication", (cemi) => {
-            this.processIncoming(cemi, link);
+            this.processIncoming(cemi, link, key);
         });
         link.on("error", (err) => {
-            this.logger.error({ link: link.constructor.name, err: err.message }, "Link error");
+            this.logger.error({ link: key, err: err.message }, "Link error");
             this.emit("error", { link, error: err });
         });
         // knxd pattern: cleanup when link goes down
         link.on("disconnected", () => {
-            this.logger.info(`Link disconnected: ${link.constructor.name}`);
-            this.unregisterLink(link);
+            this.logger.info(`Link disconnected: ${key}`);
+            this.unregisterLink(key);
         });
     }
-    unregisterLink(link) {
-        if (!this.links.has(link))
+    unregisterLink(key) {
+        if (!this.links.has(key))
             return;
         // Cleanup routing table
         for (const [addr, l] of this.addressTable.entries()) {
-            if (l === link) {
+            if (l.key === key) {
                 this.addressTable.delete(addr);
-                // If it was a dynamic client address, release it
-                this.releaseClientAddress(addr);
             }
         }
-        this.links.delete(link);
+        this.links.delete(key);
     }
     /**
      * Main entry point for any packet received from any link.
      * Based on knxd's Router::recv_L_Data and Router::trigger_cb logic.
      */
-    processIncoming(cemi, source) {
-        const cemiAny = cemi;
-        let src = cemiAny.sourceAddress;
+    processIncoming(cemi, source, keySource) {
+        if (!("sourceAddress" in cemi))
+            return;
+        GroupAddressCache_1.GroupAddressCache.getInstance().processCEMI(cemi);
+        const src = cemi.sourceAddress;
         // 1. Source Validation (knxd pattern):
         // If we know this IA is on another link, discard to prevent loops/spoofing.
         if (src && src !== "0.0.0") {
@@ -132,137 +120,221 @@ class Router extends events_1.EventEmitter {
                 return;
             }
             const existingLink = this.addressTable.get(src);
-            if (existingLink && existingLink !== source) {
+            if (existingLink && existingLink.key !== keySource) {
                 return; // Ignore packet from "wrong" interface
             }
         }
-        // 2. Source Patching (Standard KNX Requirement)
-        // If src is 0.0.0, it must be replaced by the router's/client's address
-        if (!src || src === "0.0.0") {
-            cemiAny.sourceAddress =
-                "individualAddress" in source.options &&
-                    source.options.individualAddress
-                    ? source.options.individualAddress
-                    : this.routerAddress;
-            src = cemiAny.sourceAddress;
-        }
-        // 3. IA Learning
-        this.learnAddress(src, source);
-        // 4. Loop Prevention (knxd strict pattern)
-        const buf = cemi.toBuffer();
-        // In CEMI, Ctrl1 is at offset `2 + AddIL`
-        const addIL = buf[1];
-        const ctrl1 = buf[2 + addIL];
+        // 2. IA Learning
+        this.learnAddress(src, source, keySource);
+        // 3. Loop Prevention (knxd strict pattern)
         // KNX Standard: Repeat bit is bit 5 (0x20). Active LOW (0 = repeated frame).
-        const isRepeated = (ctrl1 & 0x20) === 0;
-        const signature = this.getSignature(buf, addIL);
+        const isRepeated = !cemi.controlField1.repeat;
+        const destinationAddress = cemi.destinationAddress;
         if (isRepeated) {
-            if (this.recentSignatures.has(signature)) {
-                this.logger.debug({ signature, src }, "Loop prevented: duplicated repeated frame dropped");
+            if (this.recentDestinationAddress.has(destinationAddress)) {
+                this.logger.debug({ signature: destinationAddress, src }, "Loop prevented: duplicated repeated frame dropped");
                 return; // Drop repeated packet we've recently seen on the bus
             }
         }
         // Always record the signature. If a loop occurs, the echoed packet will have
         // the repeat flag set to 0 (since it failed to ACK or was physically echoed),
         // and we will drop it next time.
-        if (this.recentSignatures.size >= this.MAX_SIGNATURES_SIZE) {
-            const firstKey = this.recentSignatures.keys().next().value;
+        if (this.recentDestinationAddress.size >= this.MAX_SIGNATURES_SIZE) {
+            const firstKey = this.recentDestinationAddress.keys().next().value;
             if (firstKey !== undefined)
-                this.recentSignatures.delete(firstKey);
+                this.recentDestinationAddress.delete(firstKey);
         }
-        this.recentSignatures.set(signature, Date.now());
+        this.recentDestinationAddress.set(destinationAddress, Date.now());
         // 5. Route
-        this.route(cemi, source);
+        this.route(cemi, source, keySource);
     }
-    learnAddress(src, source) {
+    learnAddress(src, source, keySource) {
         // knxd pattern: don't learn 0.0.0 or special 15.15.255 (0xFFFF) addresses
         if (src !== "0.0.0" && src !== "15.15.255") {
-            if (this.addressTable.get(src) !== source) {
-                this.addressTable.set(src, source);
-                this.logger.debug(`Learned IA ${src} on link ${source.constructor.name}`);
+            if (this.addressTable.get(src)?.key !== keySource) {
+                this.addressTable.set(src, { link: source, key: keySource });
+                this.logger.debug(`Learned IA ${src} on link ${keySource}`);
             }
         }
     }
-    route(cemi, source) {
-        const cemiAny = cemi;
+    route(data, source, keySource) {
+        if (!("controlField2" in data))
+            return;
         // Hop Count Management (Protect the whole network)
-        if (cemiAny.controlField2 &&
-            typeof cemiAny.controlField2.hopCount === "number") {
-            const hops = cemiAny.controlField2.hopCount;
+        if (data.controlField2 && typeof data.controlField2.hopCount === "number") {
+            const hops = data.controlField2.hopCount;
             if (hops === 0) {
-                this.logger.debug({ src: cemiAny.sourceAddress, dst: cemiAny.destinationAddress }, "Packet dropped: hop count reached 0");
+                this.logger.debug({ src: data.sourceAddress, dst: data.destinationAddress }, "Packet dropped: hop count reached 0");
                 return; // Drop packet
             }
             if (hops < 7)
-                cemiAny.controlField2.hopCount = hops - 1;
+                data.controlField2.hopCount = hops - 1;
         }
-        const isGroup = cemiAny.controlField2?.addressType === 1;
-        const dest = cemiAny.destinationAddress;
+        const isGroup = data.controlField2?.addressType === 1;
+        const dest = data.destinationAddress;
         // If packet is destined for the router itself, consume it and don't route
         if (!isGroup && dest === this.routerAddress) {
-            this.logger.debug({ src: cemiAny.sourceAddress }, "Packet consumed by router local address");
-            this.emit("indication", cemi);
+            this.logger.debug({ src: data.sourceAddress }, "Packet consumed by router local address");
+            this.emit("indication_link", { src: source.constructor.name, msg: data });
             return;
         }
         // Selective Routing (IA)
         if (!isGroup && dest && dest !== "0.0.0" && dest !== "15.15.255") {
             const target = this.addressTable.get(dest);
             if (target) {
-                if (target !== source) {
-                    target.send(cemi).catch((err) => {
-                        this.logger.debug({ target: target.constructor.name, err: err.message }, "Selective routing failed");
+                if (target.key !== keySource) {
+                    target.link.send(data).catch((err) => {
+                        this.logger.debug({ target: target.key, err: err.message }, "Selective routing failed");
                     });
                 }
                 // Send to upper layers (KNXnet/IP server core)
-                this.emit("indication", cemi);
+                this.emit("indication_link", { src: source.constructor.name, msg: data });
                 return; // Do not flood
             }
             // If target is unknown, knxd broadcasts it to all interfaces
         }
+        const isSourceIP = keySource.includes("IP");
         // Flood to all links except source, respecting filters (knxd pattern)
-        for (const link of this.links) {
-            if (link === source)
+        for (const [key, link] of this.links) {
+            if (key === keySource)
                 continue;
             // Avoid looping back to the physical source address if known via another route
-            if (this.addressTable.get(cemiAny.sourceAddress) === link)
+            if (this.addressTable.get(data.sourceAddress)?.key === keySource)
                 continue;
             // Check if the link should filter this message
-            if (isGroup) {
-                if (link.shouldFilterGroup && !link.shouldFilterGroup(dest))
-                    continue;
-            }
-            else {
-                if (link.shouldFilterIA && !link.shouldFilterIA(dest))
-                    continue;
-            }
-            link.send(cemi).catch((err) => {
-                this.logger.debug({ link: link.constructor.name, err: err.message }, "Flooding routing failed for link");
-            });
+            const shouldSend = this.evaluateFilter(dest, isGroup, isSourceIP);
+            if (!shouldSend)
+                continue;
+            // Send to link
+            this.sendToLink(link, data);
         }
         // Notify upper layers
-        this.emit("indication", cemi);
+        this.emit("indication_link", { src: source.constructor.name, msg: data });
+    }
+    /**
+     * Evaluates if a message should be sent to a link based on configured filters.
+     * Logic: Skip if the policy is "discard all" and the address matches.
+     * Otherwise, send if the address is in the filter list or no filter exists.
+     */
+    evaluateFilter(dest, isGroup, isSourceIP) {
+        if (isSourceIP) {
+            return this.evaluateLocalFilter(dest, isGroup);
+        }
+        else {
+            return this.evaluateIpFilter(dest, isGroup);
+        }
+    }
+    evaluateLocalFilter(dest, isGroup) {
+        if (isGroup) {
+            const filter = this.toLocalFilter?.groupAddress;
+            if (!filter?.addresses?.includes(dest))
+                return true;
+            return filter.groupAddressToLocalFilterPolicie !== "discard all";
+        }
+        else {
+            const filter = this.toLocalFilter?.individualAddress;
+            if (!filter?.addresses?.includes(dest))
+                return true;
+            return filter.individualAddressToLocalFilterPolicie !== "discard all";
+        }
     }
-    getSignature(buf, addIL) {
-        // Signature based on Dst + APCI + Data (knxd style)
-        // We skip Src and HopCount because they change during routing
-        // Payload starts after CEMI header (2) + AddIL + Ctrl1 (1) + Ctrl2 (1) + Src (2)
-        // Actually, taking from Dst onwards is a solid signature.
-        // Dst is at offset 2 + addIL + 4
-        const dstOffset = 2 + addIL + 4;
-        return buf.subarray(dstOffset).toString("hex");
+    evaluateIpFilter(dest, isGroup) {
+        if (isGroup) {
+            const filter = this.toIPFilter?.groupAddress;
+            if (!filter?.addresses?.includes(dest))
+                return true;
+            return filter.groupAddressToIpFilterPolicie !== "discard all";
+        }
+        else {
+            const filter = this.toIPFilter?.individualAddress;
+            if (!filter?.addresses?.includes(dest))
+                return true;
+            return filter.individualAddressToIpFilterPolicie !== "discard all";
+        }
+    }
+    /**
+     * Sends data to a link with error handling.
+     */
+    sendToLink(link, data) {
+        link.send(data).catch((err) => {
+            this.logger.debug({ link: link.constructor.name, err: err.message }, "Flooding routing failed for link");
+        });
+    }
+    /**
+     * Broadcasts a CEMI message to all registered links.
+     */
+    async send(cemi) {
+        const promises = Array.from(this.links.entries()).map(async ([key, link]) => {
+            try {
+                await link.send(cemi);
+            }
+            catch (err) {
+                this.logger.debug({ link: key, err: err.message }, "Broadcast failed for link");
+            }
+        });
+        await Promise.all(promises);
+    }
+    /**
+     * Send a GroupValue_Read telegram to a group address to all registered links.
+     * @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), true), Buffer.alloc(0));
+        const cemi = new CEMI_1.CEMI.DataLinkLayerCEMI["L_Data.req"](null, cf1, cf2, this.routerAddress, destination, tpdu);
+        this.logger.debug({ service: cemi.constructor.name }, "Sending GroupValue_Read");
+        return this.send(cemi);
+    }
+    /**
+     * 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)");
+        }
+        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_Write_Protocol_Data_Unit), data, isShort), data);
+        const cemi = new CEMI_1.CEMI.DataLinkLayerCEMI["L_Data.req"](null, cf1, cf2, this.routerAddress, destination, tpdu);
+        this.logger.debug({ service: cemi.constructor.name }, "Sending GroupValue_Write");
+        return this.send(cemi);
     }
-    gcSignatures() {
+    gcDestinationAddress() {
         const now = Date.now();
-        for (const [sig, time] of this.recentSignatures) {
+        for (const [sig, time] of this.recentDestinationAddress) {
             // knxd keeps them for 1 second
             if (now - time > 1000)
-                this.recentSignatures.delete(sig);
+                this.recentDestinationAddress.delete(sig);
         }
     }
     async connect() {
-        await Promise.all(Array.from(this.links).map((l) => l.connect()));
+        await Promise.all(Array.from(this.links.values()).map((link) => link.connect()));
     }
     disconnect() {
+        clearInterval(this.gcInterval);
         this.links.forEach((l) => l.disconnect());
     }
 }

package/dist/connection/TPUART.d.ts

@@ -1,10 +1,11 @@
 import { KNXService } from "./KNXService";
 import { TPUARTOptions } from "../@types/interfaces/connection";
-import { ServiceMessage } from "../@types/interfaces/ServiceMessage";
-export declare class TPUARTConnection extends KNXService {
+import { CEMIInstance } from "../core/CEMI";
+export declare class TPUARTConnection extends KNXService<TPUARTOptions> {
     private serialPort;
     private receiver;
     private connectionState;
+    private isOpening;
     private initPromise;
     private msgQueue;
     private isProcessing;
@@ -21,8 +22,12 @@ export declare class TPUARTConnection extends KNXService {
     connect(): Promise<void>;
     private sendResetRequest;
     disconnect(): Promise<void>;
+    /**
+     * Enable or disable busmonitor mode.
+     * @param enabled
+     */
     setBusmonitor(enabled: boolean): Promise<void>;
-    send(data: Buffer | ServiceMessage): Promise<void>;
+    send(data: Buffer | CEMIInstance): Promise<void>;
     private enqueueFrame;
     private processQueue;
     private toUartServices;