@bitpoolos/edge-bacnet 1.6.5 → 1.6.7

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [1.6.7] - 15-01-2026
+
+Bug fix: 
+
+- Fix UI tree rendering issue with MSTP folders
+
+Minor update: 
+
+- Styling
+- Added properties to device points and minor change to device point polling
+
+## [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:

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 && !ele.getIsMstpDevice());
     if (foundParentIndex !== -1) {
       that.deviceList[foundParentIndex].addChildDevice(deviceId);
       device.setParentDeviceId(that.deviceList[foundParentIndex].getDeviceId());
@@ -939,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) => {
@@ -997,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(
@@ -1032,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;
@@ -1254,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
     );
   }
@@ -1304,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,
@@ -1319,8 +1368,8 @@ class BacnetClient extends EventEmitter {
       port: device.getPort(),
     };
 
-    // Define all properties to be read
-    const allProperties = [
+    // Define default properties for non-device objects
+    const defaultProperties = [
       { id: baEnum.PropertyIdentifier.PRESENT_VALUE },
       { id: baEnum.PropertyIdentifier.DESCRIPTION },
       { id: baEnum.PropertyIdentifier.UNITS },
@@ -1335,8 +1384,66 @@ class BacnetClient extends EventEmitter {
       { id: baEnum.PropertyIdentifier.VENDOR_NAME },
     ];
 
+    // Use device-specific properties for type 8, otherwise use default
+    const propertiesToRead = type === 8 ? BacnetDevice.getDeviceObjectProperties() : defaultProperties;
+
+    // Function to read properties individually
+    const readPropertiesIndividually = (resolve, reject) => {
+      const promises = propertiesToRead.map(
+        (property) =>
+          new Promise((propertyResolve) => {
+            that.client.readProperty(
+              addressObject,
+              { type: type, instance: instance },
+              property.id,
+              readIndividualPropsOptions,
+              (err, value) => {
+                if (err) {
+                  propertyResolve(null);
+                } else {
+                  propertyResolve({
+                    id: property.id,
+                    index: value.property.index,
+                    value: value.values,
+                  });
+                }
+              }
+            );
+          })
+      );
+
+      Promise.all(promises)
+        .then((resultArray) => {
+          // Filter out null results
+          const validResults = resultArray.filter((result) => result !== null);
+
+          resolve({
+            error: null,
+            value: {
+              values: [
+                {
+                  objectId: {
+                    type: type,
+                    instance: instance,
+                  },
+                  values: validResults,
+                },
+              ],
+            },
+          });
+        })
+        .catch(reject);
+    };
+
     return new Promise((resolve, reject) => {
-      // Try to read all properties at once
+      // For Device objects (type 8), skip ALL attempt - many MSTP devices don't support it
+      // Go straight to reading individual properties for better reliability
+      if (type === 8) {
+        readPropertiesIndividually(resolve, reject);
+        return;
+      }
+
+      // For other object types, try to read all properties at once first
       that
         ._readObject(addressObject, type, instance, [{ id: baEnum.PropertyIdentifier.ALL }], readOptions)
         .then((result) => {
@@ -1345,70 +1452,20 @@ class BacnetClient extends EventEmitter {
             resolve(result);
           } else {
             // If not, proceed to read individual properties
-            readPropertiesIndividually();
+            readPropertiesIndividually(resolve, reject);
           }
         })
         .catch(() => {
           // On error, proceed to read individual properties
-          readPropertiesIndividually();
+          readPropertiesIndividually(resolve, reject);
         });
-
-      // Function to read properties individually
-      const readPropertiesIndividually = () => {
-        const promises = allProperties.map(
-          (property, index) =>
-            new Promise((propertyResolve) => {
-              that.client.readProperty(
-                addressObject,
-                { type: type, instance: instance },
-                property.id,
-                readIndividualPropsOptions,
-                (err, value) => {
-                  if (err) {
-                    propertyResolve(null);
-                  } else {
-                    propertyResolve({
-                      id: property.id,
-                      index: value.property.index,
-                      value: value.values,
-                    });
-                  }
-                }
-              );
-            })
-        );
-
-        Promise.all(promises)
-          .then((resultArray) => {
-            // Filter out null results
-            const validResults = resultArray.filter((result) => result !== null);
-
-            resolve({
-              error: null,
-              value: {
-                values: [
-                  {
-                    objectId: {
-                      type: type,
-                      instance: instance,
-                    },
-                    values: validResults,
-                  },
-                ],
-              },
-            });
-          })
-          .catch(reject);
-      };
     });
   }
 
   _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,
@@ -1573,10 +1630,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 {
@@ -2057,10 +2112,23 @@ class BacnetClient extends EventEmitter {
                           }
                           break;
                         case baEnum.PropertyIdentifier.VENDOR_NAME:
-                          if (object.value) {
-                            if (object.value[0].value && typeof object.value[0].value == "string") {
-                              values[objectId].vendorName = object.value[0].value;
-                            }
+                          if (object.value && object.value[0] && object.value[0].value && typeof object.value[0].value == "string") {
+                            values[objectId].vendorName = object.value[0].value;
+                          }
+                          break;
+                        case baEnum.PropertyIdentifier.MODEL_NAME:
+                          if (object.value && object.value[0] && object.value[0].value && typeof object.value[0].value == "string") {
+                            values[objectId].modelName = object.value[0].value;
+                          }
+                          break;
+                        case baEnum.PropertyIdentifier.FIRMWARE_REVISION:
+                          if (object.value && object.value[0] && object.value[0].value && typeof object.value[0].value == "string") {
+                            values[objectId].firmwareRevision = object.value[0].value;
+                          }
+                          break;
+                        case baEnum.PropertyIdentifier.APPLICATION_SOFTWARE_VERSION:
+                          if (object.value && object.value[0] && object.value[0].value && typeof object.value[0].value == "string") {
+                            values[objectId].applicationSoftwareVersion = object.value[0].value;
                           }
                           break;
                       }

package/bacnet_device.js

@@ -1,4 +1,31 @@
+const bacnet = require("./resources/node-bacstack-ts/dist/index.js");
+const baEnum = bacnet.enum;
+
+// Device Object (type 8) properties - critical properties guaranteed per ASHRAE 135
+// These are the minimum required properties that all BACnet devices must support
+const DEVICE_OBJECT_PROPERTIES = [
+    { id: baEnum.PropertyIdentifier.OBJECT_IDENTIFIER },
+    { id: baEnum.PropertyIdentifier.OBJECT_NAME },
+    { id: baEnum.PropertyIdentifier.OBJECT_TYPE },
+    { id: baEnum.PropertyIdentifier.SYSTEM_STATUS },
+    { id: baEnum.PropertyIdentifier.VENDOR_NAME },
+    { id: baEnum.PropertyIdentifier.VENDOR_IDENTIFIER },
+    { id: baEnum.PropertyIdentifier.MODEL_NAME },
+    { id: baEnum.PropertyIdentifier.FIRMWARE_REVISION },
+    { id: baEnum.PropertyIdentifier.APPLICATION_SOFTWARE_VERSION },
+    { id: baEnum.PropertyIdentifier.DESCRIPTION },
+];
+
 class BacnetDevice {
+    /**
+     * Returns the standardized list of properties to read for Device objects (type 8).
+     * These are critical properties guaranteed to exist on all BACnet devices per ASHRAE 135.
+     * @returns {Array} Array of property identifier objects
+     */
+    static getDeviceObjectProperties() {
+        return DEVICE_OBJECT_PROPERTIES;
+    }
+
     constructor(fromImport, config) {
         let that = this;
 

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.5",
+  "version": "1.6.7",
   "description": "A bacnet gateway for node-red",
   "dependencies": {
     "@plus4nodered/ts-node-bacnet": "^1.0.0-beta.2",
@@ -26,13 +26,15 @@
     }
   },
   "keywords": [
+    "BACnet",
     "node-red",
     "bitpool",
     "bitpoolos",
     "edge",
     "big data",
     "iot",
-    "BACnet"
+    "building automation",
+    "bms"
   ],
   "engines": {
     "node": ">=12.0.0"

package/resources/style.css

@@ -319,8 +319,13 @@
   margin-left: 10px;
   background-color: #00aeef;
   color: #ffffff;
-  border-radius: 45%;
-  font-size: 12px;
+  border-radius: 4px;
+  font-size: 11px;
+  font-weight: 500;
+  padding: 2px 6px;
+  display: inline-block;
+  vertical-align: middle;
+  line-height: 1.2;
 }
 
 .pointAddedToRead {

package/treeBuilder.js

@@ -355,6 +355,12 @@ class treeBuilder {
     this.addPointProperty(pointProperties, "Modification Date", point.modificationDate);
     this.addPointProperty(pointProperties, "Program State", point.programState);
     this.addPointProperty(pointProperties, "Record Count", point.recordCount);
+    
+    // Add device-specific properties (type 8)
+    this.addPointProperty(pointProperties, "Vendor Name", point.vendorName);
+    this.addPointProperty(pointProperties, "Model Name", point.modelName);
+    this.addPointProperty(pointProperties, "Firmware Revision", point.firmwareRevision);
+    this.addPointProperty(pointProperties, "Application Software Version", point.applicationSoftwareVersion);
 
     // Return the array of point properties
     return pointProperties;