@bitpoolos/edge-bacnet 1.2.7 → 1.3.0

package/common.js

@@ -8,6 +8,7 @@ const os = require("os");
 const { exec } = require("child_process");
 const baEnum = require("./resources/node-bacstack-ts/dist/index.js").enum;
 const fs = require("fs");
+const { BitArray } = require("./resources/bitArray.js");
 
 const logger = createLogger({
   format: format.combine(
@@ -92,7 +93,8 @@ class BacnetClientConfig {
     manual_instance_range_end,
     device_read_schedule,
     retries,
-    cacheFileEnabled
+    cacheFileEnabled,
+    sanitise_device_schedule
   ) {
     this.apduTimeout = apduTimeout;
     this.localIpAdrress = localIpAdrress;
@@ -109,6 +111,7 @@ class BacnetClientConfig {
     this.device_read_schedule = device_read_schedule;
     this.retries = retries;
     this.cacheFileEnabled = cacheFileEnabled;
+    this.sanitise_device_schedule = sanitise_device_schedule;
   }
 }
 
@@ -179,7 +182,7 @@ const getIpAddress = function () {
       }
     }
 
-    if (os.version().includes("Ubuntu")) {
+    if (os.version().includes("Ubuntu") || os.version().includes("SMP")) {
       let allInterfaceName = "All interfaces";
       if (!results[allInterfaceName]) {
         results[allInterfaceName] = [];
@@ -222,25 +225,17 @@ const doNodeRedRestart = function () {
 // STORE CONFIG FUNCTION ==========================================================
 //
 // ================================================================================
-function Store_Config(data) {
+async function Store_Config(data) {
   try {
-    fs.access("edge-bacnet-datastore.cfg", fs.constants.W_OK, async function(err) {
-      if(err){
-        console.log("Store_Config writeAccess error found: ", err);
-      } else {
-        await fs.writeFile("edge-bacnet-datastore.cfg", data, {encoding: "utf8", flag: "w"}, (err) => {
-          if (err) {
-            console.log("Store_Config writeFile error: ", err);
-          }
-        });
+    await fs.writeFile("edge-bacnet-datastore.cfg", data, { encoding: "utf8", flag: "w" }, (err) => {
+      if (err) {
+        console.log("Store_Config writeFile error: ", err);
       }
     });
-  } catch(e){
+  } catch (e) {
     //do nothing
   }
-};
-
-
+}
 
 // READ CONFIG SYNC FUNCTION ======================================================
 //
@@ -248,15 +243,13 @@ function Store_Config(data) {
 function Read_Config_Sync() {
   var data = "{}";
   try {
-    data = fs.readFileSync("edge-bacnet-datastore.cfg", { encoding: 'utf8', flag: 'r' });
-  }
-  catch (err) {
-    console.log("Read_Config_Sync error:", err);
-    data = '{}';
+    data = fs.readFileSync("edge-bacnet-datastore.cfg", { encoding: "utf8", flag: "r" });
+  } catch (err) {
+    data = "{}";
     Store_Config(data);
   }
   return data;
-};
+}
 
 // STORE CONFIG FUNCTION - BACNET SERVER ==========================================
 //
@@ -268,7 +261,7 @@ async function Store_Config_Server(data) {
         //console.log("Store_Config_Server writeFile error: ", err);
       }
     });
-  } catch (err) {}
+  } catch (err) { }
 }
 
 // READ CONFIG SYNC FUNCTION - BACNET SERVER ======================================
@@ -279,16 +272,34 @@ function Read_Config_Sync_Server() {
   try {
     data = fs.readFileSync("edge-bacnet-server-datastore.cfg", { encoding: "utf8", flag: "r" });
   } catch (err) {
-    //console.log("Read_Config_Sync_Server error:", err);
-    if (err.errno == -4058) console.log("Edge-BACnet Server: No save file found, creating new file");
-    data = "{}";
-    Store_Config_Server(data);
+    if (err.errno == -4058) {
+      data = "{}";
+      Store_Config_Server(data);
+    }
   }
   return data;
 }
 
 function isNumber(value) {
-  return value != null && typeof value === 'number' && !isNaN(value);
+  return value != null && typeof value === "number" && !isNaN(value);
+}
+
+function decodeBitArray(size, bits) {
+  let array = [];
+  for (let i = 0; i < bits.length; i++) {
+    let bit = bits[i];
+    let bitString = bit.toString(2);
+    if (bitString.length < size) {
+      const remainingLength = size - bitString.length;
+      const backFillString = "0".repeat(remainingLength);
+      array.push(backFillString + bitString);
+    } else if (bitString.length == size) {
+      array.push(bitString);
+    }
+    if (i == bits.length - 1) {
+      return array;
+    }
+  };
 }
 
 module.exports = {
@@ -306,4 +317,5 @@ module.exports = {
   Store_Config_Server,
   Read_Config_Sync_Server,
   isNumber,
+  decodeBitArray,
 };

package/package.json

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

package/resources/bitArray.js

@@ -0,0 +1,167 @@
+/* BitArray DataType */
+
+// Constructor
+function BitArray(size, bits) {
+    // Private field - array for our bits
+    this.m_bits = new Array();
+
+    //.ctor - initialize as a copy of an array of true/false or from a numeric value
+    if (bits && bits.length) {
+        for (var i = 0; i < bits.length; i++)
+            this.m_bits.push(bits[i] ? BitArray._ON : BitArray._OFF);
+    } else if (!isNaN(bits)) {
+        this.m_bits = BitArray.shred(bits).m_bits;
+    }
+    if (size && this.m_bits.length != size) {
+        if (this.m_bits.length < size) {
+            for (var i = this.m_bits.length; i < size; i++) {
+                this.m_bits.push(BitArray._OFF);
+            }
+        } else {
+            for (var i = size; i > this.m_bits.length; i--) {
+                this.m_bits.pop();
+            }
+        }
+    }
+}
+
+/* BitArray PUBLIC INSTANCE METHODS */
+
+// read-only property - number of bits 
+BitArray.prototype.getLength = function () { return this.m_bits.length; };
+
+// accessor - get bit at index 
+BitArray.prototype.getAt = function (index) {
+    if (index < this.m_bits.length) {
+        return this.m_bits[index];
+    }
+    return null;
+};
+// accessor - set bit at index 
+BitArray.prototype.setAt = function (index, value) {
+    if (index < this.m_bits.length) {
+        this.m_bits[index] = value ? BitArray._ON : BitArray._OFF;
+    }
+};
+
+// resize the bit array (append new false/0 indexes) 
+BitArray.prototype.resize = function (newSize) {
+    var tmp = new Array();
+    for (var i = 0; i < newSize; i++) {
+        if (i < this.m_bits.length) {
+            tmp.push(this.m_bits[i]);
+        } else {
+            tmp.push(BitArray._OFF);
+        }
+    }
+    this.m_bits = tmp;
+};
+
+// Get the complimentary bit array (i.e., 01 compliments 10)
+BitArray.prototype.getCompliment = function () {
+    var result = new BitArray(this.m_bits.length);
+    for (var i = 0; i < this.m_bits.length; i++) {
+        result.setAt(i, this.m_bits[i] ? BitArray._OFF : BitArray._ON);
+    }
+    return result;
+};
+
+// Get the string representation ("101010") 
+BitArray.prototype.toString = function () {
+    var s = new String();
+    for (var i = 0; i < this.m_bits.length; i++) {
+        s = s.concat(this.m_bits[i] === BitArray._ON ? "1" : "0");
+    }
+    return s;
+};
+
+// Get the numeric value 
+BitArray.prototype.toNumber = function () {
+    var pow = 0;
+    var n = 0;
+    for (var i = this.m_bits.length - 1; i >= 0; i--) {
+        if (this.m_bits[i] === BitArray._ON) {
+            n += Math.pow(2, pow);
+        }
+        pow++;
+    }
+    return n;
+};
+
+/* STATIC METHODS */
+
+// Get the union of two bit arrays
+BitArray.getUnion = function (bitArray1, bitArray2) {
+    var len = BitArray._getLen(bitArray1, bitArray2, true);
+    var result = new BitArray(len);
+    for (var i = 0; i < len; i++) {
+        result.setAt(i, BitArray._union(bitArray1.getAt(i), bitArray2.getAt(i)));
+    }
+    return result;
+};
+
+// Get the intersection of two bit arrays 
+BitArray.getIntersection = function (bitArray1, bitArray2) {
+    var len = BitArray._getLen(bitArray1, bitArray2, true);
+    var result = new BitArray(len);
+    for (var i = 0; i < len; i++) {
+        result.setAt(i, BitArray._intersect(bitArray1.getAt(i), bitArray2.getAt(i)));
+    }
+    return result;
+};
+
+// Get the difference between to bit arrays
+BitArray.getDifference = function (bitArray1, bitArray2) {
+    var len = BitArray._getLen(bitArray1, bitArray2, true);
+    var result = new BitArray(len);
+    for (var i = 0; i < len; i++) {
+        result.setAt(i, BitArray._difference(bitArray1.getAt(i), bitArray2.getAt(i)));
+    }
+    return result;
+};
+
+// Convert a number into a bit array
+BitArray.shred = function (number) {
+    var bits = new Array();
+    var q = number;
+    do {
+        bits.push(q % 2);
+        q = Math.floor(q / 2);
+    } while (q > 0);
+    return new BitArray(bits.length, bits.reverse());
+};
+
+/* BitArray PRIVATE STATIC CONSTANTS */
+BitArray._ON = 1;
+BitArray._OFF = 0;
+
+/* BitArray PRIVATE STATIC METHODS */
+
+// Calculate the intersection of two bits 
+BitArray._intersect = function (bit1, bit2) {
+    return bit1 === BitArray._ON && bit2 === BitArray._ON ? BitArray._ON : BitArray._OFF;
+};
+
+// Calculate the union of two bits 
+BitArray._union = function (bit1, bit2) {
+    return bit1 === BitArray._ON || bit2 === BitArray._ON ? BitArray._ON : BitArray._OFF;
+};
+
+// Calculate the difference of two bits 
+BitArray._difference = function (bit1, bit2) {
+    return bit1 === BitArray._ON && bit2 !== BitArray._ON ? BitArray._ON : BitArray._OFF;
+};
+
+// Get the longest or shortest (smallest) length of the two bit arrays 
+BitArray._getLen = function (bitArray1, bitArray2, smallest) {
+    var l1 = bitArray1.getLength();
+    var l2 = bitArray2.getLength();
+
+    return l1 > l2 ? smallest ? l2 : l1 : smallest ? l2 : l1;
+};
+
+module.exports = {
+    BitArray,
+}
+
+/* END BitArray DataType */

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

@@ -671,11 +671,15 @@ const bacappDecodeApplicationData = (buffer, offset, maxOffset, objectType, prop
             const result = bacappDecodeData(buffer, offset + len, maxOffset, tag.tagNumber, tag.value);
             if (!result)
                 return;
-            const resObj = {
+            let resObj = {
                 len: len + result.len,
                 type: result.type,
                 value: result.value
             };
+            if (result.originalBitString) {
+                //protocols supported addition
+                resObj.originalBitString = result.originalBitString;
+            }
             // HACK: Drop string specific handling ASAP
             if (result.encoding !== undefined)
                 resObj.encoding = result.encoding;
@@ -796,9 +800,9 @@ const decodeReadAccessResult = (buffer, offset, apduLen) => {
                 return;
             len++;
             newEntry.value = [{
-                    type: baEnum.ApplicationTags.ERROR,
-                    value: err
-                }];
+                type: baEnum.ApplicationTags.ERROR,
+                value: err
+            }];
         }
         values.push(newEntry);
     }
@@ -876,11 +880,13 @@ const bitstringSetBitsUsed = (bitString, bytesUsed, unusedBits) => {
 const decodeBitstring = (buffer, offset, lenValue) => {
     let len = 0;
     const bitString = { value: [], bitsUsed: 0 };
+    const originalBitString = { value: [] };
     if (lenValue > 0) {
         const bytesUsed = lenValue - 1;
         if (bytesUsed <= baEnum.ASN1_MAX_BITSTRING_BYTES) {
             len = 1;
             for (let i = 0; i < bytesUsed; i++) {
+                originalBitString.value.push(buffer[offset + len]);
                 bitString.value.push(byteReverseBits(buffer[offset + len++]));
             }
             const unusedBits = buffer[offset] & 0x07;
@@ -889,7 +895,8 @@ const decodeBitstring = (buffer, offset, lenValue) => {
     }
     return {
         len: len,
-        value: bitString
+        value: bitString,
+        originalBitString: originalBitString
     };
 };
 exports.decodeBitstring = decodeBitstring;
@@ -1033,6 +1040,10 @@ const bacappDecodeData = (buffer, offset, maxLength, tagDataType, lenValueType)
             result = (0, exports.decodeBitstring)(buffer, offset, lenValueType);
             value.len += result.len;
             value.value = result.value;
+            if (result.originalBitString) {
+                //protocols supported addition
+                value.originalBitString = result.originalBitString;
+            }
             break;
         case baEnum.ApplicationTags.ENUMERATED:
             result = (0, exports.decodeEnumerated)(buffer, offset, lenValueType);

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

@@ -95,7 +95,7 @@ class Client extends events_1.EventEmitter {
             if (!result)
                 return debug('Couldn`t decode Error');
             this._invokeCallback(invokeId, new Error('BacnetError - Class:' + result.class + ' - Code:' + result.code));
-        } catch(e){
+        } catch (e) {
         }
     }
     _processAbort(invokeId, reason) {
@@ -619,14 +619,14 @@ class Client extends events_1.EventEmitter {
         baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(address, buffer);
         this._addCallback(settings.invokeId, (err, data) => {
-            try{
+            try {
                 if (err)
                     return next(err);
                 const result = baServices.readProperty.decodeAcknowledge(data.buffer, data.offset, data.length);
                 if (!result)
                     return next(new Error('INVALID_DECODING'));
                 next(null, result);
-            } catch(e){
+            } catch (e) {
                 return next(e);
             }
         });
@@ -716,7 +716,6 @@ 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, buffer);
-        //this.sendBvlc(address, buffer);
         this._addCallback(settings.invokeId, (err, data) => {
             try {
                 if (err)
@@ -725,7 +724,7 @@ class Client extends events_1.EventEmitter {
                 if (!result)
                     return next(new Error('INVALID_DECODING'));
                 next(null, result);
-            } catch(e){
+            } catch (e) {
                 return next(e);
             }
         });
@@ -1369,7 +1368,7 @@ class Client extends events_1.EventEmitter {
         baNpdu.encode(buffer, baEnum.NpduControlPriority.NORMAL_MESSAGE, receiver);
         baApdu.encodeComplexAck(buffer, baEnum.PduTypes.COMPLEX_ACK, baEnum.ConfirmedServiceChoice.READ_PROPERTY, invokeId);
         baServices.readProperty.encodeAcknowledge(buffer, objectId, property.id, property.index, value);
-        //baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
+        baBvlc.encode(buffer.buffer, baEnum.BvlcResultPurpose.ORIGINAL_UNICAST_NPDU, buffer.offset);
         this.sendBvlc(receiver, buffer);
     }
     readPropertyMultipleResponse(receiver, invokeId, values) {