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

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # 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
+
 ## [2.0.2]
 ### Fixed
 - CI pipeline adjustments

package/common/func.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { randomUUID } = require('crypto');
+
 // ---------------------------------- export ----------------------------------
 module.exports = {
     /**
@@ -63,4 +65,14 @@ module.exports = {
         else
             return err
     },
-};
+
+    /**
+     * Generate a unique job ID using node ID and uuid
+     * @param {string} nodeId - The Node-RED node instance ID.
+     * @param {string} prefix - The prefix for the job ID (e.g., 'readPoints', 'writePoints').
+     * @returns {string} - A unique job ID.
+     */
+    generateUniqueJobId: function (nodeId, prefix) {
+        return `${prefix}-${nodeId}-${randomUUID()}`;
+    },
+};

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.2",
+  "version": "2.1.0-alpha.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"

package/red-bacnet/discover_device.js

@@ -1,114 +1,117 @@
-'use strict';
-require('./_alias.js');
-
-const EventEmitter = require('events');
-
-const { print } = require('@root/common/core/util.js')
-const { nowFormatted } = require('@root/common/core/util.js')
-const { DiscoverDeviceJob } = require('@root/common/job/discover_device.js')
-const { getQueue } = require('@root/common/job/global_queue_manager.js')
-const {
-    EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_INPUT, EVENT_OUTPUT, EVENT_CLOSE
-} = require('@root/common/core/constant.js')
-
-
-// -------------------------------- functions --------------------------------
-// coalesced job remove on start and on stop, move it to here
-module.exports = function (RED) {
-    class DiscoverDevice {
-        #eventEmitter = new EventEmitter();
-
-        constructor(config) {
-            RED.nodes.createNode(this, config);
-
-            // get config
-            this.client = RED.nodes.getNode(config.client).instance;
-
-            this.network = +config.network
-            this.lowLimit = +config.lowLimit
-            this.highLimit = +config.highLimit
-            this.whoIsTimeout = +config.whoIsTimeout
-
-            // events
-            this.#subscribeListeners();
-
-            // configure job queue - use global queue
-            this.job = getQueue();
-
-            // init task
-            this.task = new DiscoverDeviceJob(
-                this.client,
-                this.#eventEmitter,
-                this.network,
-                this.lowLimit,
-                this.highLimit,
-                this.whoIsTimeout,
-            );
-            this.task.onStart();
-        }
-
-        #subscribeListeners() {
-            /**
-             * @param {Object} msg - The message object.
-            */
-            // @ts-ignore
-            this.on(EVENT_INPUT, async function (msg) {
-                /*
-                BACnet iAm handler is causing memory leak due to unable to detach after use
-                as a result, workaround is introduce before strategy to reuse discoverDeviceJob instead
-                of creating new one every time onInput is triggered
-                */
-                const jobId = (typeof msg.id === 'string' || typeof msg.id === 'number') ? msg.id : 'discoverDevices';
-
-                if (this.job.queue.map(item => item.id).includes(jobId)) {
-                    // @ts-ignore
-                    print(`Coalesced job: ${jobId}`, true)
-                    return;
-                }
-
-                this.task.network = (msg.network === undefined) ? this.network : msg.network;
-                this.task.lowLimit = (msg.lowLimit === undefined) ? this.lowLimit : msg.lowLimit;
-                this.task.highLimit = (msg.highLimit === undefined) ? this.highLimit : msg.highLimit;
-
-                this.job.addJob({
-                    id: jobId,
-                    task: this.task,
-                    priority: Number.isFinite(msg.priority) ? msg.priority : 5,
-                });
-                // @ts-ignore
-                this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
-            });
-
-            // @ts-ignore
-            this.on(EVENT_CLOSE, () => {
-                this.task.onStop();
-            })
-
-            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
-                const msg = {
-                    payload: data
-                };
-                // @ts-ignore
-                this.send(msg);
-            });
-
-            this.#eventEmitter.on(EVENT_UPDATE_STATUS, (msg) => {
-                if (msg === 100)
-                    // @ts-ignore
-                    this.status({ fill: 'green', shape: 'dot', text: `completed: ${nowFormatted()}` });
-                else
-                    // @ts-ignore
-                    this.status({ fill: 'yellow', shape: 'dot', text: `progress: ${msg} %` });
-            });
-
-            this.#eventEmitter.on(EVENT_ERROR, (err) => {
-                // @ts-ignore
-                this.error(err);
-            });
-        }
-    }
-
-    // ----- register node -----
-    RED.nodes.registerType('discover device', DiscoverDevice);
-}
-
+'use strict';
+require('./_alias.js');
+
+const EventEmitter = require('events');
+
+const { print } = require('@root/common/core/util.js')
+const { nowFormatted } = require('@root/common/core/util.js')
+const { DiscoverDeviceJob } = require('@root/common/job/discover_device.js')
+const { getQueue } = require('@root/common/job/global_queue_manager.js')
+const { generateUniqueJobId } = require('@root/common/func.js')
+const {
+    EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_INPUT, EVENT_OUTPUT, EVENT_CLOSE
+} = require('@root/common/core/constant.js')
+
+
+// -------------------------------- functions --------------------------------
+// coalesced job remove on start and on stop, move it to here
+module.exports = function (RED) {
+    class DiscoverDevice {
+        #eventEmitter = new EventEmitter();
+
+        constructor(config) {
+            RED.nodes.createNode(this, config);
+
+            // get config
+            this.client = RED.nodes.getNode(config.client).instance;
+
+            // @ts-ignore
+            this.jobId = generateUniqueJobId(this.id, 'discoverDevices');
+            this.network = +config.network
+            this.lowLimit = +config.lowLimit
+            this.highLimit = +config.highLimit
+            this.whoIsTimeout = +config.whoIsTimeout
+
+            // events
+            this.#subscribeListeners();
+
+            // configure job queue - use global queue
+            this.job = getQueue();
+
+            // init task
+            this.task = new DiscoverDeviceJob(
+                this.client,
+                this.#eventEmitter,
+                this.network,
+                this.lowLimit,
+                this.highLimit,
+                this.whoIsTimeout,
+            );
+            this.task.onStart();
+        }
+
+        #subscribeListeners() {
+            /**
+             * @param {Object} msg - The message object.
+            */
+            // @ts-ignore
+            this.on(EVENT_INPUT, async function (msg) {
+                /*
+                BACnet iAm handler is causing memory leak due to unable to detach after use
+                as a result, workaround is introduce before strategy to reuse discoverDeviceJob instead
+                of creating new one every time onInput is triggered
+                */
+                const jobId = (typeof msg.id === 'string' || typeof msg.id === 'number') ? msg.id : this.jobId;
+
+                if (this.job.queue.map(item => item.id).includes(jobId)) {
+                    // @ts-ignore
+                    print(`Coalesced job: ${jobId}`, true)
+                    return;
+                }
+
+                this.task.network = (msg.network === undefined) ? this.network : msg.network;
+                this.task.lowLimit = (msg.lowLimit === undefined) ? this.lowLimit : msg.lowLimit;
+                this.task.highLimit = (msg.highLimit === undefined) ? this.highLimit : msg.highLimit;
+
+                this.job.addJob({
+                    id: jobId,
+                    task: this.task,
+                    priority: Number.isFinite(msg.priority) ? msg.priority : 5,
+                });
+                // @ts-ignore
+                this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
+            });
+
+            // @ts-ignore
+            this.on(EVENT_CLOSE, () => {
+                this.task.onStop();
+            })
+
+            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
+                const msg = {
+                    payload: data
+                };
+                // @ts-ignore
+                this.send(msg);
+            });
+
+            this.#eventEmitter.on(EVENT_UPDATE_STATUS, (msg) => {
+                if (msg === 100)
+                    // @ts-ignore
+                    this.status({ fill: 'green', shape: 'dot', text: `completed: ${nowFormatted()}` });
+                else
+                    // @ts-ignore
+                    this.status({ fill: 'yellow', shape: 'dot', text: `progress: ${msg} %` });
+            });
+
+            this.#eventEmitter.on(EVENT_ERROR, (err) => {
+                // @ts-ignore
+                this.error(err);
+            });
+        }
+    }
+
+    // ----- register node -----
+    RED.nodes.registerType('discover device', DiscoverDevice);
+}
+

