@bitpoolos/edge-bacnet 1.4.7 → 1.5.1

package/bacnet_client.js

@@ -6,7 +6,15 @@ const bacnet = require("./resources/node-bacstack-ts/dist/index.js");
 const baEnum = bacnet.enum;
 const bacnetIdMax = baEnum.ASN1_MAX_PROPERTY_ID;
 const { EventEmitter } = require("events");
-const { getUnit, roundDecimalPlaces, Store_Config, Read_Config_Sync, isNumber, decodeBitArray } = require("./common");
+const {
+  getUnit,
+  roundDecimalPlaces,
+  parseBacnetError,
+  getBacnetErrorString,
+  Read_Config_Sync,
+  isNumber,
+  decodeBitArray,
+} = require("./common");
 const { ToadScheduler, SimpleIntervalJob, Task } = require("toad-scheduler");
 const { BacnetDevice } = require("./bacnet_device");
 const { Mutex } = require("async-mutex");
@@ -30,6 +38,7 @@ class BacnetClient extends EventEmitter {
     that.buildJsonInProgress = false;
     that.scanMatrix = [];
     that.renderListCount = 0;
+    that.portRangeMatrix = config.portRangeMatrix;
 
     try {
       if (that.config.cacheFileEnabled) {
@@ -64,12 +73,12 @@ class BacnetClient extends EventEmitter {
       };
 
       try {
-
         that.client = new bacnet.Client({
           apduTimeout: config.apduTimeout,
           interface: config.localIpAdrress,
           port: config.port,
           broadcastAddress: config.broadCastAddr,
+          portRangeMatrix: config.portRangeMatrix,
         });
         that.setMaxListeners(1);
 
@@ -185,15 +194,40 @@ class BacnetClient extends EventEmitter {
     });
   }
 
-  testFunction(address, type, instance, property) {
+  testFunction(address, port, type, instance, property) {
     let that = this;
     console.log("test function ");
+
+    let addressObject = {
+      address: address,
+      port: port,
+    };
+
+    const propertiesArray = [{ objectId: { type: type, instance: instance }, properties: [{ id: property }] }];
+
+    that.client.readPropertyMultiple(addressObject, propertiesArray, that.readPropertyMultipleOptions, (err, value) => {
+      console.log("1 - readPropertyMultiple:  ");
+
+      console.log(value);
+      if (value) {
+        // If the result has value, resolve the promise
+        console.log(value.values[0]);
+        value.values[0].values.forEach(function (value) {
+          console.log("value: ", value.value);
+        });
+      } else {
+        console.log(err);
+      }
+    });
+
     that.client.readProperty(
-      address,
+      addressObject,
       { type: type, instance: instance },
       property,
       that.readPropertyMultipleOptions,
       (err, value) => {
+        console.log("2 - readProperty:  ");
+
         console.log(value);
         if (value) {
           // If the result has value, resolve the promise
@@ -254,9 +288,13 @@ class BacnetClient extends EventEmitter {
   getProtocolSupported(device) {
     //return protocols support for device
     let that = this;
+    let addressObject = {
+      address: device.getAddress(),
+      port: device.getPort(),
+    };
     return new Promise((resolve, reject) => {
       that.client.readProperty(
-        device.getAddress(),
+        addressObject,
         { type: baEnum.ObjectType.DEVICE, instance: device.getDeviceId() },
         baEnum.PropertyIdentifier.PROTOCOL_SERVICES_SUPPORTED,
         that.readPropertyMultipleOptions,
@@ -482,10 +520,10 @@ class BacnetClient extends EventEmitter {
             }
             try {
               await that.updateDeviceName(device);
+
               if (device.getSegmentation() !== 3) {
                 try {
                   await that.getDevicePointList(device);
-
                   index++;
                   await query(index);
                 } catch (e) {
@@ -529,7 +567,7 @@ class BacnetClient extends EventEmitter {
     let that = this;
     return new Promise((resolve, reject) => {
       that
-        ._getDeviceName(device.getAddress(), device.getDeviceId())
+        ._getDeviceName(device)
         .then(function (deviceObject) {
           if (typeof deviceObject.name == "string") {
             device.setDeviceName(deviceObject.name + " " + device.getDeviceId());
@@ -538,7 +576,8 @@ class BacnetClient extends EventEmitter {
           resolve();
         })
         .catch(function (e) {
-          reject(e);
+          that.logOut("updateDeviceName error: ", e);
+          resolve();
         });
     });
   }
@@ -767,6 +806,7 @@ class BacnetClient extends EventEmitter {
 
           if (isNumber(val)) {
             pointRef.presentValue = roundDecimalPlaces(val, roundDecimal);
+            pointRef.error = "none";
             if (pointRef.meta.objectId.type == 19 || pointRef.meta.objectId.type == 13 || pointRef.meta.objectId.type == 14) {
               if (pointRef.stateTextArray && typeof pointRef.stateTextArray[0].value !== "object") {
                 if (val != 0) {
@@ -779,6 +819,9 @@ class BacnetClient extends EventEmitter {
           } else {
             if (typeof val !== "object") {
               pointRef.presentValue = val;
+              pointRef.error = "none";
+            } else if (val.errorClass && val.errorClass) {
+              pointRef.error = getBacnetErrorString(val.errorClass, val.errorClass);
             }
           }
 
@@ -792,23 +835,7 @@ class BacnetClient extends EventEmitter {
       });
     } catch (err) {
       that.logOut("Error processing batch:", err);
-
-      let deviceMetaInfo = {
-        address: device.getAddress(),
-        isMstp: device.getIsMstpDevice(),
-        deviceId: device.getDeviceId(),
-        vendorId: device.getVendorId(),
-        deviceName: deviceName,
-      };
-
-      requestArray.forEach((request) => {
-        let pointRef = request.pointRef;
-        pointRef.status = "offline";
-        pointRef.timestamp = Date.now();
-        pointRef.meta["device"] = deviceMetaInfo;
-
-        bacnetResults[deviceName][request.pointName] = pointRef;
-      });
+      await that.processIndividualPoints(device, requestArray, deviceName, bacnetResults, that, roundDecimal);
     }
   }
 
@@ -836,6 +863,7 @@ class BacnetClient extends EventEmitter {
         pointRef.meta["device"] = deviceMetaInfo;
         pointRef.timestamp = Date.now();
         pointRef.status = "online";
+        pointRef.error = "none";
 
         // Store the point data in results
         bacnetResults[deviceName][pointName] = pointRef;
@@ -845,6 +873,7 @@ class BacnetClient extends EventEmitter {
         pointRef.meta["device"] = deviceMetaInfo;
         pointRef.timestamp = Date.now();
         pointRef.status = "offline";
+        pointRef.error = parseBacnetError(err);
         bacnetResults[deviceName][pointName] = pointRef;
       }
     }
@@ -854,7 +883,7 @@ class BacnetClient extends EventEmitter {
     let that = this;
     return new Promise((resolve, reject) => {
       that
-        ._readObjectWithRequestArray(device.getAddress(), points, that.readPropertyMultipleOptions)
+        ._readObjectWithRequestArray(device, points, that.readPropertyMultipleOptions)
         .then(function (results) {
           resolve(results);
         })
@@ -866,9 +895,13 @@ class BacnetClient extends EventEmitter {
 
   updatePoint(device, point) {
     let that = this;
+    let addressObject = {
+      address: device.getAddress(),
+      port: device.getPort(),
+    };
     return new Promise((resolve, reject) => {
       that.client.readProperty(
-        device.getAddress(),
+        addressObject,
         { type: point.meta.objectId.type, instance: point.meta.objectId.instance },
         baEnum.PropertyIdentifier.PRESENT_VALUE,
         that.readPropertyMultipleOptions,
@@ -907,20 +940,21 @@ class BacnetClient extends EventEmitter {
     }
   }
 
-  _getDeviceName(address, deviceId) {
+  _getDeviceName(device) {
     let that = this;
     return new Promise((resolve, reject) => {
-      that._readDeviceName(address, deviceId, (err, result) => {
+      that._readDeviceName(device, (err, result) => {
         if (result) {
           try {
             if (result.values[0].value) {
               const deviceObject = {
                 name: result.values[0].value,
-                devicePointEntry: [{ value: { type: 8, instance: deviceId }, type: 12 }],
+                devicePointEntry: [{ value: { type: 8, instance: device.getDeviceId() }, type: 12 }],
               };
               resolve(deviceObject);
             } else {
-              that.logOut("Issue with deviceName payload, see object: ", object);
+              that.logOut("Issue with deviceName payload, see object: ", result);
+              resolve();
             }
           } catch (e) {
             that.logOut("Unable to get device name: ", e);
@@ -1016,10 +1050,14 @@ class BacnetClient extends EventEmitter {
     let that = this;
 
     return new Promise(function (resolve, reject) {
-      let address = device.getAddress();
       let deviceId = device.getDeviceId();
       let discoveredPointList = [];
 
+      let addressObject = {
+        address: device.getAddress(),
+        port: device.getPort(),
+      };
+
       let index = 1;
 
       send(index);
@@ -1032,7 +1070,7 @@ class BacnetClient extends EventEmitter {
         };
 
         that.client.readProperty(
-          address,
+          addressObject,
           { type: baEnum.ObjectType.DEVICE, instance: deviceId },
           baEnum.PropertyIdentifier.OBJECT_LIST,
           readOptions,
@@ -1052,10 +1090,14 @@ class BacnetClient extends EventEmitter {
     });
   }
 
-  _readObjectWithRequestArray(deviceAddress, requestArray, readOptions) {
+  _readObjectWithRequestArray(device, requestArray, readOptions) {
     let that = this;
+    let addressObject = {
+      address: device.getAddress(),
+      port: device.getPort(),
+    };
     return new Promise((resolve, reject) => {
-      this.client.readPropertyMultiple(deviceAddress, requestArray, readOptions, (error, value) => {
+      that.client.readPropertyMultiple(addressObject, requestArray, readOptions, (error, value) => {
         resolve({
           error: error,
           value: value,
@@ -1064,10 +1106,17 @@ class BacnetClient extends EventEmitter {
     });
   }
 
-  _readDeviceName(deviceAddress, deviceId, callback) {
+  _readDeviceName(device, callback) {
     let that = this;
+
+    let addressObject = {
+      address: device.getAddress(),
+      port: device.getPort(),
+    };
+    let deviceId = device.getDeviceId();
+
     that.client.readProperty(
-      deviceAddress,
+      addressObject,
       { type: baEnum.ObjectType.DEVICE, instance: deviceId },
       baEnum.PropertyIdentifier.OBJECT_NAME,
       that.readPropertyMultipleOptions,
@@ -1075,12 +1124,16 @@ class BacnetClient extends EventEmitter {
     );
   }
 
-  _readObjectList(deviceAddress, deviceId, readOptions, callback) {
+  _readObjectList(device, readOptions, callback) {
     let that = this;
-
+    let addressObject = {
+      address: device.getAddress(),
+      port: device.getPort(),
+    };
+    let deviceId = device.getDeviceId();
     try {
       that.client.readProperty(
-        deviceAddress,
+        addressObject,
         { type: baEnum.ObjectType.DEVICE, instance: deviceId },
         baEnum.PropertyIdentifier.OBJECT_LIST,
         readOptions,
@@ -1091,7 +1144,7 @@ class BacnetClient extends EventEmitter {
     }
   }
 
-  _readObject(deviceAddress, type, instance, properties, readOptions) {
+  _readObject(addressObject, type, instance, properties, readOptions) {
     let that = this;
     return new Promise((resolve, reject) => {
       const requestArray = [
@@ -1100,7 +1153,7 @@ class BacnetClient extends EventEmitter {
           properties: properties,
         },
       ];
-      this.client.readPropertyMultiple(deviceAddress, requestArray, readOptions, (error, value) => {
+      that.client.readPropertyMultiple(addressObject, requestArray, readOptions, (error, value) => {
         resolve({
           error: error,
           value: value,
@@ -1109,13 +1162,23 @@ class BacnetClient extends EventEmitter {
     });
   }
 
-  _readObjectFull(device, deviceAddress, type, instance) {
+  _readObjectFull(device, type, instance) {
     const that = this;
     const readOptions = {
       maxSegments: that.readPropertyMultipleOptions.maxSegments,
       maxApdu: that.readPropertyMultipleOptions.maxApdu,
     };
 
+    const readIndividualPropsOptions = {
+      maxSegments: 0,
+      maxApdu: device.getMaxApdu(),
+    };
+
+    let addressObject = {
+      address: device.getAddress(),
+      port: device.getPort(),
+    };
+
     // Define all properties to be read
     const allProperties = [
       { id: baEnum.PropertyIdentifier.PRESENT_VALUE },
@@ -1135,7 +1198,7 @@ class BacnetClient extends EventEmitter {
     return new Promise((resolve, reject) => {
       // Try to read all properties at once
       that
-        ._readObject(deviceAddress, type, instance, [{ id: baEnum.PropertyIdentifier.ALL }], readOptions)
+        ._readObject(addressObject, type, instance, [{ id: baEnum.PropertyIdentifier.ALL }], readOptions)
         .then((result) => {
           if (result.value) {
             // If the result has value, resolve the promise
@@ -1156,10 +1219,10 @@ class BacnetClient extends EventEmitter {
           (property, index) =>
             new Promise((propertyResolve) => {
               that.client.readProperty(
-                deviceAddress,
+                addressObject,
                 { type: type, instance: instance },
                 property.id,
-                readOptions,
+                readIndividualPropsOptions,
                 (err, value) => {
                   if (err) {
                     propertyResolve(null);
@@ -1200,20 +1263,30 @@ class BacnetClient extends EventEmitter {
     });
   }
 
-  _readObjectLite(device, deviceAddress, type, instance) {
+  _readObjectLite(device, type, instance) {
     const that = this;
     const readOptions = {
       maxSegments: that.readPropertyMultipleOptions.maxSegments,
       maxApdu: that.readPropertyMultipleOptions.maxApdu,
     };
 
+    const readIndividualPropsOptions = {
+      maxSegments: 0,
+      maxApdu: device.getMaxApdu(),
+    };
+
+    let addressObject = {
+      address: device.getAddress(),
+      port: device.getPort(),
+    };
+
     // Define all properties to be read
     const allProperties = [{ id: baEnum.PropertyIdentifier.PRESENT_VALUE }, { id: baEnum.PropertyIdentifier.OBJECT_NAME }];
 
     return new Promise((resolve, reject) => {
       // Try to read all properties at once
       that
-        ._readObject(deviceAddress, type, instance, allProperties, readOptions)
+        ._readObject(addressObject, type, instance, allProperties, readOptions)
         .then((result) => {
           if (result.value) {
             // If the result has value, resolve the promise
@@ -1234,10 +1307,10 @@ class BacnetClient extends EventEmitter {
           (property, index) =>
             new Promise((propertyResolve) => {
               that.client.readProperty(
-                deviceAddress,
+                addressObject,
                 { type: type, instance: instance },
                 property.id,
-                readOptions,
+                readIndividualPropsOptions,
                 (err, value) => {
                   if (err) {
                     propertyResolve(null);
@@ -1278,53 +1351,47 @@ class BacnetClient extends EventEmitter {
     });
   }
 
-  _readObjectPropList(deviceAddress, type, instance) {
-    return this._readObject(deviceAddress, type, instance, [{ id: baEnum.PropertyIdentifier.PROPERTY_LIST }]);
-  }
-
-  _readObjectId(deviceAddress, type, instance) {
-    return this._readObject(deviceAddress, type, instance, [{ id: baEnum.PropertyIdentifier.OBJECT_IDENTIFIER }]);
-  }
-
-  _readObjectPresentValue(deviceAddress, type, instance) {
-    return this._readObject(deviceAddress, type, instance, [
-      { id: baEnum.PropertyIdentifier.PRESENT_VALUE },
-      { id: baEnum.PropertyIdentifier.OBJECT_NAME },
-    ]);
-  }
-
   doWrite(value, options) {
     let that = this;
     let valuesArray = [];
     options.pointsToWrite.forEach(function (point) {
-      let deviceAddress = point.deviceAddress;
-      let writeObject = {
-        address: deviceAddress,
-        objectId: {
-          type: point.meta.objectId.type,
-          instance: point.meta.objectId.instance,
-        },
-        values: {
-          property: {
-            id: 85,
-            index: point.meta.arrayIndex,
+      try {
+        let device = that.deviceList.find((ele) => ele.getDeviceId() === point.deviceId);
+        let addressObject = {
+          address: device.getAddress(),
+          port: device.getPort(),
+        };
+
+        let writeObject = {
+          address: addressObject,
+          objectId: {
+            type: point.meta.objectId.type,
+            instance: point.meta.objectId.instance,
           },
-          value: [
-            {
-              type: options.appTag,
-              value: value,
+          values: {
+            property: {
+              id: 85,
+              index: point.meta.arrayIndex,
             },
-          ],
-        },
-        options: {
-          maxSegments: that.readPropertyMultipleOptions.maxSegments,
-          maxApdu: that.readPropertyMultipleOptions.maxApdu,
-          arrayIndex: point.meta.arrayIndex,
-          priority: options.priority,
-        },
-      };
+            value: [
+              {
+                type: options.appTag,
+                value: value,
+              },
+            ],
+          },
+          options: {
+            maxSegments: that.readPropertyMultipleOptions.maxSegments,
+            maxApdu: that.readPropertyMultipleOptions.maxApdu,
+            arrayIndex: point.meta.arrayIndex,
+            priority: options.priority,
+          },
+        };
 
-      valuesArray.push(writeObject);
+        valuesArray.push(writeObject);
+      } catch (e) {
+        that.logOut("doWrite error: ", e);
+      }
     });
 
     return that._writePropertyMultiple(valuesArray);
@@ -1348,7 +1415,7 @@ class BacnetClient extends EventEmitter {
         );
       });
     } catch (error) {
-      that.logOut(error);
+      that.logOut("_writePropertyMultiple error: ", error);
     }
   }
 
@@ -1370,7 +1437,7 @@ class BacnetClient extends EventEmitter {
         maxSegments: that.readPropertyMultipleOptions.maxSegments,
         maxApdu: that.readPropertyMultipleOptions.maxApdu,
       };
-      this._readObjectList(device.getAddress(), device.getDeviceId(), readOptions, (err, result) => {
+      this._readObjectList(device, readOptions, (err, result) => {
         if (!err) {
           try {
             resolve(result.values);
@@ -1437,6 +1504,17 @@ class BacnetClient extends EventEmitter {
     });
   }
 
+  updatePointsList(json) {
+    let that = this;
+    json.deviceList.forEach(function (updatedDevice) {
+      let foundIndex = that.deviceList.findIndex((ele) => ele.getDeviceId() == updatedDevice.deviceId);
+      if (foundIndex == -1) {
+      } else if (foundIndex !== -1) {
+        that.deviceList[foundIndex].setPointsList(updatedDevice.pointsList);
+      }
+    });
+  }
+
   updateDeviceList(json) {
     let that = this;
     return new Promise(async function (resolve, reject) {
@@ -1619,10 +1697,8 @@ class BacnetClient extends EventEmitter {
     that.buildJsonInProgress = false;
   }
 
-
   async buildJsonObject(device) {
     try {
-      const address = device.address;
       const pointList = device.getPointsList();
       const requestMutex = new Mutex();
       const promiseArray = [];
@@ -1633,13 +1709,12 @@ class BacnetClient extends EventEmitter {
 
       for (const point of pointList) {
         await requestMutex.acquire();
-
         let result;
         if (device.getIsInitialQuery()) {
-          result = await this._readObjectLite(device, address, point.value.type, point.value.instance);
+          result = await this._readObjectLite(device, point.value.type, point.value.instance);
           device.setIsInitialQuery(false);
         } else {
-          result = await this._readObjectFull(device, address, point.value.type, point.value.instance);
+          result = await this._readObjectFull(device, point.value.type, point.value.instance);
         }
 
         if (!result.error) {

package/bacnet_device.js

@@ -36,6 +36,7 @@ class BacnetDevice {
             that.isProtocolServicesSet = config.isProtocolServicesSet;
             that.isInitialQuery = config.isInitialQuery;
             that.isDumbMstpRouter = config.isDumbMstpRouter;
+            that.port = config.port;
 
         } else if (fromImport == false) {
             if (config.net && config.adr) {
@@ -66,9 +67,18 @@ class BacnetDevice {
             that.isProtocolServicesSet = false;
             that.isInitialQuery = true;
             that.isDumbMstpRouter = false;
+            that.port = config.port;
         }
     }
 
+    setPort(port) {
+        this.port = port;
+    }
+
+    getPort() {
+        return this.port;
+    }
+
     setIsDumbMstpRouter(isDumbMstp) {
         this.isDumbMstpRouter = isDumbMstp;
     }
@@ -190,6 +200,10 @@ class BacnetDevice {
         if (Number.isInteger(config.maxApdu)) this.maxApdu = config.maxApdu;
         if (Number.isInteger(config.segmentation)) this.segmentation = config.segmentation;
         if (Number.isInteger(config.vendorId)) this.vendorId = config.vendorId;
+        if (config.pointsList && config.pointsList.length > 0) {
+            this.setPointsList(config.pointsList);
+        }
+        if (config.port) this.port = config.port;
     }
 
     getPointListRetryCount() {
@@ -244,9 +258,10 @@ class BacnetDevice {
             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 == 13 || //MSI
+            point.value.type == 14 || //MSO
+            point.value.type == 19 || //MSV
+            point.value.type == 40    //CS 
         );
     }