@bitpoolos/edge-bacnet 1.6.7 → 1.6.8

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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: 

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 = [
         {
@@ -1559,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: {
@@ -1572,8 +1662,8 @@ class BacnetClient extends EventEmitter {
             },
             value: [
               {
-                type: options.appTag,
-                value: value,
+                type: resolvedAppTag,
+                value: resolvedValue,
               },
             ],
           },
@@ -1606,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);
             }
           }
         );
@@ -1938,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) {
@@ -2276,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_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.8",
   "description": "A bacnet gateway for node-red",
   "dependencies": {
     "@plus4nodered/ts-node-bacnet": "^1.0.0-beta.2",

package/resources/node-bacstack-ts/dist/lib/asn1.js

@@ -73,7 +73,7 @@ const encodeBacnetDouble = (buffer, value) => {
 };
 const decodeUnsigned = (buffer, offset, length) => ({
     len: length,
-    value: buffer.readUIntBE(offset, length)
+    value: length === 0 ? 0 : buffer.readUIntBE(offset, length)
 });
 exports.decodeUnsigned = decodeUnsigned;
 const decodeEnumerated = (buffer, offset, lenValue) => {
@@ -815,7 +815,7 @@ const decodeReadAccessResult = (buffer, offset, apduLen) => {
 exports.decodeReadAccessResult = decodeReadAccessResult;
 const decodeSigned = (buffer, offset, length) => ({
     len: length,
-    value: buffer.readIntBE(offset, length)
+    value: length === 0 ? 0 : buffer.readIntBE(offset, length)
 });
 exports.decodeSigned = decodeSigned;
 const decodeReal = (buffer, offset) => ({

package/resources/node-bacstack-ts/dist/lib/client.js

@@ -36,8 +36,13 @@ const BVLC_HEADER_LENGTH = 4;
 class Client extends events_1.EventEmitter {
     constructor(options) {
         super();
-        this._invokeCounter = 1;
         this._invokeStore = {};
+        // Per-device invoke ID counters: keyed by device address string.
+        // BACnet (ASHRAE 135 §5.4) scopes invoke IDs per originator-destination pair,
+        // so each device gets its own independent 0-255 counter rather than sharing one
+        // global counter across all devices, which would exhaust after only 256 total
+        // in-flight requests regardless of how many devices are being polled.
+        this._deviceInvokeCounters = {};
         this._lastSequenceNumber = 0;
         this._segmentStore = [];
         options = options || {};
@@ -50,7 +55,8 @@ class Client extends events_1.EventEmitter {
             interface: options.interface,
             transport: options.transport,
             broadcastAddress: options.broadcastAddress || '255.255.255.255',
-            apduTimeout: options.apduTimeout || 3000
+            apduTimeout: options.apduTimeout || 3000,
+            maxConcurrentRequests: options.maxConcurrentRequests || 250
         };
 
         this._transport = this._settings.transport || new transport_1.Transport({
@@ -66,41 +72,136 @@ class Client extends events_1.EventEmitter {
         this._transport.open();
     }
     // Helper utils
-    _getInvokeId() {
-        // Try up to 256 times to find an unused invoke ID
+    /**
+     * Returns the number of requests currently awaiting responses
+     * @returns {number} Active request count
+     */
+    getActiveRequestCount() {
+        return Object.keys(this._invokeStore).length;
+    }
+    /**
+     * Check if a new request can be sent without risking invoke ID exhaustion
+     * @returns {boolean} True if safe to send a new request
+     */
+    canSendRequest() {
+        return this.getActiveRequestCount() < this._settings.maxConcurrentRequests;
+    }
+    /**
+     * Returns the max concurrent requests setting
+     * @returns {number}
+     */
+    getMaxConcurrentRequests() {
+        return this._settings.maxConcurrentRequests;
+    }
+    /**
+     * Derives a stable, unique string key for a BACnet device from its address.
+     *
+     * BACnet (ASHRAE 135 §5.4) scopes invoke IDs per originator-destination pair.
+     * For IP devices the IP address is the discriminator.
+     * For MSTP devices routed through a BBMD/router, multiple devices share the
+     * same router IP but have distinct network+MAC addresses — those are used as
+     * the key so their invoke ID spaces remain independent.
+     *
+     * @param {string|object} addressOrObject - The address passed to a service method,
+     *   or the addressObject reconstructed from an incoming NPDU.
+     * @returns {string} A stable device key suitable for indexing _deviceInvokeCounters.
+     */
+    _makeDeviceKey(addressOrObject) {
+        if (addressOrObject === null || addressOrObject === undefined) return 'default';
+        // Plain string IP address
+        if (typeof addressOrObject === 'string') return addressOrObject;
+        // Guard against port numbers accidentally being passed as the address
+        if (typeof addressOrObject === 'number') return 'default';
+        if (typeof addressOrObject === 'object') {
+            // MSTP routed device — has net (network number) and adr (MAC address array).
+            // These fields appear both in outgoing address objects and in the sourceAddress
+            // decoded by _handleNpdu from the NPDU header of incoming MSTP responses.
+            if (addressOrObject.net !== undefined && addressOrObject.adr !== undefined) {
+                let adrHex;
+                if (Buffer.isBuffer(addressOrObject.adr)) {
+                    adrHex = addressOrObject.adr.toString('hex');
+                } else if (Array.isArray(addressOrObject.adr)) {
+                    adrHex = Buffer.from(addressOrObject.adr).toString('hex');
+                } else {
+                    adrHex = String(addressOrObject.adr);
+                }
+                return `mstp:${addressOrObject.net}:${adrHex}`;
+            }
+            // Wrapper object like {address: <ip-or-mstp-object>, port: N}
+            if (addressOrObject.address !== undefined) {
+                return this._makeDeviceKey(addressOrObject.address);
+            }
+            // Object from _handleNpdu with an ip field but no net/adr (pure IP)
+            if (addressOrObject.ip !== undefined) {
+                return addressOrObject.ip;
+            }
+        }
+        return String(addressOrObject);
+    }
+    /**
+     * Returns a free invoke ID scoped to the given device key.
+     *
+     * Each device now gets its own independent 0-255 counter, matching the
+     * BACnet spec (ASHRAE 135 §5.4).  Previously a single shared counter meant
+     * exhaustion after only 256 total in-flight requests across ALL devices,
+     * causing the fallback branch to return an already-in-use ID and silently
+     * overwrite the existing callback — the direct source of value mismatches.
+     *
+     * @param {string} deviceKey - Result of _makeDeviceKey() for the target device.
+     * @returns {number} An invoke ID (0-255) not currently in use for that device.
+     */
+    _getInvokeId(deviceKey) {
+        if (!this._deviceInvokeCounters[deviceKey]) {
+            this._deviceInvokeCounters[deviceKey] = 1;
+        }
         for (let attempts = 0; attempts < 256; attempts++) {
-            const id = this._invokeCounter++;
-            if (id >= 256) this._invokeCounter = 1;
-
+            const id = this._deviceInvokeCounters[deviceKey]++;
+            if (id >= 256) this._deviceInvokeCounters[deviceKey] = 1;
             const invokeId = id - 1;
-
-            // If this invoke ID is not currently in use, return it
-            if (!this._invokeStore[invokeId]) {
+            if (!this._invokeStore[`${deviceKey}:${invokeId}`]) {
                 return invokeId;
             }
         }
-
-        // Edge case: if all 256 invoke IDs are in use, fall back to original behavior
-        // This prevents infinite loops while maintaining backwards compatibility
-        const id = this._invokeCounter++;
-        if (id >= 256) this._invokeCounter = 1;
+        // All 256 IDs in use for this device — caller should throttle before this point.
+        // Return the next counter value so at least we don't spin forever; the
+        // _waitForRequestSlot mechanism in bacnet_client.js prevents reaching here
+        // under normal operation.
+        const id = this._deviceInvokeCounters[deviceKey]++;
+        if (id >= 256) this._deviceInvokeCounters[deviceKey] = 1;
+        debug('All 256 invoke IDs exhausted for device', deviceKey, '- reusing ID which may cause value mismatch');
         return id - 1;
     }
-    _invokeCallback(id, err, result) {
-        const callback = this._invokeStore[id];
+    /**
+     * Fires the stored callback for the given device+invokeId pair.
+     * Using a compound key prevents a response from device A triggering the
+     * callback registered for device B when both happen to share the same
+     * numeric invoke ID value.
+     */
+    _invokeCallback(deviceKey, id, err, result) {
+        const storeKey = `${deviceKey}:${id}`;
+        const callback = this._invokeStore[storeKey];
         if (callback)
             return callback(err, result);
-        debug('InvokeId ', id, ' not found -> drop package');
+        debug('InvokeId', id, 'for device', deviceKey, 'not found -> drop package');
     }
-    _addCallback(id, callback) {
+    /**
+     * Registers a callback for the given device+invokeId, with a timeout guard.
+     * The compound store key means callbacks are isolated per device, so a late
+     * response from a slow MSTP device cannot accidentally resolve a callback
+     * that belongs to a different device.
+     */
+    _addCallback(deviceKey, id, callback) {
+        const storeKey = `${deviceKey}:${id}`;
         const timeout = setTimeout(() => {
-            delete this._invokeStore[id];
+            delete this._invokeStore[storeKey];
             callback(new Error('ERR_TIMEOUT'));
+            this.emit('requestComplete', { activeCount: this.getActiveRequestCount(), timedOut: true });
         }, this._settings.apduTimeout);
-        this._invokeStore[id] = (err, data) => {
+        this._invokeStore[storeKey] = (err, data) => {
             clearTimeout(timeout);
-            delete this._invokeStore[id];
+            delete this._invokeStore[storeKey];
             callback(err, data);
+            this.emit('requestComplete', { activeCount: this.getActiveRequestCount(), timedOut: false });
         };
     }
     _getBuffer() {
@@ -110,17 +211,17 @@ class Client extends events_1.EventEmitter {
         };
     }
     // Service Handlers
-    _processError(invokeId, buffer, offset, length) {
+    _processError(deviceKey, invokeId, buffer, offset, length) {
         try {
             const result = baServices.error.decode(buffer, offset);
             if (!result)
                 return debug('Couldn`t decode Error');
-            this._invokeCallback(invokeId, new Error('BacnetError - Class:' + result.class + ' - Code:' + result.code));
+            this._invokeCallback(deviceKey, invokeId, new Error('BacnetError - Class:' + result.class + ' - Code:' + result.code));
         } catch (e) {
         }
     }
-    _processAbort(invokeId, reason) {
-        this._invokeCallback(invokeId, new Error('BacnetAbort - Reason:' + reason));
+    _processAbort(deviceKey, invokeId, reason) {
+        this._invokeCallback(deviceKey, invokeId, new Error('BacnetAbort - Reason:' + reason));
     }
     _segmentAckResponse(receiver, port, negative, server, originalInvokeId, sequencenumber, actualWindowSize) {
         const buffer = this._getBuffer();
@@ -402,6 +503,10 @@ class Client extends events_1.EventEmitter {
 
     _handlePdu(address, type, buffer, offset, length, addressObject, destAddressObject, port) {
         let result;
+        // Derive the device key from the source address.  For MSTP devices routed
+        // through a BBMD the addressObject carries the NPDU source (net + adr) which
+        // uniquely identifies the MSTP node.  For plain IP the IP string is used.
+        const deviceKey = this._makeDeviceKey(addressObject);
         // Handle different PDU types
         switch (type & baEnum.PDU_TYPE_MASK) {
             case baEnum.PduTypes.UNCONFIRMED_REQUEST:
@@ -412,12 +517,12 @@ class Client extends events_1.EventEmitter {
                 result = baApdu.decodeSimpleAck(buffer, offset);
                 offset += result.len;
                 length -= result.len;
-                this._invokeCallback(result.invokeId, null, { result: result, buffer: buffer, offset: offset + result.len, length: length - result.len });
+                this._invokeCallback(deviceKey, result.invokeId, null, { result: result, buffer: buffer, offset: offset + result.len, length: length - result.len });
                 break;
             case baEnum.PduTypes.COMPLEX_ACK:
                 result = baApdu.decodeComplexAck(buffer, offset);
                 if ((type & baEnum.PduConReqBits.SEGMENTED_MESSAGE) === 0) {
-                    this._invokeCallback(result.invokeId, null, { result: result, buffer: buffer, offset: offset + result.len, length: length - result.len });
+                    this._invokeCallback(deviceKey, result.invokeId, null, { result: result, buffer: buffer, offset: offset + result.len, length: length - result.len });
                 } else {
                     this._processSegment(addressObject, result.type, result.service, result.invokeId, baEnum.MaxSegmentsAccepted.SEGMENTS_0, baEnum.MaxApduLengthAccepted.OCTETS_50, false, result.sequencenumber, result.proposedWindowNumber, buffer, offset + result.len, length - result.len, port);
                 }
@@ -429,12 +534,12 @@ class Client extends events_1.EventEmitter {
                 break;
             case baEnum.PduTypes.ERROR:
                 result = baApdu.decodeError(buffer, offset);
-                this._processError(result.invokeId, buffer, offset + result.len, length - result.len);
+                this._processError(deviceKey, result.invokeId, buffer, offset + result.len, length - result.len);
                 break;
             case baEnum.PduTypes.REJECT:
             case baEnum.PduTypes.ABORT:
                 result = baApdu.decodeAbort(buffer, offset);
-                this._processAbort(result.invokeId, result.reason);
+                this._processAbort(deviceKey, result.invokeId, result.reason);
                 break;
             case baEnum.PduTypes.CONFIRMED_REQUEST:
                 result = baApdu.decodeConfirmedServiceRequest(buffer, offset);
@@ -639,11 +744,12 @@ class Client extends events_1.EventEmitter {
 
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
 
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId(),
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey),
             arrayIndex: options.arrayIndex || baEnum.ASN1_ARRAY_ALL
         };
         const buffer = this._getBuffer();
@@ -653,7 +759,7 @@ class Client extends events_1.EventEmitter {
         baServices.readProperty.encode(buffer, objectId.type, objectId.instance, propertyId, settings.arrayIndex);
         baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err, data) => {
+        this._addCallback(deviceKey, settings.invokeId, (err, data) => {
             try {
                 if (err)
                     return next(err);
@@ -699,11 +805,12 @@ class Client extends events_1.EventEmitter {
 
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
 
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId(),
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey),
             arrayIndex: options.arrayIndex || baEnum.ASN1_ARRAY_ALL,
             priority: options.priority
         };
@@ -713,7 +820,7 @@ class Client extends events_1.EventEmitter {
         baServices.writeProperty.encode(buffer, objectId.type, objectId.instance, propertyId, settings.arrayIndex, settings.priority, values);
         baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     /**
      * The readPropertyMultiple command reads multiple properties in multiple objects from a device.
@@ -746,11 +853,12 @@ class Client extends events_1.EventEmitter {
 
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
 
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address, null, DEFAULT_HOP_COUNT, baEnum.NetworkLayerMessageType.WHO_IS_ROUTER_TO_NETWORK, 0);
@@ -759,7 +867,7 @@ class Client extends events_1.EventEmitter {
         baServices.readPropertyMultiple.encode(buffer, propertiesArray);
         baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err, data) => {
+        this._addCallback(deviceKey, settings.invokeId, (err, data) => {
             try {
                 if (err)
                     return next(err);
@@ -811,11 +919,12 @@ class Client extends events_1.EventEmitter {
 
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
 
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -823,7 +932,7 @@ class Client extends events_1.EventEmitter {
         baServices.writePropertyMultiple.encodeObject(buffer, values);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     /**
      * The deviceCommunicationControl command enables or disables network communication of the target device.
@@ -849,10 +958,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId(),
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey),
             password: options.password
         };
         const buffer = this._getBuffer();
@@ -861,7 +971,7 @@ class Client extends events_1.EventEmitter {
         baServices.deviceCommunicationControl.encode(buffer, timeDuration, enableDisable, settings.password);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     /**
      * The reinitializeDevice command initiates a restart of the target device.
@@ -886,10 +996,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId(),
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey),
             password: options.password
         };
         const buffer = this._getBuffer();
@@ -898,7 +1009,7 @@ class Client extends events_1.EventEmitter {
         baServices.reinitializeDevice.encode(buffer, state, settings.password);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     /**
      * The writeFile command writes a file buffer to a specific position of a file object.
@@ -926,10 +1037,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -937,7 +1049,7 @@ class Client extends events_1.EventEmitter {
         baServices.atomicWriteFile.encode(buffer, false, objectId, position, fileBuffer);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err, data) => {
+        this._addCallback(deviceKey, settings.invokeId, (err, data) => {
             if (err)
                 return next(err);
             const result = baServices.atomicWriteFile.decodeAcknowledge(data.buffer, data.offset);
@@ -972,10 +1084,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -983,7 +1096,7 @@ class Client extends events_1.EventEmitter {
         baServices.atomicReadFile.encode(buffer, true, objectId, position, count);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err, data) => {
+        this._addCallback(deviceKey, settings.invokeId, (err, data) => {
             if (err)
                 return next(err);
             const result = baServices.atomicReadFile.decodeAcknowledge(data.buffer, data.offset);
@@ -1018,10 +1131,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1029,7 +1143,7 @@ class Client extends events_1.EventEmitter {
         baServices.readRange.encode(buffer, objectId, baEnum.PropertyIdentifier.LOG_BUFFER, baEnum.ASN1_ARRAY_ALL, baEnum.ReadRangeType.BY_POSITION, idxBegin, new Date(), quantity);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err, data) => {
+        this._addCallback(deviceKey, settings.invokeId, (err, data) => {
             if (err)
                 return next(err);
             const result = baServices.readRange.decodeAcknowledge(data.buffer, data.offset, data.length);
@@ -1066,10 +1180,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1077,7 +1192,7 @@ class Client extends events_1.EventEmitter {
         baServices.subscribeCov.encode(buffer, subscribeId, objectId, cancel, issueConfirmedNotifications, lifetime);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     /**
      * The subscribeProperty command subscribes to a specific property of an object for "Change of Value" notifications.
@@ -1109,10 +1224,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1120,16 +1236,17 @@ class Client extends events_1.EventEmitter {
         baServices.subscribeProperty.encode(buffer, subscribeId, objectId, cancel, issueConfirmedNotifications, 0, monitoredProperty, false, 0x0f);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     createObject(addressObject, objectId, values, options, next) {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1137,7 +1254,7 @@ class Client extends events_1.EventEmitter {
         baServices.createObject.encode(buffer, objectId, values);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     /**
      * The deleteObject command removes an object instance from a target device.
@@ -1163,10 +1280,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1174,16 +1292,17 @@ class Client extends events_1.EventEmitter {
         baServices.deleteObject.encode(buffer, objectId);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     removeListElement(addressObject, objectId, reference, values, options, next) {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1191,16 +1310,17 @@ class Client extends events_1.EventEmitter {
         baServices.addListElement.encode(buffer, objectId, reference.id, reference.index, values);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     addListElement(addressObject, objectId, reference, values, options, next) {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1208,7 +1328,7 @@ class Client extends events_1.EventEmitter {
         baServices.addListElement.encode(buffer, objectId, reference.id, reference.index, values);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     /**
      * DEPRECATED The getAlarmSummary command returns a list of all active alarms on the target device.
@@ -1231,17 +1351,18 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
         baApdu.encodeConfirmedServiceRequest(buffer, baEnum.PduTypes.CONFIRMED_REQUEST, baEnum.ConfirmedServiceChoice.GET_ALARM_SUMMARY, settings.maxSegments, settings.maxApdu, settings.invokeId, 0, 0);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err, data) => {
+        this._addCallback(deviceKey, settings.invokeId, (err, data) => {
             if (err)
                 return next(err);
             const result = baServices.alarmSummary.decode(data.buffer, data.offset, data.length);
@@ -1274,10 +1395,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1285,7 +1407,7 @@ class Client extends events_1.EventEmitter {
         baAsn1.encodeContextObjectId(buffer, 0, objectId.type, objectId.instance);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err, data) => {
+        this._addCallback(deviceKey, settings.invokeId, (err, data) => {
             if (err)
                 return next(err);
             const result = baServices.eventInformation.decode(data.buffer, data.offset, data.length);
@@ -1298,10 +1420,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1309,7 +1432,7 @@ class Client extends events_1.EventEmitter {
         baServices.alarmAcknowledge.encode(buffer, 57, objectId, eventState, ackText, evTimeStamp, ackTimeStamp);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     /**
      * The confirmedPrivateTransfer command invokes a confirmed proprietary/non-standard service.
@@ -1335,10 +1458,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1346,7 +1470,7 @@ class Client extends events_1.EventEmitter {
         baServices.privateTransfer.encode(buffer, vendorId, serviceNumber, data);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     /**
      * The unconfirmedPrivateTransfer command invokes an unconfirmed proprietary/non-standard service.
@@ -1400,10 +1524,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1411,7 +1536,7 @@ class Client extends events_1.EventEmitter {
         baServices.getEnrollmentSummary.encode(buffer, acknowledgmentFilter, options.enrollmentFilter, options.eventStateFilter, options.eventTypeFilter, options.priorityFilter, options.notificationClassFilter);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err, data) => {
+        this._addCallback(deviceKey, settings.invokeId, (err, data) => {
             if (err)
                 return next(err);
             const result = baServices.getEnrollmentSummary.decodeAcknowledge(data.buffer, data.offset, data.length);
@@ -1434,10 +1559,11 @@ class Client extends events_1.EventEmitter {
         next = next || options;
         let address = addressObject.address ? addressObject.address : addressObject;
         let port = addressObject.port ? addressObject.port : this._settings.port;
+        const deviceKey = this._makeDeviceKey(addressObject);
         const settings = {
             maxSegments: options.maxSegments || baEnum.MaxSegmentsAccepted.SEGMENTS_65,
             maxApdu: options.maxApdu || baEnum.MaxApduLengthAccepted.OCTETS_1476,
-            invokeId: options.invokeId || this._getInvokeId()
+            invokeId: (options.invokeId !== undefined && options.invokeId !== null) ? options.invokeId : this._getInvokeId(deviceKey)
         };
         const buffer = this._getBuffer();
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE | baEnum.NpduControlBits.EXPECTING_REPLY, address);
@@ -1445,7 +1571,7 @@ class Client extends events_1.EventEmitter {
         baServices.eventNotifyData.encode(buffer, eventNotification);
         //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, port, buffer);
-        this._addCallback(settings.invokeId, (err) => next(err));
+        this._addCallback(deviceKey, settings.invokeId, (err) => next(err));
     }
     // Public Device Functions
     readPropertyResponse(receiver, invokeId, objectId, property, value) {

package/resources/node-bacstack-ts/dist/lib/npdu.js

@@ -25,7 +25,7 @@ const decodeTarget = (buffer, offset) => {
 const encodeTarget = (buffer, target) => {
     buffer.buffer[buffer.offset++] = (target.net & 0xFF00) >> 8;
     buffer.buffer[buffer.offset++] = (target.net & 0x00FF) >> 0;
-    if (target.net === 0xFFFF || !target.adr) {
+    if (target.net === 0xFFFF || !target.adr || target.adr.length === 0) {
         buffer.buffer[buffer.offset++] = 0;
     }
     else {