@halsystems/red-bacnet 1.0.23 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [1.1.0]
+### Changed
+- Implemented auto resize batch size when querying using readPropertyMultiple to improve performance
+- Added readPropertyMultiple to read object list to reduce query speed
+- Changed strategy when discovering device name, implemented delay instead of burst to reduce traffic congestion and yield better result
+- Force use readProperty to read multistate object to improve result
+
+### Fixed
+- Failure to discover device name for Forwarded NPDU devices
+- Missed bacnet objects when using discover point
+
 ## [1.0.22]
 ### Fixed
 - Removed console.log in Read Point

package/common/bacnet.js

@@ -18,7 +18,8 @@ const { getErrMsg } = require('@root/common/func.js')
 // ---------------------------------- export ----------------------------------
 module.exports = {
     /**
-     * Reads the object list of a device.
+     * Reads the object list of a device using optimized batch reading.
+     * First tries readPropertyMultiple for faster performance, falls back to sequential reading if failed.
      * @param {BacnetClient} client
      * @param {object} device
      *  eg:{
@@ -38,15 +39,98 @@ module.exports = {
     readObjectList: async function (client, device) {
         const objectId = { type: baEnum.ObjectType.DEVICE, instance: device.deviceId };
         const propertyId = baEnum.PropertyIdentifier.OBJECT_LIST;
-        return await module.exports.readPropertyReturnArr(client, device, objectId, propertyId);
+
+        let result = await module.exports.readPropertyMultipleReturnArr(client, device, objectId, propertyId);
+        if (result.length == 0) {
+            result = await module.exports.readPropertyReturnArr(client, device, objectId, propertyId);
+        }
+
+        return result;
+    },
+
+    /**
+     * Reads a property that returns an array using readPropertyMultiple for better performance.
+     * Attempts to read the property in batches to minimize round trips.
+     * @param {BacnetClient} client
+     * @param {object} device
+     * @param {object} objectId
+     * @param {number} propertyId
+     * @returns array of objects
+     * @async
+     */
+    readPropertyMultipleReturnArr: async function (client, device, objectId, propertyId) {
+        let addressSet = device.ipAddress;
+        if (device.macAddress != null && device.network != null) {
+            addressSet = {
+                ip: device.ipAddress,
+                adr: device.macAddress,
+                net: device.network
+            };
+        }
+
+        const result = [];
+        let healthy = true;
+
+        // helper for single batch request
+        async function readBatch(arrayIndex) {
+            const reqArr = [{
+                objectId: objectId,
+                properties: [{
+                    id: propertyId,
+                    index: arrayIndex != null ? arrayIndex : baEnum.ASN1_ARRAY_ALL
+                }]
+            }];
+
+            return new Promise((resolve, reject) => {
+                client.readPropertyMultiple(
+                    addressSet,
+                    reqArr,
+                    { maxApdu: device.maxApdu },
+                    (err, value) => {
+                        if (err) return reject(err);
+                        resolve(value);
+                    }
+                );
+            });
+        }
+
+        // try reading all at once first
+        try {
+            const value = await readBatch(baEnum.ASN1_ARRAY_ALL);
+            if (value?.values?.[0]?.values?.[0]?.value) {
+                return value.values[0].values[0].value;
+            }
+        } catch (err) {
+            void err
+            healthy = false;
+        }
+
+        // try using index read
+        if (!healthy) {
+            for (let i = 0; ; i++) {
+                try {
+                    const res = await readBatch(i);
+                    const item = res?.values?.[0]?.values?.[0]?.value?.[0];
+
+                    if (item?.type === 105) break
+
+                    result.push(item);
+                    console.log(item)
+                } catch (err) {
+                    void err
+                    break;
+                }
+            }
+        }
+
+        return result;
     },
 
     /**
      * Smart read multiple properties from a BACnet device with concurrent read feature and various read methods
      * readMethod
      * 0: use readProperty only
-     * 1: try readPropertyMultiple with consevative query size, fallback to readProperty if failed
-     * 2: try readPropertyMultiple twice with high and conservative query size, fallback to readProperty if failed
+     * 1: try readPropertyMultiple, reduce query size if failed, and fallback to readProperty if query size reduced to 1
      * @param {BacnetClient} client
      * @param {object} device
      *  eg:{
@@ -95,16 +179,12 @@ module.exports = {
         if (readMethod > 0) {
             // calculate batch sizes
             if (device.maxApdu == null) // default batch size if null or undefined
-                batchSizes.add(20).add(5);
+                batchSizes.add(20);
             else {
-                const perValueBytes = [30, 50] // typical numeric point is 17 byte
+                const perValueBytes = [30] // typical numeric point is 17 byte
                 for (let x = 0; x < perValueBytes.length; x++)
                     batchSizes.add(Math.trunc(device.maxApdu / perValueBytes[x]))
             }
-
-            // if readMethod === 1
-            if (readMethod === 1 && batchSizes.size > 1)
-                batchSizes = new Set([...batchSizes].slice(-1));
         }
 
         for (const batchSize of batchSizes) {
@@ -112,6 +192,7 @@ module.exports = {
             let first = true
             let reqArrBatch
             let batchCount
+            let currBatchSize = batchSize
 
             do { // use current batch size until query failed
                 // get ready for next batch
@@ -132,7 +213,7 @@ module.exports = {
                     if (reqArrIndexNext >= reqArr.length)
                         break
 
-                    if (batchCount + reqArr[reqArrIndexNext].properties.length > batchSize)
+                    if (batchCount + reqArr[reqArrIndexNext].properties.length > currBatchSize)
                         break
 
                     reqArrBatch.push(reqArr[reqArrIndexNext])
@@ -143,6 +224,14 @@ module.exports = {
                 // read batch block
                 const value = await module.exports.readPropertyMultple(client, device, reqArrBatch)
                     .catch(() => {
+                        // Reduce batch size by half (minimum 1)
+                        currBatchSize = Math.max(1, Math.floor(currBatchSize / 2))
+
+                        // If batch size is too small, mark as unhealthy
+                        if (currBatchSize <= 1) {
+                            healthy = false
+                        }
+
                         reqArrIndexNext = reqArrIndex
                         healthy = false
                     })
@@ -196,7 +285,7 @@ module.exports = {
                             return value;
                         } catch (err) {
                             failedCount++;
-                            if (readMethod < 2 && failedCount >= singleReadFailedRetry)
+                            if (readMethod < 1 && failedCount >= singleReadFailedRetry)
                                 throw err
                         }
                     }
@@ -317,7 +406,7 @@ module.exports = {
      *  eg: 85
      * @returns object
      *  eg: { len: 11, objectId: { type: 19, instance: 1 },
-     *      property: { id: 85, index: 4294967295 }, values: [ { type: 2, value: 3 } ]}
+     *      property: { id: 85, index: 4294967295 }, values: [ { type: 2, value: 3 }]}
      * @async
      */
     readProperty: async function (client, device, objectId, propertyId) {
@@ -485,4 +574,4 @@ module.exports = {
                 });
         });
     },
