@bitpoolos/edge-bacnet 1.6.4 → 1.6.6

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.6.6] - 20-11-2025
+
+Minor update:
+
+- Added all stored point properties as columns to "Export point list" CSV in read node Properties tab.
+- Adjustment to point polling, setting stricter maxApdu sizes 
+
+## [1.6.5] - 09-10-2025
+
+Bug fix:
+
+- Specific users found issues of spiking values. Results after a read query are now force ordered. An adjustment made to the bacnet stack _getInvokeId function as it was running out of array space to process a high volume of request responses.
+
+
 ## [1.6.4] - 02-09-2025
 
 Minor feature:

package/bacnet_client.js

@@ -222,9 +222,31 @@ class BacnetClient extends EventEmitter {
       port: port,
     };
 
+    // Try to find the device to use device-specific options
+    let device = null;
+    if (type === 8) {
+      // Device object - instance is the device ID
+      device = that.deviceList.find(ele => ele.getDeviceId() === instance);
+    } else {
+      // For non-device objects, we can't determine the device from just address/instance
+      // This is a limitation of testFunction's current signature
+    }
+
+    // Use device-specific options if we found the device, otherwise use safer defaults
+    let readOptions;
+    if (device) {
+      readOptions = that.getDeviceSpecificOptions(device);
+    } else {
+      // Conservative defaults for unknown devices (assume small MSTP)
+      readOptions = {
+        maxSegments: 0,  // No segmentation
+        maxApdu: 2       // 206 octets - safe for most MSTP devices
+      };
+    }
+
     const propertiesArray = [{ objectId: { type: type, instance: instance }, properties: [{ id: property }] }];
 
