@bitpoolos/edge-bacnet 1.0.6 → 1.1.0

package/bacnet_client.js

@@ -1,23 +1,26 @@
 /*
   MIT License Copyright 2021, 2022 - Bitpool Pty Ltd
 */
-
-const bacnet = require('./resources/bacstack/lib/client');
-const baEnum = require('./resources/bacstack/lib/enum');
-const baAsn1 = require('./resources/bacstack/lib/asn1');
-const { EventEmitter } = require('events');
-const { DeviceObjectId, DeviceObject, logger, getUnit, roundDecimalPlaces } = require('./common');
-const { ToadScheduler, SimpleIntervalJob, Task } = require('toad-scheduler')
+const bacnet = require('./resources/node-bacnet/index.js');
+const { BacnetServer } = require("./bacnet_server.js");
+const baEnum = bacnet.enum;
+const bacnetIdMax = baEnum.ASN1_MAX_PROPERTY_ID;
+const { EventEmitter, captureRejectionSymbol } = require('events');
+const { DeviceObjectId, DeviceObject, logger, getUnit, roundDecimalPlaces, Store_Config, Read_Config_Sync } = require('./common');
+const { ToadScheduler, SimpleIntervalJob, Task } = require('toad-scheduler');
 const { BacnetDevice } = require('./bacnet_device');
 const {Mutex, Semaphore, withTimeout} = require("async-mutex");