package/red-bacnet/discover_point.js

@@ -1,93 +1,97 @@
-'use strict';
-require('./_alias.js');
-
-const EventEmitter = require('events');
-
-const { print } = require('@root/common/core/util.js')
-const { nowFormatted } = require('@root/common/core/util.js')
-const { DiscoverPointJob } = require('@root/common/job/discover_point.js')
-const { getQueue } = require('@root/common/job/global_queue_manager.js')
-const {
-    EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_INPUT, EVENT_OUTPUT
-} = require('@root/common/core/constant.js')
-
-// -------------------------------- functions --------------------------------
-module.exports = function (RED) {
-    class DiscoverPoint {
-        #eventEmitter = new EventEmitter();
-
-        constructor(config) {
-            RED.nodes.createNode(this, config);
-
-            // get config
-            this.client = RED.nodes.getNode(config.client).instance;
-            this.discoverMode = +config.discoverMode
-            this.readMethod = +config.readMethod
-            this.groupExportDeviceCount = +config.groupExportDeviceCount
-            this.maxConcurrentDeviceRead = +config.maxConcurrentDeviceRead
-            this.maxConcurrentSinglePointRead = +config.maxConcurrentSinglePointRead
-            this.concurrentTaskDelay = +config.concurrentTaskDelay
-
-            // events
-            this.#subscribeListeners();
-
-            // configure job queue - use global queue
-            this.job = getQueue();
-        }
-
-        #subscribeListeners() {
-            /**
-             * @param {Object} msg - The message object.
-            */
-            // @ts-ignore
-            this.on(EVENT_INPUT, async function (msg) {
-                const jobId = (typeof msg.id === 'string' || typeof msg.id === 'number') ? msg.id : 'discoverPoints';
-
-                if (this.job.queue.map(item => item.id).includes(jobId)) {
-                    // @ts-ignore
-                    print(`Coalesced job: ${jobId}`, true)
-                    return;
-                }
-
-                const task = new DiscoverPointJob(
-                    this.client, this.#eventEmitter, msg?.devices, this.discoverMode, this.readMethod,
-                    this.groupExportDeviceCount, this.maxConcurrentDeviceRead,
-                    this.maxConcurrentSinglePointRead, this.concurrentTaskDelay
-                );
-
-                this.job.addJob({
-                    id: jobId,
-                    task: task,
-                    priority: Number.isFinite(msg.priority) ? msg.priority : 5,
-                });
-                // @ts-ignore
-                this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
-            });
-
-            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
-                const msg = {
-                    payload: data
-                };
-                // @ts-ignore
-                this.send(msg);
-            });
-
-            this.#eventEmitter.on(EVENT_UPDATE_STATUS, (msg) => {
-                if (msg === 100)
-                    // @ts-ignore
-                    this.status({ fill: 'green', shape: 'dot', text: `completed: ${nowFormatted()}` });
-                else
-                    // @ts-ignore
-                    this.status({ fill: 'yellow', shape: 'dot', text: `progress: ${msg} %` });
-            });
-
-            this.#eventEmitter.on(EVENT_ERROR, (err) => {
-                // @ts-ignore
-                this.error(err);
-            });
-        }
-    }
-
-    // ----- register node -----
-    RED.nodes.registerType('discover point', DiscoverPoint);
-}
+'use strict';
+require('./_alias.js');
+
+const EventEmitter = require('events');
+
+const { print } = require('@root/common/core/util.js')
+const { nowFormatted } = require('@root/common/core/util.js')
+const { DiscoverPointJob } = require('@root/common/job/discover_point.js')
+const { getQueue } = require('@root/common/job/global_queue_manager.js')
+const { generateUniqueJobId } = require('@root/common/func.js')
+const {
+    EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_INPUT, EVENT_OUTPUT
+} = require('@root/common/core/constant.js')
+
+// -------------------------------- functions --------------------------------
+module.exports = function (RED) {
+    class DiscoverPoint {
+        #eventEmitter = new EventEmitter();
+
+        constructor(config) {
+            RED.nodes.createNode(this, config);
+
+            // get config
+            this.client = RED.nodes.getNode(config.client).instance;
+            this.discoverMode = +config.discoverMode
+            this.readMethod = +config.readMethod
+            this.groupExportDeviceCount = +config.groupExportDeviceCount
+            this.maxConcurrentDeviceRead = +config.maxConcurrentDeviceRead
+            this.maxConcurrentSinglePointRead = +config.maxConcurrentSinglePointRead
+            this.concurrentTaskDelay = +config.concurrentTaskDelay
+
+            // @ts-ignore
+            this.jobId = generateUniqueJobId(this.id, 'discoverPoints');
+
+            // events
+            this.#subscribeListeners();
+
+            // configure job queue - use global queue
+            this.job = getQueue();
+        }
+
+        #subscribeListeners() {
+            /**
+             * @param {Object} msg - The message object.
+            */
+            // @ts-ignore
+            this.on(EVENT_INPUT, async function (msg) {
+                const jobId = (typeof msg.id === 'string' || typeof msg.id === 'number') ? msg.id : this.jobId;
+
+                if (this.job.queue.map(item => item.id).includes(jobId)) {
+                    // @ts-ignore
+                    print(`Coalesced job: ${jobId}`, true)
+                    return;
+                }
+
+                const task = new DiscoverPointJob(
+                    this.client, this.#eventEmitter, msg?.devices, this.discoverMode, this.readMethod,
+                    this.groupExportDeviceCount, this.maxConcurrentDeviceRead,
+                    this.maxConcurrentSinglePointRead, this.concurrentTaskDelay
+                );
+
+                this.job.addJob({
+                    id: jobId,
+                    task: task,
+                    priority: Number.isFinite(msg.priority) ? msg.priority : 5,
+                });
+                // @ts-ignore
+                this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
+            });
+
+            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
+                const msg = {
+                    payload: data
+                };
+                // @ts-ignore
+                this.send(msg);
+            });
+
+            this.#eventEmitter.on(EVENT_UPDATE_STATUS, (msg) => {
+                if (msg === 100)
+                    // @ts-ignore
+                    this.status({ fill: 'green', shape: 'dot', text: `completed: ${nowFormatted()}` });
+                else
+                    // @ts-ignore
+                    this.status({ fill: 'yellow', shape: 'dot', text: `progress: ${msg} %` });
+            });
+
+            this.#eventEmitter.on(EVENT_ERROR, (err) => {
+                // @ts-ignore
+                this.error(err);
+            });
+        }
+    }
+
+    // ----- register node -----
+    RED.nodes.registerType('discover point', DiscoverPoint);
+}

