@bitpoolos/edge-bacnet 1.6.1 → 1.6.3

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## [1.6.3] - 00-06-2025
+
+Minor feature: 
+  - Device List - new right click option to MSTP NET folders - Update All Devices. Specifically updates the mstp device listed in that selected network 
+  - Inspector - Added statistic percentages as MQTT output in the Inspector node
+  - Inspector - Added online / offline stats and Total points to read as status on node
+  - Test Functions - Outputs results to both node-red console and node-red debug window now
+
+Minor update / refactor:
+  - Datamodel - Importing and Exporting datamodel displays process status and related stats (file size etc) while importing or exporting, informing the user of current state
+  - Device List - UI tree no longer stored in datamodel, as it is generated dynamically on a schedule. This significantly reduces datamodel file size, read / write time, system start up processes. 
+  - Datamodel - writes to file system for persistance and backup was being executed more often than needed. Process schedule is now on a larger interval, and write algorithm refactored and optimized. 
+  - Device List - right click -> Set Point Name feature refactored, due to many scenarios where it wasnt executing as expected.
+  - BACnet read output - error and status field setting optimized
+  - Inspector - updated ObjectType column values to show object type enum string instead of integer
+
+Bug fixes:
+  - Inspector - incorrect percentages, statistics and values in the statistics bar. Fixed and tested to represent site status more accurately 
+  - Inpsector - not flagging offline points in error statistic and table filter. Now correctly identifies "offline" points as an Error type
+  - BACnet read output - was not updating error and status correctly for full object payloads. 
+  - BACnet Server - was not outputting sucessfull write update MQTT msg after node-red deploy. 
+
+Updating: 
+  - There shouldnt be a need for users to remove nodes or do any specific action when updating to this version, however backing up a datamodel export is advised.
+
+
+## [1.6.2] - 07-05-2025
+
+Minor feature: 
+  - Added "Enable device discovery" check box to gateway settings, discovery tab. 
+    - This check box controls whether on not the auto point discovery and property discovery is enabled. 
+    - This can be used to turn off unecessary network traffic once you have discovered all of the desired devices and points.
+    - IMPORTANT - if you are updating a existing deployment, the new property will be unticked, however new installs / dragging from the pallete will by default have the option checked. So if you want to keep this enabled on an existing deployment, please check the setting. 
+    - Note - This does not turn off the whoIs task schedule.
+    - A user can use Right Click -> Update points on desired deviced in the read node tree if you would like to manually discover devices. 
+
+Minor update: 
+  - Adjusted initial whoIs broadcast delay from 5seconds to 15seconds after node-red is started with a deployed gateway. This is to ensure large cached files are completely read and loaded.
+
+Bug fixes: 
+  - Inspector:
+    - Table resized to avoid scroll bars
+    - Percentage rounding to nearest 2 decimal places rather than whole integer for more detailed data. 
+    - Loading animation added
+    - NAN years ago - removed as invalid time differential 
+    - Last seen for device points adjusted to be more accurate
+
+  
+
 ## [1.6.1] - 14-04-2025
 
 Bug fixes: 

package/bacnet_client.js

@@ -20,6 +20,7 @@ const { BacnetDevice } = require("./bacnet_device");
 const { Mutex } = require("async-mutex");
 const { treeBuilder } = require("./treeBuilder.js");
 
