@bitpoolos/edge-bacnet 1.6.1 → 1.6.3

package/bacnet_gateway.js

@@ -37,6 +37,7 @@ module.exports = function (RED) {
     this.portRangeRegisters = config.portRangeRegisters;
     this.cacheFileEnabled = config.cacheFileEnabled;
     this.sanitise_device_schedule = config.sanitise_device_schedule;
+    this.enable_device_discovery = config.enable_device_discovery;
 
     //client and config store
     this.bacnetConfig = nodeContext.get("bacnetConfig");
@@ -65,7 +66,8 @@ module.exports = function (RED) {
         node.retries,
         node.cacheFileEnabled,
         node.sanitise_device_schedule,
-        node.portRangeRegisters.filter((ele) => ele.enabled === true)
+        node.portRangeRegisters.filter((ele) => ele.enabled === true),
+        node.enable_device_discovery
       );
 
       if (typeof node.bacnetClient !== "undefined") {
@@ -213,11 +215,14 @@ module.exports = function (RED) {
     if (
       node.bacnetServerEnabled == true &&
       node.bacnetClient &&
-      node.bacnetServer &&
-      nodeContext.get("serverWritePropEvent") == false
+      node.bacnetServer
     ) {
       try {
-        node.bacnetServer.on("writeProperty", (topic, newValue) => {
+        // Clean up any existing listeners to prevent stale references
+        node.bacnetServer.removeAllListeners('writeProperty');
+
+        // Store the event handler function so we can clean it up later
+        node.writePropertyHandler = (topic, newValue) => {
           let formattedTopic = topic;
           if (
             node.nodeName !== "gateway" &&
@@ -232,8 +237,9 @@ module.exports = function (RED) {
           }
 
           node.send({ payload: newValue, topic: formattedTopic });
-        });
-        nodeContext.set("serverWritePropEvent", true);
+        };
+
+        node.bacnetServer.on("writeProperty", node.writePropertyHandler);
       } catch (e) {
         console.log("Bacnet gateway node server writePoperty error: ", e);
       }
@@ -263,12 +269,12 @@ 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);
             });
         } else if (msg.testFunc == true) {
-          node.bacnetClient.testFunction(msg.address, msg.port, msg.type, msg.instance, msg.property);
+          node.bacnetClient.testFunction(msg.address, msg.port, msg.type, msg.instance, msg.property, nodeWarn);
         } else if (msg.applyDisplayNames) {
           node.status({ fill: "blue", shape: "dot", text: "Updating display names" });
           setTimeout(() => {
@@ -277,7 +283,7 @@ module.exports = function (RED) {
 
           node.bacnetClient
             .applyDisplayNames(msg.pointsToRead)
-            .then(function (result) {})
+            .then(function (result) { })
             .catch(function (error) {
               logOut("Error in applyDisplayNames: ", error);
             });
@@ -298,7 +304,14 @@ module.exports = function (RED) {
       });
 
       node.on("close", function () {
-        //do nothing
+        // Clean up the writeProperty event listener
+        if (node.bacnetServer && node.writePropertyHandler) {
+          node.bacnetServer.removeListener('writeProperty', node.writePropertyHandler);
+          node.writePropertyHandler = null;
+        }
+
+        // Reset the serverWritePropEvent flag so it can be re-registered
+        nodeContext.set("serverWritePropEvent", false);
       });
     } catch (e) {
       console.log("Bacnet node event handler error: ", e);
@@ -459,7 +472,7 @@ module.exports = function (RED) {
         node.bacnetClient
           .updateDataModel(req)
           .then(function (result) {
-            res.send(result);
+            res.send(true);
           })
           .catch(function (error) {
             res.send(error);
@@ -558,6 +571,24 @@ module.exports = function (RED) {
       }
     });
 
+    //route handler for applyDisplayNames
+    RED.httpAdmin.post("/bitpool-bacnet-data/applyDisplayNames", function (req, res) {
+      if (!node.bacnetClient) {
+        logOut("Issue with the bacnetClient while applying display names: ", node.bacnetClient);
+        res.send(false);
+      } else {
+        node.bacnetClient
+          .applyDisplayNames(req.body.pointsToRead)
+          .then(function (result) {
+            res.send(result);
+          })
+          .catch(function (error) {
+            res.send(error);
+            logOut("Error applying display names:  ", error);
+          });
+      }
+    });
+
     //route handler for importReadList
     RED.httpAdmin.post("/bitpool-bacnet-data/importReadList", function (req, res) {
       if (!node.bacnetClient) {
@@ -946,6 +977,10 @@ module.exports = function (RED) {
       }
       return pointName;
     }
+
+    function nodeWarn(message) {
+      node.warn(message);
+    }
   }
   RED.nodes.registerType("Bacnet-Gateway", BitpoolBacnetGatewayDevice);
 };

package/bacnet_inspector.js

@@ -61,9 +61,41 @@ module.exports = function (RED) {
       site_Name: false,
     };
 
+    // Function to update node status with combined information
+    function updateNodeStatus() {
+      // Calculate offline percentage for display
+      const totalPolledPoints = cachedData.onlineCount + cachedData.offlineCount;
+      const offlinePercentage = totalPolledPoints > 0 ?
+        Math.round((cachedData.offlineCount / totalPolledPoints) * 100) : 0;
+
+      // Build comprehensive status text
+      const statusParts = [];
+
+      // Add online/offline info if we have polled points
+      if (totalPolledPoints > 0) {
+        statusParts.push(`Online: ${cachedData.onlineCount}/${totalPolledPoints} (${100 - offlinePercentage}%)`);
+      }
+
+      // Add points to read info if we have read list
+      if (cachedData.totalUniqueReadCount > 0) {
+        statusParts.push(`Total Points: ${cachedData.totalUniqueReadCount}`);
+      }
+
+      // Fallback status if no data
+      if (statusParts.length === 0) {
+        statusParts.push("No data");
+      }
+
+      // Update node status
+      node.status({ text: statusParts.join(" | ") });
+    }
+
     // Initialize cache from flow context
     initializeCache();
 
+    // Set initial status
+    updateNodeStatus();
+
     function initializeCache() {
       let flow = context.flow;
 
@@ -187,21 +219,31 @@ module.exports = function (RED) {
       } else if (msg.type === "Read") {
         calculateCombinedReadList(node, msg);
         if (done) done();
-      } else if (msg.payload && msg.payload.error !== undefined && msg.payload.error !== "none") {
-        // bacnet error msg found
-        setErrorTopics(msg);
-        if (done) done();
       } else if (msg.payload && msg.topic) {
-        //regular bacnet output
+        //regular bacnet output (including those with errors)
         // Queue the message for batch processing instead of immediate processing
         messageQueue.push({ msg, send, done });
         if (messageQueue.length >= MAX_BATCH_SIZE) {
           processBatch();
         }
+
+        // Also handle error tracking for messages with errors or offline status
+        if ((msg.payload.error !== undefined && msg.payload.error !== "none") ||
+          (msg.payload.status !== undefined && msg.payload.status === "offline")) {
+          setErrorTopics(msg);
+        }
       } else if (msg.type === "sendMqttStats") {
         // Make sure we have the latest statBlock values before sending stats
         syncStatBlockWithWorkerResults().then(() => {
           let statBlock = node.statBlock;
+          let statCounts = node.statCounts || {};
+
+          // Calculate appropriate totals for percentage calculations
+          const readCount = statCounts.readCount || 0;
+          const discoveryCount = statCounts.discoveryCount || 0;
+          const totalDevices = statCounts.totalDevices || 1; // Fallback to 1 to prevent division by zero
+
+          // Send raw values
           for (let key in statBlock) {
             let value = statBlock[key];
             let keyText = key.toUpperCase();
@@ -211,6 +253,35 @@ module.exports = function (RED) {
             };
             node.send(newMsg);
           }
+
+          // Send percentage values
+          for (let key in statBlock) {
+            let rawValue = statBlock[key];
+            let percentage = 0;
+
+            // Calculate percentage based on appropriate denominator (rounded to 2 decimal places)
+            if (key === 'unmapped') {
+              // Unmapped points are from discovery list
+              percentage = discoveryCount > 0 ? Math.round((rawValue / discoveryCount) * 10000) / 100 : 0;
+            } else if (key === 'offlinePercentage') {
+              // Already a percentage, just round to 2 decimal places
+              percentage = Math.round(rawValue * 100) / 100;
+            } else if (key === 'deviceIdConflict') {
+              // Device conflicts as percentage of total devices
+              percentage = totalDevices > 0 ? Math.round((rawValue / totalDevices) * 10000) / 100 : 0;
+            } else {
+              // All other stats (ok, error, missing, warnings, moved, deviceIdChange) are based on read list
+              percentage = readCount > 0 ? Math.round((rawValue / readCount) * 10000) / 100 : 0;
+            }
+
+            let keyText = key.toUpperCase();
+            let percentageMsg = {
+              topic: `EDGE_DEVICE_${node.siteName}/BACNETSTATS/${keyText}PERCENTAGE`,
+              payload: percentage,
+            };
+            node.send(percentageMsg);
+          }
+
           if (done) done();
         });
 
@@ -419,6 +490,10 @@ module.exports = function (RED) {
               topicData.error = error;
               entryChanged = true;
             }
+            if (status !== undefined && topicData.status !== status) {
+              topicData.status = status;
+              entryChanged = true;
+            }
 
             if (entryChanged) {
               topicData.key = topicData.deviceID + ":" + topicData.objectType + ":" + topicData.objectInstance;
@@ -436,8 +511,8 @@ module.exports = function (RED) {
         dirtyFlags.offlinePercentage = true;
       }
 
-      // Update the node status
-      node.status({ text: "Points Online: " + cachedData.onlineCount + "/" + cachedData.totalUniquePolledCount });
+      // Update the node status with combined information
+      updateNodeStatus();
 
       // Periodically call getModelStats to keep model stats updated
       // Use a debounce pattern to avoid calling it too frequently
@@ -581,6 +656,7 @@ module.exports = function (RED) {
     function setErrorTopics(msg) {
       let topic = msg.topic;
       let error = msg.payload.error;
+      let status = msg.payload.status;
 
       // Extract properties only if they exist
       let deviceID = msg.payload.meta?.device?.deviceId;
@@ -595,7 +671,8 @@ module.exports = function (RED) {
           ? msg.payload.meta.device.address.address
           : msg.payload.meta?.device?.address;
 
-      if (error !== undefined && error !== "none") {
+      // Track entries with explicit errors or offline status
+      if ((error !== undefined && error !== "none") || (status !== undefined && status === "offline")) {
         // Use the cache instead of direct flow context access
         cachedData.entriesWithErrors.set(topic, {
           deviceID: deviceID,
@@ -605,7 +682,7 @@ module.exports = function (RED) {
           displayName: displayName,
           deviceName: deviceName,
           ipAddress: ipAddress,
-          error: error,
+          error: error || (status === "offline" ? "Point offline" : "N/A"),
         });
 
         // Mark as dirty so it will be synced to flow context
@@ -771,12 +848,11 @@ module.exports = function (RED) {
       // Force sync with flow context to ensure data is immediately available
       syncWithFlowContext();
 
-      // Update the node status
-      node.status({ text: "Points To Read: " + cachedData.totalUniqueReadCount });
+      // Update the node status with combined information
+      updateNodeStatus();
     }
 
     function getPublishedPointsList() {
-      node.warn("Generating Published Points List...");
       let flow = context.flow;
       let now = new Date();
 

package/bacnet_inspector_worker.js

@@ -3,10 +3,10 @@ const { Worker } = require("worker_threads");
 const path = require("path");
 
 function getRelativeTime(timestamp) {
-  if (!timestamp) return "N/A";
+  if (!timestamp || isNaN(timestamp) || typeof timestamp !== 'number') return "N/A";
   let now = Date.now();
   let timeDiff = now - timestamp;
-  if (timeDiff < 0) return "In the future";
+  if (isNaN(timeDiff) || timeDiff < 0) return "Invalid timestamp";
 
   let seconds = Math.floor(timeDiff / 1000);
   let minutes = Math.floor(seconds / 60);
@@ -149,6 +149,7 @@ function processModelStats(data) {
     // Store the data under all variations
     const publishData = {
       error: data.error || "N/A",
+      status: data.status || "N/A",
       presentValue: data.presentValue,
       bacnetLastSeen: data.bacnetLastSeen
     };
@@ -232,15 +233,24 @@ function processModelStats(data) {
 
     if (DiscoveryKeyMatch) {
       if (PublishPointTopicMatch) {
-        const error = PublishTopicsNormalized.get(matchVariation).error;
-        if (error !== "none" && error !== "N/A") {
-          PointResult.dataModelStatus = `Point Error - Matched in Discovery / Data Model and publishing, however BACNet Error is present: ${error}`;
+        const publishData = PublishTopicsNormalized.get(matchVariation);
+        const error = publishData.error;
+        const status = publishData.status;
+
+        // Check if point has error or is offline
+        if ((error !== "none" && error !== "N/A") || status === "offline") {
+          if (status === "offline") {
+            PointResult.dataModelStatus = `Point Error - Matched in Discovery / Data Model and publishing, however point status is offline`;
+          } else {
+            PointResult.dataModelStatus = `Point Error - Matched in Discovery / Data Model and publishing, however BACNet Error is present: ${error}`;
+          }
           statBlock.error++;
         } else {
           PointResult.dataModelStatus = "Point Ok - Matched in Discovery / Data Model and publishing";
           statBlock.ok++;
         }
         PointResult.error = error;
+        PointResult.status = status; // Also store the status for reference
         pointOkCount++;
       } else {
         if (DiscoveryPointMap[ReadPointKey].objectName !== ReadPointObj.pointName) {