@halsystems/red-bacnet 2.1.1 → 2.2.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [2.2.0-alpha.1]
+### Changed
+- `ConcorrentTasksWithNetworkAwareness` added `invoke-id` generator and tracking
+- `writePoint` output `msg.payload` about failed write points after completion, and `msg.result` about written points statistics
+- `discoverPoint` send output on every device discovery completed ([] if failed), removed `groupExportDeviceCount` feature and add `msg.device` to output
+- refactored all nodes to retain original `msg` properties
+
+## [2.2.0-alpha.0]
+### Changed
+- `ConcurrentTask` changed to `ConcorrentTasksWithNetworkAwareness` round robin distributing task according to IP address to reduce congestion on a particular network
+
 ## [2.1.1]
 ### Changed
 - Reinstated `globalBroadcastAddress` filter in transport

package/common/bacnet.js

@@ -10,7 +10,20 @@ const { EVENT_ERROR, EVENT_OUTPUT } = require('@root/common/core/constant.js')
 const { concurrentTasks } = require('@root/common/core/concurrent.js')
 const { getErrMsg } = require('@root/common/func.js')
 
+// ---------------------------------- helper functions ----------------------------------
+/**
+ * Apply invoke ID to options if getNextInvokeId function is provided
+ * @param {object} options - The options object to modify
+ * @param {Function} [getNextInvokeId] - Optional function to get the next invoke ID
+ */
+function applyInvokeId(options, getNextInvokeId) {
+    if (getNextInvokeId && typeof getNextInvokeId === 'function') {
+        options.invokeId = getNextInvokeId();
+    }
+}
+
 // ---------------------------------- type def ----------------------------------
+
 /**
  * @typedef {import('@root/ext/node-bacstack/dist/index.js').Client} BacnetClient
  */
@@ -32,17 +45,19 @@ module.exports = {
      *      vendorId: 36,
      *      deviceName: 'BMS'
      *  }
