@bitpoolos/edge-bacnet 1.6.6 → 1.6.8

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [1.6.8] - 10-03-2026
+
+Bug fix: 
+
+- Spiking values. Large polling sites were experiencing intermittent spiking values, due to a overloaded invokeId stack. This stack has been refactored to be per device, instead of global. 
+
+- Fixed byteLength errors
+
+- Merged github PR's 36 and 37:
+  - Fix startup error spam: empty point list during initialization
+  - Fix boolean write failures with auto application tag detection
+
+Minor update: 
+
+- Added concurrency management. Max Concurrent Requests option in the gateway node, which throttles how many concurrent requests can be made at any given point.  
+
+## [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:

package/bacnet_client.js

@@ -36,9 +36,13 @@ class BacnetClient extends EventEmitter {
     that.manualMutex = new Mutex();
     that.pollInProgress = false;
     that.buildJsonInProgress = false;
+    that.cacheLoaded = false;
     that.scanMatrix = [];
     that.renderListCount = 0;
     that.portRangeMatrix = config.portRangeMatrix;
+    that._requestQueue = [];           // Queue of waiting request resolvers
+    that._processingQueue = false;     // Flag to prevent concurrent queue processing
+    that._maxQueueSize = 10000;        // Maximum queued requests before rejecting (sized for large sites)
 
     try {
       that.roundDecimal = config.roundDecimal;
@@ -67,6 +71,7 @@ class BacnetClient extends EventEmitter {
           port: config.port,
           broadcastAddress: config.broadCastAddr,
           portRangeMatrix: config.portRangeMatrix,
+          maxConcurrentRequests: config.maxConcurrentRequests,
         });
         that.setMaxListeners(1);
 
@@ -80,6 +85,8 @@ class BacnetClient extends EventEmitter {
 
         //query device task
         const queryDevices = new Task("simple task", () => {
+          if (!that.cacheLoaded) return;
+
           if (!that.pollInProgress && that.enable_device_discovery) {
             that.queryDevices();
           }
@@ -192,24 +199,83 @@ class BacnetClient extends EventEmitter {
     }
   }
 
+  /**
+   * Waits until a request slot is available (throttling).
+   * Uses a queue to ensure only one waiter proceeds per available slot.
+   * Rejects if the queue is full (backpressure mechanism).
+   *
+   * The previous implementation used a `while` loop inside `processQueue` which
+   * called `nextResolve()` multiple times synchronously.  Because Promise
+   * resolutions are scheduled as microtasks, none of those continuations ran
+   * before the next `canSendRequest()` check — so the while-loop could release
+   * dozens of waiters simultaneously even when only one slot was free.  The fix
+   * is to release exactly ONE waiter per `requestComplete` event, letting the
+   * microtask queue drain before the next slot check.
+   */
+  _waitForRequestSlot() {
+    let that = this;
+    return new Promise((resolve, reject) => {
+      // Fast path: a slot is available right now
+      if (that.client.canSendRequest()) {
+        resolve();
+        return;
+      }
+
+      // Backpressure: refuse to queue more work than the limit allows
+      if (that._requestQueue.length >= that._maxQueueSize) {
+        reject(new Error('ERR_REQUEST_QUEUE_FULL: Too many pending requests. Reduce polling frequency or increase Max Concurrent Requests.'));
+        return;
+      }
+
+      // Park this request until a slot opens
+      that._requestQueue.push(resolve);
+
+      if (!that._processingQueue) {
+        that._processingQueue = true;
+
+        const processQueue = () => {
+          // Release exactly ONE waiter per call.  The 'requestComplete' event
+          // fires each time a slot is freed, so we will naturally be called
+          // again once the released request registers its own callback in the
+          // invoke store and eventually completes.
+          if (that._requestQueue.length > 0 && that.client.canSendRequest()) {
+            const nextResolve = that._requestQueue.shift();
+            nextResolve();
+          }
+
+          if (that._requestQueue.length === 0) {
+            that._processingQueue = false;
+            that.client.removeListener('requestComplete', processQueue);
+          }
+        };
+
+        that.client.on('requestComplete', processQueue);
+      }
+    });
+  }
+
   async readCachedFile() {
     let that = this;
-    if (that.config.cacheFileEnabled) {
-      const cachedData = await Read_Config_Async();
-      const parsedData = JSON.parse(cachedData);
-      if (parsedData && typeof parsedData == "object") {
-        // 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);
-            that.deviceList.push(newBacnetDevice);
-          });
+    try {
+      if (that.config.cacheFileEnabled) {
+        const cachedData = await Read_Config_Async();
+        const parsedData = JSON.parse(cachedData);
+        if (parsedData && typeof parsedData == "object") {
+          // 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);
+              that.deviceList.push(newBacnetDevice);
+            });
+          }
+          if (parsedData.pointList) that.networkTree = parsedData.pointList;
+          // renderListCount is no longer cached - will be recalculated by tree builder
+          // if (parsedData.renderListCount) that.renderListCount = parsedData.renderListCount;
         }
-        if (parsedData.pointList) that.networkTree = parsedData.pointList;
-        // renderListCount is no longer cached - will be recalculated by tree builder
-        // if (parsedData.renderListCount) that.renderListCount = parsedData.renderListCount;
       }
+    } finally {
+      that.cacheLoaded = true;
     }
   }
 
