iobroker.device-watcher 2.1.0 → 2.2.1

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;
@@ -40,18 +40,13 @@ class DeviceWatcher extends utils.Adapter {
 		this.batteryLowPoweredRaw = [];
 		this.offlineDevicesRaw = [];
 
-		// raw counts
-		this.offlineDevicesCountRaw = 0;
-		this.offlineDevicesCountRawOld = 0;
-		this.lowBatteryPoweredCountRaw = 0;
-		this.upgradableDevicesCountRawOld = 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;
@@ -90,6 +85,7 @@ class DeviceWatcher extends utils.Adapter {
 				hs100: this.config.hs100Devices,
 				hue: this.config.hueDevices,
 				hueExt: this.config.hueExtDevices,
+				innogy: this.config.innogyDevices,
 				jeelink: this.config.jeelinkDevices,
 				lupusec: this.config.lupusecDevices,
 				maxcube: this.config.maxcubeDevices,
@@ -99,6 +95,7 @@ class DeviceWatcher extends utils.Adapter {
 				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,
@@ -136,6 +133,7 @@ class DeviceWatcher extends utils.Adapter {
 				hs100: this.config.hs100MaxMinutes,
 				hue: this.config.hueMaxMinutes,
 				hueExt: this.config.hueextMaxMinutes,
+				innogy: this.config.innogyMaxMinutes,
 				jeelink: this.config.jeelinkMaxMinutes,
 				lupusec: this.config.lupusecMaxMinutes,
 				maxcube: this.config.maxcubeMaxMinutes,
@@ -145,6 +143,7 @@ class DeviceWatcher extends utils.Adapter {
 				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,
@@ -196,41 +195,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
-			await this.refreshData();
+			//read data first at start
+			await this.main();
 
-			// trigger update notification on state change
-			/*
-			if (this.config.checkSendAdapterUpdateNotify) {
-				this.subscribeForeignStatesAsync(`admin.*.info.updatesJson`);
-			}*/
+			// 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);
@@ -242,11 +241,121 @@ class DeviceWatcher extends utils.Adapter {
 	 * @param {string} id
 	 * @param {ioBroker.State | null | undefined} state
 	 */
-	onStateChange(id, state) {
+	async onStateChange(id, state) {
 		// Admin JSON for Adapter updates
 		if (id && state) {
 			this.log.debug(`State changed: ${id} changed ${state.val}`);
-			//this.sendAdapterUpdatesNotification(id, state);
+			let batteryData;
+			let oldLowBatState;
+			let contactData;
+			let oldStatus;
+			let oldSignalStrength;
+
+			for (const device of this.listAllDevicesRaw) {
+				// On statechange update available datapoint
+				switch (id) {
+					case device.UpdateDP:
+						if (state.val) {
+							device.Upgradable = state.val;
+
+							await this.createLists();
+							await this.writeDatapoints();
+							if (this.config.createOwnFolder) await this.createDataForEachAdapter(device.adapterID);
+							if (!this.blacklistNotify.includes(device.Path)) {
+								await this.sendDeviceUpdatesNotification(device.Device, device.Adapter);
+							}
+						}
+						break;
+
+					case device.SignalStrengthDP:
+						oldSignalStrength = device.SignalStrength;
+						device.SignalStrength = await this.calculateSignalStrength(state, device.adapterID);
+						if (oldSignalStrength !== device.SignalStrength) {
+							await this.createLists();
+							await this.writeDatapoints();
+							if (this.config.createOwnFolder) await this.createDataForEachAdapter(device.adapterID);
+						}
+						break;
+
+					case device.batteryDP:
+						if (device.isBatteryDevice) {
+							oldLowBatState = device.LowBat;
+							batteryData = await this.getBatteryData(state.val, oldLowBatState, device.adapterID);
+
+							device.Battery = batteryData[0];
+							device.BatteryRaw = batteryData[2];
+							device.LowBat = await this.setLowbatIndicator(state.val, undefined, device.LowBatDP);
+
+							if (device.LowBat && oldLowBatState !== device.LowBat) {
+								await this.createLists();
+								await this.writeDatapoints();
+								if (this.config.createOwnFolder) await this.createDataForEachAdapter(device.adapterID);
+								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(device.Path)) {
+									await this.sendLowBatNoticiation(device.Device, device.Adapter, device.Battery);
+								}
+							} else if (!device.LowBat && oldLowBatState !== device.LowBat) {
+								await this.createLists();
+								await this.writeDatapoints();
+								if (this.config.createOwnFolder) await this.createDataForEachAdapter(device.adapterID);
+							}
+						}
+						break;
+
+					case device.LowBatDP:
+						if (device.isBatteryDevice) {
+							oldLowBatState = device.LowBat;
+							batteryData = await this.getBatteryData(device.BatteryRaw, state.val, device.adapterID);
+							device.Battery = batteryData[0];
+							device.BatteryRaw = batteryData[2];
+							device.LowBat = await this.setLowbatIndicator(device.BatteryRaw, state.val, device.LowBatDP);
+
+							if (device.LowBat && oldLowBatState !== device.LowBat) {
+								await this.createLists();
+								await this.writeDatapoints();
+								if (this.config.createOwnFolder) await this.createDataForEachAdapter(device.adapterID);
+								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(device.Path)) {
+									await this.sendLowBatNoticiation(device.Device, device.Adapter, device.Battery);
+								}
+							} else if (!device.LowBat && oldLowBatState !== device.LowBat) {
+								await this.createLists();
+								await this.writeDatapoints();
+								if (this.config.createOwnFolder) await this.createDataForEachAdapter(device.adapterID);
+							}
+						}
+
+						break;
+					case device.UnreachDP:
+					case device.DeviceStateSelectorDP:
+					case device.rssiPeerSelectorDP:
+					case device.Path:
+						oldStatus = device.Status;
+						device.UnreachState = await this.getInitValue(device.UnreachDP);
+						contactData = await this.getOnlineState(
+							device.Path,
+							device.adapterID,
+							device.UnreachDP,
+							device.SignalStrength,
+							device.UnreachState,
+							device.DeviceStateSelectorDP,
+							device.rssiPeerSelectorDP,
+						);
+						if (contactData !== undefined) {
+							device.LastContact = contactData[0];
+							device.Status = contactData[1];
+							device.SignalStrength = contactData[2];
+						}
+						if (device.Status !== oldStatus) {
+							await this.createLists();
+							await this.writeDatapoints();
+							if (this.config.createOwnFolder) await this.createDataForEachAdapter(device.adapterID);
+						}
+
+						if (device.Status && oldStatus !== device.Status && this.config.checkSendOfflineMsg && !this.blacklistNotify.includes(device.Path)) {
+							await this.sendOfflineNotifications(device.Device, device.Adapter, device.Status, device.LastContact);
+						}
+						break;
+				}
+			}
 		}
 	}
 
@@ -286,11 +395,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) {
@@ -315,25 +425,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();
@@ -342,6 +433,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
 
@@ -438,17 +543,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':
@@ -469,7 +579,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
@@ -508,6 +620,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
@@ -527,118 +796,181 @@ class DeviceWatcher extends utils.Adapter {
 	}
 
 	/**
-	 * Create Lists
+	 * get online state and time
+	 * @param {object} id - ID
+	 * @param {string} adapterID - ID of Adapter
+	 * @param {string} unreachDP - Datapoint of Unreach
+	 * @param {object} linkQuality - Linkquality Value
+	 * @param {object} deviceUnreachState - State of deviceUnreach datapoint
+	 * @param {string} deviceStateSelectorDP - Selector of device state (like .state)
+	 * @param {string} rssiPeerSelectorDP - HM RSSI Peer Datapoint
 	 */
-	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['Last contact'],
-				});
-			}
+	async getOnlineState(id, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP) {
+		let lastContactString;
+		let deviceState = 'Online';
 
-			/*----------  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'],
-					});
-				}
+		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;
 
-				// Offline List
-				if (device['Status'] === 'Offline') {
-					this.offlineDevices.push({
-						Device: device['Device'],
-						Adapter: device['Adapter'],
-						'Last contact': device['Last contact'],
-					});
+					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;
+						}
 				}
 
-				// Device update List
-				if (device['Upgradable']) {
-					this.upgradableList.push({
-						Device: device['Device'],
-						Adapter: device['Adapter'],
-					});
+				/*=============================================
+			=            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 device of this.listAllDevicesRaw) {
+			const oldContactState = device.Status;
+			device.UnreachState = await this.getInitValue(device.UnreachDP);
+			const contactData = await this.getOnlineState(
+				device.Path,
+				device.adapterID,
+				device.UnreachDP,
+				device.SignalStrength,
+				device.UnreachState,
+				device.DeviceStateSelectorDP,
+				device.rssiPeerSelectorDP,
+			);
+			if (contactData !== undefined) {
+				device.LastContact = contactData[0];
+				device.Status = contactData[1];
+				device.linkQuality = contactData[2];
+			}
+			if (this.config.checkSendOfflineMsg && oldContactState !== device.Status && !this.blacklistNotify.includes(device.Path)) {
+				await this.sendOfflineNotifications(device.Device, device.Adapter, device.Status, device.LastContact);
+			}
+		}
+		await this.createLists();
+		await this.writeDatapoints();
 	}
 
 	/**
@@ -670,347 +1002,127 @@ class DeviceWatcher extends utils.Adapter {
 				/*=============================================
 				=            Get signal strength              =
 				=============================================*/
+				let deviceQualityDP = currDeviceString + this.arrDev[i].rssiState;
 				let deviceQualityState;
-				let linkQuality;
-				let mqttNukiValue;
 
 				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;
-								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 = ' - ';
-				}
+				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 === undefined && shortDeviceBatteryState === undefined) {
-					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':
-						case 'mqttNuki':
-							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;
-
-							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;
-								}
-						}
-
-						/*=============================================
-						=            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 '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);
-					}
+				// 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';
+
+				//subscribe to states
+				this.subscribeForeignStatesAsync(deviceBatteryStateDP);
+				this.subscribeForeignStatesAsync(isLowBatDP);
+
+				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	              =
 				=============================================*/
