@bitpoolos/edge-bacnet 1.2.1 → 1.2.3

package/bacnet_client.js

@@ -80,7 +80,6 @@ class BacnetClient extends EventEmitter {
                 const queryDevices = new Task('simple task', () => {
                     if(!that.pollInProgress) that.queryDevices(); 
                     that.sanitizeDeviceList();
-                    //that.queryDevicesManually(); 
                 });
 
                 const queryJob = new SimpleIntervalJob({ seconds: parseInt(that.device_read_schedule), }, queryDevices)
@@ -199,84 +198,138 @@ class BacnetClient extends EventEmitter {
         query(index);
 
         function query(index) {
-            let device = that.deviceList[index];
+            that.queryPriorityDevices().then(function() {
 
-            if(index < that.deviceList.length) {
-                index++;
-            
-                if(typeof device == "object") {
-                    if(!device.getManualDiscoveryMode()) {
-                        try {
-                            that.getDevicePointList(device).then(function() {
-                                that.removeDeviceFromManualQueue(device);
-                                that.buildJsonObject(device).then(function() {
-                                    query(index);
+                let device = that.deviceList[index];
+
+                if(index < that.deviceList.length) {
+                    index++;
+                
+                    if(typeof device == "object") {
+                        if(!device.getManualDiscoveryMode()) {
+                            try {
+                                that.getDevicePointList(device).then(function() {
+                                    that.removeDeviceFromManualQueue(device);
+                                    that.buildJsonObject(device, null).then(function() {
+                                        query(index);
+                                    }).catch(function(e) {
+                                        that.logOut(`getDevicePointList error: ${device.getAddress()}`, e);
+                                        query(index);
+                                    });
                                 }).catch(function(e) {
                                     that.logOut(`getDevicePointList error: ${device.getAddress()}`, e);
+                                    that.addDeviceToManualQueue(device);
                                     query(index);
                                 });
-                            }).catch(function(e) {
-                                that.logOut(`getDevicePointList error: ${device.getAddress()}`, e);
-                                that.addDeviceToManualQueue(device);
+                            } catch(e) {
+                                that.logOut("Error while querying devices: ", e);
                                 query(index);
-                            });
-                        } catch(e) {
-                            that.logOut("Error while querying devices: ", e);
+                            }
+                        } else {
                             query(index);
                         }
                     } else {
+                        that.logOut("queryDevices: invalid device found: ", device);
                         query(index);
                     }
-                } else {
-                    that.logOut("queryDevices: invalid device found: ", device);
-                    query(index);
+                } else if(index == that.deviceList.length) {
+
+                    if(that.manualDiscoverQueue.length > 0) {
+                        that.queryDevicesManually();
+                    } else {
+                        that.pollInProgress = false;
+                    }
+                    
                 }
-            } else if(index == that.deviceList.length){
-                that.queryDevicesManually();
-            }
+            });
         }
     }
 
     queryDevicesManually() {
         let that = this;
-
         let index = 0;
-
         query(index);
 
         function query(index) {
-            let device = that.manualDiscoverQueue[index];
+            that.queryPriorityDevices().then(function() {
+                let device = that.manualDiscoverQueue[index];
+                if(index < that.manualDiscoverQueue.length) {
+                    index++;
+                    if(typeof device == "object") {
+                        try {
+                            if(device.shouldBeInManualMode()) {
+                                that.getDevicePointListWithoutObjectList(device).then(function() {
+                                    that.buildJsonObject(device, null).then(function() {
+                                        query(index);
+                                    }).catch(function(e) {
+                                        that.logOut(`getDevicePointList error: ${device.getAddress()}`, e);
+                                        query(index);
+                                    });
+                                }).catch(function(e){
+                                    query(index);
+                                });
+                            } else {
+                                that.removeDeviceFromManualQueue(device);
+                                query(index);
+                            }
+                        } catch(e) {
+                            query(index);
+                        }
+                    } else {
+                        query(index);
+                    }
+                } else if(index == that.manualDiscoverQueue.length) {
+                    that.pollInProgress = false;
+                }
+            });
+        }
+    }
 
-            if(index < that.manualDiscoverQueue.length) {
-                index++;
-            
-                if(typeof device == "object") {
-                    try {
-                        if(device.shouldBeInManualMode()) {
-                            that.getDevicePointListWithoutObjectList(device).then(function() {
-                                that.buildJsonObject(device).then(function() {
+    queryPriorityDevices() {
+        let that = this;
+        return new Promise((resolve, reject) => {
+            let priorityDevices = that.getPriorityDevices();
+
+            if(priorityDevices.length > 0) {
+                let index = 0;
+
+                query(index);
+        
+                function query(index) {
+                    let device = priorityDevices[index];
+        
+                    if(index < priorityDevices.length) {
+                        index++;
+                    
+                        if(typeof device == "object" && ((Date.now() - device.getLastPriorityQueueTS()) / 1000) > parseInt(that.device_read_schedule) ) {
+                            
+                            try {
+                                let points = device.getPriorityQueue();
+                                that.buildJsonObject(device, points).then(function() {
+                                    device.setLastPriorityQueueTS();
                                     query(index);
                                 }).catch(function(e) {
-                                    that.logOut(`getDevicePointList error: ${device.getAddress()}`, e);
+                                    that.logOut(`queryPriorityDevices error: ${device.getAddress()}`, e);
                                     query(index);
                                 });
-                            }).catch(function(e){
+                                
+                            } catch(e) {
+                                that.logOut("Error while querying priority devices: ", e);
                                 query(index);
-                            });
+                            }
+                            
                         } else {
-                            that.removeDeviceFromManualQueue(device);
+                            that.logOut("queryPriorityDevices: invalid device found: ", device);
                             query(index);
                         }
-                    } catch(e) {
-                        query(index);
+                    } else if(index == priorityDevices.length) {
+                        resolve()
                     }
-                } else {
-                    query(index);
                 }
-            } else if(index == that.manualDiscoverQueue.length) {
-                that.pollInProgress = false;
+            } else if(priorityDevices.length == 0) {
+                resolve()
             }
-        }
+        });
     }
 
     addDeviceToManualQueue(device) {
@@ -310,7 +363,7 @@ class BacnetClient extends EventEmitter {
         let timeoutThreshold = parseInt(that.discover_polling_schedule);
 
         that.deviceList.forEach(function(device, index) {
-            if(((Date.now() - device.lastSeen) / 1000) >  timeoutThreshold) {
+            if(((Date.now() - device.getLastSeen()) / 1000) >  timeoutThreshold && device.getPriorityQueueIsActive() == false) {
                 //render device hasnt responded to whoIs for over an hour
 
                 let renderListIndex = that.renderList.findIndex(ele => ele.deviceId == device.getDeviceId());
@@ -320,9 +373,7 @@ class BacnetClient extends EventEmitter {
 
                 delete that.networkTree[deviceKey];
 
-                if(((Date.now() - device.getLastSeen()) / 1000) >  timeoutThreshold) {
-                    that.renderList.splice(renderListIndex, 1);
-                }
+                that.renderList.splice(renderListIndex, 1);
 
                 that.deviceList.splice(index, 1);
             }
@@ -385,7 +436,6 @@ class BacnetClient extends EventEmitter {
             const queryDevices = new Task('simple task', () => {
                 if(!that.pollInProgress) that.queryDevices(); 
                 that.sanitizeDeviceList();
-                //that.queryDevicesManually();
             });
 
             const queryJob = new SimpleIntervalJob({ seconds: parseInt(config.device_read_schedule), }, queryDevices)
@@ -938,6 +988,40 @@ class BacnetClient extends EventEmitter {
         });
     }
 
+    updatePriorityQueue(req) {
+        let that = this;
+        return new Promise(async function(resolve, reject) {
+            try {
+                let keys = Object.keys(req.body);
+                if(keys.length > 0) { 
+                    keys.forEach(function(key) {
+                        let device = that.deviceList.find(ele => `${that.getDeviceAddress(ele)}-${ele.getDeviceId()}` == key);
+                        let points = req.body[key];
+                        device.setPriorityQueue(points);
+                    });
+                } else if(keys.length == 0) {
+                    that.clearPriorityQueues();
+                }
+                resolve(true);
+            } catch(e){
+                reject(e);
+            }
+        });
+    }
+
+    clearPriorityQueues() {
+        let that = this;
+        that.deviceList.forEach(function(device) {
+            device.clearPriorityQueue();
+        });
+    }
+
+    getPriorityDevices() {
+        let that = this;
+        let priorityDevices = that.deviceList.filter(device => device.getPriorityQueueIsActive() == true);
+        return priorityDevices;
+    }
+
     sortDevices(a, b) {
         if (a.deviceId < b.deviceId) {
             return -1;
@@ -1060,21 +1144,10 @@ class BacnetClient extends EventEmitter {
         });
     }
 
-    buildObjects() {
-        let that = this;
-
-        that.deviceList.forEach(function(device) {
-            that.buildJsonObject(device).then(function() {
-            }).catch(function(e) {
-                that.logOut(device.getAddress(), e)
-            });
-        });
-    }
-
-    buildJsonObject(device) {
+    buildJsonObject(device, priorityQueue) {
         let that = this;
         let address = device.address;
-        let pointList = device.getPointsList();
+        let pointList = priorityQueue !== null ? priorityQueue : device.getPointsList();
         let requestMutex = new Mutex();
 
         return new Promise(function(resolve, reject) {

package/bacnet_device.js

@@ -16,6 +16,9 @@ class BacnetDevice {
             that.manualDiscoveryMode = config.manualDiscoveryMode;
             that.mDiscoverInstanceRange = config.mDiscoverInstanceRange;
             that.pointListRetryCount = config.pointListRetryCount;
+            that.priorityQueueIsActive = config.priorityQueueIsActive;
+            that.priorityQueue = config.priorityQueue;
+            that.lastPriorityQueueTS = config.lastPriorityQueueTS;
 
         } else if(fromImport == false) {
             if(config.net && config.adr) {
@@ -36,9 +39,67 @@ class BacnetDevice {
             that.manualDiscoveryMode = false;
             that.mDiscoverInstanceRange = {start: 0, end: 100};
             that.pointListRetryCount = 0;
+            that.priorityQueueIsActive = false;
+            that.priorityQueue = [];
+            that.lastPriorityQueueTS = null;
         }
     }
 
+    setLastPriorityQueueTS() {
+        this.lastPriorityQueueTS = Date.now();
+    }
+
+    getLastPriorityQueueTS() {
+        return this.lastPriorityQueueTS;
+    }
+    
+    setPriorityQueueIsActive(bool) {
+        this.priorityQueueIsActive = bool;
+    }
+
+    getPriorityQueueIsActive() {
+        return this.priorityQueueIsActive;
+    }
+
+    updatePriorityQueue(point) {
+        let foundIndex = this.priorityQueue.findIndex(ele => ele.value.type == point.value.type && ele.value.instance == point.value.instance);
+        if(foundIndex == -1 ) {
+            //not found
+            this.priorityQueue.push(point);
+        }
+
+        if(this.priorityQueue.length > 0) {
+            this.setPriorityQueueIsActive(true);
+        } else if(this.priorityQueue.length == 0) {
+            this.setPriorityQueueIsActive(false);
+        }
+    }
+
+    setPriorityQueue(points) {
+        let queue = [];
+        let keys = Object.keys(points);
+        if(keys.length > 0) {
+            keys.forEach(function(key) {
+                let point = points[key];
+                let pointRequestObject = {type: 12, value: point.meta.objectId}
+                queue.push(pointRequestObject);
+            });
+            this.priorityQueue = queue;
+            this.setPriorityQueueIsActive(true);
+        } else if(keys.length == 0) {
+            this.setPriorityQueueIsActive(false);
+        }
+    }
+
+    getPriorityQueue(){
+        return this.priorityQueue;
+    }
+
+    clearPriorityQueue() {
+        this.priorityQueue = [];
+        this.setPriorityQueueIsActive(false);
+    }
+
     updateDeviceConfig(config) {
         if(config.address !== "" && config.address !== null && config.address !== "undefined") {
             if(config.net && config.adr) {

package/bacnet_gateway.js

@@ -264,6 +264,21 @@ module.exports = function (RED) {
       }
     });
 
+    //route handler for priority queue
+    RED.httpAdmin.post('/bitpool-bacnet-data/priorityQueue', function (req, res) {
+      if (!node.bacnetClient) {
+        logOut("Issue with the bacnetClient while getting device list: ", node.bacnetClient);
+        res.send(false);
+      } else {
+        node.bacnetClient.updatePriorityQueue(req).then(function (result) {
+          res.send(result);
+        }).catch(function (error) {
+          res.send(error);
+          logOut("Error updating priorityQueue: ", error);
+        });
+      }
+    });
+
     node.on('close', function () {
       //do nothing
     });

package/bacnet_read.html

@@ -436,21 +436,12 @@
             if (node.vm.$data.devices) node.devices = node.vm.$data.devices;
             if (node.vm.$data.readDevices) node.readDevices = node.vm.$data.readDevices;
             if (node.vm.$data.pointsToRead) node.pointsToRead = node.vm.$data.pointsToRead;
-
-            // if (node.vm.$data.devices && node.vm.$data.devices.length > 0) node.devices = node.vm.$data.devices;
-            // if (node.vm.$data.readDevices && node.vm.$data.readDevices.length > 0) node.readDevices = node.vm.$data.readDevices;
-            // if (node.vm.$data.pointsToRead && node.vm.$data.pointsToRead.length > 0) node.pointsToRead = node.vm.$data.pointsToRead;
-
         },
         oneditcancel: function () {
             let node = this;
             if (node.vm.$data.devices) node.devices = node.vm.$data.devices;
             if (node.vm.$data.readDevices) node.readDevices = node.vm.$data.readDevices;
             if (node.vm.$data.pointsToRead) node.pointsToRead = node.vm.$data.pointsToRead;
-
-            // if (node.vm.$data.devices && node.vm.$data.devices.length > 0) node.devices = node.vm.$data.devices;
-            // if (node.vm.$data.readDevices && node.vm.$data.readDevices.length > 0) node.readDevices = node.vm.$data.readDevices;
-            // if (node.vm.$data.pointsToRead && node.vm.$data.pointsToRead.length > 0) node.pointsToRead = node.vm.$data.pointsToRead;
         }
     });
 

package/bacnet_read.js

@@ -5,6 +5,8 @@
 
 
 module.exports = function (RED) {
+    const fetch = require('node-fetch');
+    const http = require("http");
     const { ReadCommandConfig } = require('./common');
     const baEnum = require('./resources/node-bacstack-ts/dist/index.js').enum;
 
@@ -49,7 +51,23 @@ module.exports = function (RED) {
         return propArr;
       };
 
-      var nodeContext = this.context().flow;
+      //send point list status for device priority queue 
+      let headers = {
+        'Content-Type' : "application/json"
+      };
+
+      const agent = new http.Agent({
+        rejectUnauthorized: false
+      });
+
+      fetch('http://localhost:1880/bitpool-bacnet-data/priorityQueue', {method: 'POST', headers: headers, agent: agent, body: JSON.stringify(node.pointsToRead)})
+      .then(function(res) {
+        //do nothing
+      }).catch(function(error) {
+        //do nothing
+      });
+
+      
 
       node.on('input', function(msg) {
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitpoolos/edge-bacnet",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "A bacnet gateway for node-red",
   "dependencies": {
     "@plus4nodered/ts-node-bacnet": "^1.0.0-beta.2",
@@ -8,6 +8,7 @@
     "cronosjs": "^1.7.1",
     "debug": "^4.1.1",
     "iconv-lite": "^0.5.1",
+    "node-fetch": "^2.6.1",
     "toad-scheduler": "^1.6.0",
     "underscore": "^1.10.2",
     "winston": "^3.2.1"