-    that.client.readPropertyMultiple(addressObject, propertiesArray, that.readPropertyMultipleOptions, (err, value) => {
+    that.client.readPropertyMultiple(addressObject, propertiesArray, readOptions, (err, value) => {
       console.log("1 - readPropertyMultiple:  ");
 
       console.log(value);
@@ -248,7 +270,7 @@ class BacnetClient extends EventEmitter {
       addressObject,
       { type: type, instance: instance },
       property,
-      that.readPropertyMultipleOptions,
+      readOptions,
       (err, value) => {
         console.log("2 - readProperty:  ");
 
@@ -316,12 +338,13 @@ class BacnetClient extends EventEmitter {
       address: device.getAddress(),
       port: device.getPort(),
     };
+    const readOptions = that.getDeviceSpecificOptions(device);
     return new Promise((resolve, reject) => {
       that.client.readProperty(
         addressObject,
         { type: baEnum.ObjectType.DEVICE, instance: device.getDeviceId() },
         baEnum.PropertyIdentifier.PROTOCOL_SERVICES_SUPPORTED,
-        that.readPropertyMultipleOptions,
+        readOptions,
         (err, value) => {
           if (err) {
             reject(err);
@@ -339,7 +362,7 @@ class BacnetClient extends EventEmitter {
     let that = this;
     let address = device.getAddress().address;
     let deviceId = device.getDeviceId();
-    let foundParentIndex = that.deviceList.findIndex((ele) => ele.getAddress() == address);
+    let foundParentIndex = that.deviceList.findIndex((ele) => that.getDeviceAddress(ele) == address);
     if (foundParentIndex !== -1) {
       that.deviceList[foundParentIndex].addChildDevice(deviceId);
       device.setParentDeviceId(that.deviceList[foundParentIndex].getDeviceId());
@@ -827,16 +850,12 @@ class BacnetClient extends EventEmitter {
       };
 
       // Process the results of the batch
-      results.value.values.forEach((pointResult) => {
-        const cacheRef = requestArray.find(
-          (ele) =>
-            ele.pointRef.meta.objectId.type === pointResult.objectId.type &&
-            ele.pointRef.meta.objectId.instance === pointResult.objectId.instance
-        );
+      results.value.values.forEach((pointResult, index) => {
+        const cacheRef = requestArray[index];
+        const pointRef = cacheRef.pointRef;
+        const pointNameRef = cacheRef.pointName;
 
-        if (cacheRef) {
-          const pointRef = cacheRef.pointRef;
-          const pointNameRef = cacheRef.pointName;
+        if (pointResult.values[0].value.length > 0) {
           const val = pointResult.values[0].value[0].value;
 
           if (isNumber(val)) {
@@ -865,13 +884,12 @@ class BacnetClient extends EventEmitter {
               pointRef.status = "online";
             }
           }
-
-          pointRef.meta["device"] = deviceMetaInfo;
-          pointRef.timestamp = Date.now();
-
-          // Store the point data in results
-          bacnetResults[deviceName][pointNameRef] = pointRef;
         }
+        pointRef.meta["device"] = deviceMetaInfo;
+        pointRef.timestamp = Date.now();
+
+        // Store the point data in results
+        bacnetResults[deviceName][pointNameRef] = pointRef;
       });
     } catch (err) {
       that.logOut("Error processing batch:", err);
@@ -944,13 +962,46 @@ class BacnetClient extends EventEmitter {
 
   async updateManyPoints(device, points) {
     try {
-      const results = await this._readObjectWithRequestArray(device, points, this.readPropertyMultipleOptions);
+      // Use device-specific options instead of global options
+      const deviceOptions = this.getDeviceSpecificOptions(device);
+      const results = await this._readObjectWithRequestArray(device, points, deviceOptions);
       return results;
     } catch (error) {
       throw error;
     }
   }
 
+  getDeviceSpecificOptions(device) {
+    let maxSegments = this.readPropertyMultipleOptions.maxSegments;
+    let maxApdu = this.readPropertyMultipleOptions.maxApdu;
+
+    // Adjust for devices with no segmentation support
+    if (device.getSegmentation() == 3) {
+      maxSegments = 0;
+    }
+
+    // Adjust maxApdu based on device capability
+    const deviceMaxApdu = device.getMaxApdu();
+    if (deviceMaxApdu <= 50) {
+      maxApdu = 0; // 50 octets
+    } else if (deviceMaxApdu <= 128) {
+      maxApdu = 1; // 128 octets  
+    } else if (deviceMaxApdu <= 206) {
+      maxApdu = 2; // 206 octets
+    } else if (deviceMaxApdu <= 480) {
+      maxApdu = 3; // 480 octets
+    } else if (deviceMaxApdu <= 1024) {
+      maxApdu = 4; // 1024 octets
+    } else {
+      maxApdu = 5; // 1476 octets
+    }
+
+    return {
+      maxSegments: maxSegments,
+      maxApdu: maxApdu
+    };
+  }
+
   updatePointWithRetry(device, point, retryCount = 1) {
     let that = this;
     const tryUpdate = (retriesLeft) => {
@@ -1002,21 +1053,8 @@ class BacnetClient extends EventEmitter {
       port: device.getPort(),
     };
 
-    let maxSegments = that.readPropertyMultipleOptions.maxSegments;
-    let maxApdu = that.readPropertyMultipleOptions.maxApdu;
-
-    if (device.getSegmentation() == 3) {
-      maxSegments = 0;
-    }
-
-    if (device.getMaxApdu() == 480) {
-      maxApdu = 3;
-    }
-
-    let settings = {
-      maxSegments: maxSegments,
-      maxApdu: maxApdu,
-    };
+    // Use device-specific options
+    const settings = that.getDeviceSpecificOptions(device);
 
     return new Promise((resolve, reject) => {
       that.client.readProperty(
@@ -1037,8 +1075,15 @@ class BacnetClient extends EventEmitter {
   }
 
   estimateMaxObjectSize(apduSize) {
-    if (apduSize < 500) {
-      return 20;
+    // Be more conservative for very small MSTP devices
+    if (apduSize <= 50) {
+      return 1;  // Only 1 object at a time for 50-byte devices
+    } else if (apduSize <= 128) {
+      return 3;  // 3 objects for 128-byte devices
+    } else if (apduSize <= 206) {
+      return 5;  // 5 objects for 206-byte devices
+    } else if (apduSize < 500) {
+      return 10; // Reduced from 20 for safety
     } else if (apduSize > 500 && apduSize < 1000) {
       //return Math.round(((apduSize - 30) / 7));
       return 50;
@@ -1217,6 +1262,32 @@ class BacnetClient extends EventEmitter {
     };
     return new Promise((resolve, reject) => {
       that.client.readPropertyMultiple(addressObject, requestArray, readOptions, (error, value) => {
+        if (value && value.values) {
+          const reorderedValues = requestArray.map((req) => {
+            const foundValue = value.values.find(
+              (val) => val.objectId.type === req.objectId.type && val.objectId.instance === req.objectId.instance
+            );
+            return (
+              foundValue || {
+                objectId: req.objectId,
+                values: [
+                  {
+                    value: [
+                      {
+                        value: {
+                          errorClass: baEnum.ErrorClass.PROPERTY,
+                          errorCode: baEnum.ErrorCode.UNKNOWN_PROPERTY,
+                        },
+                      },
+                    ],
+                  },
+                ],
+              }
+            );
+          });
+          value.values = reorderedValues;
+        }
+
         resolve({
           error: error,
           value: value,
@@ -1233,12 +1304,13 @@ class BacnetClient extends EventEmitter {
       port: device.getPort(),
     };
     let deviceId = device.getDeviceId();
+    const readOptions = that.getDeviceSpecificOptions(device);
 
     that.client.readProperty(
       addressObject,
       { type: baEnum.ObjectType.DEVICE, instance: deviceId },
       baEnum.PropertyIdentifier.OBJECT_NAME,
-      that.readPropertyMultipleOptions,
+      readOptions,
       callback
     );
   }
@@ -1283,10 +1355,8 @@ class BacnetClient extends EventEmitter {
 
   _readObjectFull(device, type, instance) {
     const that = this;
-    const readOptions = {
-      maxSegments: that.readPropertyMultipleOptions.maxSegments,
-      maxApdu: that.readPropertyMultipleOptions.maxApdu,
-    };
+    // Use device-specific options for reading all properties
+    const readOptions = that.getDeviceSpecificOptions(device);
 
     const readIndividualPropsOptions = {
       maxSegments: 0,
@@ -1384,10 +1454,8 @@ class BacnetClient extends EventEmitter {
 
   _readObjectLite(device, type, instance) {
     const that = this;
-    const readOptions = {
-      maxSegments: that.readPropertyMultipleOptions.maxSegments,
-      maxApdu: that.readPropertyMultipleOptions.maxApdu,
-    };
+    // Use device-specific options
+    const readOptions = that.getDeviceSpecificOptions(device);
 
     const readIndividualPropsOptions = {
       maxSegments: 0,
@@ -1552,10 +1620,8 @@ class BacnetClient extends EventEmitter {
   scanDevice(device) {
     let that = this;
     return new Promise((resolve, reject) => {
-      const readOptions = {
-        maxSegments: that.readPropertyMultipleOptions.maxSegments,
-        maxApdu: that.readPropertyMultipleOptions.maxApdu,
-      };
+      // Use device-specific options
+      const readOptions = that.getDeviceSpecificOptions(device);
       this._readObjectList(device, readOptions, (err, result) => {
         if (!err) {
           try {

package/bacnet_gateway.js

@@ -212,14 +212,10 @@ module.exports = function (RED) {
       }
     }
 
-    if (
-      node.bacnetServerEnabled == true &&
-      node.bacnetClient &&
-      node.bacnetServer
-    ) {
+    if (node.bacnetServerEnabled == true && node.bacnetClient && node.bacnetServer) {
       try {
         // Clean up any existing listeners to prevent stale references
-        node.bacnetServer.removeAllListeners('writeProperty');
+        node.bacnetServer.removeAllListeners("writeProperty");
 
         // Store the event handler function so we can clean it up later
         node.writePropertyHandler = (topic, newValue) => {
@@ -269,7 +265,7 @@ module.exports = function (RED) {
         } else if (msg.doUpdatePriorityDevices == true && msg.priorityDevices !== null) {
           node.bacnetClient
             .updatePriorityQueue(msg.priorityDevices)
-            .then(function (result) { })
+            .then(function (result) {})
             .catch(function (error) {
               logOut("Error updating priorityQueue: ", error);
             });
@@ -283,7 +279,7 @@ module.exports = function (RED) {
 
           node.bacnetClient
             .applyDisplayNames(msg.pointsToRead)
-            .then(function (result) { })
+            .then(function (result) {})
             .catch(function (error) {
               logOut("Error in applyDisplayNames: ", error);
             });
@@ -306,7 +302,7 @@ module.exports = function (RED) {
       node.on("close", function () {
         // Clean up the writeProperty event listener
         if (node.bacnetServer && node.writePropertyHandler) {
-          node.bacnetServer.removeListener('writeProperty', node.writePropertyHandler);
+          node.bacnetServer.removeListener("writeProperty", node.writePropertyHandler);
           node.writePropertyHandler = null;
         }
 
@@ -794,7 +790,6 @@ module.exports = function (RED) {
             if (points[point] && "presentValue" in points[point]) {
               let pointName = getPointName(points[point], point);
               let topic = getTopicString("sendSimpleWithStatus", useDeviceName, readNodeName, device, pointName);
-
               msgg.topic = topic;
               let payload = {
                 presentValue: points[point]["presentValue"],

package/bacnet_read.html

@@ -433,8 +433,20 @@
           },
           exportPointListCsv() {
             let app = this;
-            let csvContent = "ipAddress,deviceId,deviceName,pointName,objectType" + "\r\n";
+            let csvContent = "ipAddress,deviceId,deviceName,pointName,objectType,presentValue,description,units,objectName,displayName,systemStatus,modificationDate,programState,recordCount,hasPriorityArray,vendorName" + "\r\n";
             const keys = Object.keys(app.pointList);
+
+            // Helper function to safely get property value and escape for CSV
+            const getCsvValue = (value) => {
+              if (value === null || value === undefined) return "";
+              const stringValue = String(value);
+              // Escape double quotes and wrap in quotes if contains comma, newline, or double quote
+              if (stringValue.includes(',') || stringValue.includes('\n') || stringValue.includes('"')) {
+                return '"' + stringValue.replace(/"/g, '""') + '"';
+              }
+              return stringValue;
+            };
+
             for (key in keys) {
               const guid = keys[key];
               const ipAddress = guid.split("-")[0];
@@ -452,16 +464,39 @@
                 const points = Object.keys(deviceObject);
                 if (points.length > 0) {
                   for (point in points) {
+                    const pointData = deviceObject[points[point]] || {};
                     csvContent +=
-                      ipAddress +
+                      getCsvValue(ipAddress) +
+                      "," +
+                      getCsvValue(deviceId) +
+                      "," +
+                      getCsvValue(deviceName) +
+                      "," +
+                      getCsvValue(points[point]) +
+                      "," +
+                      getCsvValue(pointData.meta?.objectId?.type) +
                       "," +
-                      deviceId +
+                      getCsvValue(pointData.presentValue) +
                       "," +
-                      deviceName +
+                      getCsvValue(pointData.description) +
                       "," +
-                      points[point] +
+                      getCsvValue(pointData.units) +
                       "," +
-                      deviceObject[points[point]].meta.objectId.type +
+                      getCsvValue(pointData.objectName) +
+                      "," +
+                      getCsvValue(pointData.displayName) +
+                      "," +
+                      getCsvValue(pointData.systemStatus) +
+                      "," +
+                      getCsvValue(pointData.modificationDate) +
+                      "," +
+                      getCsvValue(pointData.programState) +
+                      "," +
+                      getCsvValue(pointData.recordCount) +
+                      "," +
+                      getCsvValue(pointData.hasPriorityArray) +
+                      "," +
+                      getCsvValue(pointData.vendorName) +
                       "\r\n";
 
                     if (parseInt(point) == points.length - 1 && parseInt(key) == keys.length - 1) {
@@ -687,14 +722,14 @@
             let app = this;
             let device = app.getDeviceFromDeviceList(slotProps.node.ipAddr, slotProps.node.deviceId);
             if (device) {
-              app.nodeService.purgeDevice(device).then(function (result) {});
+              app.nodeService.purgeDevice(device).then(function (result) { });
             }
           },
           updatePointsForDevice(slotProps) {
             let app = this;
             let device = app.getDeviceFromDeviceList(slotProps.node.ipAddr, slotProps.node.deviceId);
             if (device) {
-              app.nodeService.updatePointsForDevice(device).then(function (result) {});
+              app.nodeService.updatePointsForDevice(device).then(function (result) { });
             }
           },
           updatePoint(slotProps) {
@@ -705,7 +740,7 @@
             });
             const deviceKey = `${app.getDeviceAddress(device.address)}-${device.deviceId}`;
             if (device) {
-              app.nodeService.updatePoint(deviceKey, pointKey).then(function (result) {});
+              app.nodeService.updatePoint(deviceKey, pointKey).then(function (result) { });
             }
           },
           setDeviceName() {
@@ -1708,4 +1743,4 @@
     <li><a href="https://wiki.bitpool.com/">wiki.bitpool.com</a> - find more documentation.</li>
     <li><a href="https://bacnet.org/">BACnet</a> - find more about the protocol.</li>
   </ul>
-</script>
+</script>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitpoolos/edge-bacnet",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "description": "A bacnet gateway for node-red",
   "dependencies": {
     "@plus4nodered/ts-node-bacnet": "^1.0.0-beta.2",
@@ -54,4 +54,4 @@
     "type": "github",
     "url": "git+https://github.com/bitpool/edge-bacnet.git"
   }
-}
+}

package/resources/node-bacstack-ts/dist/lib/client.js

@@ -67,9 +67,23 @@ class Client extends events_1.EventEmitter {
     }
     // Helper utils
     _getInvokeId() {
+        // Try up to 256 times to find an unused invoke ID
+        for (let attempts = 0; attempts < 256; attempts++) {
+            const id = this._invokeCounter++;
+            if (id >= 256) this._invokeCounter = 1;
+
+            const invokeId = id - 1;
+
+            // If this invoke ID is not currently in use, return it
+            if (!this._invokeStore[invokeId]) {
+                return invokeId;
+            }
+        }
+
+        // Edge case: if all 256 invoke IDs are in use, fall back to original behavior
+        // This prevents infinite loops while maintaining backwards compatibility
         const id = this._invokeCounter++;
-        if (id >= 256)
-            this._invokeCounter = 1;
+        if (id >= 256) this._invokeCounter = 1;
         return id - 1;
     }
     _invokeCallback(id, err, result) {