-				let deviceUpdateSelector;
+				const deviceUpdateDP = currDeviceString + this.arrDev[i].upgrade;
 				let isUpgradable;
 
 				if (this.config.checkSendDeviceUpgrade) {
-					deviceUpdateSelector = await this.getInitValue(currDeviceString + this.arrDev[i].upgrade);
+					const deviceUpdateSelector = await this.getInitValue(deviceUpdateDP);
+
 					if (deviceUpdateSelector) {
 						isUpgradable = true;
-					} else {
+					} else if (!deviceUpdateSelector) {
 						isUpgradable = false;
 					}
+					// subscribe to states
+					this.subscribeForeignStatesAsync(deviceUpdateDP);
 				}
 
 				/*=============================================
@@ -1018,33 +1130,51 @@ 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,
-							Upgradable: isUpgradable,
-						});
-					}
+				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,
 					});
 				}
@@ -1053,10 +1183,133 @@ class DeviceWatcher extends utils.Adapter {
 				return;
 			}
 		} // <-- end of loop
-		await this.createLists();
-		await this.countDevices();
 	} // <-- end of createData
 
+	/**
+	 * Create Lists
+	 */
+	async createLists(adptName) {
+		this.linkQualityDevices = [];
+		this.batteryPowered = [];
+		this.batteryLowPowered = [];
+		this.listAllDevices = [];
+		this.offlineDevices = [];
+		this.batteryLowPoweredRaw = [];
+		this.offlineDevicesRaw = [];
+		this.upgradableList = [];
+
+		if (adptName === undefined) {
+			adptName = '';
+		}
+
+		for (const device of this.listAllDevicesRaw) {
+			if (device.adapterID.includes(adptName)) {
+				/*----------  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
 	 */
@@ -1064,13 +1317,12 @@ class DeviceWatcher extends utils.Adapter {
 		// create Data for each Adapter in own lists
 		this.log.debug(`Function started: ${this.createDataForEachAdapter.name}`);
 
-		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 device of this.listAllDevicesRaw) {
+				if (device.adapterID.includes(adptName)) {
 					// list device only if selected adapter matched with device
-					await this.createData(i);
+					await this.createLists(adptName);
+					await this.writeDatapoints(adptName);
 				}
 			}
 
@@ -1089,22 +1341,10 @@ class DeviceWatcher extends utils.Adapter {
 		this.log.debug(`Function started: ${this.createDataOfAllAdapter.name}`);
 
 		try {
-			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);
+				await this.createLists();
 			}
-
-			// send message if new devices are offline
-			if (this.config.checkSendOfflineMsg) await this.sendOfflineNotifications();
-
-			// send overview of upgradable devices
-			if (this.config.checkSendDeviceUpgrade) await this.sendDeviceUpdatesNotification();
-
 			await this.writeDatapoints(); // fill the datapoints
 		} catch (error) {
 			this.errorReporting('[createDataOfAllAdapter]', error);
@@ -1291,12 +1531,12 @@ class DeviceWatcher extends utils.Adapter {
 					let deviceList = '';
 
 					for (const id of this.batteryLowPoweredRaw) {
-						if (!this.blacklistNotify.includes(id['Path'])) {
+						if (!this.blacklistNotify.includes(id.Path)) {
 							if (!this.config.showAdapterNameinMsg) {
-								deviceList = `${deviceList}\n${id['Device']} (${id['Battery']})`;
+								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']})`;
+								deviceList = `${deviceList}\n${id.Adapter}: ${id.Device} (${id.Battery})`;
 							}
 						}
 					}
@@ -1313,41 +1553,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
+	 **/
+	async sendLowBatNoticiation(deviceName, adapter, battery) {
+		this.log.debug(`Start the function: ${this.sendLowBatNoticiation.name}`);
+
+		try {
+			let msg = '';
+			let deviceList = '';
+
+			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
+	 * @param {string} deviceName
+	 * @param {string} adapter
+	 * @param {string} status
+	 * @param {string} lastContact
 	 */
-	async sendOfflineNotifications() {
+	async sendOfflineNotifications(deviceName, adapter, status, lastContact) {
 		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'])) {
-					if (!this.config.showAdapterNameinMsg) {
-						deviceList = `${deviceList}\n${id['Device']} (${id['Last contact']})`;
-					} else {
-						deviceList = `${deviceList}\n${id['Adapter']}: ${id['Device']} (${id['Last contact']})`;
-					}
-				}
+			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);
 		}
@@ -1386,11 +1651,11 @@ class DeviceWatcher extends utils.Adapter {
 					let deviceList = '';
 
 					for (const id of this.offlineDevicesRaw) {
-						if (!this.blacklistNotify.includes(id['Path'])) {
+						if (!this.blacklistNotify.includes(id.Path)) {
 							if (!this.config.showAdapterNameinMsg) {
-								deviceList = `${deviceList}\n${id['Device']} (${id['Last contact']})`;
+								deviceList = `${deviceList}\n${id.Device} (${id.LastContact})`;
 							} else {
-								deviceList = `${deviceList}\n${id['Adapter']}: ${id['Device']} (${id['Last contact']})`;
+								deviceList = `${deviceList}\n${id.Adapter}: ${id.Device} (${id.LastContact})`;
 							}
 						}
 					}
@@ -1408,69 +1673,29 @@ class DeviceWatcher extends utils.Adapter {
 		}
 	} //<--End of daily offline notification
 
-	/**
-	 * check if adapter updates are available and send notification
-	 * @param {string} id
-	 * @param {ioBroker.State | null | undefined} state
-	 */
-	/*
-	async sendAdapterUpdatesNotification(id, state) {
-		this.log.debug(`Start the function: ${this.sendAdapterUpdatesNotification.name}`);
-
-		try {
-			if (state && state !== undefined) {
-				const list = await this.parseData(state.val);
-				let msg = '';
-				let adapterList = '';
-
-				for (const [id] of Object.entries(list)) {
-					adapterList = `${adapterList}\n${this.capitalize(id)} - Version: ${list[id].availableVersion}`;
-				}
-				if (adapterList.length !== 0) {
-					msg = `Neue Adapter Updates vorhanden: \n`;
-
-					this.log.info(msg + adapterList);
-					await this.setStateAsync('lastNotification', msg + adapterList, true);
-					await this.sendNotification(msg + adapterList);
-				}
-			}
-		} catch (error) {
-			this.errorReporting('[sendAdapterUpdatesNotification]', error);
-		}
-		this.log.debug(`Finished the function: ${this.sendAdapterUpdatesNotification.name}`);
-	}*/
-
 	/**
 	 * check if device updates are available and send notification
+	 * @param {string} deviceName
+	 * @param {string} adapter
 	 **/
-	async sendDeviceUpdatesNotification() {
+	async sendDeviceUpdatesNotification(deviceName, adapter) {
 		this.log.debug(`Start the function: ${this.sendDeviceUpdatesNotification.name}`);
 
 		try {
 			let msg = '';
 			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 !== this.upgradableDevicesCountRawOld) {
-				if (deviceList.length >= 1) {
-					msg = `Neue Geräte Updates vorhanden: \n`;
-
-					this.log.info(msg + deviceList);
-					this.upgradableDevicesCountRawOld = deviceList.length;
-					await this.setStateAsync('lastNotification', msg + deviceList, true);
-					await this.sendNotification(msg + deviceList);
-				} else {
-					this.upgradableDevicesCountRawOld = deviceList.length;
-				}
+			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);
 		}
@@ -1478,35 +1703,58 @@ class DeviceWatcher extends utils.Adapter {
 	}
 
 	/**
-	 * reset arrays and counts
+	 * send shedule message with offline devices
 	 */
-	async resetVars() {
-		//Reset all arrays and counts
-		this.log.debug(`Function started: ${this.resetVars.name}`);
+	async sendUpgradeNotificationsShedule() {
+		const time = this.config.checkSendUpgradeTime.split(':');
 
-		// arrays
-		this.offlineDevices = [];
-		this.linkQualityDevices = [];
-		this.batteryPowered = [];
-		this.batteryLowPowered = [];
-		this.listAllDevices = [];
-		this.listAllDevicesRaw = [];
+		const checkDays = []; // list of selected days
 
-		// raws
-		this.batteryLowPoweredRaw = [];
-		this.offlineDevicesRaw = [];
-		this.lowBatteryPoweredCountRaw = 0;
-		this.offlineDevicesCountRaw = 0;
+		// 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);
 
-		// counts
-		this.offlineDevicesCount = 0;
-		this.deviceCounter = 0;
-		this.linkQualityCount = 0;
-		this.batteryPoweredCount = 0;
-		this.lowBatteryPoweredCount = 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.log.debug(`Function finished: ${this.resetVars.name}`);
-	} // <-- end of resetVars
+						this.sendNotification(`Geräte Upgrade:\n${deviceList}`);
+					}
+				} catch (error) {
+					this.errorReporting('[sendUpgradeNotificationsShedule]', error);
+				}
+			});
+		}
+	} //<--End of daily offline notification
 
 	/**
 	 * @param {string} [adptName] - Adaptername
@@ -1529,6 +1777,7 @@ 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 no device is count, write the JSON List with default value
@@ -1545,12 +1794,6 @@ 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 no device is count, write the JSON List with default value
@@ -1561,12 +1804,16 @@ 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.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
@@ -1577,12 +1824,6 @@ 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 no device is count, write the JSON List with default value
@@ -1593,12 +1834,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');
@@ -1637,7 +1892,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>`;
 		}
 
@@ -1673,7 +1928,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>`;
 		}
 
@@ -1941,6 +2196,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: {},
+		});
 	}
 
 	/**