@bitpoolos/edge-bacnet 1.6.7 → 1.6.9

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.6.9] - 01-07-2026
+
+Bug fix:
+
+- Recover missing points during discovery on small MSTP devices (e.g. RC FlexOne) that reject ReadProperty(ALL). When the "read all" attempt fails, discovery now tries a single targeted ReadPropertyMultiple for the required properties before falling back to per-property reads. This avoids the request storm that could cause the device to reject reads and silently drop Analog/Binary Output points from the model.
+
+- Fixed object-type whitelist filter leaking non-whitelisted objects (e.g. trend-logs) into the model. A malformed object-list entry could throw and abort the filter, leaving the point list unfiltered. The filter is now null-safe, so it always applies and only whitelisted object types are kept.
+
+- Added a discovery log when an object is dropped because no OBJECT_NAME was returned (read likely rejected), to aid diagnosis.
+
+## [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: 

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,
@@ -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 = [
         {
@@ -1435,6 +1521,26 @@ class BacnetClient extends EventEmitter {
         .catch(reject);
     };
 
+    // Targeted middle tier: request the needed properties in ONE ReadPropertyMultiple.
+    // Used when ALL is rejected (e.g. RC FlexOne / small MSTP that don't support reading
+    // the ALL pseudo-property). Same property set as the per-property fallback, so stored
+    // data is identical - just one request instead of ~12. Falls through to the
+    // per-property reads only if this targeted read also fails.
+    const readTargetedMultiple = (resolve, reject) => {
+      that
+        ._readObject(addressObject, type, instance, propertiesToRead, readOptions)
+        .then((result) => {
+          if (result.value) {
+            resolve(result);
+          } else {
+            readPropertiesIndividually(resolve, reject);
+          }
+        })
+        .catch(() => {
+          readPropertiesIndividually(resolve, reject);
+        });
+    };
+
     return new Promise((resolve, reject) => {
       // For Device objects (type 8), skip ALL attempt - many MSTP devices don't support it
       // Go straight to reading individual properties for better reliability
@@ -1451,13 +1557,15 @@ class BacnetClient extends EventEmitter {
             // If the result has value, resolve the promise
             resolve(result);
           } else {
-            // If not, proceed to read individual properties
-            readPropertiesIndividually(resolve, reject);
+            // ALL returned no value - try the targeted multi-property RPM before
+            // falling back to the per-property storm.
+            readTargetedMultiple(resolve, reject);
           }
         })
         .catch(() => {
-          // On error, proceed to read individual properties
-          readPropertiesIndividually(resolve, reject);
+          // ALL errored - try the targeted multi-property RPM before falling back
+          // to the per-property storm.
+          readTargetedMultiple(resolve, reject);
         });
     });
   }
@@ -1559,10 +1667,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: {
@@ -1572,8 +1684,8 @@ class BacnetClient extends EventEmitter {
             },
             value: [
               {
-                type: options.appTag,
-                value: value,
+                type: resolvedAppTag,
+                value: resolvedValue,
               },
             ],
           },
@@ -1606,7 +1718,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);
             }
           }
         );