+     * @param {Function} [getNextInvokeId]
+     *  optional function to get the next invoke ID
      * @returns array of objects
      *  eg: [{type: 12, value: {type: 8, instance: 123}, ...],
      * @async
      */
-    readObjectList: async function (client, device) {
+    readObjectList: async function (client, device, getNextInvokeId) {
         const objectId = { type: baEnum.ObjectType.DEVICE, instance: device.deviceId };
         const propertyId = baEnum.PropertyIdentifier.OBJECT_LIST;
 
-        let result = await module.exports.readPropertyMultipleReturnArr(client, device, objectId, propertyId);
+        let result = await module.exports.readPropertyMultipleReturnArr(client, device, objectId, propertyId, getNextInvokeId);
         if (result.length == 0) {
-            result = await module.exports.readPropertyReturnArr(client, device, objectId, propertyId);
+            result = await module.exports.readPropertyReturnArr(client, device, objectId, propertyId, getNextInvokeId);
         }
 
         return result;
@@ -55,10 +70,12 @@ module.exports = {
      * @param {object} device
      * @param {object} objectId
      * @param {number} propertyId
+     * @param {Function} [getNextInvokeId]
+     *  optional function to get the next invoke ID
      * @returns array of objects
      * @async
      */
-    readPropertyMultipleReturnArr: async function (client, device, objectId, propertyId) {
+    readPropertyMultipleReturnArr: async function (client, device, objectId, propertyId, getNextInvokeId) {
         let addressSet = device.ipAddress;
         if (device.macAddress != null && device.network != null) {
             addressSet = {
@@ -82,10 +99,14 @@ module.exports = {
             }];
 
             return new Promise((resolve, reject) => {
+                const options = { maxApdu: device.maxApdu };
+                applyInvokeId(options, getNextInvokeId);
+
                 client.readPropertyMultiple(
+
                     addressSet,
                     reqArr,
-                    { maxApdu: device.maxApdu },
+                    options,
                     (err, value) => {
                         if (err) return reject(err);
                         resolve(value);
@@ -156,13 +177,15 @@ module.exports = {
      *  retry times for single read failed
      * @param {number} concurrentTaskDelay
      *  delay between concurrent tasks
+     * @param {Function} [getNextInvokeId]
+     *  optional function to get the next invoke ID
      * @returns array of objects
      *  eg: [{type: 12, value: {type: 8, instance: 123}, ...],
      * @async
      */
     smartReadProperty: async function (
         client, device, reqArr, readMethod = 1, maxConcurrentSinglePointRead = 5,
-        singleReadFailedRetry = 5, concurrentTaskDelay = 50
+        singleReadFailedRetry = 5, concurrentTaskDelay = 50, getNextInvokeId
     ) {
         /* reqArr example
         [{
@@ -226,7 +249,7 @@ module.exports = {
                 } while (!batchFull)
 
                 // read batch block
-                const value = await module.exports.readPropertyMultple(client, device, reqArrBatch)
+                const value = await module.exports.readPropertyMultple(client, device, reqArrBatch, getNextInvokeId)
                     .catch(() => {
                         // Reduce batch size by half (minimum 1)
                         currBatchSize = Math.max(1, Math.floor(currBatchSize / 2))
@@ -274,7 +297,7 @@ module.exports = {
                     id: `${x}-${y}`,
                     task: async () => {
                         try {
-                            let value = await module.exports.readProperty(client, device, req.objectId, prop.id);
+                            let value = await module.exports.readProperty(client, device, req.objectId, prop.id, getNextInvokeId);
 
                             if (value == null) {
                                 value = {
@@ -351,11 +374,13 @@ module.exports = {
      *  maximum concurrent point to write
      * @param {number} concurrentTaskDelay
      *  delay between concurrent tasks
+     * @param {Function} [getNextInvokeId]
+     *  optional function to get the next invoke ID
      * @async
      */
     smartWriteProperty: async function (
         client, device, writePoints, eventEmitter, maxConcurrentWrite,
-        concurrentTaskDelay = 50
+        concurrentTaskDelay = 50, getNextInvokeId
     ) {
         const entries = Object.entries(writePoints);
 
@@ -373,7 +398,8 @@ module.exports = {
                             { type: point.bacType, instance: point.bacInstance },
                             point.bacProp,
                             [{ type: point.valueType, value: point.value }],
-                            point.priority
+                            point.priority,
+                            getNextInvokeId
                         );
                     } catch (err) {
                         eventEmitter.emit(EVENT_ERROR, { id: id, error: getErrMsg(err) });
@@ -416,12 +442,14 @@ module.exports = {
      *  eg:{ type: 2, instance: 1 }
      * @param {number} propertyId
      *  eg: 85
+     * @param {Function} [getNextInvokeId]
+     *  optional function to get the next invoke ID
      * @returns object
      *  eg: { len: 11, objectId: { type: 19, instance: 1 },
      *      property: { id: 85, index: 4294967295 }, values: [ { type: 2, value: 3 }]}
      * @async
      */
-    readProperty: async function (client, device, objectId, propertyId) {
+    readProperty: async function (client, device, objectId, propertyId, getNextInvokeId) {
         let addressSet = device.ipAddress
         if (device.macAddress != null && device.network != null) {
             addressSet = {
@@ -432,17 +460,21 @@ module.exports = {
         }
 
         return new Promise((resolve, reject) => {
+            const options = { maxApdu: device.maxApdu };
+            applyInvokeId(options, getNextInvokeId);
+
             client.readProperty(
                 addressSet,
                 objectId,
                 propertyId,
-                { maxApdu: device.maxApdu },
+                options,
                 (err, value) => {
                     if (err)
                         reject(err);
                     else
                         resolve(value);
-                });
+                }
+            );
         });
     },
 
@@ -456,11 +488,13 @@ module.exports = {
      *  eg:{ type: 2, instance: 1 }
      * @param {number} propertyId
      *  eg: 85
+     * @param {Function} [getNextInvokeId]
+     *  optional function to get the next invoke ID
      * @returns array of objects
      *  eg: [{type: 12, value: {type: 8, instance: 123}, ...],
      * @async
      */
-    readPropertyReturnArr: async function (client, device, objectId, propertyId) {
+    readPropertyReturnArr: async function (client, device, objectId, propertyId, getNextInvokeId) {
         const result = [];
 
         let addressSet = device.ipAddress
@@ -474,10 +508,14 @@ module.exports = {
 
         async function readPropertyPart(index) {
             return new Promise((resolve, reject) => {
-                client.readProperty(addressSet,
+                const options = { maxApdu: device.maxApdu, arrayIndex: index };
+                applyInvokeId(options, getNextInvokeId);
+
+                client.readProperty(
+                    addressSet,
                     objectId,
                     propertyId,
-                    { maxApdu: device.maxApdu, arrayIndex: index },
+                    options,
                     (err, value) => {
                         if (err) {
                             if (index === 1)
@@ -493,7 +531,8 @@ module.exports = {
                                 readPropertyPart(index + 1).then(resolve).catch(reject);
                             }
                         }
-                    });
+                    }
+                );
             });
         }
 
@@ -512,6 +551,8 @@ module.exports = {
      *      properties: [ { id: 85 }, ... ]
      *  },
      *  ...]
+     * @param {Function} [getNextInvokeId]
+     *  optional function to get the next invoke ID
      * @returns object
      *  eg: {"len":1937,"values":[{
      *      "objectId":{"type":3,"instance":0},
@@ -519,7 +560,7 @@ module.exports = {
      * ...}]}
      * @async
      */
-    readPropertyMultple: async function (client, device, reqArr) {
+    readPropertyMultple: async function (client, device, reqArr, getNextInvokeId) {
         let addressSet = device.ipAddress
         if (device.macAddress != null && device.network != null) {
             addressSet = {
@@ -530,16 +571,20 @@ module.exports = {
         }
 
         return new Promise((resolve, reject) => {
+            const options = { maxApdu: device.maxApdu };
+            applyInvokeId(options, getNextInvokeId);
+
             client.readPropertyMultiple(
                 addressSet,
                 reqArr,
-                { maxApdu: device.maxApdu },
+                options,
                 (err, value) => {
                     if (err)
                         reject(err);
                     else
                         resolve(value);
-                });
+                }
+            );
         });
     },
 
@@ -557,10 +602,12 @@ module.exports = {
      *  eg:[{type: 2, value: 3}]
      * @param {number} priority
      *  eg: 8
+     * @param {Function} [getNextInvokeId]
+     *  optional function to get the next invoke ID
      * @returns true / undefined: true if success, else undefined
      * @async
      */
-    writeProperty: async function (client, device, objectId, propertyId, writeValue, priority) {
+    writeProperty: async function (client, device, objectId, propertyId, writeValue, priority, getNextInvokeId) {
         let addressSet = device.ipAddress
         if (device.macAddress != null && device.network != null) {
             addressSet = {
@@ -576,6 +623,7 @@ module.exports = {
             if (priority !== null && priority !== undefined) {
                 options.priority = priority;
             }
+            applyInvokeId(options, getNextInvokeId);
 
             client.writeProperty(
                 addressSet,

package/common/core/concurrent.js

@@ -54,4 +54,153 @@ module.exports = {
         await Promise.allSettled(executing);
         return results;
     },
-};
+
+    /**
+     * Executes a list of tasks concurrently with IP address awareness.
+     * Tasks targeting the same IP address will execute sequentially.
+     * Tasks targeting different IP addresses can execute in parallel.
+     * Invoke IDs are automatically managed per-task to avoid collisions.
+     *
+     * @param {EventEmitter} eventEmitter - The event emitter to emit events to.
+     * @param {Array} tasks - The list of tasks to execute. Each task should have:
+     *                        { id, device: { ipAddress, ... }, task: async (getNextInvokeId) => {...} }
+     * @param {number} maxConcurrent - The maximum number of concurrent tasks.
+     * @param {number} concurrentTaskDelay - The delay between concurrent tasks.
+     * @returns {Promise<Array>} - A promise that resolves with an array of results.
+     * @async
+    */
+    concurrentTasksWithNetworkAwareness: async function (
+        eventEmitter, tasks, maxConcurrent, concurrentTaskDelay = 50
+    ) {
+        const executing = new Set();
+        const results = [];
+        const ipAddressInUse = new Set(); // Track which IPs are currently executing
+
+        // Create a sequential invoke ID generator with tracking
+        let invokeIdCounter = 1;
+        const invokeIdsInUse = new Set(); // Track which invoke IDs are currently in use
+
+        // Pending tasks that have not been started yet.
+        // We keep them in a list and remove them once scheduled so that a
+        // task blocked by a busy IP never blocks later tasks with free IPs.
+        const pending = tasks.map(({ id, device, task }) => ({
+            id,
+            task,
+            // Extract IP address from device (handle "ip:port" format)
+            ipAddress: device?.ipAddress ? device.ipAddress.split(':')[0] : null,
+        }));
+
+        /**
+         * Start a single task and wire up its lifecycle. When the task settles
+         * it releases its IP so waiting tasks targeting the same IP can run.
+         * Creates a per-task invoke ID generator that tracks and releases IDs.
+         *
+         * @param {{id: any, task: Function, ipAddress: string|null}} item
+         */
+        const startTask = (item) => {
+            const { id, task, ipAddress } = item;
+            if (ipAddress) ipAddressInUse.add(ipAddress);
+
+            // Track invoke IDs issued to this specific task
+            const taskInvokeIds = new Set();
+
+            // Create a task-scoped getNextInvokeId function that:
+            // 1. Finds the next available invoke ID (1-255)
+            // 2. Skips IDs already in use
+            // 3. Tracks the ID for later release
+            const taskGetNextInvokeId = () => {
+                let attempts = 0;
+                while (attempts < 255) {
+                    const candidateId = invokeIdCounter++;
+                    if (invokeIdCounter > 255) invokeIdCounter = 1;
+
+                    // If this ID is not in use, claim it
+                    if (!invokeIdsInUse.has(candidateId)) {
+                        invokeIdsInUse.add(candidateId);
+                        taskInvokeIds.add(candidateId);
+                        return candidateId;
+                    }
+                    attempts++;
+                }
+
+                // Fallback: if all 255 IDs are exhausted (shouldn't happen with proper concurrency limits),
+                // just return the next ID anyway
+                const fallbackId = invokeIdCounter++;
+                if (invokeIdCounter > 255) invokeIdCounter = 1;
+                invokeIdsInUse.add(fallbackId);
+                taskInvokeIds.add(fallbackId);
+                return fallbackId;
+            };
+
+            const promise = task(taskGetNextInvokeId)
+                .then(result => {
+                    eventEmitter.emit(EVENT_OUTPUT, { id, result });
+                    results.push({ id, result });
+                })
+                .catch(error => {
+                    eventEmitter.emit(EVENT_ERROR, { id, error });
+                    results.push({ id, error });
+                })
+                .finally(() => {
+                    executing.delete(promise);
+                    // Release the IP address so waiting tasks can run
+                    if (ipAddress) ipAddressInUse.delete(ipAddress);
+                    // Release all invoke IDs that were issued to this task
+                    for (const invokeId of taskInvokeIds) {
+                        invokeIdsInUse.delete(invokeId);
+                    }
+                });
+
+            executing.add(promise);
+        };
+
+        /**
+         * Schedule as many pending tasks as possible, respecting both the
+         * global concurrency limit and per-IP exclusivity. Scans the whole
+         * pending list (not just the head) so a busy IP does not block later
+         * tasks targeting free IPs.
+         *
+         * @async
+         */
+        const scheduleAvailable = async () => {
+            let i = 0;
+            while (i < pending.length && executing.size < maxConcurrent) {
+                const candidate = pending[i];
+
+                // Skip (leave in queue) if this IP is currently in use
+                if (candidate.ipAddress && ipAddressInUse.has(candidate.ipAddress)) {
+                    i++;
+                    continue;
+                }
+
+                // Remove from pending and start it
+                pending.splice(i, 1);
+                startTask(candidate);
+
+                if (concurrentTaskDelay > 0)
+                    await delay(concurrentTaskDelay);
+            }
+        };
+
+        // Keep pumping until every task has been scheduled and finished.
+        // Each loop: schedule what we can, then wait for at least one task to
+        // settle (which frees a concurrency slot and/or an IP) before retrying.
+        while (pending.length > 0 || executing.size > 0) {
+            await scheduleAvailable();
+
+            if (executing.size > 0) {
+                // Wait for one in-flight task to settle before scheduling more.
+                await Promise.race(executing);
+            } else if (pending.length > 0) {
+                // Nothing running but tasks remain (all were blocked by busy
+                // IPs that just got released). Yield briefly and retry.
+                /* istanbul ignore next */
+                await delay(concurrentTaskDelay > 0 ? concurrentTaskDelay : 1);
+            }
+        }
+
+        // Safety net: ensure all promises have fully settled.
+        await Promise.allSettled(executing);
+        return results;
+    },
+};

package/common/job/discover_device.js

@@ -27,18 +27,20 @@ module.exports = {
          * Construct a DiscoverDeviceJob.
          * @param {BacnetClient} client - Bacnet client to use for the discovery.
          * @param {EventEmitter} eventEmitter - Status and error event emitter.
+         * @param {Object} msg - Original incoming message.
          * @param {number} network - Network to discover devices on, eg: 65535 / 1 / 1001
          * @param {number} lowLimit - Low limit of the network range.
          * @param {number} highLimit - High limit of the network range.
          * @param {number} whoIsTimeout - Who is request timeout in milliseconds.
          */
         constructor(
-            client, eventEmitter, network, lowLimit, highLimit, whoIsTimeout,
+            client, eventEmitter, msg, network, lowLimit, highLimit, whoIsTimeout,
             name = 'discover device'
         ) {
             super();
             this.client = client
             this.eventEmitter = eventEmitter
+            this.msg = msg
             this.network = network
             this.lowLimit = lowLimit
             this.highLimit = highLimit
@@ -86,7 +88,11 @@ module.exports = {
                                 validatedDevices.push(result);
                             }
 
-                            this.eventEmitter.emit(EVENT_OUTPUT, validatedDevices);
+                            this.msg.payload = validatedDevices;
+                            delete this.msg.network;
+                            delete this.msg.lowLimit;
+                            delete this.msg.highLimit;
+                            this.eventEmitter.emit(EVENT_OUTPUT, this.msg);
                             this.#updateProgress(100)
                             resolve();
                         }).catch(error => {
@@ -146,8 +152,7 @@ module.exports = {
                 const deviceInfo = await readDeviceName(d, addressSet);
                 this.discoveredDevices.push(deviceInfo);
 
-                // throttle to avoid bursts
-                await delay(75); // tweak between 50–150ms
+                await delay(50);
                 this.#updateProgress(
                     Math.min(90, Math.round((80 / this.discoverList.length) * (i + 1) + 10))
                 );
@@ -188,4 +193,4 @@ module.exports = {
             this.eventEmitter.emit(EVENT_UPDATE_STATUS, progress);
         }
     },
-}
+}

package/common/job/discover_point.js

@@ -13,7 +13,7 @@ const { readObjectList, smartReadProperty } = require('@root/common/bacnet.js')
 const { bacnetUnitMap } = require('@root/common/bacnet_unit.js')
 const { EG_BACNET_DEVICES } = require('@root/common/example')
 const { errMsg, getErrMsg } = require('@root/common/func.js')
-const { concurrentTasks } = require('@root/common/core/concurrent.js')
+const { concurrentTasksWithNetworkAwareness } = require('@root/common/core/concurrent.js')
 const {
     ERR_GENERIC, ERR_SCHEMA_VALIDATION, ERR_INVALID_DATA_TYPE, ERR_IGNORE_DUPLICATED_DEVICE_NAME,
     ERR_READING_POINTS,
@@ -53,20 +53,19 @@ const supportedObjectTypes = [
 module.exports = {
     DiscoverPointJob: class DiscoverPointJob extends BaseJob {
         devices = [];
-        pointsList = [];
 
         constructor(
-            client, eventEmitter, inputDevices, discoverMode, readMethod, groupExportDeviceCount,
+            client, eventEmitter, msg, discoverMode, readMethod,
             maxConcurrentDeviceRead, maxConcurrentSinglePointRead, concurrentTaskDelay = 50,
             name = 'discover point'
         ) {
             super();
             this.client = client
             this.eventEmitter = eventEmitter
-            this.inputDevices = inputDevices
+            this.msg = msg
+            this.inputDevices = msg?.devices
             this.discoverMode = discoverMode
             this.readMethod = readMethod
-            this.groupExportDeviceCount = groupExportDeviceCount
             this.maxConcurrentDeviceRead = maxConcurrentDeviceRead
             this.maxConcurrentSinglePointRead = maxConcurrentSinglePointRead
             this.concurrentTaskDelay = concurrentTaskDelay
@@ -74,7 +73,7 @@ module.exports = {
         }
 
         async execute() {
-            this.#updateProgress(0)
+            this.#updateProgress('discovering')
 
             return new Promise((resolve) => {
                 try {
@@ -88,7 +87,7 @@ module.exports = {
                                 example: EG_BACNET_DEVICES
                             })
                         )
-                        this.#updateProgress(100)
+                        this.#updateProgress('completed')
                         resolve();
                         return
                     }
@@ -124,14 +123,16 @@ module.exports = {
                         this.devices.push(result);
                     }
 
-                    this.#updateProgress(10)
+                    // If no valid devices, complete immediately
+                    if (this.devices.length === 0) {
+                        this.#updateProgress('completed')
+                        resolve();
+                        return
+                    }
 
                     // read all device points
                     this.#readAllDevicePoints().then(() => {
-                        if (this.pointsList.length > 0)
-                            this.#exportPoints();
-
-                        this.#updateProgress(100)
+                        this.#updateProgress('completed')
                         resolve();
                     });
                 } catch (err) {
@@ -145,23 +146,17 @@ module.exports = {
             const discoverPointEvent = new EventEmitter();
             const size = this.devices.length;
             let count = 0;
-            let discoveredDevices = 0
 
             discoverPointEvent.on(EVENT_OUTPUT, (data) => {
-                this.#updateProgress(
-                    Math.round((85 / size) * (count + 1) + 10)
-                )
-
-                if (Array.isArray(data.result))
-                    this.pointsList.push(...data.result);
-
                 count++;
-                discoveredDevices++;
-
-                if (discoveredDevices >= this.groupExportDeviceCount) {
-                    this.#exportPoints();
-                    discoveredDevices = 0
+                // Export points immediately after each device is discovered
+                if (Array.isArray(data.result?.points)) {
+                    this.#exportPoints(data.result?.points, data.result?.device);
+                } else {
+                    // Export empty array if no points discovered
+                    this.#exportPoints([], data.result?.device);
                 }
+                this.#updateProgress(count, size);
             });
 
             discoverPointEvent.on(EVENT_ERROR, (data) => {
@@ -170,13 +165,16 @@ module.exports = {
 
             const tasks = this.devices.map((d, i) => ({
                 id: d.deviceName,
-                task: async () => {
+                device: d,
+                task: async (getNextInvokeId) => {
                     void i
                     try {
-                        const objectList = await readObjectList(this.client, d);
+                        const objectList = await readObjectList(this.client, d, getNextInvokeId);
 
                         // istanbul ignore next
-                        if (objectList == null) return;
+                        if (objectList == null) {
+                            return { device: d, points: [] }
+                        }
 
                         let objectListFinal = objectList
                             .map(obj => {
@@ -205,33 +203,42 @@ module.exports = {
 
                         return await readPoints(
                             d, objectListFinal, discoverPointEvent, this.name, this.client, this.readMethod,
-                            this.maxConcurrentSinglePointRead, this.concurrentTaskDelay
+                            this.maxConcurrentSinglePointRead, this.concurrentTaskDelay, getNextInvokeId
                         );
                     } catch (error) {
                         this.eventEmitter.emit(EVENT_ERROR, errMsg(this.name, `Error reading ${d.deviceName} points`, error));
+                        return { device: d, points: [] }
                     }
                 }
             }));
 
-            await concurrentTasks(discoverPointEvent, tasks, this.maxConcurrentDeviceRead);
+            await concurrentTasksWithNetworkAwareness(discoverPointEvent, tasks, this.maxConcurrentDeviceRead);
         }
 
-        #updateProgress(progress) {
-            this.eventEmitter.emit(EVENT_UPDATE_STATUS, progress);
+        #updateProgress(discovered, total) {
+            let message;
+            if (typeof discovered === 'string') {
+                // discovered is a status message like 'initializing' or 'completed'
+                message = discovered;
+            } else {
+                // discovered and total are numbers
+                message = `discovered: ${discovered}/${total}`;
+            }
+            this.eventEmitter.emit(EVENT_UPDATE_STATUS, message);
         }
 
-        #exportPoints() {
+        #exportPoints(points, device) {
             let exportPointsList = [];
-            for (let i = 0; i < this.pointsList.length; i++) {
+            for (let i = 0; i < points.length; i++) {
                 const { error, value: result } = bacnetPointSchema.validate(
-                    this.pointsList[i], { stripUnknown: true }
+                    points[i], { stripUnknown: true }
                 );
                 // istanbul ignore next
                 {
                     if (error) {
                         this.eventEmitter.emit(EVENT_ERROR, errMsg(
                             this.name, ERR_SCHEMA_VALIDATION, {
-                            bacnetPoint: this.pointsList[i],
+                            bacnetPoint: points[i],
                             error: error,
                         }));
                         continue
@@ -240,8 +247,10 @@ module.exports = {
                 exportPointsList.push(result);
             }
 
-            this.eventEmitter.emit(EVENT_OUTPUT, exportPointsList);
-            this.pointsList = [];
+            this.msg.payload = exportPointsList;
+            this.msg.device = device;
+            delete this.msg.devices;
+            this.eventEmitter.emit(EVENT_OUTPUT, this.msg);
         }
     }
 }
@@ -249,7 +258,7 @@ module.exports = {
 // ---------------------------------- functions ----------------------------------
 const readPoints = async (
     device, objects, eventEmitter, name, client, readMethod, maxConcurrentSinglePointRead,
-    concurrentTaskDelay
+    concurrentTaskDelay, getNextInvokeId
 ) => {
     const points = [];
 
@@ -270,7 +279,7 @@ const readPoints = async (
     try {
         // First request - get basic properties
         const result = await smartReadProperty(
-            client, device, reqArr, readMethod, maxConcurrentSinglePointRead, 50, concurrentTaskDelay
+            client, device, reqArr, readMethod, maxConcurrentSinglePointRead, 50, concurrentTaskDelay, getNextInvokeId
         );
 
         // Process basic properties first
@@ -291,7 +300,7 @@ const readPoints = async (
             try {
                 // Force use single read on state text to reduce loss especially long text
                 const stateTextResult = await smartReadProperty(
-                    client, device, stateTextReqArr, 0, 1, 50, concurrentTaskDelay
+                    client, device, stateTextReqArr, 0, 1, 50, concurrentTaskDelay, getNextInvokeId
                 );
 
                 // Update points with STATE_TEXT
@@ -314,11 +323,10 @@ const readPoints = async (
                 ));
             }
         }
-
-        return points;
     } catch (error) {
         eventEmitter.emit(EVENT_ERROR, errMsg(name, ERR_READING_POINTS, error));
     }
+    return { device: device, points: points }
 };
 
 const updatePointWithStateText = (point, stateTextData) => {

package/common/job/read_point.js

@@ -9,7 +9,7 @@ const { EVENT_OUTPUT, EVENT_UPDATE_STATUS, EVENT_ERROR } = require('@root/common
 const { smartReadProperty } = require('@root/common/bacnet.js')
 const { EG_BACNET_DEVICES, EG_BACNET_POINTS } = require('@root/common/example')
 const { facetsStrToObj, errMsg, getErrMsg } = require('@root/common/func.js')
-const { concurrentTasks } = require('@root/common/core/concurrent.js')
+const { concurrentTasksWithNetworkAwareness } = require('@root/common/core/concurrent.js')
 const {
     ERR_GENERIC, ERR_SCHEMA_VALIDATION, ERR_INVALID_DATA_TYPE, ERR_DUPLICATED_DEVICE_NAME,
     ERR_DUPLICATED_POINT_ID, ERR_POINT_NOT_ATTACHED_TO_DEVICE, ERR_READING_POINT
@@ -22,14 +22,15 @@ module.exports = {
         devicePointSeparator = '.';
 
         constructor(
-            client, eventEmitter, devices, points, readMethod, maxConcurrentDeviceRead = 2,
+            client, eventEmitter, msg, readMethod, maxConcurrentDeviceRead = 2,
             maxConcurrentSinglePointRead = 5, concurrentTaskDelay = 50, name = 'read point'
         ) {
             super();
             this.client = client
             this.eventEmitter = eventEmitter
-            this.devices = devices
-            this.points = points
+            this.msg = msg
+            this.devices = msg?.devices
+            this.points = msg?.points
             this.readMethod = readMethod
             this.maxConcurrentDeviceRead = maxConcurrentDeviceRead
             this.maxConcurrentSinglePointRead = maxConcurrentSinglePointRead
@@ -231,15 +232,16 @@ module.exports = {
                 .filter(([_, v]) => Array.isArray(v.points) && v.points.length > 0)  // eslint-disable-line
                 .map(([k, v]) => ({
                     id: k,
-                    task: async () => {
+                    device: v.device,
+                    task: async (getNextInvokeId) => {
                         return await smartReadProperty(
                             this.client, v.device, v.points, this.readMethod,
-                            this.maxConcurrentSinglePointRead, 10, this.concurrentTaskDelay
+                            this.maxConcurrentSinglePointRead, 10, this.concurrentTaskDelay, getNextInvokeId
                         );
                     }
                 }));
 
-            await concurrentTasks(smartReadEvent, tasks, this.maxConcurrentDeviceRead);
+            await concurrentTasksWithNetworkAwareness(smartReadEvent, tasks, this.maxConcurrentDeviceRead);
 
             // format final result
             this.points.forEach(p => {
@@ -310,7 +312,10 @@ module.exports = {
                 exportPoints[k] = result;
             }
 
-            this.eventEmitter.emit(EVENT_OUTPUT, exportPoints);
+            this.msg.payload = exportPoints;
+            delete this.msg.devices;
+            delete this.msg.points;
+            this.eventEmitter.emit(EVENT_OUTPUT, this.msg);
         }
     }
-}
+}

package/common/job/write_point.js

@@ -9,7 +9,7 @@ const { EVENT_UPDATE_STATUS, EVENT_ERROR, EVENT_OUTPUT } = require('@root/common
 const { smartWriteProperty } = require('@root/common/bacnet.js')
 const { EG_BACNET_DEVICES, EG_BACNET_POINTS, EG_BACNET_WRITE_POINTS } = require('@root/common/example')
 const { errMsg, getErrMsg } = require('@root/common/func.js')
-const { concurrentTasks } = require('@root/common/core/concurrent.js')
+const { concurrentTasksWithNetworkAwareness } = require('@root/common/core/concurrent.js')
 const {
     ERR_GENERIC, ERR_SCHEMA_VALIDATION, ERR_INVALID_DATA_TYPE, ERR_DUPLICATED_DEVICE_NAME,
     ERR_DUPLICATED_POINT_ID, ERR_POINT_NOT_ATTACHED_TO_DEVICE, ERR_WRITE_POINT_NOT_FOUND,
@@ -23,7 +23,7 @@ module.exports = {
         devicePointSeparator = '.';
 
         constructor(
-            client, eventEmitter, devices, points, writePoints,
+            client, eventEmitter, msg,
             maxConcurrentDeviceWrite = 2, maxConcurrentPointWrite = 1,
             concurrentTaskDelay = 50,
             name = 'write point'
@@ -31,9 +31,10 @@ module.exports = {
             super();
             this.client = client
             this.eventEmitter = eventEmitter
-            this.devices = devices
-            this.points = points
-            this.writePoints = writePoints
+            this.msg = msg
+            this.devices = msg?.devices
+            this.points = msg?.points
+            this.writePoints = msg?.writePoints
             this.maxConcurrentDeviceWrite = maxConcurrentDeviceWrite
             this.maxConcurrentPointWrite = maxConcurrentPointWrite
             this.concurrentTaskDelay = concurrentTaskDelay
@@ -286,10 +287,11 @@ module.exports = {
                 .filter(([_, v]) => (void _, Object.keys(v.writePoints).length > 0))
                 .map(([k, v]) => ({
                     id: k,
-                    task: async () => {
+                    device: v.device,
+                    task: async (getNextInvokeId) => {
                         return await smartWriteProperty(
                             this.client, v.device, v.writePoints, smartWriteEvent,
-                            this.maxConcurrentPointWrite, this.concurrentTaskDelay
+                            this.maxConcurrentPointWrite, this.concurrentTaskDelay, getNextInvokeId
                         );
                     }
                 }));
@@ -310,8 +312,42 @@ module.exports = {
                 ));
             });
 
-            await concurrentTasks(smartWriteEvent, tasks, this.maxConcurrentDeviceWrite);
+            await concurrentTasksWithNetworkAwareness(smartWriteEvent, tasks, this.maxConcurrentDeviceWrite);
+
+            // emit output with msg containing failed points and results
+            this.#exportWriteResults();
         }
 
+        #exportWriteResults() {
+            // Separate successful and failed points
+            const failedPoints = {};
+            let totalPoints = 0;
+            let successfulPoints = 0;
+
+            Object.entries(this.writePointDetails).forEach(([key, value]) => {
+                totalPoints++;
+                // Check if point has an error property (would be set if write failed)
+                if (value.error) {
+                    failedPoints[key] = value;
+                } else {
+                    successfulPoints++;
+                }
+            });
+
+            // Update msg with results
+            this.msg.payload = failedPoints;
+            this.msg.result = {
+                written: successfulPoints,
+                failed: Object.keys(failedPoints).length,
+                total: totalPoints
+            };
+
+            // Remove input properties from msg
+            delete this.msg.devices;
+            delete this.msg.points;
+            delete this.msg.writePoints;
+
+            this.eventEmitter.emit(EVENT_OUTPUT, this.msg);
+        }
     }
 }

package/package.json

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

package/red-bacnet/discover_device.js

@@ -42,6 +42,7 @@ module.exports = function (RED) {
             this.task = new DiscoverDeviceJob(
                 this.client,
                 this.#eventEmitter,
+                null,
                 this.network,
                 this.lowLimit,
                 this.highLimit,
@@ -72,12 +73,14 @@ module.exports = function (RED) {
                 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.task.msg = msg;
 
                 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` });
             });
@@ -87,10 +90,7 @@ module.exports = function (RED) {
                 this.task.onStop();
             })
 
-            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
-                const msg = {
-                    payload: data
-                };
+            this.#eventEmitter.on(EVENT_OUTPUT, (msg) => {
                 // @ts-ignore
                 this.send(msg);
             });
@@ -114,4 +114,3 @@ module.exports = function (RED) {
     // ----- register node -----
     RED.nodes.registerType('discover device', DiscoverDevice);
 }
-

package/red-bacnet/discover_point.html

@@ -7,7 +7,6 @@
             client: { type: "bacnet client", required: true },
             discoverMode: { value: 0, required: true, validate: RED.validators.number() },
             readMethod: { value: 2, required: true, validate: RED.validators.number() },
-            groupExportDeviceCount: { value: 30000, required: true, validate: RED.validators.number() },
             maxConcurrentDeviceRead: { value: 1, required: true, validate: RED.validators.number() },
             maxConcurrentSinglePointRead: { value: 10, required: true, validate: RED.validators.number() },
             concurrentTaskDelay: { value: 0, required: true, validate: RED.validators.number() },
@@ -46,10 +45,6 @@
             <option value="1">Comprehensive Read</option>
         </select>
     </div>
-    <div class="form-row">
-        <label for="node-input-groupExportDeviceCount"><i class="fa fa-tag"></i> Group Export Device Count</label>
-        <input type="number" id="node-input-groupExportDeviceCount" placeholder="50", min="10", max="1000">
-    </div>
     <div class="form-row">
         <label for="node-input-maxConcurrentDeviceRead"><i class="fa fa-tag"></i> Max Concurrent Device Read</label>
         <input type="number" id="node-input-maxConcurrentDeviceRead" placeholder="1" , min="1" , max="1000">
@@ -81,9 +76,6 @@
         <dd> <b>Read Single Only</b>: use <code>readProperty</code></dd>
         <dd> <b>Comprehensive Read</b>: try <code>readPropertyMultiple</code>, reduce query size if failed, and fallback to <code>readProperty</code> if query size reduced to 1</dd>
 
-        <dt>groupExportDeviceCount<span class="property-type">number</span></dt>
-        <dd> Emit <code>msg.payload</code> once discovered devices count reaches this limit</dd>
-
         <dt>maxConcurrentDeviceRead<span class="property-type">number</span></dt>
         <dd> Devices count to discover simultaneously.</dd>
         <dd> <b> USE WITH CAUTION!</b> Reduce to low value on a slow network</dd>

package/red-bacnet/discover_point.js

@@ -24,7 +24,6 @@ module.exports = function (RED) {
             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
@@ -54,8 +53,8 @@ module.exports = function (RED) {
                 }
 
                 const task = new DiscoverPointJob(
-                    this.client, this.#eventEmitter, msg?.devices, this.discoverMode, this.readMethod,
-                    this.groupExportDeviceCount, this.maxConcurrentDeviceRead,
+                    this.client, this.#eventEmitter, msg, this.discoverMode, this.readMethod,
+                    this.maxConcurrentDeviceRead,
                     this.maxConcurrentSinglePointRead, this.concurrentTaskDelay
                 );
 
@@ -68,21 +67,18 @@ module.exports = function (RED) {
                 this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
             });
 
-            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
-                const msg = {
-                    payload: data
-                };
+            this.#eventEmitter.on(EVENT_OUTPUT, (msg) => {
                 // @ts-ignore
                 this.send(msg);
             });
 
             this.#eventEmitter.on(EVENT_UPDATE_STATUS, (msg) => {
-                if (msg === 100)
+                if (msg === 'completed')
                     // @ts-ignore
                     this.status({ fill: 'green', shape: 'dot', text: `completed: ${nowFormatted()}` });
                 else
                     // @ts-ignore
-                    this.status({ fill: 'yellow', shape: 'dot', text: `progress: ${msg} %` });
+                    this.status({ fill: 'yellow', shape: 'dot', text: `${msg}` });
             });
 
             this.#eventEmitter.on(EVENT_ERROR, (err) => {

package/red-bacnet/read_point.js

@@ -44,38 +44,34 @@ module.exports = function (RED) {
             */
             // @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 ReadPointJob(
                     this.client,
                     this.#eventEmitter,
-                    msg.devices,
-                    msg.points,
+                    msg,
                     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,
+                    priority: Number.isFinite(msg.priority) ? msg.priority : 3,
                 });
                 // @ts-ignore
                 this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
             });
 
-            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
-                const msg = {
-                    payload: data
-                };
+            this.#eventEmitter.on(EVENT_OUTPUT, (msg) => {
                 // @ts-ignore
                 this.send(msg);
             });

package/red-bacnet/write_point.html

@@ -37,7 +37,7 @@
         <input type="number" id="node-input-maxConcurrentPointWrite" placeholder="5" , min="1" , max="1000">
     </div>
     <div class="form-row">
-        <label for="node-input-concurrentTaskDelay"><i class="fa fa-tag"></i> Concurrent Task Delay</label>
+        <label for="node-input-concurrentTaskDelay"><i class="fa fa-tag"></i> Concurrent Task Delay (ms)</label>
         <input type="number" id="node-input-concurrentTaskDelay" placeholder="0" , min="0" , max="10000">
     </div>
 </script>

package/red-bacnet/write_point.js

@@ -43,16 +43,6 @@ module.exports = function (RED) {
             */
             // @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)) {
@@ -61,6 +51,15 @@ module.exports = function (RED) {
                     return;
                 }
 
+                const task = new WritePointJob(
+                    this.client,
+                    this.#eventEmitter,
+                    msg,
+                    this.maxConcurrentDeviceWrite,
+                    this.maxConcurrentPointWrite,
+                    this.concurrentTaskDelay
+                );
+
                 this.job.addJob({
                     id: jobId,
                     task: task,
@@ -70,10 +69,7 @@ module.exports = function (RED) {
                 this.status({ fill: 'yellow', shape: 'dot', text: `in queue` });
             });
 
-            this.#eventEmitter.on(EVENT_OUTPUT, (data) => {
-                const msg = {
-                    payload: data
-                };
+            this.#eventEmitter.on(EVENT_OUTPUT, (msg) => {
                 // @ts-ignore
                 this.send(msg);
             });