-}
+}

package/common/core/concurrent.js

@@ -2,6 +2,7 @@
 require('./_alias.js');
 
 const { EVENT_OUTPUT, EVENT_ERROR } = require('@root/common/core/constant.js');
+const { delay } = require('@root/common/core/util.js');
 
 // ---------------------------------- type def ----------------------------------
 /**
@@ -43,8 +44,7 @@ module.exports = {
                 await Promise.race(executing);
             }
 
-            // need delay?
-            // if (typeof delay === 'function') await delay(1);
+            await delay(50)
         }
 
         await Promise.allSettled(executing);

package/common/job/discover_device.js

@@ -31,10 +31,9 @@ module.exports = {
          * @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.
-         * @param {number} readDeviceNameTimeout - Read device name timeout in milliseconds.
          */
         constructor(
-            client, eventEmitter, network, lowLimit, highLimit, whoIsTimeout, readDeviceNameTimeout,
+            client, eventEmitter, network, lowLimit, highLimit, whoIsTimeout,
             name = 'discover device'
         ) {
             super();
@@ -44,7 +43,6 @@ module.exports = {
             this.lowLimit = lowLimit
             this.highLimit = highLimit
             this.whoIsTimeout = whoIsTimeout
-            this.readDeviceNameTimeout = readDeviceNameTimeout
             this.name = name
         }
 
@@ -108,7 +106,6 @@ module.exports = {
          * @returns {Promise<void>}
          */
         async #readDevices() {
-            const chunkSize = 100;
             const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 
             const readDeviceName = (d, addressSet) => {
@@ -138,26 +135,22 @@ module.exports = {
                 });
             };
 
-            for (let i = 0; i < this.discoverList.length; i += chunkSize) {
-                const chunk = this.discoverList.slice(i, i + chunkSize);
+            for (let i = 0; i < this.discoverList.length; i++) {
+                const d = this.discoverList[i];
 
-                const promises = chunk.map(d => {
-                    let addressSet = d.address;
-                    if (d.adr !== undefined && d.net !== undefined) {
-                        addressSet = { ip: d.address, adr: d.adr, net: d.net };
-                    }
-
-                    return readDeviceName(d, addressSet)
-                        .then(deviceInfo => this.discoveredDevices.push(deviceInfo));
-                });
+                let addressSet = d.address;
+                if (d.adr !== undefined && d.net !== undefined) {
+                    addressSet = { ip: d.address, adr: d.adr, net: d.net };
+                }
 
-                await Promise.allSettled(promises);
-                await delay(this.readDeviceNameTimeout);
+                const deviceInfo = await readDeviceName(d, addressSet);
+                this.discoveredDevices.push(deviceInfo);
 
-                // update progress
+                // throttle to avoid bursts
+                await delay(75); // tweak between 50–150ms
                 this.#updateProgress(
-                    Math.min(90, Math.round((80 / this.discoverList.length) * (i + chunkSize) + 10))
-                )
+                    Math.min(90, Math.round((80 / this.discoverList.length) * (i + 1) + 10))
+                );
             }
 
             this.#updateProgress(90)