package/red-bacnet/read_point.js

@@ -1,97 +1,101 @@
-'use strict';
-require('./_alias.js');
-
-const EventEmitter = require('events');
-
-const { print } = require('@root/common/core/util.js')
-const { nowFormatted } = require('@root/common/core/util.js')
-const { ReadPointJob } = require('@root/common/job/read_point.js')
-const { getQueue } = require('@root/common/job/global_queue_manager.js')
-const {
-    EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_INPUT, EVENT_OUTPUT
-} = require('@root/common/core/constant.js')
-
-
-// -------------------------------- functions --------------------------------
-module.exports = function (RED) {
-    class ReadPoint {
-        #eventEmitter = new EventEmitter();
-
-        constructor(config) {
-            RED.nodes.createNode(this, config);
-
-            // get config
-            this.client = RED.nodes.getNode(config.client).instance;
-            this.readMethod = +config.readMethod
-            this.maxConcurrentDeviceRead = +config.maxConcurrentDeviceRead
-            this.maxConcurrentSinglePointRead = +config.maxConcurrentSinglePointRead
-            this.concurrentTaskDelay = +config.concurrentTaskDelay
-
-            // events
-            this.#subscribeListeners();
-
-            // configure job queue - use global queue
-            this.job = getQueue();
-        }
-
-        #subscribeListeners() {
-            /**
-             * @param {Object} msg - The message object.
-            */
-            // @ts-ignore
-            this.on(EVENT_INPUT, async function (msg) {
-                const task = new ReadPointJob(
-                    this.client,
-                    this.#eventEmitter,
-                    msg.devices,
-                    msg.points,
-                    this.readMethod,
-                    this.maxConcurrentDeviceRead,
-                    this.maxConcurrentSinglePointRead,
-                    this.concurrentTaskDelay
-                );
-
-                const jobId = (typeof msg.id === 'string' || typeof msg.id === 'number') ? msg.id : 'readPoints';
-
-                if (this.job.queue.map(item => item.id).includes(jobId)) {
-                    // @ts-ignore
-                    print(`Coalesced job: ${jobId}`, true)
-                    return;
-                }
-
-                this.job.addJob({
-                    id: jobId,
-                    task: task,
-                    priority: Number.isFinite(msg.priority) ? msg.priority : 2,
-                });
-                // @ts-ignore
-                this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
-            });
-
-            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
-                const msg = {
-                    payload: data
-                };
-                // @ts-ignore
-                this.send(msg);
-            });
-
-            this.#eventEmitter.on(EVENT_UPDATE_STATUS, (msg) => {
-                if (msg === 100)
-                    // @ts-ignore
-                    this.status({ fill: 'green', shape: 'dot', text: `completed: ${nowFormatted()}` });
-                else
-                    // @ts-ignore
-                    this.status({ fill: 'yellow', shape: 'dot', text: `progress: ${msg} %` });
-            });
-
-            this.#eventEmitter.on(EVENT_ERROR, (err) => {
-                // @ts-ignore
-                this.error(err);
-            });
-        }
-    }
-
-    // ----- register node -----
-    RED.nodes.registerType('read point', ReadPoint);
-}
+'use strict';
+require('./_alias.js');
+
+const EventEmitter = require('events');
+
+const { print } = require('@root/common/core/util.js')
+const { nowFormatted } = require('@root/common/core/util.js')
+const { ReadPointJob } = require('@root/common/job/read_point.js')
+const { getQueue } = require('@root/common/job/global_queue_manager.js')
+const { generateUniqueJobId } = require('@root/common/func.js')
+const {
+    EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_INPUT, EVENT_OUTPUT
+} = require('@root/common/core/constant.js')
+
+
+// -------------------------------- functions --------------------------------
+module.exports = function (RED) {
+    class ReadPoint {
+        #eventEmitter = new EventEmitter();
+
+        constructor(config) {
+            RED.nodes.createNode(this, config);
+
+            // get config
+            this.client = RED.nodes.getNode(config.client).instance;
+            this.readMethod = +config.readMethod
+            this.maxConcurrentDeviceRead = +config.maxConcurrentDeviceRead
+            this.maxConcurrentSinglePointRead = +config.maxConcurrentSinglePointRead
+            this.concurrentTaskDelay = +config.concurrentTaskDelay
+
+            // @ts-ignore
+            this.jobId = generateUniqueJobId(this.id, 'readPoints');
+
+            // events
+            this.#subscribeListeners();
+
+            // configure job queue - use global queue
+            this.job = getQueue();
+        }
+
+        #subscribeListeners() {
+            /**
+             * @param {Object} msg - The message object.
+            */
+            // @ts-ignore
+            this.on(EVENT_INPUT, async function (msg) {
+                const task = new ReadPointJob(
+                    this.client,
+                    this.#eventEmitter,
+                    msg.devices,
+                    msg.points,
+                    this.readMethod,
+                    this.maxConcurrentDeviceRead,
+                    this.maxConcurrentSinglePointRead,
+                    this.concurrentTaskDelay
+                );
+
+                const jobId = (typeof msg.id === 'string' || typeof msg.id === 'number') ? msg.id : this.jobId;
+
+                if (this.job.queue.map(item => item.id).includes(jobId)) {
+                    // @ts-ignore
+                    print(`Coalesced job: ${jobId}`, true)
+                    return;
+                }
+
+                this.job.addJob({
+                    id: jobId,
+                    task: task,
+                    priority: Number.isFinite(msg.priority) ? msg.priority : 2,
+                });
+                // @ts-ignore
+                this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
+            });
+
+            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
+                const msg = {
+                    payload: data
+                };
+                // @ts-ignore
+                this.send(msg);
+            });
+
+            this.#eventEmitter.on(EVENT_UPDATE_STATUS, (msg) => {
+                if (msg === 100)
+                    // @ts-ignore
+                    this.status({ fill: 'green', shape: 'dot', text: `completed: ${nowFormatted()}` });
+                else
+                    // @ts-ignore
+                    this.status({ fill: 'yellow', shape: 'dot', text: `progress: ${msg} %` });
+            });
+
+            this.#eventEmitter.on(EVENT_ERROR, (err) => {
+                // @ts-ignore
+                this.error(err);
+            });
+        }
+    }
+
+    // ----- register node -----
+    RED.nodes.registerType('read point', ReadPoint);
+}