@@ -331,7 +397,7 @@ class BacnetClient extends EventEmitter {
     }
   }
 
-  getProtocolSupported(device) {
+  async getProtocolSupported(device) {
     //return protocols support for device
     let that = this;
     let addressObject = {
@@ -339,6 +405,10 @@ class BacnetClient extends EventEmitter {
       port: device.getPort(),
     };
     const readOptions = that.getDeviceSpecificOptions(device);
+
+    // Wait for a request slot before proceeding
+    await that._waitForRequestSlot();
+
     return new Promise((resolve, reject) => {
       that.client.readProperty(
         addressObject,
@@ -362,7 +432,7 @@ class BacnetClient extends EventEmitter {
     let that = this;
     let address = device.getAddress().address;
     let deviceId = device.getDeviceId();
-    let foundParentIndex = that.deviceList.findIndex((ele) => that.getDeviceAddress(ele) == 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());
@@ -674,6 +744,8 @@ class BacnetClient extends EventEmitter {
 
       // //query device task
       const queryDevices = new Task("simple task", () => {
+        if (!that.cacheLoaded) return;
+
         if (!that.pollInProgress && that.enable_device_discovery) {
           that.queryDevices();
         }
@@ -1046,7 +1118,7 @@ class BacnetClient extends EventEmitter {
   }
 
   //used in the doRead querying work flow
-  updatePoint(device, point) {
+  async updatePoint(device, point) {
     let that = this;
     let addressObject = {
       address: device.getAddress(),
@@ -1056,6 +1128,9 @@ class BacnetClient extends EventEmitter {
     // Use device-specific options
     const settings = that.getDeviceSpecificOptions(device);
 
+    // Wait for a request slot before proceeding
+    await that._waitForRequestSlot();
+
     return new Promise((resolve, reject) => {
       that.client.readProperty(
         addressObject,
@@ -1226,13 +1301,16 @@ class BacnetClient extends EventEmitter {
 
       send(index);
 
-      function send(index) {
+      async function send(index) {
         let readOptions = {
           maxSegments: that.readPropertyMultipleOptions.maxSegments,
           maxApdu: that.readPropertyMultipleOptions.maxApdu,
           arrayIndex: index,
         };
 
+        // Wait for a request slot before proceeding
+        await that._waitForRequestSlot();
+
         that.client.readProperty(
           addressObject,
           { type: baEnum.ObjectType.DEVICE, instance: deviceId },
@@ -1254,12 +1332,16 @@ class BacnetClient extends EventEmitter {
     });
   }
 
-  _readObjectWithRequestArray(device, requestArray, readOptions) {
+  async _readObjectWithRequestArray(device, requestArray, readOptions) {
     let that = this;
     let addressObject = {
       address: device.getAddress(),
       port: device.getPort(),
     };
+
+    // Wait for a request slot before proceeding
+    await that._waitForRequestSlot();
+
     return new Promise((resolve, reject) => {
       that.client.readPropertyMultiple(addressObject, requestArray, readOptions, (error, value) => {
         if (value && value.values) {
@@ -1335,8 +1417,12 @@ class BacnetClient extends EventEmitter {
     }
   }
 
-  _readObject(addressObject, type, instance, properties, readOptions) {
+  async _readObject(addressObject, type, instance, properties, readOptions) {
     let that = this;
+
+    // Wait for a request slot before proceeding
+    await that._waitForRequestSlot();
+
     return new Promise((resolve, reject) => {
       const requestArray = [
         {
@@ -1368,8 +1454,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 },
@@ -1384,8 +1470,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) => {
@@ -1394,61 +1538,13 @@ 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);
-      };
     });
   }
 
@@ -1549,10 +1645,14 @@ class BacnetClient extends EventEmitter {
           port: device.getPort(),
         };
 
+        let objectType = point.meta.objectId.type;
+        let resolvedAppTag = that._resolveAppTag(objectType, options.appTag);
+        let resolvedValue = that._coerceWriteValue(value, resolvedAppTag);
+
         let writeObject = {
           address: addressObject,
           objectId: {
-            type: point.meta.objectId.type,
+            type: objectType,
             instance: point.meta.objectId.instance,
           },
           values: {
@@ -1562,8 +1662,8 @@ class BacnetClient extends EventEmitter {
             },
             value: [
               {
-                type: options.appTag,
-                value: value,
+                type: resolvedAppTag,
+                value: resolvedValue,
               },
             ],
           },
@@ -1596,7 +1696,8 @@ class BacnetClient extends EventEmitter {
           point.options,
           (err, value) => {
             if (err) {
-              that.logOut(err);
+              let objType = that.getObjectType(point.objectId.type) || point.objectId.type;
+              that.logOut("writeProperty error for " + objType + ":" + point.objectId.instance + " - ", err);
             }
           }
         );
@@ -1928,7 +2029,7 @@ class BacnetClient extends EventEmitter {
       const promiseArray = [];
 
       if (typeof pointList === "undefined" || pointList.length === 0) {
-        throw new Error("Unable to build network tree, empty point list");
+        return { deviceList: this.deviceList, pointList: this.networkTree };
       }
 
       for (const point of pointList) {
@@ -2102,10 +2203,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;
                       }
@@ -2253,6 +2367,40 @@ class BacnetClient extends EventEmitter {
     }
   }
 
+  _resolveAppTag(objectType, userAppTag) {
+    // If user explicitly set an app tag (not auto), use it
+    if (userAppTag !== -1) return userAppTag;
+
+    // Auto-detect based on BACnet object type
+    switch (objectType) {
+      case 3: // BI
+      case 4: // BO
+      case 5: // BV
+        return 9; // ENUMERATED
+      case 13: // MI
+      case 14: // MO
+      case 19: // MV
+        return 2; // UNSIGNED_INT
+      default:
+        return 4; // REAL
+    }
+  }
+
+  _coerceWriteValue(value, appTag) {
+    switch (appTag) {
+      case 9: // ENUMERATED - binary objects expect 0 (inactive) or 1 (active)
+        if (value === true || value === 1 || value === "1" ||
+            value === "true" || value === "active" || value === "on") {
+          return 1;
+        }
+        return 0;
+      case 2: // UNSIGNED_INT - multistate objects expect positive integers
+        return parseInt(value) || 0;
+      default:
+        return value;
+    }
+  }
+
   getObjectType(objectId) {
     switch (objectId) {
       case 0:

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_gateway.html

@@ -165,6 +165,7 @@
       local_device_address: { value: "", required: true },
       local_interface_name: { value: "", required: false },
       apduTimeout: { value: 6000 },
+      maxConcurrentRequests: { value: 250 },
       roundDecimal: { value: 2 },
       local_device_port: { value: 47808, required: true },
       apduSize: { value: "5", required: true },
@@ -837,6 +838,13 @@
     oneditsave: function () {
       let node = this;
 
+      // Validate and clamp maxConcurrentRequests (1-250)
+      // BACnet protocol limits invoke IDs to 256, so 250 is the safe max
+      let maxConcurrent = parseInt(document.getElementById("node-input-maxConcurrentRequests").value) || 250;
+      if (maxConcurrent < 1) maxConcurrent = 1;
+      if (maxConcurrent > 250) maxConcurrent = 250;
+      document.getElementById("node-input-maxConcurrentRequests").value = maxConcurrent;
+
       document.getElementById("node-input-discover_polling_schedule").value = getTimePeriodInSeconds(
         document.getElementById("node-input-discover_polling_schedule_value").value,
         document.getElementById("node-input-discover_polling_schedule_options").value
@@ -1090,6 +1098,13 @@
         <input type="text" id="node-input-apduTimeout" placeholder="10000" />
       </div>
 
+      <div class="form-row bp-row">
+        <label for="node-input-maxConcurrentRequests"
+          ><i class="icon-tag"></i> <span data-i18n="bitpool-bacnet.label.maxConcurrentRequests"></span>Max Concurrent Requests</label
+        >
+        <input type="number" id="node-input-maxConcurrentRequests" placeholder="250" min="1" max="250" />
+      </div>
+
       <div class="form-row bp-row" style="display: none;">
         <label for="node-input-apduSize"
           ><i class="icon-tag"></i> <span data-i18n="bitpool-bacnet.label.apduSize"></span>Max Apdu Size</label
@@ -1310,6 +1325,7 @@
   <h3><strong>Discovery Tab</strong></h3>
   <ul class="node-ports">
     <li>APDU Timeout - BACnet msg timeout option</li>
+    <li>Max Concurrent Requests - Maximum number of simultaneous BACnet requests (1-250). Lower values reduce invoke ID exhaustion on large MSTP networks. Default: 250</li>
     <li>Max APDU Size - BACnet max apdu size</li>
     <li>Max Segments - BACnet max segments</li>
     <li>
@@ -1341,6 +1357,72 @@
     <li>Clear Server Points - a schedule for the locally generated BACnet points to get cleared from the node object store</li>
   </ul>
 
+  <h3><strong>Performance Tuning &amp; Throttling</strong></h3>
+  <p>
+    For large BACnet networks, especially those with many MS/TP devices, proper tuning is essential to prevent 
+    communication issues like value spiking, timeouts, and data corruption.
+  </p>
+
+  <h4>Understanding the BACnet Invoke ID Limit</h4>
+  <p>
+    The BACnet protocol uses an 8-bit "invoke ID" to match requests with responses. This limits the number of 
+    simultaneous outstanding requests to <strong>256</strong>. When polling many devices/points rapidly, this 
+    limit can be exhausted, causing responses to be matched with the wrong requests (value spiking).
+  </p>
+
+  <h4>Key Settings for Large Networks</h4>
+  <table style="width:100%; border-collapse: collapse; margin: 10px 0;">
+    <tr style="background-color: #f0f0f0;">
+      <th style="border: 1px solid #ddd; padding: 8px; text-align: left;">Setting</th>
+      <th style="border: 1px solid #ddd; padding: 8px; text-align: left;">Recommended</th>
+      <th style="border: 1px solid #ddd; padding: 8px; text-align: left;">Description</th>
+    </tr>
+    <tr>
+      <td style="border: 1px solid #ddd; padding: 8px;"><strong>Max Concurrent Requests</strong></td>
+      <td style="border: 1px solid #ddd; padding: 8px;">64-100 (MSTP)<br>150-200 (IP only)</td>
+      <td style="border: 1px solid #ddd; padding: 8px;">Limits simultaneous in-flight requests. Lower for slow MSTP networks.</td>
+    </tr>
+    <tr>
+      <td style="border: 1px solid #ddd; padding: 8px;"><strong>APDU Timeout</strong></td>
+      <td style="border: 1px solid #ddd; padding: 8px;">8000-15000ms (MSTP)<br>3000-6000ms (IP only)</td>
+      <td style="border: 1px solid #ddd; padding: 8px;">How long to wait for a response. MSTP token-passing adds latency.</td>
+    </tr>
+  </table>
+
+  <h4>Tuning Guidelines by Network Type</h4>
+  <ul class="node-ports">
+    <li>
+      <strong>BACnet/IP Only (few devices):</strong> Default settings usually work. Max Concurrent: 200-250, Timeout: 3000-6000ms
+    </li>
+    <li>
+      <strong>BACnet/IP with MS/TP routers (moderate):</strong> Max Concurrent: 100-150, Timeout: 6000-10000ms
+    </li>
+    <li>
+      <strong>Large MS/TP Networks (100+ devices):</strong> Max Concurrent: 64-100, Timeout: 10000-15000ms
+    </li>
+    <li>
+      <strong>Very Large Networks (500+ devices):</strong> Max Concurrent: 50-75, Timeout: 12000-20000ms. 
+      Consider segmenting polling across multiple read nodes with staggered schedules.
+    </li>
+  </ul>
+
+  <h4>Symptoms of Poor Tuning</h4>
+  <ul class="node-ports">
+    <li><strong>Value Spiking:</strong> Random incorrect values appearing briefly → Lower Max Concurrent Requests</li>
+    <li><strong>Many Timeouts:</strong> Points frequently showing offline → Increase APDU Timeout</li>
+    <li><strong>Slow Discovery:</strong> Devices/points taking too long to appear → May need higher Max Concurrent (if not MSTP-bound)</li>
+    <li><strong>Network Congestion:</strong> Other BACnet traffic affected → Lower Max Concurrent Requests and increase polling intervals</li>
+  </ul>
+
+  <h4>Best Practices</h4>
+  <ul class="node-ports">
+    <li>Start with conservative settings (lower Max Concurrent, higher Timeout) and tune up gradually</li>
+    <li>For MS/TP networks, remember that token-passing adds 50-200ms latency per device hop</li>
+    <li>Use longer polling intervals (5-15 minutes) for stable values; shorter (30s-1min) for critical points only</li>
+    <li>Monitor for timeout errors in the console (enable "Log BACnet Errors to Console")</li>
+    <li>If experiencing issues, reduce Max Concurrent Requests by 25% and test again</li>
+  </ul>
+
   <h3><strong>Examples</strong></h3>
   <p>
     For example flows, please use the examples section for this node. These examples can be found at: Node-red hamburger menu on

package/bacnet_gateway.js

@@ -38,6 +38,7 @@ module.exports = function (RED) {
     this.cacheFileEnabled = config.cacheFileEnabled;
     this.sanitise_device_schedule = config.sanitise_device_schedule;
     this.enable_device_discovery = config.enable_device_discovery;
+    this.maxConcurrentRequests = config.maxConcurrentRequests;
 
     //client and config store
     this.bacnetConfig = nodeContext.get("bacnetConfig");
@@ -67,7 +68,8 @@ module.exports = function (RED) {
         node.cacheFileEnabled,
         node.sanitise_device_schedule,
         node.portRangeRegisters.filter((ele) => ele.enabled === true),
-        node.enable_device_discovery
+        node.enable_device_discovery,
+        node.maxConcurrentRequests
       );
 
       if (typeof node.bacnetClient !== "undefined") {