@halsystems/red-bacnet 2.0.3 → 2.1.0-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [2.1.0-alpha.0]
+### Added
+- BACnet client now listening to both `interface` and `broadcastAddress`
+
+### Changed
+- `discover_devices` to drop devices that are not within the low and high limit
+
+### Fixed
+- Fixed unable to discover devices from broadcast when `interface` is not set to `0.0.0.0`
+
+
 ## [2.0.3]
 ### Fixed
 - Added unique job id to same node type to avoid same time triggered nodes job being coalesced

package/common/job/discover_device.js

@@ -165,7 +165,12 @@ module.exports = {
             const adr = device.adr
             const net = device.net
 
+            // Check for duplicate
             if (this.knownDevices.has(deviceId)) return;
+
+            // Drop device if deviceId is not within the low and high limit
+            if (deviceId < this.lowLimit || deviceId > this.highLimit) return;
+
             this.discoverList.push({
                 deviceId: deviceId,
                 address: address,

package/ext/node-bacstack/dist/lib/client.js

@@ -59,6 +59,13 @@ class Client extends events_1.EventEmitter {
         // Setup code
         this._transport.on('message', this._receiveData.bind(this));
         this._transport.on('error', this._receiveError.bind(this));
+
+        // Add a default error handler to prevent unhandled error events
+        // This will be overridden if the user adds their own error listener
+        this.on('error', (err) => {
+            debug('Unhandled error event:', err);
+        });
+
         this._transport.open();
     }
     // Helper utils

package/ext/node-bacstack/dist/lib/transport.js

@@ -1,62 +1,114 @@
-'use strict';
+"use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transport = void 0;
 const dgram_1 = require("dgram");
 const events_1 = require("events");
 const DEFAULT_BACNET_PORT = 47808;
+const GLOBAL_BROADCAST_ADDRESS = "255.255.255.255";
+const UDP_TYPE = "udp4";
+
 class Transport extends events_1.EventEmitter {
     constructor(settings) {
         super();
-        try {
-            this._lastSendMessages = {};
-            this._settings = settings;
-            this._server = (0, dgram_1.createSocket)({ type: 'udp4', reuseAddr: true });
-            this._server.on('message', (msg, rinfo) => {
-                // NOTE HAL modified
-                const port = rinfo.port || DEFAULT_BACNET_PORT;
-                // this.emit('message', msg, `${rinfo.address}:${port}`);
-                if (port === DEFAULT_BACNET_PORT)
-                    this.emit('message', msg, rinfo.address);
-                else
-                    this.emit('message', msg, `${rinfo.address}:${rinfo.port || DEFAULT_BACNET_PORT}`);
-            });
-            this._server.on('error', (err) => this.emit('message', err));
+        this._settings = settings;
+        this._server = null;
+        this._broadcastServer = null;
 
-        } catch (e) {
-            //console.log("Transport constructor error: ", e);
+        this._server = (0, dgram_1.createSocket)({
+            type: UDP_TYPE,
+            reuseAddr: true,
+        });
+        this._setupSocket(this._server);
+
+        if (
+            this._settings.broadcastAddress &&
+            this._settings.broadcastAddress !== GLOBAL_BROADCAST_ADDRESS &&
+            this._settings.broadcastAddress !== this._settings.interface
+        ) {
+            this._broadcastServer = (0, dgram_1.createSocket)({
+                type: UDP_TYPE,
+                reuseAddr: true,
+            });
+            this._setupSocket(this._broadcastServer);
         }
     }
+
+    _setupSocket(socket) {
+        socket.on("message", (msg, rinfo) => {
+            const port = rinfo.port || DEFAULT_BACNET_PORT;
+            if (port === DEFAULT_BACNET_PORT) {
+                this.emit("message", msg, rinfo.address);
+            } else {
+                this.emit("message", msg, `${rinfo.address}:${port}`);
+            }
+        });
+        socket.on("error", (err) => this.emit("error", err));
+    }
+
     getBroadcastAddress() {
         return this._settings.broadcastAddress;
     }
+
     getMaxPayload() {
         return 1482;
     }
+
     send(buffer, offset, receiver) {
-        if (!receiver) {
-            receiver = this.getBroadcastAddress();
-            const dataToSend = Buffer.alloc(offset);
-            // Sort out broadcasted messages that we also receive
-            // TODO Find a better way?
-            const hrTime = process.hrtime();
-            const messageKey = hrTime[0] * 1000000000 + hrTime[1];
-            buffer.copy(dataToSend, 0, 0, offset);
-            this._lastSendMessages[messageKey] = dataToSend;
-            setTimeout(() => {
-                delete this._lastSendMessages[messageKey];
-            }, 10000); // delete after 10s, hopefully all cases are handled by that
+        const target = receiver || this.getBroadcastAddress();
+        if (!target) {
+            this.emit(
+                "error",
+                new Error("No receiver specified and no broadcast address configured"),
+            );
+            return;
         }
 
-        const [address, port] = receiver.split(':');
-        this._server.send(buffer, 0, offset, port || this._settings.port || DEFAULT_BACNET_PORT, address);
+        const [address, port] = target.split(":");
+        this._server.send(
+            buffer,
+            0,
+            offset,
+            port || this._settings.port || DEFAULT_BACNET_PORT,
+            address,
+            (err) => {
+                if (err) {
+                    this.emit("error", err);
+                }
+            },
+        );
     }
+
     open() {
+        this._server.on("error", (err) => this.emit("error", err));
         this._server.bind(this._settings.port, this._settings.interface, () => {
             this._server.setBroadcast(true);
         });
+
+        if (this._broadcastServer) {
+            this._broadcastServer.on("error", (err) => {
+                this.emit("error", err);
+                this._broadcastServer.close();
+                this._broadcastServer = null;
+            });
+            this._broadcastServer.bind(
+                this._settings.port,
+                this._settings.broadcastAddress,
+                () => {
+                    this._broadcastServer.setBroadcast(true);
+                }
+            );
+        }
     }
+
     close() {
-        this._server.close();
+        if (this._server) {
+            this._server.removeAllListeners();
+            this._server.close();
+        }
+        if (this._broadcastServer) {
+            this._broadcastServer.removeAllListeners();
+            this._broadcastServer.close();
+        }
     }
 }
 exports.Transport = Transport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halsystems/red-bacnet",
-  "version": "2.0.3",
+  "version": "2.1.0-alpha.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"