package/red-bacnet/write_point.js

@@ -1,95 +1,99 @@
-'use strict';
-require('./_alias.js');
-
-const EventEmitter = require('events');
-
-const { print } = require('@root/common/core/util.js')
-const { nowFormatted } = require('@root/common/core/util.js')
-const { WritePointJob } = require('@root/common/job/write_point.js')
-const { getQueue } = require('@root/common/job/global_queue_manager.js')
-const {
-    EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_INPUT, EVENT_OUTPUT
-} = require('@root/common/core/constant.js')
-
-
-// -------------------------------- functions --------------------------------
-module.exports = function (RED) {
-    class WritePoint {
-        #eventEmitter = new EventEmitter();
-
-        constructor(config) {
-            RED.nodes.createNode(this, config);
-
-            // get config
-            this.client = RED.nodes.getNode(config.client).instance;
-            this.maxConcurrentDeviceWrite = +config.maxConcurrentDeviceWrite
-            this.maxConcurrentPointWrite = +config.maxConcurrentPointWrite
-            this.concurrentTaskDelay = +config.concurrentTaskDelay
-
-            // events
-            this.#subscribeListeners();
-
-            // configure job queue - use global queue
-            this.job = getQueue();
-        }
-
-        #subscribeListeners() {
-            /**
-             * @param {Object} msg - The message object.
-            */
-            // @ts-ignore
-            this.on(EVENT_INPUT, async function (msg) {
-                const task = new WritePointJob(
-                    this.client,
-                    this.#eventEmitter,
-                    msg.devices,
-                    msg.points,
-                    msg.writePoints,
-                    this.maxConcurrentDeviceWrite,
-                    this.maxConcurrentPointWrite,
-                    this.concurrentTaskDelay
-                );
-                const jobId = (typeof msg.id === 'string' || typeof msg.id === 'number') ? msg.id : 'writePoints';
-
-                if (this.job.queue.map(item => item.id).includes(jobId)) {
-                    // @ts-ignore
-                    print(`Coalesced job: ${jobId}`, true)
-                    return;
-                }
-
-                this.job.addJob({
-                    id: jobId,
-                    task: task,
-                    priority: Number.isFinite(msg.priority) ? msg.priority : 2,
-                });
-                // @ts-ignore
-                this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
-            });
-
-            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
-                const msg = {
-                    payload: data
-                };
-                // @ts-ignore
-                this.send(msg);
-            });
-
-            this.#eventEmitter.on(EVENT_UPDATE_STATUS, (msg) => {
-                if (msg === 100)
-                    // @ts-ignore
-                    this.status({ fill: 'green', shape: 'dot', text: `completed: ${nowFormatted()}` });
-                else
-                    // @ts-ignore
-                    this.status({ fill: 'yellow', shape: 'dot', text: `progress: ${msg} %` });
-            });
-
-            this.#eventEmitter.on(EVENT_ERROR, (err) => {
-                // @ts-ignore
-                this.error(err);
-            });
-        }
-    }
-
-    // ----- register node -----
-    RED.nodes.registerType('write point', WritePoint);
-}
+'use strict';
+require('./_alias.js');
+
+const EventEmitter = require('events');
+
+const { print } = require('@root/common/core/util.js')
+const { nowFormatted } = require('@root/common/core/util.js')
+const { WritePointJob } = require('@root/common/job/write_point.js')
+const { getQueue } = require('@root/common/job/global_queue_manager.js')
+const { generateUniqueJobId } = require('@root/common/func.js')
+const {
+    EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_INPUT, EVENT_OUTPUT
+} = require('@root/common/core/constant.js')
+
+
+// -------------------------------- functions --------------------------------
+module.exports = function (RED) {
+    class WritePoint {
+        #eventEmitter = new EventEmitter();
+
+        constructor(config) {
+            RED.nodes.createNode(this, config);
+
+            // get config
+            this.client = RED.nodes.getNode(config.client).instance;
+            this.maxConcurrentDeviceWrite = +config.maxConcurrentDeviceWrite
+            this.maxConcurrentPointWrite = +config.maxConcurrentPointWrite
+            this.concurrentTaskDelay = +config.concurrentTaskDelay
+
+            // @ts-ignore
+            this.jobId = generateUniqueJobId(this.id, 'writePoints');
+
+            // events
+            this.#subscribeListeners();
+
+            // configure job queue - use global queue
+            this.job = getQueue();
+        }
+
+        #subscribeListeners() {
+            /**
+             * @param {Object} msg - The message object.
+            */
+            // @ts-ignore
+            this.on(EVENT_INPUT, async function (msg) {
+                const task = new WritePointJob(
+                    this.client,
+                    this.#eventEmitter,
+                    msg.devices,
+                    msg.points,
+                    msg.writePoints,
+                    this.maxConcurrentDeviceWrite,
+                    this.maxConcurrentPointWrite,
+                    this.concurrentTaskDelay
+                );
+                const jobId = (typeof msg.id === 'string' || typeof msg.id === 'number') ? msg.id : this.jobId;
+
+                if (this.job.queue.map(item => item.id).includes(jobId)) {
+                    // @ts-ignore
+                    print(`Coalesced job: ${jobId}`, true)
+                    return;
+                }
+
+                this.job.addJob({
+                    id: jobId,
+                    task: task,
+                    priority: Number.isFinite(msg.priority) ? msg.priority : 2,
+                });
+                // @ts-ignore
+                this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
+            });
+
+            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
+                const msg = {
+                    payload: data
+                };
+                // @ts-ignore
+                this.send(msg);
+            });
+
+            this.#eventEmitter.on(EVENT_UPDATE_STATUS, (msg) => {
+                if (msg === 100)
+                    // @ts-ignore
+                    this.status({ fill: 'green', shape: 'dot', text: `completed: ${nowFormatted()}` });
+                else
+                    // @ts-ignore
+                    this.status({ fill: 'yellow', shape: 'dot', text: `progress: ${msg} %` });
+            });
+
+            this.#eventEmitter.on(EVENT_ERROR, (err) => {
+                // @ts-ignore
+                this.error(err);
+            });
+        }
+    }
+
+    // ----- register node -----
+    RED.nodes.registerType('write point', WritePoint);
+}