@@ -1938,7 +2051,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) {
@@ -2146,6 +2259,12 @@ class BacnetClient extends EventEmitter {
                   that.logOut("issue resolving bacnet payload, see error:  ", e);
                   reject(e);
                 }
+              } else {
+                that.logOut(
+                  "[discovery] dropped " + bac_obj + ":" + pointProperty.objectId.instance +
+                  " on device " + device.getDeviceId() +
+                  " - no OBJECT_NAME returned (read likely rejected)"
+                );
               }
             });
           } else {
@@ -2276,6 +2395,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

@@ -268,10 +268,20 @@ class BacnetDevice {
     }
 
     setPointsList(newPoints) {
+        // Whitelisted object types kept in the model:
+        // DEVICE(8) AI(0) AO(1) AV(2) BI(3) BO(4) BV(5) MSI(13) MSO(14) MSV(19) CS(40)
+        const allowedTypes = new Set([8, 0, 1, 2, 3, 4, 5, 13, 14, 19, 40]);
+
         for (let index = 0; index < newPoints.length; index++) {
             let newPoint = newPoints[index];
-            if (newPoint) {
-                let foundIndex = this.pointsList.findIndex(ele => ele.value.type == newPoint.value.type && ele.value.instance == newPoint.value.instance);
+            // Guard against malformed entries (e.g. a bad object-list read with no .value):
+            // skip them here so they never enter pointsList and can't throw the dedup below.
+            if (newPoint && newPoint.value && newPoint.value.type !== undefined) {
+                let foundIndex = this.pointsList.findIndex(
+                    ele => ele && ele.value &&
+                           ele.value.type == newPoint.value.type &&
+                           ele.value.instance == newPoint.value.instance
+                );
                 if (foundIndex == -1) {
                     //not found
                     this.pointsList.push(newPoint);
@@ -279,19 +289,10 @@ class BacnetDevice {
             }
         }
 
-        this.pointsList = this.pointsList.filter((point) =>
-            point.value.type == 8 ||  //DEVICE
-            point.value.type == 0 ||  //AI
-            point.value.type == 1 ||  //AV
-            point.value.type == 2 ||  //AO
-            point.value.type == 3 ||  //BI
-            point.value.type == 4 ||  //BV
-            point.value.type == 5 ||  //BO
-            point.value.type == 13 || //MSI
-            point.value.type == 14 || //MSO
-            point.value.type == 19 || //MSV
-            point.value.type == 40    //CS 
-        );
+        // Optional chaining so a malformed element is EXCLUDED (allowedTypes.has(undefined) === false)
+        // instead of throwing and aborting the filter, which previously left pointsList unfiltered
+        // and leaked non-whitelisted types (trend-logs etc.) into the model.
+        this.pointsList = this.pointsList.filter(point => allowedTypes.has(point?.value?.type));
     }
 
     getDevicePoints() {

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") {

package/bacnet_write.html

@@ -8,7 +8,7 @@
     color: "#00aeef",
     defaults: {
       name: { value: "" },
-      applicationTag: { value: "4" },
+      applicationTag: { value: "-1" },
       priority: { value: "16" },
       pointsToWrite: { value: [] },
       writeDevices: { value: [] },
@@ -943,6 +943,7 @@
           ><i class="icon-tag"></i><span data-i18n="bitpool-bacnet.label.applicationTag"></span> Application Tag</label
         >
         <select id="node-input-applicationTag">
+          <option value="-1">AUTO</option>
           <option value="0">NULL</option>
           <option value="1">BOOLEAN</option>
           <option value="2">UNSIGNED_INT</option>

package/common.js

@@ -67,7 +67,8 @@ class BacnetClientConfig {
     cacheFileEnabled,
     sanitise_device_schedule,
     portRangeMatrix,
-    enable_device_discovery
+    enable_device_discovery,
+    maxConcurrentRequests
   ) {
     this.apduTimeout = apduTimeout;
     this.localIpAdrress = localIpAdrress;
@@ -87,6 +88,12 @@ class BacnetClientConfig {
     this.sanitise_device_schedule = sanitise_device_schedule;
     this.portRangeMatrix = this.generatePortRangeArray(portRangeMatrix);
     this.enable_device_discovery = enable_device_discovery;
+    // Clamp maxConcurrentRequests between 1 and 250
+    // BACnet protocol limits invoke IDs to 256, so 250 is the safe maximum
+    let clampedMaxConcurrent = parseInt(maxConcurrentRequests) || 250;
+    if (clampedMaxConcurrent < 1) clampedMaxConcurrent = 1;
+    if (clampedMaxConcurrent > 250) clampedMaxConcurrent = 250;
+    this.maxConcurrentRequests = clampedMaxConcurrent;
   }
 
   generatePortRangeArray(rangeMatrix) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitpoolos/edge-bacnet",
-  "version": "1.6.7",
+  "version": "1.6.9",
   "description": "A bacnet gateway for node-red",
   "dependencies": {
     "@plus4nodered/ts-node-bacnet": "^1.0.0-beta.2",

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,41 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**System Information (please complete the following information):**
- - OS: [e.g. iOS]
- - Browser [e.g. chrome, safari]
- - Version [e.g. 1.2]
- - Node-RED version: 
- - NodeJS version: 
-
-**Are you running Node-RED in a docker container or directly on the operating system or virtual machine?**
-
-
-
-**Please provide a dump of the Node-RED error log with the Error logging and Device Found check box options enabled (found in _gateway_ node - _Discovery_ tab) if applicable:**
- 
-
-
-**Additional context**
-Add any other context about the problem here.