+
 class BacnetClient extends EventEmitter {
 
     //client constructor
     constructor(config) {
         super();
         let that = this;
+
+        let cachedData = JSON.parse(Read_Config_Sync());
+
         that.deviceList = [];
-        that.pointReferenceList = [];
         that.networkTree = {};
         that.lastWhoIs = null;
         that.client = null;
@@ -25,6 +28,17 @@ class BacnetClient extends EventEmitter {
         that.scheduler = new ToadScheduler();
         that.mutex = new Mutex();
 
+        if(typeof cachedData == "object") {
+            if(cachedData.renderList) that.renderList = cachedData.renderList;
+            if(cachedData.deviceList) {
+                cachedData.deviceList.forEach(function(device) {
+                    let newBacnetDevice = new BacnetDevice(true, device);
+                    that.deviceList.push(newBacnetDevice);
+                });
+            }
+            if(cachedData.pointList) that.networkTree = cachedData.pointList;
+        }
+
         try {
             that.config = config;
             that.roundDecimal = config.roundDecimal;
@@ -34,10 +48,16 @@ class BacnetClient extends EventEmitter {
             that.device_id_range_enabled = config.device_id_range_enabled;
             that.device_id_range_start = config.device_id_range_start;
             that.device_id_range_end = config.device_id_range_end;
+            that.deviceId = config.deviceId;
+            that.broadCastAddr = config.broadCastAddr;
+            that.manual_instance_range_enabled = config.manual_instance_range_enabled;
+            that.manual_instance_range_start = config.manual_instance_range_start;
+            that.manual_instance_range_end = config.manual_instance_range_end;
+            that.bacnetServerEnabled = config.bacnetServerEnabled;
 
             that.readPropertyMultipleOptions = {
                 maxSegments: that.maxSegments,
-                apduSize: that.apduSize
+                maxApdu: that.apduSize
             };
 
             try {
@@ -51,11 +71,12 @@ class BacnetClient extends EventEmitter {
 
                 const job = new SimpleIntervalJob({ seconds: parseInt(that.discover_polling_schedule), }, task)
                 
-                that.scheduler.addSimpleIntervalJob(job)
+                that.scheduler.addSimpleIntervalJob(job);
 
                 //query device task
-                const queryDevices = new Task('simple task', () => { 
+                const queryDevices = new Task('simple task', () => {
                     that.queryDevices(); 
+                    that.sanitizeDeviceList();
                 });
 
                 const queryJob = new SimpleIntervalJob({ seconds: parseInt(that.discover_polling_schedule), }, queryDevices)
@@ -63,7 +84,7 @@ class BacnetClient extends EventEmitter {
                 that.scheduler.addSimpleIntervalJob(queryJob);
 
                 //buildNetworkTreeData task
-                const buildNetworkTree = new Task('simple task', () => { 
+                const buildNetworkTree = new Task('simple task', () => {
                     that.buildNetworkTreeData();
                 });
 
@@ -77,45 +98,88 @@ class BacnetClient extends EventEmitter {
                     that.queryDevices();
                   }, "5000")
 
-            } catch(e){
-                console.log("Issue initializing client: ", e)
+            } catch(e) {
+                that.logOut("Issue initializing client: ", e)
             }
 
             //who is callback
             that.client.on('iAm', (device) => {
-                //only add unique device to array
-                let foundIndex = that.deviceList.findIndex(ele => ele.getAddress() == device.address);
-                if(foundIndex == -1) {
-                    let newBacnetDevice = new BacnetDevice(device);
-                    newBacnetDevice.setLastSeen(Date.now());
-                    that.updateDeviceName(newBacnetDevice);
-                    that.deviceList.push(newBacnetDevice);
-
-                } else if(foundIndex !== -1) {
-                    that.deviceList[foundIndex].updateDeviceConfig(device);
-                    that.deviceList[foundIndex].setLastSeen(Date.now());
-                    that.updateDeviceName(that.deviceList[foundIndex]);
+                if(device.header.sender.address !== that.config.localIpAdrress) {
+                    if(that.device_id_range_enabled) {
+                        if(device.payload.deviceId >= that.device_id_range_start && device.payload.deviceId <= that.device_id_range_end) {
+                            //only add unique device to array
+                            let foundIndex = that.deviceList.findIndex(ele => ele.getDeviceId() == device.payload.deviceId);
+                            if(foundIndex == -1) {
+                                let newBacnetDevice = new BacnetDevice(false, device);
+                                newBacnetDevice.setLastSeen(Date.now());
+                                that.updateDeviceName(newBacnetDevice);
+                                that.deviceList.push(newBacnetDevice);
+
+                            } else if(foundIndex !== -1) {
+                                that.deviceList[foundIndex].updateDeviceConfig(device);
+                                that.deviceList[foundIndex].setLastSeen(Date.now());
+                                that.updateDeviceName(that.deviceList[foundIndex]);
+                            }
+                            
+                            //emit event for node-red to log 
+                            that.emit('deviceFound', device);
+                        }
+                    } else {
+                        //only add unique device to array
+                        let foundIndex = that.deviceList.findIndex(ele => ele.getDeviceId() == device.payload.deviceId);
+                        if(foundIndex == -1) {
+                            let newBacnetDevice = new BacnetDevice(false, device);
+                            newBacnetDevice.setLastSeen(Date.now());
+                            that.updateDeviceName(newBacnetDevice);
+                            that.deviceList.push(newBacnetDevice);
+
+                        } else if(foundIndex !== -1) {
+                            that.deviceList[foundIndex].updateDeviceConfig(device);
+                            that.deviceList[foundIndex].setLastSeen(Date.now());
+                            that.updateDeviceName(that.deviceList[foundIndex]);
+                        }
+                        
+                        //emit event for node-red to log 
+                        that.emit('deviceFound', device);
+                    }
                 }
-                
-                //emit event for node-red to log 
-                that.emit('deviceFound', device);
             });
-        } catch(e){
-            console.log("Issue with creating bacnet client, see error:  ", e);
+
+        } catch(e) {
+            that.logOut("Issue with creating bacnet client, see error:  ", e);
         }
 
         that.client.on('error', (err) => {
-            console.log('Error occurred: ', err);
+            that.logOut('Error occurred: ', err);
 
             if(err.errno == -4090){
-                console.log("Invalid Client information or incorrect IP address provided");
+                that.logOut("Invalid Client information or incorrect IP address provided");
             } else if(err.errno == -49) {
-                console.log("Invalid IP address provided");
+                that.logOut("Invalid IP address provided");
             } else {
                 that.reinitializeClient(that.config);
             }
         });
+    }
 
+    logOut(param1, param2) {
+        let that = this;
+        that.emit('bacnetErrorLog', param1, param2);
+    }
+
+    rebuildDataModel() {
+        let that = this;
+        return new Promise((resolve, reject) => {
+            try {
+                that.deviceList = [];
+                that.renderList = [];
+                that.networkTree = {};
+                resolve(true);
+            } catch(e) {
+                that.logOut("Error clearing BACnet data model: ", e);
+                reject(e);
+            }
+        });
     }
 
     queryDevices() {
@@ -125,26 +189,60 @@ class BacnetClient extends EventEmitter {
             .acquire()
             .then(function(release) {
                 try {
+
                     that.getDevicePointList(device).then(function() {
                         that.buildJsonObject(device).then(function() {
                             release();
                         }).catch(function(e) {
                             release();
                         });
-                    }).catch(function(e){
+                    }).catch(function(e) {
+                        that.getDevicePointListWithoutObjectList(device).then(function() {
+                            that.buildJsonObject(device).then(function() {
+                                release();
+                            }).catch(function(e) {
+                                release();
+                            });
+                        }).catch(function(e) {
+                            release();
+                        });
                         release();
                     });
+
                 } catch(e) {
-                    console.log("Error while querying devices: ", e);
+                    that.logOut("Error while querying devices: ", e);
                     release();
                 }
             });
         });
+        Store_Config(JSON.stringify({renderList: that.renderList, deviceList: that.deviceList, pointList: that.networkTree}));
+    }
+
+    sanitizeDeviceList() {
+        let that = this;
+
+        that.deviceList.forEach(function(device, index) {
+            if(((Date.now() - device.getLastSeen()) / 1000) >  3600) {
+                //device hasnt responded to whoIs for over an hour
+
+                let deviceKey = (typeof device.getAddress() == "object") ? device.getAddress().address + "-" + device.getDeviceId() : device.getAddress() + "-" + device.getDeviceId();            
+                delete that.networkTree[deviceKey];
+
+                if(that.renderList){
+                    let foundIndex = that.renderList.findIndex(ele => ele.ipAddr == device.getAddress() && ele.deviceId == device.getDeviceId());
+                    if(foundIndex !== -1) {
+                        that.renderList.splice(foundIndex, 1);
+                    }
+                }
+
+                that.deviceList.splice(index, 1);
+            }
+        });
     }
 
     updateDeviceName(device) {
         let that = this;
-        that._getDeviceName(device.address, device.deviceId).then(function(deviceName) {
+        that._getDeviceName(device.getAddress(), device.getDeviceId()).then(function(deviceName) {
             device.setDeviceName(deviceName);
         });
     }
@@ -152,21 +250,34 @@ class BacnetClient extends EventEmitter {
     reinitializeClient(config) {
         let that = this;
 
+        that.config = config;
+        that.roundDecimal = config.roundDecimal;
+        that.apduSize = config.apduSize;
+        that.maxSegments = config.maxSegments;
+        that.discover_polling_schedule = config.discover_polling_schedule;
         that.device_id_range_enabled = config.device_id_range_enabled;
         that.device_id_range_start = config.device_id_range_start;
         that.device_id_range_end = config.device_id_range_end;
-
-        if(that.client !== null) {
-            that.client.close();
-            that.client = null;
-        } 
+        that.deviceId = config.deviceId;
+        that.broadCastAddr = config.broadCastAddr;
+        that.manual_instance_range_enabled = config.manual_instance_range_enabled;
+        that.manual_instance_range_start = config.manual_instance_range_start;
+        that.manual_instance_range_end = config.manual_instance_range_end;
+        that.bacnetServerEnabled = config.bacnetServerEnabled;
 
         if(that.scheduler !== null) {
             that.scheduler.stop();
         }
 
-        try{
-            that.client = new bacnet({ apduTimeout: config.apduTimeout, interface: config.localIpAdrress, port: config.port, broadcastAddress: config.broadCastAddr});
+        try {
+            that.client._settings.apduTimeout = config.apduTimeout;
+            that.client._settings.interface = config.localIpAdrress;
+            that.client._settings.port = config.port;
+            that.client._settings.broadcastAddress = config.broadCastAddr;
+
+            that.client._transport.interface = config.localIpAdrress;
+            that.client._transport.port = config.port;
+            that.client._transport.broadcastAddress = config.broadCastAddr;
 
             const task = new Task('simple task', () => { 
                 that.globalWhoIs(); 
@@ -179,26 +290,12 @@ class BacnetClient extends EventEmitter {
             that.globalWhoIs();
 
         } catch(e){
-            console.log("Error reinitializing bacnet client: ", e)
+            that.logOut("Error reinitializing bacnet client: ", e)
         }
     };
 
-    buildPointReferenceList(promiseArray){
+    getValidPointProperties(point, requestedProps) {
         let that = this;
-
-        let points = promiseArray.map(function(element){return element.point})
-        let promises = promiseArray.map(function(element){return element.promise})
-        promiseArray.forEach(function(element){
-            let point = element.point;
-
-            Promise.resolve(element.promise).then(function(result){
-                that.pointReferenceList.push({})
-            });
-        });
-
-    }
-
-    getValidPointProperties(point, requestedProps){
         let availableProps = point.propertyList;
         let newProps = [];
 
@@ -208,43 +305,46 @@ class BacnetClient extends EventEmitter {
                 if(foundInAvailable) newProps.push(prop);
             });
             //add object name for use in formatting
-            newProps.push({id: baEnum.PropertyIds.PROP_OBJECT_NAME});
+            newProps.push({id: baEnum.PropertyIdentifier.OBJECT_NAME});
         } catch(e){
-            console.log("Issue finding valid object properties, see error: ", e);
+            that.logOut("Issue finding valid object properties, see error: ", e);
         }
 
         return newProps;
     }
 
-    doRead(readConfig, outputType, msgId) {
+    doRead(readConfig, outputType, objectPropertyType, msgId) {
         let that = this;
-
         that.roundDecimal = readConfig.precision;
         let devicesToRead = Object.keys(readConfig.pointsToRead);
-        let propertiesToRead = readConfig.objectProperties;
 
         try {
-            devicesToRead.forEach(function(deviceAddress) {
-                let requestArray = [];
-                let readPromiseArray = [];
-                let pointsToReadNames = Object.keys(readConfig.pointsToRead[deviceAddress]);
-                let device = that.deviceList.find(ele => ele.address == deviceAddress);
-                pointsToReadNames.forEach(function(pointName, index) {
-                    let point = readConfig.pointsToRead[deviceAddress][pointName];
-                    readPromiseArray.push(that._readObjectFull(deviceAddress, point.meta.objectId.type, point.meta.objectId.instance));
-                });
-                that.readDeviceAndEmitJSON(readPromiseArray, device, outputType, propertiesToRead, msgId);
+            let bacnetResults = {};
+            devicesToRead.forEach(function(key, index) {
+                let device = that.deviceList.find(ele => `${that.getDeviceAddress(ele)}-${ele.getDeviceId()}` == key);
+                let deviceName = device.getDeviceName();
+                bacnetResults[deviceName] = readConfig.pointsToRead[key];
+                if(index == devicesToRead.length - 1) that.emit('values', bacnetResults, outputType, objectPropertyType);
             });
-
-        } catch(e){
-            console.log("Issue doing read, see error: ", e);
+        } catch(e) {
+            that.logOut("Issue doing read, see error: ", e);
         }
+    }
 
+    getDeviceAddress(device){
+        switch(typeof device.getAddress()) {
+            case "object":
+                return device.getAddress().address;
+            case "string":
+                return device.getAddress();
+            default:    
+                return device.getAddress();
+        }
     }
 
-    readDeviceAndEmitJSON(readPromiseArray, device, outputType, propertiesToRead, msgId) {
+    readDeviceAndEmitJSON(readPromiseArray, device, outputType, propertiesToRead, objectPropertyType, msgId) {
         let that = this;
-        let deviceName = device.deviceName;
+        let deviceName = device.getDeviceName();
 
         let bacnetResults = {
             [deviceName]: []
@@ -261,45 +361,69 @@ class BacnetClient extends EventEmitter {
                         element.values.forEach(function(point){
                             point.values.forEach(function(object) {                             
                                 let toReadProperty = propertiesToRead.findIndex(ele => ele.id == object.id);
+                                let objectName = that._findValueById(point.values, baEnum.PropertyIdentifier.OBJECT_NAME);
                                 //checks for error code json structure, returned for invalid bacnet requests
-                                if(!object.value.value && toReadProperty !== -1) {      
+                                if(!object.value.value && toReadProperty !== -1 && objectName !== "") {      
                                     var currobjectId = point.objectId.type
                                     let bac_obj = that.getObjectType(currobjectId);                                
-                                    let objectName = that._findValueById(point.values, baEnum.PropertyIds.PROP_OBJECT_NAME);
-
                                     let objectId;
-                                    if(objectName !== null) {
-                                        objectName = objectName.split(" ").join("_");
-                                        objectId = objectName + "_" + bac_obj + '_' + point.objectId.instance;
-                                    } else {
-                                        objectId = bac_obj + '_' + point.objectId.instance;
-                                    }
+                                    objectId = objectName;
 
                                     //init json object
                                     if(!values[objectId]) values[objectId] = {};
 
                                     switch(object.id) {
-                                        case baEnum.PropertyIds.PROP_PRESENT_VALUE:                                            
-                                            if(object.value[0] && object.value[0].value) values[objectId].presentValue = roundDecimalPlaces(object.value[0].value, that.roundDecimal);
+                                        case baEnum.PropertyIdentifier.PRESENT_VALUE:
+                                            if(object.value[0] && 
+                                               object.value[0].value !== "undefined" && 
+                                               object.value[0].value !== null && 
+                                               typeof object.value[0].value == "number") {
+                                                    values[objectId].presentValue = roundDecimalPlaces(object.value[0].value, that.roundDecimal);
+                                               } else if(object.value[0] && 
+                                                object.value[0].value !== "undefined" && 
+                                                object.value[0].value !== null && 
+                                                typeof object.value[0].value == "string") {
+                                                    values[objectId].presentValue = object.value[0].value;
+                                               }
                                             break;
-                                        case baEnum.PropertyIds.PROP_DESCRIPTION:
+                                        case baEnum.PropertyIdentifier.DESCRIPTION:
                                             if(object.value[0]) values[objectId].description = object.value[0].value;
                                             break;
-                                        case baEnum.PropertyIds.PROP_STATUS_FLAGS:
+                                        case baEnum.PropertyIdentifier.STATUS_FLAGS:
                                             if(object.value[0] && object.value[0].value) values[objectId].statusFlags = that.getStatusFlags(object);
                                             break;
-                                        case baEnum.PropertyIds.PROP_RELIABILITY:
+                                        case baEnum.PropertyIdentifier.RELIABILITY:
                                             if(object.value[0]) values[objectId].reliability = that.getPROP_RELIABILITY(object.value[0].value);
                                             break; 
-                                        case baEnum.PropertyIds.PROP_OUT_OF_SERVICE:
+                                        case baEnum.PropertyIdentifier.OUT_OF_SERVICE:
                                             if(object.value[0]) values[objectId].outOfService = object.value[0].value;
                                             break;
-                                        case baEnum.PropertyIds.PROP_UNITS:
+                                        case baEnum.PropertyIdentifier.UNITS:
                                             if(object.value[0] && object.value[0].value) values[objectId].units = getUnit(object.value[0].value);
                                             break;
-                                        case baEnum.PropertyIds.PROP_OBJECT_NAME:
+                                        case baEnum.PropertyIdentifier.OBJECT_NAME:
                                             if(object.value[0] && object.value[0].value) values[objectId].objectName = object.value[0].value;
                                             break;
+                                        case baEnum.PropertyIdentifier.SYSTEM_STATUS:
+                                            if(object.value[0]){
+                                                values[objectId].systemStatus = that.getPROP_SYSTEM_STATUS(object.value[0].value);
+                                            }
+                                            break;    
+                                        case baEnum.PropertyIdentifier.MODIFICATION_DATE:
+                                            if(object.value[0]) {
+                                                values[objectId].modificationDate = object.value[0].value;
+                                            }
+                                            break;      
+                                        case baEnum.PropertyIdentifier.PROGRAM_STATE:
+                                            if(object.value[0]){
+                                                values[objectId].programState = that.getPROP_PROGRAM_STATE(object.value[0].value);
+                                            }
+                                            break;
+                                        case baEnum.PropertyIdentifier.RECORD_COUNT:
+                                            if(object.value[0] ) {
+                                                values[objectId].recordCount = object.value[0].value;
+                                            }
+                                            break;
                                     }
                                 }
                             });
@@ -307,11 +431,11 @@ class BacnetClient extends EventEmitter {
                         bacnetResults[deviceName] = values;
 
                     } catch(e) {
-                        console.log("issue resolving bacnet payload, see error:  ", e);
+                        that.logOut("issue resolving bacnet payload, see error:  ", e);
                     }
                 });
                 if(Object.keys(bacnetResults[deviceName]).length !== 0) {
-                    that.emit('values', device, bacnetResults, outputType, msgId, successfulResults);
+                    that.emit('values', bacnetResults, outputType, objectPropertyType);
                 }
                 
             }).catch(function (error) {
@@ -319,12 +443,10 @@ class BacnetClient extends EventEmitter {
             });
 
         } catch(e){
-            console.log("Issue reading from device, see error: ", e);
+            that.logOut("Issue reading from device, see error: ", e);
         }
     }
 
-
-
     _getDeviceName(address, deviceId) {
         let that = this;
         return new Promise((resolve, reject) => {
@@ -335,10 +457,10 @@ class BacnetClient extends EventEmitter {
                             if(object.value[0]) {
                                 resolve(object.value[0].value);
                             } else {
-                                console.log("Issue with deviceName payload, see object: ", object);
+                                that.logOut("Issue with deviceName payload, see object: ", object);
                             }
                         } catch(e){
-                            console.log("Unable to get device name: ", e);
+                            that.logOut("Unable to get device name: ", e);
                         }
                     });
                 }            
@@ -347,9 +469,10 @@ class BacnetClient extends EventEmitter {
     }
 
     getPropertiesForType(props, type) {
+        let that = this;
         let newProps = [];
         props.forEach(function(prop) {
-            //console.log(prop);
+            //that.logOut(prop);
             switch(type){
                 case 0:  //analog-input
                     newProps.push(prop);
@@ -370,13 +493,13 @@ class BacnetClient extends EventEmitter {
                     newProps.push(prop);
                     break;
                 case 13:
-                    if(prop.id == baEnum.PropertyIds.PROP_PRESENT_VALUE || prop.id == baEnum.PropertyIds.PROP_OBJECT_NAME) newProps.push(prop);
+                    if(prop.id == baEnum.PropertyIdentifier.PRESENT_VALUE || prop.id == baEnum.PropertyIdentifier.OBJECT_NAME) newProps.push(prop);
                     break;     
                 case 14:
-                    if(prop.id == baEnum.PropertyIds.PROP_PRESENT_VALUE || prop.id == baEnum.PropertyIds.PROP_OBJECT_NAME) newProps.push(prop);
+                    if(prop.id == baEnum.PropertyIdentifier.PRESENT_VALUE || prop.id == baEnum.PropertyIdentifier.OBJECT_NAME) newProps.push(prop);
                     break;   
                 case 19:
-                    if(prop.id == baEnum.PropertyIds.PROP_PRESENT_VALUE || prop.id == baEnum.PropertyIds.PROP_OBJECT_NAME) newProps.push(prop);
+                    if(prop.id == baEnum.PropertyIdentifier.PRESENT_VALUE || prop.id == baEnum.PropertyIdentifier.OBJECT_NAME) newProps.push(prop);
                     break;              
             }
         });
@@ -387,21 +510,122 @@ class BacnetClient extends EventEmitter {
         let that = this;
         return new Promise(async function(resolve, reject) {
             try {
+                device.setManualDiscoveryMode(false);
                 let result = await that.scanDevice(device);
                 device.setPointsList(result);
                 resolve(result);
+            } catch(e) {
+                that.logOut(`Error getting point list for ${device.getAddress()} - ${device.getDeviceId()}: `, e);
+                reject(e);
+            }
+        });
+    }
+
+    getDevicePointListWithoutObjectList(device) {
+        let that = this;
+        return new Promise(function(resolve, reject) {
+            try {
+                device.setManualDiscoveryMode(true);
+                that.scanDeviceManually(device).then(function(result) {
+                    device.setPointsList(result);
+                    resolve(result);
+                }).catch(function(error) {
+                    reject(error);
+                });
+
 
             } catch(e) {
-                console.log("Error getting point list: ", e);
+                that.logOut("Error getting point list: ", e);
                 reject(e);
             }
             
         });
     }
 
-    _readObjectWithRequestArray(deviceAddress, requestArray) {
+    scanDeviceManually(device) {
         let that = this;
+        return new Promise(function(resolve, reject) {
+            let objectNameProperty = [{ id: baEnum.PropertyIdentifier.OBJECT_NAME }];
+            let address = device.getAddress();
+            let objectTypeList = [0, 1, 2, 3];
+            let instanceRange = {start: 0, end: 100};
+            let requestArray = [];
+            let maxRequestThreshold = 1000;
+            let requestRate = 20;
+            let requestBuffer = [];
+            let sendBuffer = [];
+
+            if(that.manual_instance_range_enabled == true) {
+                instanceRange.start = that.manual_instance_range_start;
+                maxRequestThreshold = that.manual_instance_range_end;
+                if(that.manual_instance_range_end < requestRate) {
+                    requestRate = that.manual_instance_range_end;
+                }
+            }
+
+            for(let typeListIndex = 0; typeListIndex < objectTypeList.length; typeListIndex++){
+                let objectType = objectTypeList[typeListIndex];
+                for(let i = instanceRange.start; i <= instanceRange.end; i++) {
+
+                    requestArray.push({
+                        objectId: { type: objectType, instance: i },
+                        properties: objectNameProperty
+                    })
+
+                    if(requestArray.length == requestRate ) {
+                        requestBuffer.push(that._readObjectWithRequestArray(address, requestArray));
+                        instanceRange.end += requestRate;
+                        requestArray = [];
+                        if(i >= maxRequestThreshold) {
+                            instanceRange.end = maxRequestThreshold;
+                            if(typeListIndex == objectTypeList.length-1) {
+                                send();
+                            }
+                            
+                            break;
+                        }
+                    }
+                }
 
+                instanceRange.end = 100;
+            };
+
+            function send() {
+
+                for(let index = 0; index < requestBuffer.length; index++) {
+                    let promise = requestBuffer[index];
+                    try {
+                        Promise.resolve(promise).then(function(result) {
+                            let keys = Object.keys(result);
+                            for (const [key, value] of Object.entries(result)) {
+                                if(key == "value" && typeof value == "object") {
+                                    for(let x = 0; x < value.values.length; x++) {
+                                        let ele = value.values[x];
+                                        let valueRoot = ele.values[0].value[0];
+                                        if(!valueRoot.value.errorClass && !valueRoot.value.errorCode) {
+                                            sendBuffer.push({"value": ele.objectId, "type": 12});
+                                        }
+                                    }
+                                }
+                            }
+
+                            if(index == requestBuffer.length - 1) {
+                                resolve(sendBuffer);
+                            }
+
+                        }).catch(function(error) {
+                            reject(error);
+                        });
+                    } catch(e) {
+                        reject(e)
+                    }
+                }
+            }
+        });
+    }
+
+    _readObjectWithRequestArray(deviceAddress, requestArray) {
+        let that = this;
         return new Promise((resolve, reject) => {
             this.client.readPropertyMultiple(deviceAddress, requestArray, that.readPropertyMultipleOptions, (error, value) => {
                 resolve({
@@ -431,9 +655,9 @@ class BacnetClient extends EventEmitter {
     _readDeviceName(deviceAddress, deviceId, callback){
         let that = this;
         const requestArray = [{
-            objectId: { type: baEnum.ObjectTypes.OBJECT_DEVICE, instance: deviceId },
+            objectId: { type: baEnum.ObjectType.DEVICE, instance: deviceId },
             properties: [
-                { id: baEnum.PropertyIds.PROP_OBJECT_NAME }
+                { id: baEnum.PropertyIdentifier.OBJECT_NAME }
             ]
         }];
 
@@ -443,53 +667,45 @@ class BacnetClient extends EventEmitter {
     _readObjectList(deviceAddress, deviceId, callback) {
         let that = this;
         const requestArray = [{
-            objectId: { type: baEnum.ObjectTypes.OBJECT_DEVICE, instance: deviceId },
-            properties: [{ id: baEnum.PropertyIds.PROP_OBJECT_LIST }
+            objectId: { type: baEnum.ObjectType.DEVICE, instance: deviceId },
+            properties: [{ id: baEnum.PropertyIdentifier.OBJECT_LIST }
             ]
         }];
         
         try {
             that.client.readPropertyMultiple(deviceAddress, requestArray, that.readPropertyMultipleOptions, callback);
         } catch(e) {
-            console.log("Error reading object list:  ", e);
+            that.logOut("Error reading object list:  ", e);
         }
     }
 
     _readObjectFull(deviceAddress, type, instance) {
 
         return this._readObject(deviceAddress, type, instance, [
-            { id: baEnum.PropertyIds.PROP_OBJECT_IDENTIFIER },
-            { id: baEnum.PropertyIds.PROP_OBJECT_NAME },
-            { id: baEnum.PropertyIds.PROP_OBJECT_TYPE },
-            { id: baEnum.PropertyIds.PROP_DESCRIPTION },
-            { id: baEnum.PropertyIds.PROP_UNITS },
-            { id: baEnum.PropertyIds.PROP_PRESENT_VALUE },
-            { id: baEnum.PropertyIds.PROP_PROPERTY_LIST },
-            { id: baEnum.PropertyIds.PROP_STATUS_FLAGS },
-            { id: baEnum.PropertyIds.PROP_RELIABILITY },
-            { id: baEnum.PropertyIds.PROP_OUT_OF_SERVICE }
+            { id: baEnum.PropertyIdentifier.ALL }
         ]);
+
     };
 
     _readObjectPropList(deviceAddress, type, instance) {
 
         return this._readObject(deviceAddress, type, instance, [
-            { id: baEnum.PropertyIds.PROP_PROPERTY_LIST }
+            { id: baEnum.PropertyIdentifier.PROPERTY_LIST }
         ]);
     };
 
     _readObjectId(deviceAddress, type, instance) {
 
         return this._readObject(deviceAddress, type, instance, [
-            { id: baEnum.PropertyIds.PROP_OBJECT_IDENTIFIER }
+            { id: baEnum.PropertyIdentifier.OBJECT_IDENTIFIER }
         ]);
     }
 
     _readObjectPresentValue(deviceAddress, type, instance) {
 
         return this._readObject(deviceAddress, type, instance, [
-            { id: baEnum.PropertyIds.PROP_PRESENT_VALUE },
-            { id: baEnum.PropertyIds.PROP_OBJECT_NAME}
+            { id: baEnum.PropertyIdentifier.PRESENT_VALUE },
+            { id: baEnum.PropertyIdentifier.OBJECT_NAME}
         ]);
     }
 
@@ -500,7 +716,7 @@ class BacnetClient extends EventEmitter {
         options.pointsToWrite.forEach(function(point){
 
             let deviceAddress = point.deviceAddress;
-
+            
             if(valuesArray[deviceAddress] == null || valuesArray[deviceAddress] == undefined){
                 valuesArray[deviceAddress] = [];
             }
@@ -546,11 +762,11 @@ class BacnetClient extends EventEmitter {
                 Promise.all(writePromises).then(function(result) {
                     resolve(result);
                 }).catch(function(e) {
-                    console.log("Error writing:  ", e);
+                    that.logOut("Error writing:  ", e);
                 });
             });
         } catch (error) {
-            console.log(error);
+            that.logOut(error);
         }
     }
 
@@ -573,11 +789,11 @@ class BacnetClient extends EventEmitter {
         const objectInfo = object.values[0].objectId;
         const deviceObjectId = new DeviceObjectId(objectInfo.type, objectInfo.instance);
         const objectProperties = object.values[0].values;
-        const name = this._findValueById(objectProperties, baEnum.PropertyIds.PROP_OBJECT_NAME);
-        const PROP_DESCRIPTION = this._findValueById(objectProperties, baEnum.PropertyIds.PROP_DESCRIPTION);
-        const type = this._findValueById(objectProperties, baEnum.PropertyIds.PROP_OBJECT_TYPE);
-        const PROP_UNITS = this._findValueById(objectProperties, baEnum.PropertyIds.PROP_UNITS);
-        const presentValue = this._findValueById(objectProperties, baEnum.PropertyIds.PROP_PRESENT_VALUE);
+        const name = this._findValueById(objectProperties, baEnum.PropertyIdentifier.OBJECT_NAME);
+        const PROP_DESCRIPTION = this._findValueById(objectProperties, baEnum.PropertyIdentifier.DESCRIPTION);
+        const type = this._findValueById(objectProperties, baEnum.PropertyIdentifier.OBJECT_TYPE);
+        const PROP_UNITS = this._findValueById(objectProperties, baEnum.PropertyIdentifier.UNITS);
+        const presentValue = this._findValueById(objectProperties, baEnum.PropertyIdentifier.PRESENT_VALUE);
 
         return new DeviceObject(deviceObjectId, name, PROP_DESCRIPTION, type, PROP_UNITS, presentValue);
     }
@@ -612,16 +828,17 @@ class BacnetClient extends EventEmitter {
     }
 
     scanDevice(device) {
+        let that = this;
         return new Promise((resolve, reject) => {
-            this._readObjectList(device.address, device.deviceId, (err, result) => {
+            this._readObjectList(device.getAddress(), device.getDeviceId(), (err, result) => {
                 if (!err) {
                     try {
                         resolve(result.values[0].values[0].value);
                     } catch(e) {
-                        console.log("Issue with getting device point list, see error:  ", e);
+                        that.logOut("Issue with getting device point list, see error:  ", e);
                     }
                 } else {
-                    logger.log('error', `Error while fetching objects: ${err}`);
+                    that.logOut(`Error while fetching objects: ${err}`);
                     reject(err);
                 }
             });
@@ -632,7 +849,7 @@ class BacnetClient extends EventEmitter {
     shutDownClient() {
         let that = this;
         if(that.client) that.client.close((err, result) => {
-            console.log(err, result);
+            that.logOut(err, result);
         });
     };
 
@@ -640,7 +857,8 @@ class BacnetClient extends EventEmitter {
         let that = this;
         let options = {
             lowLimit: 0,
-            highLimit: baAsn1.BACNET_MAX_INSTANCE
+            highLimit: bacnetIdMax,
+            'net': 65535
         };
 
         if(that.device_id_range_enabled == true) {
@@ -649,7 +867,7 @@ class BacnetClient extends EventEmitter {
         }
 
         if(that.client) {
-            that.client.whoIs(options);
+            that.client.whoIs({'net': 65535});
         } else {
             that.reinitializeClient(that.config);
         }
@@ -681,56 +899,95 @@ class BacnetClient extends EventEmitter {
     }
 
     buildNetworkTreeData() {
-        let that = this;        
+        let that = this;  
+        that.buildTreeMutex = new Mutex();
+        let displayNameCharThreshold = 40;
         return new Promise(async function(resolve, reject) {
             if(!that.renderList) that.renderList = [];
             if(that.deviceList && that.networkTree) {
                 that.deviceList.forEach(function(deviceInfo, index) {
-                    let ipAddr = deviceInfo.getAddress();
-                    let deviceName = deviceInfo.getDeviceName() == null ? ipAddr : deviceInfo.getDeviceName();                    
-                    let deviceObject = that.networkTree[ipAddr];
-
-                    if(deviceObject) {
-                        let children = [];
-                        let pointIndex = 0;
+                    that.buildTreeMutex 
+                    .acquire()
+                    .then(function(release) {
+
+                        let ipAddr = typeof deviceInfo.getAddress() == "object" ? deviceInfo.getAddress().address : deviceInfo.getAddress();
+                        let deviceId = deviceInfo.getDeviceId();
+                        let deviceName = deviceInfo.getDeviceName() == null ? ipAddr : deviceInfo.getDeviceName();
+                        let deviceKey = ipAddr + "-" + deviceInfo.getDeviceId();
+                        let deviceObject = that.networkTree[deviceKey];
+                        let isMstpDevice = deviceInfo.getIsMstpDevice();
+                        let manualDiscoveryMode = deviceInfo.getManualDiscoveryMode();
+
+                        if(deviceObject) {
+                            let children = [];
+                            let pointIndex = 0;
+
+                            for(const pointName in deviceObject) {
+                                let pointProperties = [];
+                                let values = deviceObject[pointName];
+                                let displayName = pointName;
+                                if(pointName.length > displayNameCharThreshold) {
+                                    displayName = "";
+                                    let charArray = pointName.split("");
+                                    for(let i = 0; i < charArray.length; i++) {
+                                        if(i < displayNameCharThreshold){
+                                            displayName += charArray[i];
+                                        }
+                                    }
+                                    displayName += "...";
+                                }
 
-                        for(const pointName in deviceObject) {
-                            let pointProperties = [];
-                            let values = deviceObject[pointName];
+                                if(values.objectName){
+                                    pointProperties.push({"key": `${index}-${pointIndex}-0`, "label": `Name: ${values.objectName}`, "data": values.objectName, "icon": "pi pi-bolt", "children": null});
+                                }
+                                if(values.objectType){
+                                    pointProperties.push({"key": `${index}-${pointIndex}-1`, "label": `Object Type: ${values.objectType}`, "data": values.objectType, "icon": "pi pi-bolt", "children": null});
+                                } 
+                                if(values.objectID && values.objectID.instance) {
+                                    pointProperties.push({"key": `${index}-${pointIndex}-2`, "label": `Object Instance: ${values.objectID.instance}`, "data": values.objectID.instance, "icon": "pi pi-bolt", "children": null});
+                                }
+                                if(values.description){
+                                    pointProperties.push({"key": `${index}-${pointIndex}-3`, "label": `Description: ${values.description}`, "data": `${values.description}`, "icon": "pi pi-bolt", "children": null});
+                                }
+                                if(values.units){
+                                    pointProperties.push({"key": `${index}-${pointIndex}-4`, "label": `Units: ${values.units}`, "data": `${values.units}`, "icon": "pi pi-bolt", "children": null});
+                                }
+                                if(values.presentValue !== "undefined" && values.presentValue !== null && typeof values.presentValue !== "undefined") {
+                                    pointProperties.push({"key": `${index}-${pointIndex}-5`, "label": `Present Value: ${values.presentValue}`, "data": `${values.presentValue}`, "icon": "pi pi-bolt", "children": null});
+                                }
+                                if(values.systemStatus !== null && typeof values.systemStatus !== "undefined" && values.systemStatus !== ""){
+                                    pointProperties.push({"key": `${index}-${pointIndex}-6`, "label": `System Status: ${values.systemStatus}`, "data": `${values.systemStatus}`, "icon": "pi pi-bolt", "children": null});
+                                }
+                                if(values.modificationDate && !values.modificationDate.errorClass) {
+                                    pointProperties.push({"key": `${index}-${pointIndex}-7`, "label": `Modification Date: ${values.modificationDate}`, "data": `${values.modificationDate}`, "icon": "pi pi-bolt", "children": null});
+                                }
+                                if(values.programState){
+                                    pointProperties.push({"key": `${index}-${pointIndex}-8`, "label": `Program State: ${values.programState}`, "data": `${values.programState}`, "icon": "pi pi-bolt", "children": null});
+                                }
+                                if(values.recordCount && !values.recordCount.errorClass){
+                                    pointProperties.push({"key": `${index}-${pointIndex}-9`, "label": `Record Count: ${values.recordCount}`, "data": `${values.recordCount}`, "icon": "pi pi-bolt", "children": null});
+                                }
 
-                            if(values.objectName){
-                                pointProperties.push({"key": `${index}-${pointIndex}-0`, "label": `Name: ${values.objectName}`, "data": values.objectName, "icon": "pi pi-bolt", "children": null});
-                            }
-                            if(values.objectType){
-                                pointProperties.push({"key": `${index}-${pointIndex}-1`, "label": `Object Type: ${values.objectType}`, "data": values.objectType, "icon": "pi pi-bolt", "children": null});
-                            } 
-                            if(values.objectID && values.objectID.instance) {
-                                pointProperties.push({"key": `${index}-${pointIndex}-2`, "label": `Object Instance: ${values.objectID.instance}`, "data": values.objectID.instance, "icon": "pi pi-bolt", "children": null});
+                                children.push({"key": `${index}-${pointIndex}`, "label": displayName, "data": displayName, "pointName": pointName, "icon": that.getPointIcon(values.meta.objectId.type), "children": pointProperties, "type": "point", "parentDevice": deviceName, "showAdded": false, "bacnetType": values.meta.objectId.type})
+                                pointIndex++;
                             }
-                            if(values.description){
-                                pointProperties.push({"key": `${index}-${pointIndex}-3`, "label": `Description: ${values.description}`, "data": `${values.description}`, "icon": "pi pi-bolt", "children": null});
+                            let foundIndex = that.renderList.findIndex(ele => ele.key == index && ele.deviceId == deviceId);
+                            if(foundIndex !== -1) {
+                                that.renderList[foundIndex] = {"key": index, "label": deviceName, "data": deviceName, "icon": that.getDeviceIcon(isMstpDevice, manualDiscoveryMode), "children": children.sort(that.sortPoints), "type": "device", "lastSeen": deviceInfo.getLastSeen(), "showAdded": false, "ipAddr": ipAddr, "deviceId": deviceId, "isMstpDevice": isMstpDevice};
+                            } else if(foundIndex == -1) {
+                                that.renderList.push({"key": index, "label": deviceName, "data": deviceName, "icon": that.getDeviceIcon(isMstpDevice, manualDiscoveryMode), "children": children.sort(that.sortPoints), "type": "device", "lastSeen": deviceInfo.getLastSeen(), "showAdded": false, "ipAddr": ipAddr, "deviceId": deviceId, "isMstpDevice": isMstpDevice});
                             }
-                            if(values.units){
-                                pointProperties.push({"key": `${index}-${pointIndex}-4`, "label": `Units: ${values.units}`, "data": `${values.units}`, "icon": "pi pi-bolt", "children": null});
+                            if(index == that.deviceList.length - 1) {
+                                resolve({renderList: that.renderList, deviceList: that.deviceList, pointList: that.networkTree, pollFrequency: that.discover_polling_schedule});
                             }
-                            if(values.presentValue !== "undefined" && values.presentValue !== null) {
-                                pointProperties.push({"key": `${index}-${pointIndex}-5`, "label": `Present Value: ${values.presentValue}`, "data": `${values.presentValue}`, "icon": "pi pi-bolt", "children": null});
+                        } else {
+                            if(index == that.deviceList.length - 1) {
+                                resolve({renderList: that.renderList, deviceList: that.deviceList, pointList: that.networkTree, pollFrequency: that.discover_polling_schedule});
                             }
-                            children.push({"key": `${index}-${pointIndex}`, "label": pointName, "data": pointName, "icon": "", "children": pointProperties, "type": "point", "parentDevice": deviceName, "showAdded": false, "bacnetType": values.meta.objectId.type})
-                            pointIndex++;
-                        }
-                        let foundIndex = that.renderList.findIndex(ele => ele.key == index && ele.ipAddr == ipAddr);
-                        if(foundIndex !== -1) {
-                            that.renderList[foundIndex] = {"key": index, "label": deviceName, "data": deviceName, "icon": "pi pi-box", "children": children.sort(that.sortPoints), "type": "device", "lastSeen": deviceInfo.getLastSeen(), "showAdded": false, "ipAddr": ipAddr};
-                        } else if(foundIndex == -1) {
-                            that.renderList.push({"key": index, "label": deviceName, "data": deviceName, "icon": "pi pi-box", "children": children.sort(that.sortPoints), "type": "device", "lastSeen": deviceInfo.getLastSeen(), "showAdded": false, "ipAddr": ipAddr});
                         }
-                        if(index == that.deviceList.length - 1) {
-                            resolve({renderList: that.renderList, deviceList: that.deviceList, pointList: that.networkTree, pollFrequency: that.discover_polling_schedule});
-                        }
-                    } else {
-                        if(index == that.deviceList.length - 1) resolve({renderList: that.renderList, deviceList: that.deviceList, pointList: that.networkTree, pollFrequency: that.discover_polling_schedule});
-                    }
+                        
+                        release();
+                    });
                 });
             }
         });
@@ -740,125 +997,171 @@ class BacnetClient extends EventEmitter {
         let that = this;    
         let address = device.address;
         let pointList = device.getPointsList();
+        let requestMutex = new Mutex();
 
-        return new Promise(function(resolve, reject) {           
+        return new Promise(function(resolve, reject) {
             let promiseArray = [];
-            pointList.forEach(function(point, pointListIndex) {
-                promiseArray.push(that._readObjectFull(address, point.value.type, point.value.instance));
-                if(pointListIndex == pointList.length - 1) {
-                    Promise.all(promiseArray).then(function(objectList){
-                        that.buildResponse(objectList, device).then(function() {
-                            that.lastNetworkPoll = Date.now();
-                            resolve({deviceList: that.deviceList, pointList: that.networkTree});
-                        }).catch(function(e){
-                            console.log("Error while building json object: ", e);
-                            reject(e);
+            if(typeof pointList !== "undefined" && pointList.length > 0) {
+                pointList.forEach(function(point, pointListIndex) {
+                    requestMutex
+                    .acquire()
+                    .then(function(release) {
+                        that._readObjectFull(address, point.value.type, point.value.instance).then(function(result) {
+
+                            if(!result.error) {
+                                promiseArray.push(result);
+                            }
+
+                            release();
+
+                            if(pointListIndex == pointList.length - 1) {
+                                that.buildResponse(promiseArray, device).then(function() {
+                                    that.lastNetworkPoll = Date.now();
+                                    resolve({deviceList: that.deviceList, pointList: that.networkTree});
+                                }).catch(function(e){
+                                    that.logOut("Error while building json object: ", e);
+                                    reject(e);
+                                });
+                            }
+                            
+                        }).catch(function(e) {
+                            release();
+                            that.logOut("_readObjectFull error: ", e);
+
+                            if(pointListIndex == pointList.length - 1) {
+                                that.buildResponse(promiseArray, device).then(function() {
+                                    that.lastNetworkPoll = Date.now();
+                                    resolve({deviceList: that.deviceList, pointList: that.networkTree});
+                                }).catch(function(e){
+                                    that.logOut("Error while building json object: ", e);
+                                    reject(e);
+                                });
+                            }
+
                         });
-                    }).catch(function(e) {
-                        console.log("Error while building json object: ", e);
-                        reject(e);
                     });
-                }
-            });
+                });
+            } else {
+                reject("Unable to build network tree, empty point list");
+            }
         });
     }
 
     // Builds response object for a fully qualified 
     buildResponse(fullObjects, device) {
         let that = this;
-        let deviceName = device.getDeviceName();
-        let ipAddr = device.getAddress();
-
         return new Promise(function(resolve, reject) {
-            let values = that.networkTree[device.getAddress()] ? that.networkTree[device.getAddress()] : {};
-
-            for(let i = 0; i < fullObjects.length; i++) {
-            
+            let deviceKey = (typeof device.getAddress() == "object") ? device.getAddress().address + "-" + device.getDeviceId() : device.getAddress() + "-" + device.getDeviceId();            
+            let values = that.networkTree[deviceKey] ? that.networkTree[deviceKey] : {};
+            for(let i = 0; i < fullObjects.length; i++) {            
                 let obj = fullObjects[i];
                 let successfulResult = !obj.error ? obj.value : null;
-
                 if(successfulResult) {
                     successfulResult.values.forEach(function(pointProperty, pointPropertyIndex) {
-
                         let currobjectId = pointProperty.objectId.type
                         let bac_obj = that.getObjectType(currobjectId);
-                        
-                        let objectName = that._findValueById(pointProperty.values, baEnum.PropertyIds.PROP_OBJECT_NAME);
-                        let objectType = that._findValueById(pointProperty.values, baEnum.PropertyIds.PROP_OBJECT_TYPE);
-                        
+                        let objectName = that._findValueById(pointProperty.values, baEnum.PropertyIdentifier.OBJECT_NAME);
+                        let objectType = that._findValueById(pointProperty.values, baEnum.PropertyIdentifier.OBJECT_TYPE);
                         let objectId;
                         if(objectName !== null) {
-                            objectName = objectName.split(" ").join("_");
                             objectId = objectName + "_" + bac_obj + '_' + pointProperty.objectId.instance;
                         } else {
                             objectId = bac_obj + '_' + pointProperty.objectId.instance;
                         }
-
-                        if(!values[objectId]) values[objectId] = {};
-                        values[objectId].meta = {
-                            objectId: pointProperty.objectId
-                        };
-                        
                         try {
                             pointProperty.values.forEach(function(object, objectIndex) {
                                 //checks for error code json structure, returned for invalid bacnet requests
-                                if(!object.value.value) {
+                                //if(!object.value.value && !object.value[0].value.errorClass && !object.value.errorClass) {
+                                if(object && object.value && !object.value.errorClass) {
+
+
+                                    if(!values[objectId]) values[objectId] = {};
+                                    values[objectId].meta = {
+                                        objectId: pointProperty.objectId
+                                    };
+
                                     switch(object.id) {
-                                        case baEnum.PropertyIds.PROP_PRESENT_VALUE:
+                                        case baEnum.PropertyIdentifier.PRESENT_VALUE:
                                             if(object.value[0] && object.value[0].value !== "undefined" && object.value[0].value !== null) {
                                                 //check for binary object type
-                                                if(objectType == 3 || objectType == 4 || objectType == 5){
+                                                if(objectType == 3 || objectType == 4 || objectType == 5) {
                                                     if(object.value[0].value == 0) {
                                                         values[objectId].presentValue = false;
                                                     } else if(object.value[0].value == 1) {
                                                         values[objectId].presentValue = true;
                                                     }
+                                                } else if(objectType == 40) {
+                                                        //character string
+                                                        values[objectId].presentValue = object.value[0].value;
                                                 } else {
                                                     values[objectId].presentValue = roundDecimalPlaces(object.value[0].value, 2);
                                                 }
                                             } 
                                             values[objectId].meta.arrayIndex = object.index;
                                             break;
-                                        case baEnum.PropertyIds.PROP_DESCRIPTION:
+                                        case baEnum.PropertyIdentifier.DESCRIPTION:
                                             if(object.value[0]) values[objectId].description = object.value[0].value;
                                             break;
-                                        case baEnum.PropertyIds.PROP_UNITS:
+                                        case baEnum.PropertyIdentifier.UNITS:
                                             if(object.value[0] && object.value[0].value) values[objectId].units = getUnit(object.value[0].value);
                                             break;
-                                        case baEnum.PropertyIds.PROP_OBJECT_NAME:
+                                        case baEnum.PropertyIdentifier.OBJECT_NAME:
                                             if(object.value[0] && object.value[0].value) values[objectId].objectName = object.value[0].value;
                                             break;
-                                        case baEnum.PropertyIds.PROP_OBJECT_TYPE:
+                                        case baEnum.PropertyIdentifier.OBJECT_TYPE:
                                             if(object.value[0] && object.value[0].value) values[objectId].objectType = object.value[0].value;
                                             break;
-                                        case baEnum.PropertyIds.PROP_OBJECT_IDENTIFIER:
+                                        case baEnum.PropertyIdentifier.OBJECT_IDENTIFIER:
                                             if(object.value[0] && object.value[0].value) values[objectId].objectID = object.value[0].value;
                                             break;    
-                                        case baEnum.PropertyIds.PROP_PROPERTY_LIST:
+                                        case baEnum.PropertyIdentifier.PROPERTY_LIST:
                                             if(object.value) values[objectId].propertyList = that.mapPropsToArray(object.value);
-                                            break;                                                                                        
+                                            break;         
+                                            
+                                        case baEnum.PropertyIdentifier.SYSTEM_STATUS:
+                                            if(object.value[0]){
+                                                values[objectId].systemStatus = that.getPROP_SYSTEM_STATUS(object.value[0].value);
+                                            } 
+                                            break;    
+
+                                        case baEnum.PropertyIdentifier.MODIFICATION_DATE:
+                                            if(object.value[0]) {
+                                                values[objectId].modificationDate = object.value[0].value;
+                                            }
+                                            break;      
+                                        
+                                        case baEnum.PropertyIdentifier.PROGRAM_STATE:
+                                            if(object.value[0]){
+                                                values[objectId].programState = that.getPROP_PROGRAM_STATE(object.value[0].value);
+                                            }
+                                            break;
+
+                                        case baEnum.PropertyIdentifier.RECORD_COUNT:
+                                            if(object.value[0] ) {
+                                                values[objectId].recordCount = object.value[0].value;
+                                            }
+                                            break;                                            
                                     }
                                 }
-
                                 if(pointPropertyIndex == successfulResult.values.length - 1 && objectIndex == pointProperty.values.length - 1 && i == fullObjects.length - 1) {
-                                    that.networkTree[device.getAddress()] = values;
+                                    that.networkTree[deviceKey] = values;
                                     resolve(that.networkTree);
                                 } 
                             });
                         } catch(e) {
-                            console.log("issue resolving bacnet payload, see error:  ", e);
+                            that.logOut("issue resolving bacnet payload, see error:  ", e);
                             reject(e);
                         }
                     });
                 } else {
                     //error found in point property
                     if(i == fullObjects.length - 1) {
-                        that.networkTree[device.getAddress()] = values;
+                        that.networkTree[deviceKey] = values;
                         resolve(that.networkTree);
                     }
                 }
             }
-            reject("Unexpectedly found end of loop, line 861");
+            reject("Unexpectedly found end of loop, line 1170");
         });
     }
 
@@ -870,6 +1173,104 @@ class BacnetClient extends EventEmitter {
         return uniquePropArray;
     }
 
+    getPROP_PROGRAM_STATE(value) {
+        switch(value) {
+            case 0:
+                return "0 - Idle";
+            case 1:
+                return "1 - Loading";
+            case 2:
+                return "2 - Running";
+            case 3:
+                return "3 - Waiting";
+            case 4:
+                return "4 - Halted";
+            case 5:
+                return "5 - Unloading";
+            default:
+                return "";
+        }
+    }
+
+    getPROP_SYSTEM_STATUS(value) {
+        switch(value) {
+            case 0:
+                return "0 - Operational";
+            case 1:
+                return "1 - Operational Readonly";
+            case 2:
+                return "2 - Download Required";
+            case 3:
+                return "3 - Download In Progress";
+            case 4:
+                return "4 - Non Operational";
+            case 5:
+                return "5 - Backup In Progress";
+            default:
+                return "";
+        }
+    }
+
+    getPointIcon(objectId) {
+        switch(objectId) {
+            case 0:
+                //AI
+                return "pi pi-tags";
+            case 1:
+                //AO
+                return "pi pi-tags";
+            case 2:
+                //AV
+                return "pi pi-tags";
+            case 3: 
+                //BI
+                return "pi pi-tags";
+            case 4:
+                //BO
+                return "pi pi-tags";
+            case 5:
+                //BV
+                return "pi pi-tags";
+            case 8:
+                //Device
+                return "pi pi-box";
+            case 13: 
+                //MI
+                return "pi pi-tags";
+            case 14:
+                //MO
+                return "pi pi-tags";
+            case 19:
+                //MV
+                return "pi pi-tags";
+            case 10:
+                //File
+                return "pi pi-file";
+            case 16:
+                //Program
+                return "pi pi-database";
+            case 20:
+                //Trendlog
+                return "pi pi-chart-line";
+            case 15:
+                //Notification Class
+                return "pi pi-bell";
+            case 56:
+                return "pi pi-sitemap";
+            case 178:
+                return "pi pi-lock";
+            case 20:
+                return "pi pi-chart-line";        
+            case 17:
+                return "pi pi-calendar";
+            case 6:
+                return "pi pi-calendar";
+            default:
+                //Return circle for all other types
+                return "pi pi-tags";
+        }
+    }
+
     getObjectType(objectId) {
         switch(objectId) {
             case 0:
@@ -892,6 +1293,8 @@ class BacnetClient extends EventEmitter {
                 return "MO";
             case 19:
                 return "MV";
+            case 40:
+                return "CS";
             default: 
                 return "";
         }
@@ -935,6 +1338,20 @@ class BacnetClient extends EventEmitter {
     getStatusFlags(flags) {
         return flags.value[0].value;
     }
+
+    getDeviceIcon(isMstp, manualDiscoveryMode) {
+        if(manualDiscoveryMode == true) {
+            return "pi pi-exclamation-triangle"
+        } else if(manualDiscoveryMode == false) {
+            if(isMstp == true) {
+                return "pi pi-share-alt"
+            } else if(isMstp == false) {
+               return "pi pi-server"
+            }
+        }
+
+        return "pi pi-server";
+    };
 }
 
 module.exports = { BacnetClient };