package/common/job/discover_point.js

@@ -240,6 +240,8 @@ const readPoints = async (
     device, objects, eventEmitter, name, client, readMethod, maxConcurrentSinglePointRead
 ) => {
     const points = [];
+
+    // First query - get basic properties (excluding STATE_TEXT)
     const reqArr = objects.map(obj => ({
         objectId: { type: obj.value.type, instance: obj.value.instance },
         properties: [
@@ -250,38 +252,80 @@ const readPoints = async (
                 { id: baEnum.PropertyIdentifier.INACTIVE_TEXT },
                 { id: baEnum.PropertyIdentifier.ACTIVE_TEXT }
             ] : []),
-            ...(multiStateObjectTypes.includes(obj.value.type) ? [{ id: baEnum.PropertyIdentifier.STATE_TEXT }] : []),
-            // ...(scheduleObjectTypes.includes(obj.value.type) ? [
-            //     { id: baEnum.PropertyIdentifier.WEEKLY_SCHEDULE },
-            //     { id: baEnum.PropertyIdentifier.EXCEPTION_SCHEDULE },
-            //     { id: baEnum.PropertyIdentifier.SCHEDULE_DEFAULT }
-            // ] : [])
         ]
     }));
 
     try {
+        // First request - get basic properties
         const result = await smartReadProperty(
             client, device, reqArr, readMethod, maxConcurrentSinglePointRead, 50
         );
+
+        // Process basic properties first
         result.forEach(i => {
-            /** i example
-                {
-                    objectId: { type: 1, instance: 0 },
-                    values: [
-                        { id: 85, index: 4294967295, value: [Array] },
-                        { id: 77, index: 4294967295, value: [Array] }
-                    ]
-                }
-             */
             const point = processPoint(i, device.deviceName);
             points.push(point);
         });
-        return points
+
+        // Second query - get STATE_TEXT for multistate objects only
+        const multistateObjects = objects.filter(obj => multiStateObjectTypes.includes(obj.value.type));
+
+        if (multistateObjects.length > 0) {
+            const stateTextReqArr = multistateObjects.map(obj => ({
+                objectId: { type: obj.value.type, instance: obj.value.instance },
+                properties: [{ id: baEnum.PropertyIdentifier.STATE_TEXT }]
+            }));
+
+            try {
+                // Force use single read on state text to reduce loss especially long text
+                const stateTextResult = await smartReadProperty(
+                    client, device, stateTextReqArr, 0, 1, 50
+                );
+
+                // Update points with STATE_TEXT
+                stateTextResult.forEach(stateTextData => {
+                    const matchingPoint = points.find(point =>
+                        point.bacType === stateTextData.objectId.type &&
+                        point.bacInstance === stateTextData.objectId.instance
+                    );
+
+                    if (matchingPoint) {
+                        updatePointWithStateText(matchingPoint, stateTextData);
+                    }
+                });
+            } catch (stateTextError) {
+                // Log the error but don't fail the entire operation
+                eventEmitter.emit(EVENT_ERROR, errMsg(
+                    name,
+                    'Warning: Failed to read STATE_TEXT properties',
+                    stateTextError
+                ));
+            }
+        }
+
+        return points;
     } catch (error) {
         eventEmitter.emit(EVENT_ERROR, errMsg(name, ERR_READING_POINTS, error));
     }
 };
 