+
 class BacnetClient extends EventEmitter {
   //client constructor
   constructor(config) {
@@ -28,6 +29,7 @@ class BacnetClient extends EventEmitter {
     that.config = config;
     that.deviceList = [];
     that.networkTree = {};
+    that.renderList = [];
     that.lastWhoIs = null;
     that.client = null;
     that.lastNetworkPoll = null;
@@ -52,6 +54,7 @@ class BacnetClient extends EventEmitter {
       that.deviceRetryCount = parseInt(config.retries);
       that.sanitise_device_schedule = config.sanitise_device_schedule;
       that.buildTreeException = false;
+      that.enable_device_discovery = config.enable_device_discovery;
 
       that.readPropertyMultipleOptions = {
         maxSegments: 112,
@@ -80,11 +83,11 @@ class BacnetClient extends EventEmitter {
 
         //query device task
         const queryDevices = new Task("simple task", () => {
-          if (!that.pollInProgress) {
+          if (!that.pollInProgress && that.enable_device_discovery) {
             that.queryDevices();
           }
 
-          if (!that.buildJsonInProgress) {
+          if (!that.buildJsonInProgress && that.enable_device_discovery) {
             that.buildJsonTree();
           }
         });
@@ -106,10 +109,15 @@ class BacnetClient extends EventEmitter {
         setTimeout(() => {
           that.globalWhoIs();
           setTimeout(() => {
-            that.queryDevices();
-            that.buildJsonTree();
+            if (!that.pollInProgress && that.enable_device_discovery) {
+              that.queryDevices();
+            }
+
+            if (!that.buildJsonInProgress && that.enable_device_discovery) {
+              that.buildJsonTree();
+            }
           }, "4000");
-        }, "5000");
+        }, "15000");
 
       } catch (e) {
         that.logOut("Issue initializing client: ", e);
@@ -195,7 +203,8 @@ class BacnetClient extends EventEmitter {
       const cachedData = await Read_Config_Async();
       const parsedData = JSON.parse(cachedData);
       if (parsedData && typeof parsedData == "object") {
-        if (parsedData.renderList) that.renderList = parsedData.renderList;
+        // renderList is no longer cached - will be rebuilt by tree builder
+        // if (parsedData.renderList) that.renderList = parsedData.renderList;
         if (parsedData.deviceList) {
           parsedData.deviceList.forEach(function (device) {
             let newBacnetDevice = new BacnetDevice(true, device);
@@ -203,12 +212,13 @@ class BacnetClient extends EventEmitter {
           });
         }
         if (parsedData.pointList) that.networkTree = parsedData.pointList;
-        if (parsedData.renderListCount) that.renderListCount = parsedData.renderListCount;
+        // renderListCount is no longer cached - will be recalculated by tree builder
+        // if (parsedData.renderListCount) that.renderListCount = parsedData.renderListCount;
       }
     }
   }
 
-  testFunction(address, port, type, instance, property) {
+  testFunction(address, port, type, instance, property, nodeWarnCallback) {
     let that = this;
     console.log("test function ");
 
@@ -223,6 +233,11 @@ class BacnetClient extends EventEmitter {
       console.log("1 - readPropertyMultiple:  ");
 
       console.log(value);
+
+      if (nodeWarnCallback) {
+        nodeWarnCallback(value);
+      }
+
       if (value) {
         // If the result has value, resolve the promise
         console.log(value.values[0]);
@@ -615,6 +630,7 @@ class BacnetClient extends EventEmitter {
     that.deviceId = config.deviceId;
     that.broadCastAddr = config.broadCastAddr;
     that.device_read_schedule = config.device_read_schedule;
+    that.enable_device_discovery = config.enable_device_discovery;
 
     if (that.scheduler !== null) {
       that.scheduler.stop();
@@ -640,11 +656,11 @@ class BacnetClient extends EventEmitter {
 
       // //query device task
       const queryDevices = new Task("simple task", () => {
-        if (!that.pollInProgress) {
+        if (!that.pollInProgress && that.enable_device_discovery) {
           that.queryDevices();
         }
 
-        if (!that.buildJsonInProgress) {
+        if (!that.buildJsonInProgress && that.enable_device_discovery) {
           that.buildJsonTree();
         }
       });
@@ -713,35 +729,30 @@ class BacnetClient extends EventEmitter {
     const that = this;
     const roundDecimal = readConfig.precision;
     const devicesToRead = Object.keys(readConfig.pointsToRead);
-    const bacnetResults = {};
-    let pendingRequests = 0;
+    let completedDevices = 0;
 
     try {
-      // Process all devices in sequence
-      for (let deviceIndex = 0; deviceIndex < devicesToRead.length; deviceIndex++) {
-        const key = devicesToRead[deviceIndex];
+      // Create array of device processing promises
+      const devicePromises = devicesToRead.map(async (key, deviceIndex) => {
         const device = that.findDeviceByKey(key);
-        if (!device) continue;
+        if (!device) return null;
 
         const deviceName = that.computeDeviceName(device);
         const deviceKey = that.createDeviceKey(device);
         const deviceObject = that.networkTree[deviceKey];
         const maxObjectCount = that.estimateMaxObjectSize(device.getMaxApdu());
 
-        if (!bacnetResults[deviceName]) {
-          bacnetResults[deviceName] = {};
-        }
+        const bacnetResults = {};
+        bacnetResults[deviceName] = {};
 
         // Process points for the current device
         const pointsToRead = readConfig.pointsToRead[key];
         const pointNames = Object.keys(pointsToRead);
         let totalPoints = pointNames.length - 1;
         let requestArray = [];
-        let processedPoints = 0; // Counter for processed points
 
         // Process each point for the device in batches
         for (let i = 0; i < pointNames.length; i++) {
-
           const pointName = pointNames[i];
           if (pointName === "deviceName") {
             continue;
@@ -764,17 +775,7 @@ class BacnetClient extends EventEmitter {
           }
 
           // Process the batch when the request array is full or the last point is reached
-          if (requestArray.length === maxObjectCount) {
-            if (device.getProtocolServiceSupport("ReadPropertyMultiple") == true) {
-              await that.processBatch(device, requestArray, deviceName, bacnetResults, that, roundDecimal);
-            } else {
-              await that.processIndividualPoints(device, requestArray, deviceName, bacnetResults, that, roundDecimal);
-            }
-
-            requestArray = [];
-            // Increment the processed points counter
-            processedPoints += maxObjectCount;
-          } else if (i === pointNames.length - 1) {
+          if (requestArray.length === maxObjectCount || i === pointNames.length - 1) {
             if (device.getProtocolServiceSupport("ReadPropertyMultiple") == true) {
               await that.processBatch(device, requestArray, deviceName, bacnetResults, that, roundDecimal);
             } else {
@@ -782,28 +783,43 @@ class BacnetClient extends EventEmitter {
             }
 
             requestArray = [];
-            // Increment the processed points counter
-            processedPoints += i;
           }
+        }
 
-          // Check if all points for the device have been processed
-          if (processedPoints >= totalPoints) {
-            pendingRequests++;
-
-            // Emit the `values` event for the current device
-            that.emit(
-              "values",
-              bacnetResults,
-              outputType,
-              objectPropertyType,
-              readNodeName,
-              pendingRequests,
-              devicesToRead.length
-            );
-            delete bacnetResults[deviceName];
-          }
+        // Return results for this device
+        return {
+          deviceName,
+          results: bacnetResults,
+          deviceIndex: deviceIndex + 1,
+          totalDevices: devicesToRead.length
+        };
+      });
+
+      // Process all devices in parallel and emit results as they complete
+      const results = await Promise.allSettled(devicePromises);
+
+      results.forEach((result, index) => {
+        if (result.status === 'fulfilled' && result.value) {
+          completedDevices++;
+          const { deviceName, results: bacnetResults, deviceIndex, totalDevices } = result.value;
+
+          // Emit the `values` event for this device immediately
+          that.emit(
+            "values",
+            bacnetResults,
+            outputType,
+            objectPropertyType,
+            readNodeName,
+            completedDevices,
+            totalDevices
+          );
+        } else {
+          // Handle failed device (offline/error)
+          completedDevices++;
+          that.logOut(`Device ${devicesToRead[index]} failed:`, result.reason);
         }
-      }
+      });
+
     } catch (error) {
       that.logOut("doRead error: ", error);
     }
@@ -840,6 +856,7 @@ class BacnetClient extends EventEmitter {
           if (isNumber(val)) {
             pointRef.presentValue = roundDecimalPlaces(val, roundDecimal);
             pointRef.error = "none";
+            pointRef.status = "online";
             if (pointRef.meta.objectId.type == 19 || pointRef.meta.objectId.type == 13 || pointRef.meta.objectId.type == 14) {
               if (pointRef.stateTextArray && typeof pointRef.stateTextArray[0].value !== "object") {
                 if (val != 0) {
@@ -853,14 +870,18 @@ class BacnetClient extends EventEmitter {
             if (typeof val !== "object") {
               pointRef.presentValue = val;
               pointRef.error = "none";
+              pointRef.status = "online";
             } else if (val.errorClass && val.errorClass) {
               pointRef.error = getBacnetErrorString(val.errorClass, val.errorClass);
+              pointRef.status = "offline";
+            } else {
+              pointRef.error = "none";
+              pointRef.status = "online";
             }
           }
 
           pointRef.meta["device"] = deviceMetaInfo;
           pointRef.timestamp = Date.now();
-          pointRef.status = "online";
 
           // Store the point data in results
           bacnetResults[deviceName][pointNameRef] = pointRef;
@@ -892,6 +913,8 @@ class BacnetClient extends EventEmitter {
 
           if (isNumber(val)) {
             pointRef.presentValue = roundDecimalPlaces(val, roundDecimal);
+            pointRef.error = "none";
+            pointRef.status = "online";
 
             if (pointRef.meta.objectId.type == 19 || pointRef.meta.objectId.type == 13 || pointRef.meta.objectId.type == 14) {
               if (pointRef.stateTextArray && typeof pointRef.stateTextArray[0].value !== "object") {
@@ -903,13 +926,21 @@ class BacnetClient extends EventEmitter {
               }
             }
           } else {
-            pointRef.presentValue = val;
+            if (typeof val !== "object") {
+              pointRef.presentValue = val;
+              pointRef.error = "none";
+              pointRef.status = "online";
+            } else if (val.errorClass && val.errorClass) {
+              pointRef.error = getBacnetErrorString(val.errorClass, val.errorClass);
+              pointRef.status = "offline";
+            } else {
+              pointRef.error = "none";
+              pointRef.status = "online";
+            }
           }
 
           pointRef.meta["device"] = deviceMetaInfo;
           pointRef.timestamp = Date.now();
-          pointRef.status = "online";
-          pointRef.error = "none";
 
           // Store the point data in results
           bacnetResults[deviceName][pointName] = pointRef;
@@ -1674,7 +1705,7 @@ class BacnetClient extends EventEmitter {
         if (json.body.renderListCount) {
           that.renderListCount = json.body.renderListCount;
         }
-        resolve();
+        resolve(true);
       } catch (e) {
         reject(e);
       }

package/bacnet_gateway.html

@@ -136,6 +136,16 @@
         body: JSON.stringify({ k: deviceKey, p: pointName, n: pointDisplayName }),
       }).then((res) => res.json());
     }
+    applyDisplayNames(pointsToRead) {
+      return fetch(RED.settings.httpNodeRoot + "bitpool-bacnet-data/applyDisplayNames", {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ pointsToRead: pointsToRead }),
+      }).then((res) => res.json());
+    }
     importReadList(payload) {
       return fetch(RED.settings.httpNodeRoot + "bitpool-bacnet-data/importReadList", {
         method: "POST",
@@ -177,6 +187,7 @@
       sanitise_device_schedule: { value: "60", required: false },
       sanitise_device_schedule_value: { value: "1", required: false },
       sanitise_device_schedule_options: { value: "Hours", required: false },
+      enable_device_discovery: { value: true, required: true },
     },
     networkInterfaces: [],
     inputs: 1,
@@ -395,25 +406,130 @@
         });
       });
 
+      function setDataModelUpdateStatus(status, type, autoClear) {
+        const statusElement = $("#data-model-update-status");
+        statusElement.text(status);
+
+        // Remove existing status classes
+        statusElement.removeClass("status-success status-error status-warning status-info");
+
+        // Add appropriate styling based on type
+        switch (type) {
+          case "success":
+            statusElement.addClass("status-success");
+            break;
+          case "error":
+            statusElement.addClass("status-error");
+            break;
+          case "warning":
+            statusElement.addClass("status-warning");
+            break;
+          case "info":
+          default:
+            statusElement.addClass("status-info");
+            break;
+        }
+
+        // Auto-clear success messages after 5 seconds
+        if (autoClear !== false && type === "success") {
+          setTimeout(() => {
+            statusElement.text("");
+            statusElement.removeClass("status-success");
+          }, 5000);
+        }
+      }
+
       //Import complete Data model
       $("#file-upload-database").on("change", function (event) {
         const input = event.target.files[0];
+
+        if (!input) {
+          setDataModelUpdateStatus("No file selected", "warning");
+          return;
+        }
+
+        // Validate file type
+        if (!input.name.toLowerCase().endsWith('.json')) {
+          setDataModelUpdateStatus("Please select a valid JSON file", "error");
+          return;
+        }
+
+        // Check file size (warn if larger than 10MB)
+        const fileSizeMB = (input.size / (1024 * 1024)).toFixed(2);
+        if (input.size > 10 * 1024 * 1024) {
+          setDataModelUpdateStatus(`Large file detected (${fileSizeMB}MB). Import may take several minutes...`, "warning");
+        }
+
+        // Confirmation dialog for potentially destructive operation
+        if (!confirm(`Are you sure you want to import this data model?\n\nFile: ${input.name}\nSize: ${fileSizeMB}MB\n\nThis will replace the existing data model and cannot be undone.`)) {
+          // Reset the file input
+          $(this).val('');
+          setDataModelUpdateStatus("Import cancelled", "info");
+          return;
+        }
+
         const reader = new FileReader();
 
-        reader.onload = function (e) {
-          const text = e.target.result;
+        reader.onloadstart = function () {
+          setDataModelUpdateStatus("Reading file...", "info");
+        };
 
-          let jsonPayload = JSON.parse(text);
+        reader.onprogress = function (e) {
+          if (e.lengthComputable) {
+            const percentLoaded = Math.round((e.loaded / e.total) * 100);
+            setDataModelUpdateStatus(`Reading file... ${percentLoaded}%`, "info");
+          }
+        };
 
-          $.ajax({
-            type: "POST",
-            url: RED.settings.httpNodeRoot + "bitpool-bacnet-data/updateDataModel",
-            dataType: "json",
-            contentType: "application/json",
-            data: JSON.stringify(jsonPayload),
-            success: function (result) { },
-            timeout: 0,
-          });
+        reader.onload = function (e) {
+          setDataModelUpdateStatus("Parsing JSON data...", "info");
+
+          try {
+            const text = e.target.result;
+            let jsonPayload = JSON.parse(text);
+
+            setDataModelUpdateStatus("Uploading data model to server...", "info");
+
+            $.ajax({
+              type: "POST",
+              url: RED.settings.httpNodeRoot + "bitpool-bacnet-data/updateDataModel",
+              dataType: "json",
+              contentType: "application/json",
+              data: JSON.stringify(jsonPayload),
+              success: function (data, status, xhr) {
+                setDataModelUpdateStatus(`Data model imported successfully! (${fileSizeMB}MB processed)`, "success");
+                // Clear the file input
+                $("#file-upload-database").val('');
+              },
+              error: function (xhr, status, error) {
+                let errorMsg = "Failed to import data model";
+                if (xhr.responseText) {
+                  try {
+                    const errorResponse = JSON.parse(xhr.responseText);
+                    errorMsg += ": " + (errorResponse.message || errorResponse.error || xhr.responseText);
+                  } catch (e) {
+                    errorMsg += ": " + xhr.responseText;
+                  }
+                } else {
+                  errorMsg += ": " + (error || status || "Unknown error");
+                }
+                setDataModelUpdateStatus(errorMsg, "error");
+                // Clear the file input
+                $("#file-upload-database").val('');
+              },
+              timeout: 0,
+            });
+          } catch (parseError) {
+            setDataModelUpdateStatus("Invalid JSON file: " + parseError.message, "error");
+            // Clear the file input
+            $("#file-upload-database").val('');
+          }
+        };
+
+        reader.onerror = function () {
+          setDataModelUpdateStatus("Error reading file", "error");
+          // Clear the file input
+          $("#file-upload-database").val('');
         };
 
         reader.readAsText(input);
@@ -421,16 +537,82 @@
 
       // Export complete Data model
       $("#file-export-database").click(function (params) {
+        // Confirmation dialog
+        if (!confirm("Are you sure you want to export the complete data model?\n\nThis may take some time for large databases.")) {
+          setDataModelUpdateStatus("Export cancelled", "info");
+          return;
+        }
+
+        setDataModelUpdateStatus("Retrieving data model from server...", "info");
+
+        const startTime = Date.now();
+
         $.ajax({
           url: RED.settings.httpNodeRoot + "bitpool-bacnet-data/getDataModel",
           success: function (deviceList) {
-            let data = "text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(deviceList));
-            let aEle = document.getElementById("exportJSON");
-            aEle.setAttribute("href", "data:" + data);
-            aEle.setAttribute("download", "edge-bacnet-datastore.json");
-            aEle.click();
+            try {
+              setDataModelUpdateStatus("Preparing download...", "info");
+
+              // Calculate data size
+              const jsonString = JSON.stringify(deviceList);
+              const dataSize = new Blob([jsonString]).size;
+              const dataSizeMB = (dataSize / (1024 * 1024)).toFixed(2);
+
+              // Create a Blob with the JSON data
+              const blob = new Blob([jsonString], { type: 'application/json' });
+
+              // Create an object URL from the Blob
+              const url = URL.createObjectURL(blob);
+
+              // Generate filename with timestamp
+              const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+              const filename = `edge-bacnet-datastore-${timestamp}.json`;
+
+              // Set the URL to the link and trigger download
+              let aEle = document.getElementById("exportJSON");
+              aEle.setAttribute("href", url);
+              aEle.setAttribute("download", filename);
+              aEle.click();
+
+              // Calculate duration
+              const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+
+              setDataModelUpdateStatus(`Export completed successfully! (${dataSizeMB}MB, ${duration}s)`, "success");
+
+              // Release the object URL when done
+              setTimeout(() => {
+                URL.revokeObjectURL(url);
+              }, 2000);
+
+            } catch (error) {
+              console.error("Error exporting data model:", error);
+              setDataModelUpdateStatus("Failed to create download file: " + error.message, "error");
+            }
           },
-          timeout: 0,
+          error: function (xhr, status, error) {
+            console.error("AJAX error retrieving data model:", status, error);
+            let errorMsg = "Failed to retrieve data model from server";
+
+            if (xhr.status === 0) {
+              errorMsg += " (Connection timeout or server unavailable)";
+            } else if (xhr.status === 404) {
+              errorMsg += " (Endpoint not found)";
+            } else if (xhr.status === 500) {
+              errorMsg += " (Internal server error)";
+            } else if (xhr.responseText) {
+              try {
+                const errorResponse = JSON.parse(xhr.responseText);
+                errorMsg += ": " + (errorResponse.message || errorResponse.error);
+              } catch (e) {
+                errorMsg += ": " + xhr.responseText;
+              }
+            } else {
+              errorMsg += ": " + (error || status || "Unknown error");
+            }
+
+            setDataModelUpdateStatus(errorMsg, "error");
+          },
+          timeout: 60000, // 60 second timeout for large exports
         });
       });
 
@@ -817,6 +999,39 @@
     .database-file-label-div {
       padding-top: 15px;
     }
+    /* Status indicator styles */
+    .status-success {
+      color: #28a745 !important;
+      font-weight: 500;
+      background-color: #d4edda;
+      border: 1px solid #c3e6cb;
+      border-radius: 4px;
+      padding: 8px 12px;
+    }
+    .status-error {
+      color: #dc3545 !important;
+      font-weight: 500;
+      background-color: #f8d7da;
+      border: 1px solid #f5c6cb;
+      border-radius: 4px;
+      padding: 8px 12px;
+    }
+    .status-warning {
+      color: #856404 !important;
+      font-weight: 500;
+      background-color: #fff3cd;
+      border: 1px solid #ffeaa7;
+      border-radius: 4px;
+      padding: 8px 12px;
+    }
+    .status-info {
+      color: #0c5460 !important;
+      font-weight: 500;
+      background-color: #d1ecf1;
+      border: 1px solid #bee5eb;
+      border-radius: 4px;
+      padding: 8px 12px;
+    }
   </style>
 
   <div class="form-row node-input-read-tabs-row">
@@ -985,6 +1200,11 @@
         </select>
       </div>
 
+      <div class="form-row bp-checkbox-row">
+        <input type="checkbox" id="node-input-enable_device_discovery" class="bp-checkbox" />
+        <label for="node-input-enable_device_discovery"> Enable device discovery </label>
+      </div>
+
       <div class="form-row bp-checkbox-row">
         <input type="checkbox" id="node-input-cacheFileEnabled" class="bp-checkbox" />
         <label for="node-input-cacheFileEnabled"> Enable cache file </label>
@@ -1064,6 +1284,7 @@
         <input id="file-export-database" class="inputStyle" style="width: 258px; display: none;" />
         <a id="exportJSON" style="display: none"></a>
       </div>
+      <div id="data-model-update-status" class="data-model-update-status" style="margin-top: 10px;"></div>
     </div>
   </div>
 </script>
@@ -1100,6 +1321,7 @@
       the this bacnet client will enter into manual discovery mode, where it iterates through types and instnace ranges. This
       range can be used to limit this manual scanning
     </li>
+    <li>Enable device discovery - toggles whether automatic device discovery, object scanning, and tree building is enabled.</li>
     <li>Log Device Found - toggles logging of found devices to the node-red debug tab.</li>
     <li>Log BACnet Errors to Console - toggles logging of BACnet related errors to the node-red console</li>
   </ul>