iobroker.device-watcher 2.0.3 → 2.2.0

package/main.js

@@ -10,7 +10,7 @@ const schedule = require('node-schedule');
 const arrApart = require('./lib/arrApart.js'); // list of supported adapters
 
 // Sentry error reporting, disable when testing code!
-const enableSendSentry = true;
+const enableSendSentry = false;
 
 // indicator if the adapter is running or not (for intervall/shedule)
 let isUnloaded = false;
@@ -33,23 +33,20 @@ class DeviceWatcher extends utils.Adapter {
 		this.blacklistNotify = [];
 		this.arrDev = [];
 		this.adapterSelected = [];
+		this.upgradableList = [];
 
 		// raw arrays
 		this.listAllDevicesRaw = [];
 		this.batteryLowPoweredRaw = [];
 		this.offlineDevicesRaw = [];
 
-		// raw counts
-		this.offlineDevicesCountRaw = 0;
-		this.offlineDevicesCountRawOld = 0;
-		this.lowBatteryPoweredCountRaw = 0;
-
 		// counts
 		this.offlineDevicesCount = 0;
 		this.deviceCounter = 0;
 		this.linkQualityCount = 0;
 		this.batteryPoweredCount = 0;
 		this.lowBatteryPoweredCount = 0;
+		this.upgradableDevicesCount = 0;
 
 		// Interval timer
 		this.refreshDataTimeout = null;
@@ -74,6 +71,7 @@ class DeviceWatcher extends utils.Adapter {
 
 			this.supAdapter = {
 				alexa2: this.config.alexa2Devices,
+				apcups: this.config.apcupsDevices,
 				ble: this.config.bleDevices,
 				deconz: this.config.deconzDevices,
 				enocean: this.config.enoceanDevices,
@@ -94,6 +92,9 @@ class DeviceWatcher extends utils.Adapter {
 				mihome: this.config.mihomeDevices,
 				mihomeGW: this.config.mihomeDevices,
 				mihomeVacuum: this.config.mihomeVacuumDevices,
+				mqttClientZigbee2Mqtt: this.config.mqttClientZigbee2MqttDevices,
+				mqttNuki: this.config.mqttNukiDevices,
+				musiccast: this.config.musiccastDevices,
 				netatmo: this.config.netatmoDevices,
 				nukiExt: this.config.nukiExtDevices,
 				nut: this.config.nutDevices,
@@ -117,6 +118,7 @@ class DeviceWatcher extends utils.Adapter {
 
 			this.maxMinutes = {
 				alexa2: this.config.alexa2MaxMinutes,
+				apcups: this.config.apcupsMaxMinutes,
 				ble: this.config.bleMaxMinutes,
 				deconz: this.config.deconzMaxMinutes,
 				enocean: this.config.enoceanMaxMinutes,
@@ -137,6 +139,9 @@ class DeviceWatcher extends utils.Adapter {
 				mihome: this.config.mihomeMaxMinutes,
 				mihomeGW: this.config.mihomeMaxMinutes,
 				mihomeVacuum: this.config.mihomeVacuumMaxMinutes,
+				mqttClientZigbee2Mqtt: this.config.mqttClientZigbee2MqttMaxMinutes,
+				mqttNuki: this.config.mqttNukiMaxMinutes,
+				musiccast: this.config.musiccastMaxMinutes,
 				netatmo: this.config.netatmoMaxMinutes,
 				nukiExt: this.config.nukiextendMaxMinutes,
 				nut: this.config.nutMaxMinutes,
@@ -188,35 +193,41 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			//create and fill datapoints for each adapter if selected
-			try {
-				for (const [id] of Object.entries(arrApart)) {
-					if (!isUnloaded) {
-						if (this.supAdapter !== undefined && this.supAdapter[id]) {
-							if (this.config.createOwnFolder) {
+			if (this.config.createOwnFolder) {
+				try {
+					for (const [id] of Object.entries(arrApart)) {
+						if (!isUnloaded) {
+							if (this.supAdapter !== undefined && this.supAdapter[id]) {
 								await this.createDPsForEachAdapter(id);
 								if (this.config.createHtmlList) await this.createHtmlListDatapoints(id);
-								this.log.debug(`Created datapoints for ${await this.capitalize(id)}`);
+								this.log.debug(`Created datapoints for ${this.capitalize(id)}`);
 							}
+						} else {
+							return; // cancel run if unloaded was called.
 						}
-					} else {
-						return; // cancel run if unloaded was called.
 					}
+				} catch (error) {
+					this.errorReporting('[onReady - create and fill datapoints for each adapter]', error);
 				}
-			} catch (error) {
-				this.errorReporting('[onReady - create and fill datapoints for each adapter]', error);
 			}
 
 			// create HTML list
 			if (this.config.createHtmlList) await this.createHtmlListDatapoints();
 
-			// update data in interval
+			//read data first at start
+			await this.main();
+
+			// update last contact data in interval
 			await this.refreshData();
 
 			// send overview for low battery devices
-			if (this.config.checkSendBatteryMsg) await this.sendBatteryNotifyShedule();
+			if (this.config.checkSendBatteryMsgDaily) await this.sendBatteryNotifyShedule();
 
 			// send overview of offline devices
 			if (this.config.checkSendOfflineMsgDaily) await this.sendOfflineNotificationsShedule();
+
+			// send overview of upgradeable devices
+			if (this.config.checkSendUpgradeMsgDaily) await this.sendUpgradeNotificationsShedule();
 		} catch (error) {
 			this.errorReporting('[onReady]', error);
 			this.terminate ? this.terminate(15) : process.exit(15);
@@ -228,13 +239,106 @@ class DeviceWatcher extends utils.Adapter {
 	 * @param {string} id
 	 * @param {ioBroker.State | null | undefined} state
 	 */
-	onStateChange(id, state) {
-		if (state) {
-			// The state was changed
-			this.log.warn(`state ${id} changed: ${state.val} (ack = ${state.ack})`);
-		} else {
-			// The state was deleted
-			this.log.warn(`state ${id} deleted`);
+	async onStateChange(id, state) {
+		// Admin JSON for Adapter updates
+		if (id && state) {
+			this.log.debug(`State changed: ${id} changed ${state.val}`);
+			let batteryData;
+			let oldLowBatState;
+			let contactData;
+			let oldStatus;
+			let oldSignalStrength;
+
+			for (const i of this.listAllDevicesRaw) {
+				// On statechange update available datapoint
+				switch (id) {
+					case i.UpdateDP:
+						if (state.val) {
+							i.Upgradable = state.val;
+
+							await this.createLists();
+
+							await this.writeDatapoints();
+							await this.sendDeviceUpdatesNotification(i.Device, i.Adapter, i.Path);
+						}
+						break;
+
+					case i.SignalStrengthDP:
+						oldSignalStrength = i.SignalStrength;
+						i.SignalStrength = await this.calculateSignalStrength(state, i.adapterID);
+						if (oldSignalStrength !== i.SignalStrength) {
+							await this.createLists();
+
+							await this.writeDatapoints();
+						}
+						break;
+
+					case i.batteryDP:
+						oldLowBatState = i.LowBat;
+						batteryData = await this.getBatteryData(state.val, oldLowBatState, i.adapterID);
+
+						i.Battery = batteryData[0];
+						i.BatteryRaw = batteryData[2];
+						i.LowBat = await this.setLowbatIndicator(state.val, undefined, i.LowBatDP);
+
+						if (i.LowBat && oldLowBatState !== i.LowBat) {
+							await this.createLists();
+
+							await this.writeDatapoints();
+							if (this.config.checkSendBatteryMsg) {
+								await this.sendLowBatNoticiation(i.Device, i.Adapter, i.Battery, i.Path);
+							}
+						} else if (!i.LowBat && oldLowBatState !== i.LowBat) {
+							await this.createLists();
+
+							await this.writeDatapoints();
+						}
+						break;
+
+					case i.LowBatDP:
+						oldLowBatState = i.LowBat;
+						batteryData = await this.getBatteryData(i.BatteryRaw, state.val, i.adapterID);
+						i.Battery = batteryData[0];
+						i.BatteryRaw = batteryData[2];
+						i.LowBat = await this.setLowbatIndicator(i.BatteryRaw, state.val, i.LowBatDP);
+
+						if (i.LowBat && oldLowBatState !== i.LowBat) {
+							await this.createLists();
+
+							await this.writeDatapoints();
+							if (this.config.checkSendBatteryMsg) {
+								await this.sendLowBatNoticiation(i.Device, i.Adapter, i.Battery, i.Path);
+							}
+						} else if (!i.LowBat && oldLowBatState !== i.LowBat) {
+							await this.createLists();
+
+							await this.writeDatapoints();
+						}
+						break;
+					case i.UnreachDP:
+					case i.DeviceStateSelectorDP:
+					case i.rssiPeerSelectorDP:
+					case i.Path:
+						oldStatus = i.Status;
+						i.UnreachState = await this.getInitValue(i.UnreachDP);
+						contactData = await this.getOnlineState(i.Path, i.adapterID, i.UnreachDP, i.SignalStrength, i.UnreachState, i.DeviceStateSelectorDP, i.rssiPeerSelectorDP);
+						if (contactData !== undefined) {
+							i.LastContact = contactData[0];
+							i.Status = contactData[1];
+							i.SignalStrength = contactData[2];
+						}
+						if (i.Status !== oldStatus) {
+							await this.createLists();
+
+							await this.writeDatapoints();
+						}
+
+						if (i.Status && oldStatus !== i.Status && this.config.checkSendOfflineMsg) {
+							await this.sendOfflineNotifications(i.Device, i.Adapter, i.Status, i.LastContact, i.Path);
+						}
+						break;
+				}
+			}
 		}
 	}
 
@@ -274,11 +378,12 @@ class DeviceWatcher extends utils.Adapter {
 
 	/**
 	 * refresh data with interval
+	 * is neccessary to refresh lastContact data, especially of devices without state changes
 	 */
 	async refreshData() {
 		const nextTimeout = this.config.updateinterval * 1000;
 
-		await this.main();
+		await this.checkLastContact();
 
 		// Clear existing timeout
 		if (this.refreshDataTimeout) {
@@ -303,25 +408,6 @@ class DeviceWatcher extends utils.Adapter {
 	async main() {
 		this.log.debug(`Function started: ${this.main.name}`);
 
-		// fill datapoints for each adapter if selected
-		try {
-			for (const [id] of Object.entries(arrApart)) {
-				if (!isUnloaded) {
-					if (this.supAdapter !== undefined && this.supAdapter[id]) {
-						if (this.config.createOwnFolder) {
-							await this.createDataForEachAdapter(id);
-							this.log.debug(`Created and filled data for ${await this.capitalize(id)}`);
-						}
-					}
-				} else {
-					this.log.warn('broke up');
-					return; // cancel run if unloaded was called.
-				}
-			}
-		} catch (error) {
-			this.errorReporting('[main - create and fill datapoints for each adapter]', error);
-		}
-
 		// fill counts and lists of all selected adapter
 		try {
 			await this.createDataOfAllAdapter();
@@ -330,6 +416,20 @@ class DeviceWatcher extends utils.Adapter {
 			this.errorReporting('[main - create data of all adapter]', error);
 		}
 
+		// fill datapoints for each adapter if selected
+		if (this.config.createOwnFolder) {
+			try {
+				for (const [id] of Object.entries(arrApart)) {
+					if (this.supAdapter !== undefined && this.supAdapter[id]) {
+						await this.createDataForEachAdapter(id);
+						this.log.debug(`Created and filled data for ${this.capitalize(id)}`);
+					}
+				}
+			} catch (error) {
+				this.errorReporting('[main - create and fill datapoints for each adapter]', error);
+			}
+		}
+
 		this.log.debug(`Function finished: ${this.main.name}`);
 	} //<--End of main function
 
@@ -426,16 +526,22 @@ class DeviceWatcher extends utils.Adapter {
 			const shortDeviceObject = await this.getForeignObjectAsync(shortCurrDeviceString);
 			const shortshortDeviceObject = await this.getForeignObjectAsync(shortshortCurrDeviceString);
 			let deviceName;
+			let folderName;
+			let deviceID;
 
 			// Get ID with currDeviceString from datapoint
 			switch (this.arrDev[i].adapterID) {
 				// Get ID for Switchbot and ESPHome Devices
 				case 'switchbotBle':
 				case 'esphome':
-				case 'fullybrowser':
+				case 'apcups':
 					deviceName = await this.getInitValue(currDeviceString + this.arrDev[i].id);
 					break;
 
+				case 'fullybrowser':
+					deviceName = (await this.getInitValue(currDeviceString + this.arrDev[i].id)) + ' ' + (await this.getInitValue(currDeviceString + this.arrDev[i].id2));
+					break;
+
 				// Get ID with short currDeviceString from objectjson
 				case 'hueExt':
 				case 'hmrpc':
@@ -456,7 +562,9 @@ class DeviceWatcher extends utils.Adapter {
 				// Get ID with short currDeviceString from datapoint
 				case 'mihomeVacuum':
 				case 'roomba':
-					deviceName = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].id);
+					folderName = shortCurrDeviceString.slice(shortCurrDeviceString.lastIndexOf('.') + 1);
+					deviceID = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].id);
+					deviceName = `I${folderName} ${deviceID}`;
 					break;
 
 				//Get ID of foldername
@@ -495,6 +603,163 @@ class DeviceWatcher extends utils.Adapter {
 		}
 	}
 
+	/**
+	 * calculate Signalstrength
+	 * @param {object} deviceQualityState - State value
+	 * @param {object} adapterID - adapter name
+	 */
+	async calculateSignalStrength(deviceQualityState, adapterID) {
+		let linkQuality;
+		let mqttNukiValue;
+
+		if (deviceQualityState != null) {
+			switch (typeof deviceQualityState.val) {
+				case 'number':
+					if (this.config.trueState) {
+						linkQuality = deviceQualityState.val;
+					} else {
+						switch (adapterID) {
+							case 'roomba':
+							case 'sonoff':
+								linkQuality = deviceQualityState.val + '%'; // If quality state is already an percent value
+								break;
+							case 'lupusec':
+								linkQuality = deviceQualityState.val;
+								break;
+
+							default:
+								// If quality state is an RSSI value calculate in percent:
+								if (deviceQualityState.val == -255) {
+									linkQuality = ' - ';
+								} else if (deviceQualityState.val < 0) {
+									linkQuality = Math.min(Math.max(2 * (deviceQualityState.val + 100), 0), 100) + '%';
+									// If Quality State is an value between 0-255 (zigbee) calculate in percent:
+								} else if (deviceQualityState.val >= 0) {
+									linkQuality = parseFloat(((100 / 255) * deviceQualityState.val).toFixed(0)) + '%';
+								}
+								break;
+						}
+					}
+					break;
+
+				case 'string':
+					switch (adapterID) {
+						case 'netatmo':
+							// for Netatmo devices
+							linkQuality = deviceQualityState.val;
+							break;
+						case 'nukiExt':
+							linkQuality = ' - ';
+							break;
+						case 'mqttNuki':
+							linkQuality = deviceQualityState.val;
+							mqttNukiValue = parseInt(linkQuality);
+							if (this.config.trueState) {
+								linkQuality = deviceQualityState.val;
+							} else if (mqttNukiValue < 0) {
+								linkQuality = Math.min(Math.max(2 * (mqttNukiValue + 100), 0), 100) + '%';
+								// If Quality State is an value between 0-255 (zigbee) calculate in percent:
+							}
+					}
+					break;
+			}
+		} else {
+			linkQuality = ' - ';
+		}
+		return linkQuality;
+	}
+
+	/**
+	 * get battery data
+	 * @param {object} deviceBatteryState - State value
+	 * @param {object} deviceLowBatState - State value
+	 * @param {object} adapterID - adapter name
+	 */
+	async getBatteryData(deviceBatteryState, deviceLowBatState, adapterID) {
+		let batteryHealthRaw;
+		let batteryHealth;
+		let isBatteryDevice;
+
+		if (deviceBatteryState === undefined) {
+			if (deviceLowBatState !== undefined) {
+				switch (deviceLowBatState) {
+					case 'none':
+						break;
+					default:
+						if (deviceLowBatState !== true || deviceLowBatState === 'NORMAL' || deviceLowBatState === 1) {
+							batteryHealth = 'ok';
+							isBatteryDevice = true;
+						} else {
+							batteryHealth = 'low';
+							isBatteryDevice = true;
+						}
+						break;
+				}
+			} else {
+				batteryHealth = ' - ';
+			}
+		} else {
+			switch (adapterID) {
+				case 'hmrpc':
+					if (deviceBatteryState === 0 || (deviceBatteryState && deviceBatteryState >= 6)) {
+						batteryHealth = ' - ';
+					} else {
+						batteryHealth = deviceBatteryState + 'V';
+						batteryHealthRaw = deviceBatteryState;
+						isBatteryDevice = true;
+					}
+					break;
+				default:
+					batteryHealth = deviceBatteryState + '%';
+					batteryHealthRaw = deviceBatteryState;
+					isBatteryDevice = true;
+					break;
+			}
+		}
+		return [batteryHealth, isBatteryDevice, batteryHealthRaw];
+	}
+
+	/**
+	 *set low bat indicator
+	 * @param {object} deviceBatteryState
+	 * @param {object} deviceLowBatState
+	 * @param {object} isLowBatDP
+	 */
+
+	async setLowbatIndicator(deviceBatteryState, deviceLowBatState, isLowBatDP) {
+		let lowBatIndicator = false;
+		/*=============================================
+		=            Set Lowbat indicator             =
+		=============================================*/
+		if (deviceLowBatState !== null && isLowBatDP !== 'none') {
+			switch (typeof deviceLowBatState) {
+				case 'number':
+					if (deviceLowBatState === 0) {
+						lowBatIndicator = true;
+					}
+					break;
+
+				case 'string':
+					if (deviceLowBatState !== 'NORMAL') {
+						// Tado devices
+						lowBatIndicator = true;
+					}
+					break;
+
+				case 'boolean':
+					if (deviceLowBatState) {
+						lowBatIndicator = true;
+					}
+					break;
+			}
+		} else {
+			if (deviceBatteryState < this.config.minWarnBatterie) {
+				lowBatIndicator = true;
+			}
+		}
+		return lowBatIndicator;
+	}
+
 	/**
 	 * get Last Contact
 	 * @param {object} selector - Selector
@@ -514,109 +779,167 @@ class DeviceWatcher extends utils.Adapter {
 	}
 
 	/**
-	 * Create Lists
+	 * get online state and time
+	 *
 	 */
-	async createLists() {
-		this.linkQualityDevices = [];
-		this.batteryPowered = [];
-		this.batteryLowPowered = [];
-		this.listAllDevices = [];
-		this.offlineDevices = [];
-		this.batteryLowPoweredRaw = [];
-		this.offlineDevicesRaw = [];
+	async getOnlineState(id, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP) {
+		let lastContactString;
+		let deviceState = 'Online';
 
-		for (const device of this.listAllDevicesRaw) {
-			/*----------  fill raw lists  ----------*/
-			// low bat list
-			if (device['LowBat'] && device['Status'] !== 'Offline') {
-				this.batteryLowPoweredRaw.push({
-					Path: device['Path'],
-					Device: device['Device'],
-					Adapter: device['Adapter'],
-					Battery: device['Battery'],
-				});
-			}
-			// offline raw list
-			if (device['Status'] === 'Offline') {
-				this.offlineDevicesRaw.push({
-					Path: device['Path'],
-					Device: device['Device'],
-					Adapter: device['Adapter'],
-					'Last contact': device['Last contact'],
-				});
-			}
+		try {
+			const deviceMainSelector = await this.getForeignStateAsync(id);
+			if (deviceMainSelector) {
+				const deviceUnreachSelector = await this.getForeignStateAsync(unreachDP);
+				const deviceStateSelector = await this.getForeignStateAsync(deviceStateSelectorDP); // for hmrpc devices
+				const rssiPeerSelector = await this.getForeignStateAsync(rssiPeerSelectorDP);
+				const lastContact = await this.getTimestamp(deviceMainSelector.ts);
+				const lastDeviceUnreachStateChange = deviceUnreachSelector != undefined ? await this.getTimestamp(deviceUnreachSelector.lc) : await this.getTimestamp(deviceMainSelector.ts);
+				//  If there is no contact since user sets minutes add device in offline list
+				// calculate to days after 48 hours
+				switch (unreachDP) {
+					case 'none':
+						lastContactString = await this.getLastContact(deviceMainSelector.ts);
+						break;
 
-			/*----------  fill user lists  ----------*/
-			if (!this.blacklistLists.includes(device['Path'])) {
-				this.listAllDevices.push({
-					Device: device['Device'],
-					Adapter: device['Adapter'],
-					Battery: device['Battery'],
-					'Signal strength': device['Signal strength'],
-					'Last contact': device['Last contact'],
-					Status: device['Status'],
-				});
-				// LinkQuality lists
-				if (device['Signal strength'] != ' - ') {
-					this.linkQualityDevices.push({
-						Device: device['Device'],
-						Adapter: device['Adapter'],
-						'Signal strength': device['Signal strength'],
-					});
-				}
-				// Battery lists
-				if (device['isBatteryDevice']) {
-					this.batteryPowered.push({
-						Device: device['Device'],
-						Adapter: device['Adapter'],
-						Battery: device['Battery'],
-						Status: device['Status'],
-					});
-				}
-				// Low Bat lists
-				if (device['LowBat'] && device['Status'] !== 'Offline') {
-					this.batteryLowPowered.push({
-						Device: device['Device'],
-						Adapter: device['Adapter'],
-						Battery: device['Battery'],
-					});
+					default:
+						//State changed
+						if (adapterID === 'hmrpc') {
+							if (linkQuality !== ' - ') {
+								if (deviceUnreachState) {
+									lastContactString = await this.getLastContact(deviceMainSelector.lc);
+								} else {
+									lastContactString = await this.getLastContact(deviceMainSelector.ts);
+								}
+							} else {
+								if (deviceStateSelector) {
+									// because old hm devices don't send rssi states
+									lastContactString = await this.getLastContact(deviceStateSelector.ts);
+								} else if (rssiPeerSelector) {
+									// because old hm sensors don't send rssi/state values
+									lastContactString = await this.getLastContact(rssiPeerSelector.ts);
+								}
+							}
+						} else {
+							if (!deviceUnreachState) {
+								lastContactString = await this.getLastContact(deviceMainSelector.lc);
+							} else {
+								lastContactString = await this.getLastContact(deviceMainSelector.ts);
+							}
+							break;
+						}
 				}
 
-				// Offline List
-				if (device['Status'] === 'Offline') {
-					this.offlineDevices.push({
-						Device: device['Device'],
-						Adapter: device['Adapter'],
-						'Last contact': device['Last contact'],
-					});
+				/*=============================================
+			=            Set Online Status             =
+			=============================================*/
+				if (this.maxMinutes !== undefined) {
+					switch (adapterID) {
+						case 'hmrpc':
+						case 'hmiP':
+						case 'maxcube':
+							if (this.maxMinutes[adapterID] <= 0) {
+								if (deviceUnreachState) {
+									deviceState = 'Offline'; //set online state to offline
+									linkQuality = '0%'; // set linkQuality to nothing
+								}
+							} else if (lastDeviceUnreachStateChange > this.maxMinutes[adapterID] && deviceUnreachState) {
+								deviceState = 'Offline'; //set online state to offline
+								linkQuality = '0%'; // set linkQuality to nothing
+							}
+							break;
+						case 'apcups':
+						case 'hue':
+						case 'hueExt':
+						case 'ping':
+						case 'deconz':
+						case 'shelly':
+						case 'sonoff':
+						case 'unifi':
+						case 'zigbee':
+						case 'zigbee2MQTT':
+							if (this.maxMinutes[adapterID] <= 0) {
+								if (!deviceUnreachState) {
+									deviceState = 'Offline'; //set online state to offline
+									linkQuality = '0%'; // set linkQuality to nothing
+								}
+							} else if (!deviceUnreachState && lastDeviceUnreachStateChange > this.maxMinutes[adapterID]) {
+								deviceState = 'Offline'; //set online state to offline
+								linkQuality = '0%'; // set linkQuality to nothing
+							}
+							break;
+						case 'mqttClientZigbee2Mqtt':
+							if (this.maxMinutes[adapterID] <= 0) {
+								if (deviceUnreachState !== 'online') {
+									deviceState = 'Offline'; //set online state to offline
+									linkQuality = '0%'; // set linkQuality to nothing
+								}
+							} else if (deviceUnreachState !== 'online' && lastDeviceUnreachStateChange > this.maxMinutes[adapterID]) {
+								deviceState = 'Offline'; //set online state to offline
+								linkQuality = '0%'; // set linkQuality to nothing
+							}
+							break;
+						case 'mihome':
+							if (deviceUnreachState !== undefined) {
+								if (this.maxMinutes[adapterID] <= 0) {
+									if (!deviceUnreachState) {
+										deviceState = 'Offline'; //set online state to offline
+										linkQuality = '0%'; // set linkQuality to nothing
+									}
+								} else if (lastContact > this.maxMinutes[adapterID]) {
+									deviceState = 'Offline'; //set online state to offline
+									linkQuality = '0%'; // set linkQuality to nothing
+								}
+							} else {
+								if (this.config.mihomeMaxMinutes <= 0) {
+									if (this.maxMinutes[adapterID] <= 0) {
+										deviceState = 'Offline'; //set online state to offline
+										linkQuality = '0%'; // set linkQuality to nothing
+									}
+								} else if (lastContact > this.maxMinutes[adapterID]) {
+									deviceState = 'Offline'; //set online state to offline
+									linkQuality = '0%'; // set linkQuality to nothing
+								}
+							}
+							break;
+						default:
+							if (this.maxMinutes[adapterID] <= 0) {
+								if (!deviceUnreachState) {
+									deviceState = 'Offline'; //set online state to offline
+									linkQuality = '0%'; // set linkQuality to nothing
+								}
+							} else if (lastContact > this.maxMinutes[adapterID]) {
+								deviceState = 'Offline'; //set online state to offline
+								linkQuality = '0%'; // set linkQuality to nothing
+							}
+							break;
+					}
 				}
 			}
+			return [lastContactString, deviceState, linkQuality];
+		} catch (error) {
+			this.errorReporting('[getLastContact]', error);
 		}
 	}
 
 	/**
-	 * Count devices for each type
+	 * when was last contact of device
 	 */
-	async countDevices() {
-		// Count how many devices with link Quality
-		this.linkQualityCount = this.linkQualityDevices.length;
-
-		// Count how many devcies are offline
-		this.offlineDevicesCount = this.offlineDevices.length;
-
-		// Count how many devices are with battery
-		this.batteryPoweredCount = this.batteryPowered.length;
-
-		// 3d. Count how many devices are with low battery
-		this.lowBatteryPoweredCount = this.batteryLowPowered.length;
-
-		// Count how many devices are exists
-		this.deviceCounter = this.listAllDevices.length;
-
-		// raws
-
-		// Count how many devcies are offline
-		this.offlineDevicesCountRaw = this.offlineDevicesRaw.length;
+	async checkLastContact() {
+		for (const i of this.listAllDevicesRaw) {
+			const oldContactState = i.Status;
+			i.UnreachState = await this.getInitValue(i.UnreachDP);
+			const contactData = await this.getOnlineState(i.Path, i.adapterID, i.UnreachDP, i.SignalStrength, i.UnreachState, i.DeviceStateSelectorDP, i.rssiPeerSelectorDP);
+			if (contactData !== undefined) {
+				i.LastContact = contactData[0];
+				i.Status = contactData[1];
+				i.linkQuality = contactData[2];
+			}
+			if (oldContactState !== i.Status) {
+				await this.sendOfflineNotifications(i.Device, i.Adapter, i.Status, i.LastContact, i.Path);
+			}
+		}
+		await this.createLists();
+		await this.writeDatapoints();
 	}
 
 	/**
@@ -648,327 +971,127 @@ class DeviceWatcher extends utils.Adapter {
 				/*=============================================
 				=            Get signal strength              =
 				=============================================*/
+				let deviceQualityDP = currDeviceString + this.arrDev[i].rssiState;
 				let deviceQualityState;
-				let linkQuality;
 
 				switch (adapterID) {
 					case 'mihomeVacuum':
-						deviceQualityState = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].rssiState);
+						deviceQualityDP = shortCurrDeviceString + this.arrDev[i].rssiState;
+						deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
 						break;
 
 					case 'netatmo':
-						deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiState);
+						deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
 						if (!deviceQualityState) {
-							deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rfState);
+							deviceQualityDP = currDeviceString + this.arrDev[i].rfState;
+							deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
 						}
 						break;
 
 					default:
-						deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiState);
+						deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
 						break;
 				}
+				//subscribe to states
+				this.subscribeForeignStatesAsync(deviceQualityDP);
 
-				if (deviceQualityState != null) {
-					switch (typeof deviceQualityState.val) {
-						case 'number':
-							if (this.config.trueState) {
-								linkQuality = deviceQualityState.val;
-							} else {
-								switch (adapterID) {
-									case 'roomba':
-									case 'sonoff':
-										linkQuality = deviceQualityState.val + '%'; // If quality state is already an percent value
-										break;
-									case 'lupusec':
-										linkQuality = deviceQualityState.val;
-										break;
-
-									default:
-										// If quality state is an RSSI value calculate in percent:
-										if (deviceQualityState.val == -255) {
-											linkQuality = ' - ';
-										} else if (deviceQualityState.val < 0) {
-											linkQuality = Math.min(Math.max(2 * (deviceQualityState.val + 100), 0), 100) + '%';
-											// If Quality State is an value between 0-255 (zigbee) calculate in percent:
-										} else if (deviceQualityState.val >= 0) {
-											linkQuality = parseFloat(((100 / 255) * deviceQualityState.val).toFixed(0)) + '%';
-										}
-										break;
-								}
-							}
-							break;
-
-						case 'string':
-							switch (adapterID) {
-								case 'netatmo':
-									// for Netatmo devices
-									linkQuality = deviceQualityState.val;
-									break;
-								case 'nukiExt':
-									linkQuality = ' - ';
-									break;
-							}
-							break;
-					}
-				} else {
-					linkQuality = ' - ';
-				}
+				let linkQuality = await this.calculateSignalStrength(deviceQualityState, adapterID);
 
 				/*=============================================
 				=         	    Get battery data       	      =
 				=============================================*/
-				let batteryHealth;
-				let lowBatIndicator;
-				let isBatteryDevice;
-
+				let deviceBatteryStateDP;
+				let deviceBatteryState;
 				// Get battery states
-				let deviceBatteryState = await this.getInitValue(currDeviceString + this.arrDev[i].battery);
-				if (deviceBatteryState === undefined) {
-					deviceBatteryState = await this.getInitValue(currDeviceString + this.arrDev[i].battery2);
-				}
-
-				// Get battery states with short path
-				let shortDeviceBatteryState = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].battery);
-				if (shortDeviceBatteryState === undefined) {
-					shortDeviceBatteryState = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].battery2);
-				}
-
-				// Get low bat states
-				let deviceLowBatState = await this.getInitValue(currDeviceString + this.arrDev[i].isLowBat);
-				if (deviceLowBatState === undefined) {
-					deviceLowBatState = await this.getInitValue(currDeviceString + this.arrDev[i].isLowBat2);
-				}
-
-				if (!deviceBatteryState && !shortDeviceBatteryState) {
-					if (deviceLowBatState !== undefined) {
-						switch (this.arrDev[i].isLowBat || this.arrDev[i].isLowBat2) {
-							case 'none':
-								batteryHealth = ' - ';
-								break;
-							default:
-								if (deviceLowBatState === false || deviceLowBatState === 'NORMAL' || deviceLowBatState === 1) {
-									batteryHealth = 'ok';
-									isBatteryDevice = true;
-								} else {
-									batteryHealth = 'low';
-									isBatteryDevice = true;
-								}
-								break;
-						}
-					} else {
-						batteryHealth = ' - ';
-					}
-				} else {
-					switch (adapterID) {
-						case 'hmrpc':
-							if (deviceBatteryState === 0 || (deviceBatteryState && deviceBatteryState >= 6)) {
-								batteryHealth = ' - ';
-							} else {
-								batteryHealth = deviceBatteryState + 'V';
-								isBatteryDevice = true;
-							}
-							break;
-
-						case 'hueExt':
-						case 'mihomeVacuum':
-							if (shortDeviceBatteryState) {
-								batteryHealth = shortDeviceBatteryState + '%';
-								isBatteryDevice = true;
-							}
-							break;
-
-						default:
-							batteryHealth = deviceBatteryState + '%';
-							isBatteryDevice = true;
-					}
-				}
-
-				/*=============================================
-				=            Set Lowbat indicator             =
-				=============================================*/
-				switch (typeof deviceLowBatState) {
-					case 'number':
-						if (deviceLowBatState === 0) {
-							lowBatIndicator = true;
-						}
-						break;
-
-					case 'string':
-						if (deviceLowBatState !== 'NORMAL') {
-							// Tado devices
-							lowBatIndicator = true;
-						}
-						break;
-
-					case 'boolean':
-						if (deviceLowBatState) {
-							lowBatIndicator = true;
+				switch (adapterID) {
+					case 'hueExt':
+					case 'mihomeVacuum':
+					case 'mqttNuki':
+						deviceBatteryStateDP = shortCurrDeviceString + this.arrDev[i].battery;
+						deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
+						if (deviceBatteryState === undefined) {
+							deviceBatteryStateDP = shortCurrDeviceString + this.arrDev[i].battery2;
+							deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
 						}
 						break;
-
-					default: // if the battery state is under the set limit
-						if (deviceBatteryState && deviceBatteryState < this.config.minWarnBatterie) {
-							lowBatIndicator = true;
+					default:
+						deviceBatteryStateDP = currDeviceString + this.arrDev[i].battery;
+						deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
+						if (deviceBatteryState === undefined) {
+							deviceBatteryStateDP = currDeviceString + this.arrDev[i].battery2;
+							deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
 						}
 						break;
 				}
 
-				/*=============================================
-				=          Get last contact of device         =
-				=============================================*/
-				let lastContactString;
-				let deviceState = 'Online';
-
-				const deviceMainSelector = await this.getForeignStateAsync(id);
-				const deviceUnreachSelector = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].reach);
-				const deviceStateSelector = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].stateValue); // for hmrpc devices
-				const rssiPeerSelector = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiPeerState);
-
-				if (deviceMainSelector) {
-					try {
-						const lastContact = await this.getTimestamp(deviceMainSelector.ts);
-						const deviceUnreachState = await this.getInitValue(currDeviceString + this.arrDev[i].reach);
-						const lastDeviceUnreachStateChange = deviceUnreachSelector != undefined ? await this.getTimestamp(deviceUnreachSelector.lc) : await this.getTimestamp(deviceMainSelector.ts);
-						const shortDeviceUnreachState = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].reach);
-
-						//  If there is no contact since user sets minutes add device in offline list
-						// calculate to days after 48 hours
-						switch (this.arrDev[i].reach) {
-							case 'none':
-								lastContactString = await this.getLastContact(deviceMainSelector.ts);
-								break;
+				// Get low bat states
+				let isLowBatDP = currDeviceString + this.arrDev[i].isLowBat;
+				let deviceLowBatState = await this.getInitValue(isLowBatDP);
+				if (deviceLowBatState === undefined) {
+					isLowBatDP = currDeviceString + this.arrDev[i].isLowBat2;
+					deviceLowBatState = await this.getInitValue(isLowBatDP);
+				}
+				if (deviceLowBatState === undefined) isLowBatDP = 'none';
 
-							default:
-								//State changed
-								if (adapterID === 'hmrpc') {
-									if (linkQuality !== ' - ') {
-										if (deviceUnreachState) {
-											lastContactString = await this.getLastContact(deviceMainSelector.lc);
-										} else {
-											lastContactString = await this.getLastContact(deviceMainSelector.ts);
-										}
-									} else {
-										if (deviceStateSelector) {
-											// because old hm devices don't send rssi states
-											lastContactString = await this.getLastContact(deviceStateSelector.ts);
-										} else if (rssiPeerSelector) {
-											// because old hm sensors don't send rssi/state values
-											lastContactString = await this.getLastContact(rssiPeerSelector.ts);
-										}
-									}
-								} else {
-									if (!deviceUnreachState) {
-										lastContactString = await this.getLastContact(deviceMainSelector.lc);
-									} else {
-										lastContactString = await this.getLastContact(deviceMainSelector.ts);
-									}
-									break;
-								}
-						}
+				//subscribe to states
+				this.subscribeForeignStatesAsync(deviceBatteryStateDP);
+				this.subscribeForeignStatesAsync(isLowBatDP);
 
-						/*=============================================
-						=            Set Online Status             =
-						=============================================*/
-						if (this.maxMinutes !== undefined) {
-							switch (adapterID) {
-								case 'hmrpc':
-								case 'hmiP':
-								case 'maxcube':
-									if (this.maxMinutes[adapterID] <= 0) {
-										if (deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											linkQuality = '0%'; // set linkQuality to nothing
-										}
-									} else if (lastDeviceUnreachStateChange > this.maxMinutes[adapterID] && deviceUnreachState) {
-										deviceState = 'Offline'; //set online state to offline
-										linkQuality = '0%'; // set linkQuality to nothing
-									}
-									break;
-								case 'ping':
-								case 'deconz':
-									if (this.maxMinutes[adapterID] <= 0) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											linkQuality = '0%'; // set linkQuality to nothing
-										}
-									} else if (lastDeviceUnreachStateChange > this.maxMinutes[adapterID] && !deviceUnreachState) {
-										deviceState = 'Offline'; //set online state to offline
-										linkQuality = '0%'; // set linkQuality to nothing
-									}
-									break;
-								case 'unifi':
-									if (this.maxMinutes[adapterID] <= 0) {
-										if (deviceUnreachState === 0) {
-											deviceState = 'Offline'; //set online state to offline
-											linkQuality = '0%'; // set linkQuality to nothing
-										}
-									} else if (this.maxMinutes !== undefined && lastContact > this.maxMinutes[adapterID]) {
-										deviceState = 'Offline'; //set online state to offline
-										linkQuality = '0%'; // set linkQuality to nothing
-									}
-									break;
-								case 'shelly':
-								case 'sonoff':
-									if (this.maxMinutes[adapterID] <= 0) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											linkQuality = '0%'; // set linkQuality to nothing
-										}
-									} else if (!deviceUnreachState && lastDeviceUnreachStateChange > this.maxMinutes[adapterID]) {
-										deviceState = 'Offline'; //set online state to offline
-										linkQuality = '0%'; // set linkQuality to nothing
-									}
-									break;
-								case 'mihomeVacuum':
-									if (this.maxMinutes[adapterID] <= 0) {
-										if (!shortDeviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											linkQuality = '0%'; // set linkQuality to nothing
-										}
-									} else if (lastContact > this.maxMinutes[adapterID]) {
-										deviceState = 'Offline'; //set online state to offline
-										linkQuality = '0%'; // set linkQuality to nothing
-									}
-									break;
-								case 'mihome':
-									if (this.arrDev[i].battery === 'none') {
-										if (this.maxMinutes[adapterID] <= 0) {
-											if (!deviceUnreachState) {
-												deviceState = 'Offline'; //set online state to offline
-												linkQuality = '0%'; // set linkQuality to nothing
-											}
-										} else if (lastContact > this.maxMinutes[adapterID]) {
-											deviceState = 'Offline'; //set online state to offline
-											linkQuality = '0%'; // set linkQuality to nothing
-										}
-									} else {
-										if (this.config.mihomeMaxMinutes <= 0) {
-											if (this.maxMinutes[adapterID] <= 0) {
-												deviceState = 'Offline'; //set online state to offline
-												linkQuality = '0%'; // set linkQuality to nothing
-											}
-										} else if (lastContact > this.maxMinutes[adapterID]) {
-											deviceState = 'Offline'; //set online state to offline
-											linkQuality = '0%'; // set linkQuality to nothing
-										}
-									}
-									break;
-								default:
-									if (this.maxMinutes[adapterID] <= 0) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											linkQuality = '0%'; // set linkQuality to nothing
-										}
-									} else if (lastContact > this.maxMinutes[adapterID]) {
-										deviceState = 'Offline'; //set online state to offline
-										linkQuality = '0%'; // set linkQuality to nothing
-									}
-									break;
-							}
-						}
-					} catch (error) {
-						this.errorReporting('[getLastContact]', error);
+				const batteryData = await this.getBatteryData(deviceBatteryState, deviceLowBatState, adapterID);
+				const batteryHealth = batteryData[0];
+				const batteryHealthRaw = batteryData[2];
+				const isBatteryDevice = batteryData[1];
+				let lowBatIndicator;
+
+				if (isBatteryDevice) {
+					lowBatIndicator = await this.setLowbatIndicator(deviceBatteryState, deviceLowBatState, isLowBatDP);
+				}
+
+				/*=============================================
+				=          Get last contact of device         =
+				=============================================*/
+				let unreachDP = currDeviceString + this.arrDev[i].reach;
+				const deviceStateSelectorDP = shortCurrDeviceString + this.arrDev[i].stateValue;
+				const rssiPeerSelectorDP = currDeviceString + this.arrDev[i].rssiPeerState;
+
+				let deviceUnreachState = await this.getInitValue(unreachDP);
+				if (deviceUnreachState === undefined) {
+					unreachDP = shortCurrDeviceString + this.arrDev[i].reach;
+					deviceUnreachState = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].reach);
+				}
+
+				// subscribe to states
+				this.subscribeForeignStatesAsync(id);
+				this.subscribeForeignStatesAsync(unreachDP);
+				this.subscribeForeignStatesAsync(deviceStateSelectorDP);
+				this.subscribeForeignStatesAsync(rssiPeerSelectorDP);
+
+				const onlineState = await this.getOnlineState(id, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP);
+				let deviceState;
+				let lastContactString;
+
+				if (onlineState) {
+					lastContactString = onlineState[0];
+					deviceState = onlineState[1];
+					linkQuality = onlineState[2];
+				}
+
+				/*=============================================
+				=            Get update data	              =
+				=============================================*/
+				const deviceUpdateDP = currDeviceString + this.arrDev[i].upgrade;
+				let isUpgradable;
+
+				if (this.config.checkSendDeviceUpgrade) {
+					const deviceUpdateSelector = await this.getInitValue(deviceUpdateDP);
+
+					if (deviceUpdateSelector) {
+						isUpgradable = true;
+					} else if (!deviceUpdateSelector) {
+						isUpgradable = false;
 					}
+					// subscribe to states
+					this.subscribeForeignStatesAsync(deviceUpdateDP);
 				}
 
 				/*=============================================
@@ -976,32 +1099,52 @@ class DeviceWatcher extends utils.Adapter {
 				=============================================*/
 
 				/* Add only devices with battery in the rawlist */
-				if (this.listOnlyBattery) {
-					if (isBatteryDevice) {
-						this.listAllDevicesRaw.push({
-							Path: id,
-							Device: deviceName,
-							Adapter: adapter,
-							isBatteryDevice: isBatteryDevice,
-							Battery: batteryHealth,
-							LowBat: lowBatIndicator,
-							'Signal strength': linkQuality,
-							'Last contact': lastContactString,
-							Status: deviceState,
-						});
-					}
+				if (this.listOnlyBattery && isBatteryDevice) {
+					this.listAllDevicesRaw.push({
+						Path: id,
+						Device: deviceName,
+						adapterID: adapterID,
+						Adapter: adapter,
+						isBatteryDevice: isBatteryDevice,
+						Battery: batteryHealth,
+						BatteryRaw: batteryHealthRaw,
+						batteryDP: deviceBatteryStateDP,
+						LowBat: lowBatIndicator,
+						LowBatDP: isLowBatDP,
+						SignalStrengthDP: deviceQualityDP,
+						SignalStrength: linkQuality,
+						UnreachState: deviceUnreachState,
+						UnreachDP: unreachDP,
+						DeviceStateSelectorDP: deviceStateSelectorDP,
+						rssiPeerSelectorDP: rssiPeerSelectorDP,
+						LastContact: lastContactString,
+						Status: deviceState,
+						UpdateDP: deviceUpdateDP,
+						Upgradable: isUpgradable,
+					});
 				} else {
 					/* Add all devices */
 					this.listAllDevicesRaw.push({
 						Path: id,
 						Device: deviceName,
+						adapterID: adapterID,
 						Adapter: adapter,
 						isBatteryDevice: isBatteryDevice,
 						Battery: batteryHealth,
+						BatteryRaw: batteryHealthRaw,
+						batteryDP: deviceBatteryStateDP,
 						LowBat: lowBatIndicator,
-						'Signal strength': linkQuality,
-						'Last contact': lastContactString,
+						LowBatDP: isLowBatDP,
+						SignalStrengthDP: deviceQualityDP,
+						SignalStrength: linkQuality,
+						UnreachState: deviceUnreachState,
+						UnreachDP: unreachDP,
+						DeviceStateSelectorDP: deviceStateSelectorDP,
+						rssiPeerSelectorDP: rssiPeerSelectorDP,
+						LastContact: lastContactString,
 						Status: deviceState,
+						UpdateDP: deviceUpdateDP,
+						Upgradable: isUpgradable,
 					});
 				}
 			} else {
@@ -1010,9 +1153,127 @@ class DeviceWatcher extends utils.Adapter {
 			}
 		} // <-- end of loop
 		await this.createLists();
-		await this.countDevices();
 	} // <-- end of createData
 
+	/**
+	 * Create Lists
+	 */
+	async createLists() {
+		this.linkQualityDevices = [];
+		this.batteryPowered = [];
+		this.batteryLowPowered = [];
+		this.listAllDevices = [];
+		this.offlineDevices = [];
+		this.batteryLowPoweredRaw = [];
+		this.offlineDevicesRaw = [];
+		this.upgradableList = [];
+
+		for (const device of this.listAllDevicesRaw) {
+			/*----------  fill raw lists  ----------*/
+			// low bat list
+			if (device.LowBat && device.Status !== 'Offline') {
+				this.batteryLowPoweredRaw.push({
+					Path: device.Path,
+					Device: device.Device,
+					Adapter: device.Adapter,
+					Battery: device.Battery,
+				});
+			}
+			// offline raw list
+			if (device.Status === 'Offline') {
+				this.offlineDevicesRaw.push({
+					Path: device.Path,
+					Device: device.Device,
+					Adapter: device.Adapter,
+					'Last contact': device.LastContact,
+				});
+			}
+
+			/*----------  fill user lists  ----------*/
+			if (!this.blacklistLists.includes(device.Path)) {
+				this.listAllDevices.push({
+					Device: device.Device,
+					Adapter: device.Adapter,
+					Battery: device.Battery,
+					'Signal strength': device.SignalStrength,
+					'Last contact': device.LastContact,
+					Status: device.Status,
+				});
+				// LinkQuality lists
+				if (device.SignalStrength != ' - ') {
+					this.linkQualityDevices.push({
+						Device: device.Device,
+						Adapter: device.Adapter,
+						'Signal strength': device.SignalStrength,
+					});
+				}
+				// Battery lists
+				if (device['isBatteryDevice']) {
+					this.batteryPowered.push({
+						Device: device.Device,
+						Adapter: device.Adapter,
+						Battery: device.Battery,
+						Status: device.Status,
+					});
+				}
+				// Low Bat lists
+				if (device.LowBat && device.Status !== 'Offline') {
+					this.batteryLowPowered.push({
+						Device: device.Device,
+						Adapter: device.Adapter,
+						Battery: device.Battery,
+					});
+				}
+
+				// Offline List
+				if (device.Status === 'Offline') {
+					this.offlineDevices.push({
+						Device: device.Device,
+						Adapter: device.Adapter,
+						'Last contact': device.LastContact,
+					});
+				}
+
+				// Device update List
+				if (device.Upgradable) {
+					this.upgradableList.push({
+						Device: device.Device,
+						Adapter: device.Adapter,
+					});
+				}
+			}
+		}
+		await this.countDevices();
+	}
+
+	/**
+	 * Count devices for each type
+	 */
+	async countDevices() {
+		// Count how many devices with link Quality
+		this.linkQualityCount = this.linkQualityDevices.length;
+
+		// Count how many devcies are offline
+		this.offlineDevicesCount = this.offlineDevices.length;
+
+		// Count how many devices are with battery
+		this.batteryPoweredCount = this.batteryPowered.length;
+
+		// 3d. Count how many devices are with low battery
+		this.lowBatteryPoweredCount = this.batteryLowPowered.length;
+
+		// Count how many devices are exists
+		this.deviceCounter = this.listAllDevices.length;
+
+		// Count how many devices has update available
+		this.upgradableDevicesCount = this.upgradableList.length;
+
+		// raws
+
+		// Count how many devcies are offline
+		this.offlineDevicesCountRaw = this.offlineDevicesRaw.length;
+	}
+
 	/**
 	 * @param {string} adptName - Adapter name
 	 */
@@ -1023,10 +1284,11 @@ class DeviceWatcher extends utils.Adapter {
 		await this.resetVars(); // reset the arrays and counts
 
 		try {
-			for (let i = 0; i < this.arrDev.length; i++) {
-				if (this.arrDev[i].adapterID.includes(adptName)) {
+			for (const i of this.listAllDevicesRaw) {
+				if (i.adapterID.includes(adptName)) {
 					// list device only if selected adapter matched with device
-					await this.createData(i);
+					await this.createLists();
+					await this.writeDatapoints();
 				}
 			}
 
@@ -1048,16 +1310,8 @@ class DeviceWatcher extends utils.Adapter {
 			await this.resetVars(); // reset the arrays and counts
 
 			for (let i = 0; i < this.arrDev.length; i++) {
-				if (!isUnloaded) {
-					await this.createData(i);
-				} else {
-					return; // cancel run if unloaded was called.
-				}
+				await this.createData(i);
 			}
-
-			// send message if new devices are offline
-			if (this.config.checkSendOfflineMsg) await this.sendOfflineNotifications();
-
 			await this.writeDatapoints(); // fill the datapoints
 		} catch (error) {
 			this.errorReporting('[createDataOfAllAdapter]', error);
@@ -1190,6 +1444,26 @@ class DeviceWatcher extends utils.Adapter {
 		} catch (error) {
 			this.errorReporting('[sendNotification Lovelace]', error);
 		}
+
+		// Synochat Notification
+		try {
+			if (this.config.instanceSynochat) {
+				//first check if instance is living
+				const synochatAliveState = await this.getInitValue('system.adapter.' + this.config.instanceSynochat + '.alive');
+
+				if (!synochatAliveState) {
+					this.log.warn('Synochat instance is not running. Message could not be sent. Please check your instance configuration.');
+				} else {
+					if (this.config.channelSynochat !== undefined) {
+						await this.setForeignStateAsync(`${this.config.instanceSynochat}.${this.config.channelSynochat}.message`, text);
+					} else {
+						this.log.warn('Synochat channel is not set. Message could not be sent. Please check your instance configuration.');
+					}
+				}
+			}
+		} catch (error) {
+			this.errorReporting('[sendNotification Synochat]', error);
+		}
 	} // <-- End of sendNotification function
 
 	/**
@@ -1224,15 +1498,20 @@ class DeviceWatcher extends utils.Adapter {
 					let deviceList = '';
 
 					for (const id of this.batteryLowPoweredRaw) {
-						if (!this.blacklistNotify.includes(id['Path'])) {
-							deviceList = `${deviceList}\n${id['Device']} (${id['Battery']})`;
+						if (!this.blacklistNotify.includes(id.Path)) {
+							if (!this.config.showAdapterNameinMsg) {
+								deviceList = `${deviceList}\n${id.Device} (${id.Battery})`;
+							} else {
+								// Add adaptername if checkbox is checked true in options by user
+								deviceList = `${deviceList}\n${id.Adapter}: ${id.Device} (${id.Battery})`;
+							}
 						}
 					}
 					if (deviceList.length > 0) {
 						this.log.info(`Niedrige Batteriezustände: ${deviceList}`);
 						this.setStateAsync('lastNotification', `Niedrige Batteriezustände: ${deviceList}`, true);
 
-						this.sendNotification(`Niedriege Batteriezustände: ${deviceList}`);
+						this.sendNotification(`Niedrige Batteriezustände: ${deviceList}`);
 					}
 				} catch (error) {
 					this.errorReporting('[sendBatteryNotifyShedule]', error);
@@ -1241,37 +1520,66 @@ class DeviceWatcher extends utils.Adapter {
 		}
 	} //<--End of battery notification
 
+	/**
+	 * check if device updates are available and send notification
+	 * @param {string} deviceName
+	 * @param {string} adapter
+	 * @param {string} battery
+	 * @param {string} devicePath
+	 **/
+	async sendLowBatNoticiation(deviceName, adapter, battery, devicePath) {
+		this.log.debug(`Start the function: ${this.sendLowBatNoticiation.name}`);
+
+		try {
+			let msg = '';
+			let deviceList = '';
+
+			if (!this.blacklistNotify.includes(devicePath)) {
+				if (!this.config.showAdapterNameinMsg) {
+					deviceList = `${deviceList}\n${deviceName} (${battery})`;
+				} else {
+					deviceList = `${deviceList}\n${adapter}: ${deviceName} (${battery})`;
+				}
+			}
+			msg = `Gerät mit geringer Batterie erkannt: \n`;
+
+			this.log.info(msg + deviceList);
+			await this.setStateAsync('lastNotification', msg + deviceList, true);
+			await this.sendNotification(msg + deviceList);
+		} catch (error) {
+			this.errorReporting('[sendLowBatNoticiation]', error);
+		}
+		this.log.debug(`Finished the function: ${this.sendLowBatNoticiation.name}`);
+	}
+
 	/**
 	 * send message if an device is offline
 	 */
-	async sendOfflineNotifications() {
+	async sendOfflineNotifications(deviceName, adapter, status, lastContact, devicePath) {
 		this.log.debug(`Start the function: ${this.sendOfflineNotifications.name}`);
 
 		try {
 			let msg = '';
 			let deviceList = '';
 
-			for (const id of this.offlineDevicesRaw) {
-				if (!this.blacklistNotify.includes(id['Path'])) {
-					deviceList = `${deviceList}\n${id['Device']} (${id['Last contact']})`;
+			if (!this.blacklistNotify.includes(devicePath)) {
+				if (!this.config.showAdapterNameinMsg) {
+					deviceList = `${deviceList}\n${deviceName} (${lastContact})`;
+				} else {
+					deviceList = `${deviceList}\n${adapter}: ${deviceName} (${lastContact})`;
 				}
 			}
-			if (deviceList.length !== this.offlineDevicesCountRawOld) {
-				if (deviceList.length == 0) {
-					msg = 'Alle Geräte sind Online.';
-				} else if (deviceList.length == 1) {
-					// make singular if it is only one device
-					msg = 'Folgendes Gerät ist seit einiger Zeit nicht erreichbar: \n';
-				} else if (deviceList.length >= 2) {
-					//make plural if it is more than one device
-					msg = `Folgende Geräte sind seit einiger Zeit nicht erreichbar: \n`;
-				}
-
-				this.log.info(msg + deviceList);
-				this.offlineDevicesCountRawOld = deviceList.length;
-				await this.setStateAsync('lastNotification', msg + deviceList, true);
-				await this.sendNotification(msg + deviceList);
+			if (status === 'Online') {
+				// make singular if it is only one device
+				msg = 'Folgendes Gerät ist wieder erreichbar: \n';
+			} else if (status === 'Offline') {
+				//make plural if it is more than one device
+				msg = `Folgendes Gerät ist seit einiger Zeit nicht erreichbar: \n`;
 			}
+
+			this.log.info(msg + deviceList);
+			await this.setStateAsync('lastNotification', msg + deviceList, true);
+			await this.sendNotification(msg + deviceList);
 		} catch (error) {
 			this.errorReporting('[sendOfflineMessage]', error);
 		}
@@ -1310,8 +1618,12 @@ class DeviceWatcher extends utils.Adapter {
 					let deviceList = '';
 
 					for (const id of this.offlineDevicesRaw) {
-						if (!this.blacklistNotify.includes(id['Path'])) {
-							deviceList = `${deviceList}\n${id['Device']} (${id['Last contact']})`;
+						if (!this.blacklistNotify.includes(id.Path)) {
+							if (!this.config.showAdapterNameinMsg) {
+								deviceList = `${deviceList}\n${id.Device} (${id.LastContact})`;
+							} else {
+								deviceList = `${deviceList}\n${id.Adapter}: ${id.Device} (${id.LastContact})`;
+							}
 						}
 					}
 
@@ -1328,6 +1640,91 @@ class DeviceWatcher extends utils.Adapter {
 		}
 	} //<--End of daily offline notification
 
+	/**
+	 * check if device updates are available and send notification
+	 * @param {string} deviceName
+	 * @param {string} adapter
+	 * @param {string} devicePath
+	 **/
+	async sendDeviceUpdatesNotification(deviceName, adapter, devicePath) {
+		this.log.debug(`Start the function: ${this.sendDeviceUpdatesNotification.name}`);
+
+		try {
+			let msg = '';
+			let deviceList = '';
+
+			if (!this.blacklistNotify.includes(devicePath)) {
+				if (!this.config.showAdapterNameinMsg) {
+					deviceList = `${deviceList}\n${deviceName}`;
+				} else {
+					deviceList = `${deviceList}\n${adapter}: ${deviceName}`;
+				}
+			}
+			msg = `Neue Geräte Updates vorhanden: \n`;
+
+			this.log.info(msg + deviceList);
+			await this.setStateAsync('lastNotification', msg + deviceList, true);
+			await this.sendNotification(msg + deviceList);
+		} catch (error) {
+			this.errorReporting('[sendDeviceUpdatesNotification]', error);
+		}
+		this.log.debug(`Finished the function: ${this.sendDeviceUpdatesNotification.name}`);
+	}
+
+	/**
+	 * send shedule message with offline devices
+	 */
+	async sendUpgradeNotificationsShedule() {
+		const time = this.config.checkSendUpgradeTime.split(':');
+
+		const checkDays = []; // list of selected days
+
+		// push the selected days in list
+		if (this.config.checkUpgradeMonday) checkDays.push(1);
+		if (this.config.checkUpgradeTuesday) checkDays.push(2);
+		if (this.config.checkUpgradeWednesday) checkDays.push(3);
+		if (this.config.checkUpgradeThursday) checkDays.push(4);
+		if (this.config.checkUpgradeFriday) checkDays.push(5);
+		if (this.config.checkUpgradeSaturday) checkDays.push(6);
+		if (this.config.checkUpgradeSunday) checkDays.push(0);
+
+		if (checkDays.length >= 1) {
+			// check if an day is selected
+			this.log.debug(`Number of selected days for daily Upgrade message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
+		} else {
+			this.log.warn(`No days selected for daily Upgrade message. Please check the instance configuration!`);
+			return; // cancel function if no day is selected
+		}
+
+		if (!isUnloaded) {
+			const cron = '10 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
+			schedule.scheduleJob(cron, () => {
+				try {
+					let deviceList = '';
+
+					for (const id of this.upgradableList) {
+						if (!this.blacklistNotify.includes(id.Path)) {
+							if (!this.config.showAdapterNameinMsg) {
+								deviceList = `${deviceList}\n${id.Device}`;
+							} else {
+								deviceList = `${deviceList}\n${id.Adapter}: ${id.Device}`;
+							}
+						}
+					}
+
+					if (deviceList.length > 0) {
+						this.log.info(`Geräte Upgrade: ${deviceList}`);
+						this.setStateAsync('lastNotification', `Geräte Upgrade: ${deviceList}`, true);
+
+						this.sendNotification(`Geräte Upgrade:\n${deviceList}`);
+					}
+				} catch (error) {
+					this.errorReporting('[sendUpgradeNotificationsShedule]', error);
+				}
+			});
+		}
+	} //<--End of daily offline notification
+
 	/**
 	 * reset arrays and counts
 	 */
@@ -1341,13 +1738,11 @@ class DeviceWatcher extends utils.Adapter {
 		this.batteryPowered = [];
 		this.batteryLowPowered = [];
 		this.listAllDevices = [];
-		this.listAllDevicesRaw = [];
+		//this.listAllDevicesRaw = [];
 
 		// raws
 		this.batteryLowPoweredRaw = [];
 		this.offlineDevicesRaw = [];
-		this.lowBatteryPoweredCountRaw = 0;
-		this.offlineDevicesCountRaw = 0;
 
 		// counts
 		this.offlineDevicesCount = 0;
@@ -1355,6 +1750,7 @@ class DeviceWatcher extends utils.Adapter {
 		this.linkQualityCount = 0;
 		this.batteryPoweredCount = 0;
 		this.lowBatteryPoweredCount = 0;
+		this.upgradableDevicesCount = 0;
 
 		this.log.debug(`Function finished: ${this.resetVars.name}`);
 	} // <-- end of resetVars
@@ -1380,14 +1776,15 @@ class DeviceWatcher extends utils.Adapter {
 			await this.setStateAsync(`${dpSubFolder}countAll`, { val: this.deviceCounter, ack: true });
 			await this.setStateAsync(`${dpSubFolder}batteryCount`, { val: this.batteryPoweredCount, ack: true });
 			await this.setStateAsync(`${dpSubFolder}lowBatteryCount`, { val: this.lowBatteryPoweredCount, ack: true });
+			await this.setStateAsync(`${dpSubFolder}upgradableCount`, { val: this.upgradableDevicesCount, ack: true });
 
-			if (this.deviceCounter == 0) {
+			if (this.deviceCounter === 0) {
 				// if no device is count, write the JSON List with default value
 				this.listAllDevices = [{ Device: '--none--', Adapter: '', Battery: '', 'Last contact': '', 'Signal strength': '' }];
 			}
 			await this.setStateAsync(`${dpSubFolder}listAll`, { val: JSON.stringify(this.listAllDevices), ack: true });
 
-			if (this.linkQualityCount == 0) {
+			if (this.linkQualityCount === 0) {
 				// if no device is count, write the JSON List with default value
 				this.linkQualityDevices = [{ Device: '--none--', Adapter: '', 'Signal strength': '' }];
 			}
@@ -1396,14 +1793,8 @@ class DeviceWatcher extends utils.Adapter {
 				val: JSON.stringify(this.linkQualityDevices),
 				ack: true,
 			});
-			//write HTML list
-			if (this.config.createHtmlList)
-				await this.setStateAsync(`${dpSubFolder}linkQualityListHTML`, {
-					val: await this.creatLinkQualityListHTML(this.linkQualityDevices, this.linkQualityCount),
-					ack: true,
-				});
 
-			if (this.offlineDevicesCount == 0) {
+			if (this.offlineDevicesCount === 0) {
 				// if no device is count, write the JSON List with default value
 				this.offlineDevices = [{ Device: '--none--', Adapter: '', 'Last contact': '' }];
 			}
@@ -1412,14 +1803,18 @@ class DeviceWatcher extends utils.Adapter {
 				val: JSON.stringify(this.offlineDevices),
 				ack: true,
 			});
-			//write HTML list
-			if (this.config.createHtmlList)
-				await this.setStateAsync(`${dpSubFolder}offlineListHTML`, {
-					val: await this.createOfflineListHTML(this.offlineDevices, this.offlineDevicesCount),
-					ack: true,
-				});
 
-			if (this.batteryPoweredCount == 0) {
+			if (this.upgradableDevicesCount === 0) {
+				// if no device is count, write the JSON List with default value
+				this.upgradableList = [{ Device: '--none--', Adapter: '', 'Last contact': '' }];
+			}
+			//write JSON list
+			await this.setStateAsync(`${dpSubFolder}upgradableList`, {
+				val: JSON.stringify(this.upgradableList),
+				ack: true,
+			});
+
+			if (this.batteryPoweredCount === 0) {
 				// if no device is count, write the JSON List with default value
 				this.batteryPowered = [{ Device: '--none--', Adapter: '', Battery: '' }];
 			}
@@ -1428,14 +1823,8 @@ class DeviceWatcher extends utils.Adapter {
 				val: JSON.stringify(this.batteryPowered),
 				ack: true,
 			});
-			//write HTML list
-			if (this.config.createHtmlList)
-				await this.setStateAsync(`${dpSubFolder}batteryListHTML`, {
-					val: await this.createBatteryListHTML(this.batteryPowered, this.batteryPoweredCount, false),
-					ack: true,
-				});
 
-			if (this.lowBatteryPoweredCount == 0) {
+			if (this.lowBatteryPoweredCount === 0) {
 				// if no device is count, write the JSON List with default value
 				this.batteryLowPowered = [{ Device: '--none--', Adapter: '', Battery: '' }];
 			}
@@ -1444,12 +1833,26 @@ class DeviceWatcher extends utils.Adapter {
 				val: JSON.stringify(this.batteryLowPowered),
 				ack: true,
 			});
+
 			//write HTML list
-			if (this.config.createHtmlList)
+			if (this.config.createHtmlList) {
+				await this.setStateAsync(`${dpSubFolder}linkQualityListHTML`, {
+					val: await this.creatLinkQualityListHTML(this.linkQualityDevices, this.linkQualityCount),
+					ack: true,
+				});
+				await this.setStateAsync(`${dpSubFolder}offlineListHTML`, {
+					val: await this.createOfflineListHTML(this.offlineDevices, this.offlineDevicesCount),
+					ack: true,
+				});
+				await this.setStateAsync(`${dpSubFolder}batteryListHTML`, {
+					val: await this.createBatteryListHTML(this.batteryPowered, this.batteryPoweredCount, false),
+					ack: true,
+				});
 				await this.setStateAsync(`${dpSubFolder}lowBatteryListHTML`, {
 					val: await this.createBatteryListHTML(this.batteryLowPowered, this.lowBatteryPoweredCount, true),
 					ack: true,
 				});
+			}
 
 			// create timestamp of last run
 			const lastCheck = this.formatDate(new Date(), 'DD.MM.YYYY') + ' - ' + this.formatDate(new Date(), 'hh:mm:ss');
@@ -1488,7 +1891,7 @@ class DeviceWatcher extends utils.Adapter {
 			html += `<tr>
 			<td><font>${device.Device}</font></td>
 			<td align=center><font>${device.Adapter}</font></td>
-			<td align=right><font>${device['Signal strength']}</font></td>
+			<td align=right><font>${device.SignalStrength}</font></td>
 			</tr>`;
 		}
 
@@ -1507,7 +1910,7 @@ class DeviceWatcher extends utils.Adapter {
 			return a.localeCompare(b);
 		});
 		let html = `<center>
-		<b>Offline Devices: <font color=${deviceCount == 0 ? '#3bcf0e' : 'orange'}>${deviceCount}</b><small></small></font>
+		<b>Offline Devices: <font color=${deviceCount === 0 ? '#3bcf0e' : 'orange'}>${deviceCount}</b><small></small></font>
 		<p></p>
 		</center>   
 		<table width=100%>
@@ -1524,7 +1927,7 @@ class DeviceWatcher extends utils.Adapter {
 			html += `<tr>
 			<td><font>${device.Device}</font></td>
 			<td align=center><font>${device.Adapter}</font></td>
-			<td align=center><font color=orange>${device['Last contact']}</font></td>
+			<td align=center><font color=orange>${device.LastContact}</font></td>
 			</tr>`;
 		}
 
@@ -1544,7 +1947,7 @@ class DeviceWatcher extends utils.Adapter {
 			return a.localeCompare(b);
 		});
 		let html = `<center>
-		<b>${isLowBatteryList == true ? 'Schwache ' : ''}Batterie Devices: <font color=${isLowBatteryList == true ? (deviceCount > 0 ? 'orange' : '#3bcf0e') : ''}>${deviceCount}</b></font>
+		<b>${isLowBatteryList === true ? 'Schwache ' : ''}Batterie Devices: <font color=${isLowBatteryList === true ? (deviceCount > 0 ? 'orange' : '#3bcf0e') : ''}>${deviceCount}</b></font>
 		<p></p>
 		</center>   
 		<table width=100%>
@@ -1792,6 +2195,54 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			native: {},
 		});
+
+		await this.setObjectNotExistsAsync(`${adptName}.upgradableCount`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'Number of devices with available updates ',
+					de: 'Anzahl der Geräte mit verfügbaren Updates',
+					ru: 'Количество устройств с доступными обновлениями',
+					pt: 'Número de dispositivos com atualizações disponíveis',
+					nl: 'Nummer van apparatuur met beschikbare updates',
+					fr: 'Nombre de dispositifs avec mises à jour disponibles',
+					it: 'Numero di dispositivi con aggiornamenti disponibili',
+					es: 'Número de dispositivos con actualizaciones disponibles',
+					pl: 'Liczba urządzeń z dostępną aktualizacją',
+					uk: 'Кількість пристроїв з доступними оновленнями',
+					'zh-cn': '现有更新的装置数目',
+				},
+				type: 'number',
+				role: 'value',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+
+		await this.setObjectNotExistsAsync(`${adptName}.upgradableList`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'JSON List of devices with available updates ',
+					de: 'JSON Liste der Geräte mit verfügbaren Updates',
+					ru: 'ДЖСОН Список устройств с доступными обновлениями',
+					pt: 'J. Lista de dispositivos com atualizações disponíveis',
+					nl: 'JSON List van apparatuur met beschikbare updates',
+					fr: 'JSON Liste des appareils avec mises à jour disponibles',
+					it: 'JSON Elenco dei dispositivi con aggiornamenti disponibili',
+					es: 'JSON Lista de dispositivos con actualizaciones disponibles',
+					pl: 'JSON Lista urządzeń korzystających z aktualizacji',
+					uk: 'Сонце Перелік пристроїв з доступними оновленнями',
+					'zh-cn': '附 件 现有最新设备清单',
+				},
+				type: 'array',
+				role: 'json',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
 	}
 
 	/**