+const updatePointWithStateText = (point, stateTextData) => {
+    const stateTextProp = stateTextData.values.find(prop => prop.id === baEnum.PropertyIdentifier.STATE_TEXT);
+    const states = stateTextProp?.value;
+
+    if (Array.isArray(states)) {
+        // Update the facets with state text information
+        const stateTextFacet = `range:{${states.map((item, index) => `${index + 1}:${item.value}`).join(';')}}`;
+
+        // If point already has facets, append; otherwise, set new facets
+        if (point.facets) {
+            point.facets += `;${stateTextFacet}`;
+        } else {
+            point.facets = stateTextFacet;
+        }
+    }
+};
+
 const processPoint = (i, deviceName) => {
     const point = {
         deviceName,
@@ -310,12 +354,8 @@ const setPointFacets = (point, i) => {
         const inactive = i.values.find(prop => prop.id === baEnum.PropertyIdentifier.INACTIVE_TEXT)?.value?.[0]?.value;
         const active = i.values.find(prop => prop.id === baEnum.PropertyIdentifier.ACTIVE_TEXT)?.value?.[0]?.value;
         point.facets = `falseText:${inactive ? inactive : 'false'};trueText:${active ? active : 'true'}`;
-    } else if (multiStateObjectTypes.includes(point.bacType)) {
-        const states = i.values.find(prop => prop.id === baEnum.PropertyIdentifier.STATE_TEXT)?.value;
-        if (Array.isArray(states)) {
-            point.facets = `range:{${states.map((item, index) => `${index + 1}:${item.value}`).join(';')}}`;
-        }
     }
+    // STATE_TEXT handling removed from here - now handled separately
 };
 
 const setPointValues = (point, i) => {

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

@@ -12,8 +12,10 @@ const encode = (buffer, func, msgLength) => {
 exports.encode = encode;
 const decode = (buffer, offset) => {
     let len;
+    let linkAddress;
     const func = buffer[1];
     const msgLength = (buffer[2] << 8) | (buffer[3] << 0);
+
     if (buffer[0] !== baEnum.BVLL_TYPE_BACNET_IP || buffer.length !== msgLength)
         return;
     switch (func) {
@@ -25,6 +27,27 @@ const decode = (buffer, offset) => {
             break;
         case baEnum.BvlcResultPurpose.FORWARDED_NPDU:
             len = 10;
+            // HAL modified. Extract BVLC IP and port from buffer
+            if (buffer.length >= 10) {
+                const ipParts = [buffer[4], buffer[5], buffer[6], buffer[7]];
+                const port = (buffer[8] << 8) | buffer[9];
+
+                // Validate IP octets (0–255 only)
+                const isValidIp = ipParts.every(octet => Number.isInteger(octet) && octet >= 0 && octet <= 255);
+
+                // Validate port (1–65535; BACnet default is 47808)
+                const isValidPort = Number.isInteger(port) && port > 0 && port <= 65535;
+
+                // Extra IP rules
+                const isBroadcast = ipParts.every(octet => octet === 255); // 255.255.255.255
+                const isMulticast = ipParts[0] >= 224 && ipParts[0] <= 239; // 224.0.0.0 – 239.255.255.255
+                const isZero = ipParts.every(octet => octet === 0); // 0.0.0.0
+
+                if (isValidIp && isValidPort && !isBroadcast && !isMulticast && !isZero) {
+                    const ip = ipParts.join(".");
+                    linkAddress = (port === 47808) ? ip : `${ip}:${port}`;
+                }
+            }
             break;
         case baEnum.BvlcResultPurpose.REGISTER_FOREIGN_DEVICE:
         case baEnum.BvlcResultPurpose.READ_FOREIGN_DEVICE_TABLE:
@@ -41,7 +64,8 @@ const decode = (buffer, offset) => {
     return {
         len: len,
         func: func,
-        msgLength: msgLength
+        msgLength: msgLength,
+        linkAddress: linkAddress
     };
 };
 exports.decode = decode;

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

@@ -458,6 +458,8 @@ class Client extends events_1.EventEmitter {
         this._handlePdu(remoteAddress, apduType, buffer, offset, msgLength, addressObject, destAddress);
     }
     _receiveData(buffer, remoteAddress) {
+        let srcAddress = remoteAddress
+
         // Check data length
         if (buffer.length < baEnum.BVLC_HEADER_LENGTH)
             return debug('Received invalid data -> Drop package');
@@ -465,9 +467,14 @@ class Client extends events_1.EventEmitter {
         const result = baBvlc.decode(buffer, 0);
         if (!result)
             return debug('Received invalid BVLC header -> Drop package');
-        // Check BVLC function
+        // Check BVLC virtual link controller address if defined
         if (result.func === baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU || result.func === baEnum.BvlcResultPurpose.ORIGINAL_BROADCAST_NPDU || result.func === baEnum.BvlcResultPurpose.FORWARDED_NPDU) {
-            this._handleNpdu(buffer, result.len, buffer.length - result.len, remoteAddress);
+            // HAL modified. Use BACnet link address if exists
+            if (result.func === baEnum.BvlcResultPurpose.FORWARDED_NPDU && result.linkAddress) {
+                srcAddress = result.linkAddress
+            }
+
+            this._handleNpdu(buffer, result.len, buffer.length - result.len, srcAddress);
         }
         else {
             debug('Received unknown BVLC function -> Drop package');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halsystems/red-bacnet",
-  "version": "1.0.23",
+  "version": "1.1.0",
   "description": "NodeRED BACnet IP client",
   "email": "open_source@halsystems.com.au",
   "repository": {

package/red-bacnet/discover_device.html

@@ -9,7 +9,6 @@
             lowLimit: { value: 0, required: true, validate: RED.validators.number() },
             highLimit: { value: 4194304, required: true, validate: RED.validators.number() },
             whoIsTimeout: { value: 3000, required: true, validate: RED.validators.number() },
-            readDeviceTimeout: { value: 1000, required: true, validate: RED.validators.number() },
         },
         inputs: 1,
         outputs: 1,
@@ -46,10 +45,6 @@
         <label for="node-input-whoIsTimeout"><i class="fa fa-tag"></i> Who Is Timeout (ms)</label>
         <input type="number" id="node-input-whoIsTimeout" placeholder="3000", min="100", max="3600000">
     </div>
-    <div class="form-row">
-        <label for="node-input-readDeviceTimeout"><i class="fa fa-tag"></i> Read Device Timeout (ms)</label>
-        <input type="number" id="node-input-readDeviceTimeout" placeholder="1000", min="100", max="3600000">
-    </div>
 </script>
 
 <script type="text/html" data-help-name="discover device">

package/red-bacnet/discover_device.js

@@ -28,7 +28,6 @@ module.exports = function (RED) {
             this.lowLimit = +config.lowLimit
             this.highLimit = +config.highLimit
             this.whoIsTimeout = +config.whoIsTimeout
-            this.readDeviceTimeout = +config.readDeviceTimeout
 
             // events
             this.#subscribeListeners();
@@ -45,7 +44,6 @@ module.exports = function (RED) {
                 this.lowLimit,
                 this.highLimit,
                 this.whoIsTimeout,
-                this.readDeviceTimeout
             );
             this.task.onStart();
         }

package/red-bacnet/discover_point.html

@@ -41,8 +41,7 @@
         <label for="node-input-readMethod"><i class="fa fa-list"></i> Read Method</label>
         <select id="node-input-readMethod">
             <option value="0">Read Single Only</option>
-            <option value="1">Read Multiple Fallback Single</option>
-            <option value="2">Comprehensive Read</option>
+            <option value="1">Comprehensive Read</option>
         </select>
     </div>
     <div class="form-row">
@@ -73,8 +72,7 @@
 
         <dt>readMethod<span class="property-type">number</span></dt>
         <dd> <b>Read Single Only</b>: use <code>readProperty</code></dd>
-        <dd> <b>Read Multiple Fallback Single</b>: try <code>readPropertyMultiple</code> with consevative query size, fallback to <code>readProperty</code> if failed</dd>
-        <dd> <b>Comprehensive Read</b>: try <code>readPropertyMultiple</code> twice with high and conservative query size, fallback to <code>readProperty</code> if failed</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>