iobroker.device-watcher 1.0.1 → 2.0.0

package/main.js

@@ -6,10 +6,13 @@
 
 const utils = require('@iobroker/adapter-core');
 const adapterName = require('./package.json').name.split('.').pop();
+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;
 
+// indicator if the adapter is running or not (for intervall/shedule)
 let isUnloaded = false;
 
 class DeviceWatcher extends utils.Adapter {
@@ -27,7 +30,9 @@ class DeviceWatcher extends utils.Adapter {
 		this.batteryPowered = [];
 		this.batteryLowPowered = [];
 		this.listAllDevices = [];
-		this.blacklistArr = [];
+		this.listAllDevicesRaw = [];
+		this.blacklistLists = [];
+		this.blacklistNotify = [];
 		this.arrDev = [];
 		this.adapterSelected = [];
 
@@ -38,284 +43,13 @@ class DeviceWatcher extends utils.Adapter {
 		this.batteryPoweredCount = 0;
 		this.lowBatteryPoweredCount = 0;
 
-		this.deviceReachable = '';
-
 		// Interval timer
 		this.refreshDataTimeout = null;
 
-		// Information for dev: add ' 0_userdata.0. ' to selector for testing with own datapoints.
-		/*
-		This is the main template:
-				'Selektor': '',
-				'adapter': '',
-				'battery': 'none',
-				'reach': 'none',
-				'isLowBat': 'none',
-				'id': 'none''
-		*/
-
-		// arrays of supported adapters
-		this.arrApart = {
-			alexa2: {
-				'Selektor': 'alexa2.*.online',
-				'adapter': 'alexa2',
-				'battery': 'none',
-				'reach': '.online',
-				'isLowBat': 'none'
-			},
-			ble: {
-				'Selektor': 'ble.*.rssi',
-				'adapter': 'ble',
-				'battery': '.battery',
-				'reach': 'none',
-				'isLowBat': 'none'
-			},
-			deconz: {
-				'Selektor': 'deconz.*.reachable',
-				'adapter': 'deconz',
-				'battery': '.battery',
-				'reach': '.reachable',
-				'isLowBat': 'none'
-			},
-			enocean: {
-				'Selektor': 'enocean.*.rssi',
-				'adapter': 'enocean',
-				'battery': '.BS',
-				'reach': 'none',
-				'isLowBat': 'none'
-			},
-			esphome: {
-				'Selektor': 'esphome.*._online',
-				'adapter': 'esphome',
-				'battery': 'none',
-				'reach': '._online',
-				'isLowBat': 'none',
-				'id': '.name'
-			},
-			fritzdect: {
-				'Selektor': 'fritzdect.*.present',
-				'adapter': 'fritzDect',
-				'battery': '.battery',
-				'reach': '.present',
-				'isLowBat': '.batterylow'
-			},
-			harmony: {
-				'Selektor': 'harmony.*.hubConnected',
-				'adapter': 'harmony',
-				'battery': 'none',
-				'reach': '.hubConnected',
-				'isLowBat': 'none'
-			},
-			ham: {
-				'Selektor': 'ham.*.Battery-Level',
-				'adapter': 'ham',
-				'battery': '.Battery-Level',
-				'reach': 'none',
-				'isLowBat': 'none',
-				'id': '.Name'
-			},
-			hmiP: {
-				'Selektor': 'hmip.*.rssiDeviceValue',
-				'adapter': 'hmiP',
-				'rssiState': '.rssiDeviceValue',
-				'battery': 'none',
-				'reach': '.unreach',
-				'isLowBat': '.lowBat',
-			},
-			homematic: {
-				'Selektor': 'hm-rpc.*.UNREACH',
-				'adapter': 'homematic',
-				'rssiState': '.RSSI_DEVICE',
-				'battery': '.OPERATING_VOLTAGE',
-				'reach': '.UNREACH',
-				'isLowBat': '.LOW_BAT',
-				'isLowBat2': '.LOWBAT',
-				'stateValue': '.1.STATE'
-			},
-			hue: {
-				'Selektor': 'hue.*.reachable',
-				'adapter': 'hue',
-				'battery': '.battery',
-				'reach': '.reachable',
-				'isLowBat': 'none'
-			},
-			hueExt: {
-				'Selektor': 'hue-extended.*.reachable',
-				'adapter': 'hue-extended',
-				'battery': '.config.battery',
-				'reach': '.reachable',
-				'isLowBat': 'none'
-			},
-			jeelink: {
-				'Selektor': 'jeelink.*.lowBatt',
-				'adapter': 'jeelink',
-				'battery': 'none',
-				'reach': 'none',
-				'isLowBat': '.lowBatt'
-			},
-			meross: {
-				'Selektor': 'meross.*.online',
-				'adapter': 'meross',
-				'battery': '.battery',
-				'reach': '.online',
-				'isLowBat': 'none'
-			},
-			mihome: {
-				'Selektor': 'mihome.*.percent',
-				'adapter': 'miHome',
-				'battery': '.percent',
-				'reach': 'none',
-				'isLowBat': 'none'
-			},
-			mihomeGW: {
-				'Selektor': 'mihome.*.connected',
-				'adapter': 'miHome',
-				'battery': 'none',
-				'reach': '.connected',
-				'isLowBat': 'none'
-			},
-			mihomeVacuum: {
-				'Selektor': 'mihome-vacuum.*.connection',
-				'adapter': 'mihomeVacuum',
-				'rssiState': '.deviceInfo.wifi_signal',
-				'battery': '.info.battery',
-				'battery2': '.control.battary_life',
-				'reach': '.info.connection',
-				'isLowBat': 'none',
-				'id': '.deviceInfo.model'
-			},
-			netatmo: {
-				'Selektor': 'netatmo.*.LastUpdate',
-				'adapter': 'netatmo',
-				'rssiState': '.WifiStatus',
-				'rfState': '.RfStatus',
-				'battery': '.BatteryStatus',
-				'reach': 'none',
-				'isLowBat': 'none'
-			},
-			nukiExt: {
-				'Selektor': 'nuki-extended.*.lastDataUpdate',
-				'adapter': 'nuki-extended',
-				'rssiState': 'none',
-				'battery': '.batteryChargeState',
-				'reach': 'none',
-				'isLowBat': '.batteryCritical'
-			},
-			nut: {
-				'Selektor': 'nut.*.charge',
-				'adapter': 'nut',
-				'battery': '.charge',
-				'reach': 'none',
-				'isLowBat': 'none'
-			},
-			ping: {
-				'Selektor': 'ping.*.alive',
-				'adapter': 'ping',
-				'battery': 'none',
-				'reach': '.alive',
-				'isLowBat': 'none'
-			},
-			roomba: {
-				'Selektor': 'roomba.*.signal',
-				'adapter': 'roomba',
-				'battery': '.battery',
-				'reach': '._connected',
-				'isLowBat': 'none',
-				'id': '.device.name'
-			},
-			shelly: {
-				'Selektor': 'shelly.*.online',
-				'adapter': 'shelly',
-				'rssiState': '.rssi',
-				'battery': '.sensor.battery',
-				'reach': '.online',
-				'isLowBat': 'none'
-			},
-			sonoff: {
-				'Selektor': 'sonoff.*.alive',
-				'adapter': 'sonoff',
-				'rssiState': '.Wifi_Signal',
-				'battery': '.battery',
-				'reach': '.alive',
-				'isLowBat': 'none'
-			},
-			sonos: {
-				'Selektor': 'sonos.*.alive',
-				'adapter': 'sonos',
-				'battery': 'none',
-				'reach': '.alive',
-				'isLowBat': 'none'
-			},
-			switchbotBle: {
-				'Selektor': 'switchbot-ble.*.rssi',
-				'adapter': 'switchbotBle',
-				'battery': '.battery',
-				'reach': 'none',
-				'isLowBat': 'none',
-				'id': '.id'
-			},
-			tado: {
-				'Selektor': 'tado.*.batteryState',
-				'adapter': 'tado',
-				'rssiState': 'none',
-				'battery': 'none',
-				'reach': '.connectionState.value',
-				'isLowBat': '.batteryState',
-				'id': 'none'
-			},
-			tradfri: {
-				'Selektor': 'tradfri.*.lastSeen',
-				'adapter': 'tradfri',
-				'rssiState': 'none',
-				'battery': '.batteryPercentage',
-				'reach': '.alive',
-				'isLowBat': 'none',
-				'id': 'none'
-			},
-			unifi: {
-				'Selektor': 'unifi.*.state',
-				'adapter': 'unifi',
-				'battery': 'none',
-				'reach': '.state',
-				'isLowBat': 'none',
-				'id': 'none'
-			},
-			wled: {
-				'Selektor': 'wled.*._online',
-				'adapter': 'wled',
-				'rssiState': '.wifi.rssi',
-				'battery': 'none',
-				'reach': '._online',
-				'isLowBat': 'none',
-				'id': 'none'
-			},
-			yeelight: {
-				'Selektor': 'yeelight-2.*.connect',
-				'adapter': 'yeelight-2',
-				'battery': 'none',
-				'reach': '.connect',
-				'isLowBat': 'none'
-			},
-			zigbee: {
-				'Selektor': 'zigbee.*.link_quality',
-				'adapter': 'zigbee',
-				'battery': '.battery',
-				'reach': '.available',
-				'isLowBat': '.battery_low'
-			},
-			zwave: {
-				'Selektor': 'zwave2.*.ready',
-				'adapter': 'zwave',
-				'battery': '.Battery.level',
-				'reach': '.ready',
-				'isLowBat': '.Battery.isLow'
-			}
-		};
-
 		this.on('ready', this.onReady.bind(this));
-		// this.on('stateChange', this.onStateChange.bind(this));
+		this.on('stateChange', this.onStateChange.bind(this));
 		// this.on('objectChange', this.onObjectChange.bind(this));
-		// this.on('message', this.onMessage.bind(this));
+		this.on('message', this.onMessage.bind(this));
 		this.on('unload', this.onUnload.bind(this));
 
 	}
@@ -326,6 +60,8 @@ class DeviceWatcher extends utils.Adapter {
 		isUnloaded = false;
 
 		try {
+			this.listOnlyBattery = this.config.listOnlyBattery;
+
 			this.supAdapter = {
 				alexa2: this.config.alexa2Devices,
 				ble: this.config.bleDevices,
@@ -336,10 +72,13 @@ class DeviceWatcher extends utils.Adapter {
 				ham: this.config.hamDevices,
 				harmony: this.config.harmonyDevices,
 				hmiP : this.config.hmiPDevices,
-				homematic: this.config.homematicDevices,
+				hmrpc: this.config.hmrpcDevices,
+				hs100: this.config.hs100Devices,
 				hue: this.config.hueDevices,
 				hueExt: this.config.hueExtDevices,
 				jeelink: this.config.jeelinkDevices,
+				lupusec: this.config.lupusecDevices,
+				maxcube: this.config.maxcubeDevices,
 				meross: this.config.merossDevices,
 				mihome: this.config.mihomeDevices,
 				mihomeGW: this.config.mihomeDevices,
@@ -359,13 +98,54 @@ class DeviceWatcher extends utils.Adapter {
 				wled: this.config.wledDevices,
 				yeelight: this.config.yeelightDevices,
 				zigbee: this.config.zigbeeDevices,
+				zigbee2MQTT: this.config.zigbee2mqttDevices,
 				zwave: this.config.zwaveDevices,
 			};
 
-			for (const [id] of Object.entries(this.arrApart)) {
+			this.maxMinutes = {
+				alexa2: this.config.alexa2MaxMinutes,
+				ble: this.config.bleMaxMinutes,
+				deconz: this.config.deconzMaxMinutes,
+				enocean: this.config.enoceanMaxMinutes,
+				esphome: this.config.esphomeMaxMinutes,
+				fritzdect: this.config.fritzdectMaxMinutes,
+				ham: this.config.hamMaxMinutes,
+				harmony: this.config.harmonyMaxMinutes,
+				hmiP : this.config.hmiPMaxMinutes,
+				hmrpc: this.config.hmrpcMaxMinutes,
+				hs100: this.config.hs100MaxMinutes,
+				hue: this.config.hueMaxMinutes,
+				hueExt: this.config.hueextMaxMinutes,
+				jeelink: this.config.jeelinkMaxMinutes,
+				lupusec: this.config.lupusecMaxMinutes,
+				maxcube: this.config.maxcubeMaxMinutes,
+				meross: this.config.merossMaxMinutes,
+				mihome: this.config.mihomeMaxMinutes,
+				mihomeGW: this.config.mihomeMaxMinutes,
+				mihomeVacuum: this.config.mihomeVacuumMaxMinutes,
+				netatmo: this.config.netatmoMaxMinutes,
+				nukiExt: this.config.nukiextendMaxMinutes,
+				nut: this.config.nutMaxMinutes,
+				ping: this.config.pingMaxMinutes,
+				roomba: this.config.roombaMaxMinutes,
+				shelly: this.config.shellyMaxMinutes,
+				sonoff: this.config.sonoffMaxMinutes,
+				sonos: this.config.sonosMaxMinutes,
+				switchbotBle: this.config.switchbotMaxMinutes,
+				tado: this.config.tadoMaxMinutes,
+				tradfri: this.config.tradfriMaxMinutes,
+				unifi: this.config.unifiMaxMinutes,
+				wled: this.config.wledMaxMinutes,
+				yeelight: this.config.yeelightMaxMinutes,
+				zigbee: this.config.zigbeeMaxMinutes,
+				zigbee2MQTT: this.config.zigbee2mqttMaxMinutes,
+				zwave: this.config.zwaveMaxMinutes,
+			};
+
+			for (const [id] of Object.entries(arrApart)) {
 				if (!isUnloaded) {
 					if (this.supAdapter[id]) {
-						this.arrDev.push(this.arrApart[id]);
+						this.arrDev.push(arrApart[id]);
 						this.adapterSelected.push(await this.capitalize(id));
 					}
 				} else {
@@ -393,7 +173,7 @@ class DeviceWatcher extends utils.Adapter {
 
 			//create and fill datapoints for each adapter if selected
 			try {
-				for (const [id] of Object.entries(this.arrApart)) {
+				for (const [id] of Object.entries(arrApart)) {
 					if (!isUnloaded) {
 						if ((this.supAdapter !== undefined) && (this.supAdapter[id])) {
 
@@ -417,12 +197,65 @@ class DeviceWatcher extends utils.Adapter {
 			// update data in interval
 			await this.refreshData();
 
+			// send overview for low battery devices
+			if (this.config.checkSendBatteryMsg) await this.sendBatteryNotifyShedule();
+
+			// send overview of offline devices
+			if (this.config.checkSendOfflineMsgDaily) await this.sendOfflineNotificationsShedule();
+
 		} catch (error) {
 			this.errorReporting('[onReady]', error);
 			this.terminate ? this.terminate(15) : process.exit(15);
 		}
 	} // <-- onReady end
 
+	/**
+     * Is called if a subscribed state changes
+     * @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`);
+		}
+	}
+
+	/**
+     * @param {ioBroker.Message} obj
+     */
+	onMessage(obj) {
+		const devices = [];
+		let myCount = 0;
+		let result;
+
+		switch (obj.command) {
+			case 'devicesList':
+				if(obj.message){
+					try{
+						result = this.listAllDevicesRaw;
+						for(const element in result){
+							const label = 'Device: ' + result[element].Device + '  - Adapter: ' + result[element].Adapter;
+							const myValueObject = {deviceName: result[element].Device, adapter: result[element].Adapter, path: result[element].Path};
+							devices[myCount] = {label: label,value: JSON.stringify(myValueObject)};
+							myCount ++;
+						}
+						this.sendTo(obj.from, obj.command, devices, obj.callback);
+					}
+					catch(error){
+						this.sendTo(obj.from, obj.command, obj.callback);
+					}
+				}
+				else{
+					this.sendTo(obj.from, obj.command, obj.callback);
+				}
+				break;
+		}
+	}
+
 	async refreshData() {
 		const nextTimeout = this.config.updateinterval * 1000;
 
@@ -433,7 +266,6 @@ class DeviceWatcher extends utils.Adapter {
 			this.log.debug('clearing old refresh timeout');
 			this.clearTimeout(this.refreshDataTimeout);
 		}
-
 		if (!isUnloaded) {
 			this.refreshDataTimeout = this.setTimeout(() => {
 				this.log.debug('Updating Data');
@@ -450,38 +282,31 @@ class DeviceWatcher extends utils.Adapter {
 	async main() {
 		this.log.debug(`Function started: ${this.main.name}`);
 
+		// fill datapoints for each adapter if selected
 		try {
-
-			// fill datapoints for each adapter if selected
-			try {
-				for (const [id] of Object.entries(this.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 each adapter`);
-							}
+			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.
 					}
+				} 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();
-				this.log.debug(`Created and filled data for all adapters`);
-			} catch (error) {
-				this.errorReporting('[main - create data of all adapter]', error);
 			}
+		} 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();
+			this.log.debug(`Created and filled data for all adapters`);
 		} catch (error) {
-			this.errorReporting('[main]', error);
+			this.errorReporting('[main - create data of all adapter]', error);
 		}
 
 		this.log.debug(`Function finished: ${this.main.name}`);
@@ -490,15 +315,23 @@ class DeviceWatcher extends utils.Adapter {
 
 	/**
 	 * @param {string} sentence - Word which should be capitalize
-	 **/
+	 */
 	async capitalize(sentence) {
 		//make the first letter uppercase
 		return sentence && sentence[0].toUpperCase() + sentence.slice(1);
 	}
 
+	/**
+	 * @param {number} dpValue - get Time of this datapoint
+	 */
+	async getTimestamp(dpValue) {
+		const time = new Date();
+		return dpValue = Math.round((time.getTime() - dpValue) / 1000 / 60);
+	}
+
 	/**
 	 * @param {object} obj - State of datapoint
-	 **/
+	 */
 	async getInitValue(obj) {
 		//state can be null or undefinded
 		const foreignState = await this.getForeignStateAsync(obj);
@@ -507,7 +340,7 @@ class DeviceWatcher extends utils.Adapter {
 
 	/**
 	 * @param {object} obj - State of own datapoint
-	 **/
+	 */
 	async getOwnInitValue(obj) {
 		//state can be null or undefinded for own states
 		const stateVal = await this.getStateAsync(obj);
@@ -517,874 +350,578 @@ class DeviceWatcher extends utils.Adapter {
 	async createBlacklist() {
 		this.log.debug(`Function started: ${this.createBlacklist.name}`);
 
-		const myBlacklist = this.config.tableBlacklist;
+		if (!isUnloaded) {
+			const myBlacklist = this.config.tableBlacklist;
 
-		for (const i in myBlacklist) {
-			if (!isUnloaded) {
-				this.blacklistArr.push(myBlacklist[i].device);
-			} else {
-				return; // cancel run if unloaded was called.
+			for (const i in myBlacklist) {
+				const blacklistParse = JSON.parse(myBlacklist[i].devices);
+				// push devices in list to ignor device in lists
+				if (myBlacklist[i].checkIgnorLists) {
+					this.blacklistLists.push(blacklistParse.path);
+				}
+				// push devices in list to ignor device in notifications
+				if (myBlacklist[i].checkIgnorNotify) {
+					this.blacklistNotify.push(blacklistParse.deviceName);
+				}
 			}
+
+			if (this.blacklistLists.length >= 1) this.log.info(`Found items on blacklist for lists: ${this.blacklistLists}`);
+			if (this.blacklistNotify.length >= 1) this.log.info(`Found items on blacklist for notificatioons: ${this.blacklistNotify}`);
+		} else {
+			return; // cancel run if unloaded was called.
 		}
-		this.log.info(`Found items on the blacklist: ${this.blacklistArr}`);
+
 		this.log.debug(`Function finished: ${this.createBlacklist.name}`);
 	}
 
 	/**
-	 * @param {object} i - Device Object
-	 **/
-	async createData(i) {
-		const devices = await this.getForeignStatesAsync(this.arrDev[i].Selektor);
-		const deviceAdapterName = await this.capitalize(this.arrDev[i].adapter);
-
-		/*----------  Start of second main loop  ----------*/
-		for (const [id] of Object.entries(devices)) {
-			if (!isUnloaded) {
-				if (!this.blacklistArr.includes(id)) {
-
-					const currDeviceString = id.slice(0, (id.lastIndexOf('.') + 1) - 1);
-					const shortCurrDeviceString = currDeviceString.slice(0, (currDeviceString.lastIndexOf('.') + 1) - 1);
-					const shortshortCurrDeviceString = shortCurrDeviceString.slice(0, (shortCurrDeviceString.lastIndexOf('.') + 1) - 1);
-
-					// Get device name
-					const deviceObject = await this.getForeignObjectAsync(currDeviceString);
-					const shortDeviceObject = await this.getForeignObjectAsync(shortCurrDeviceString);
-					const shortshortDeviceObject = await this.getForeignObjectAsync(shortshortCurrDeviceString);
-					let deviceName;
-
-					// Get ID with currDeviceString from datapoint
-					switch (this.arrDev[i].adapter) {
-						case 'switchbotBle':	// Get ID for Switchbot and ESPHome Devices
-						case 'esphome':
-							deviceName = await this.getInitValue(currDeviceString + this.arrDev[i].id);
-							break;
-
-							// Get ID with short currDeviceString from objectjson
-						case 'hue-extended':
-						case 'homematic':
-						case 'nuki-extended':
-						case 'wled':
-							if (shortDeviceObject && typeof shortDeviceObject === 'object') {
-								deviceName = shortDeviceObject.common.name;
-							}
-							break;
-
-							// Get ID with short short currDeviceString vom objectjson
-						case 'hmiP':
-							if (shortshortDeviceObject && typeof shortshortDeviceObject === 'object') {
-								deviceName = shortshortDeviceObject.common.name;
-							}
-							break;
-
-							// Get ID with short currDeviceString from datapoint
-						case 'mihomeVacuum':
-						case 'roomba':
-							deviceName = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].id);
-							break;
-
-							//Get ID of foldername
-						case 'tado':
-							deviceName = currDeviceString.slice(currDeviceString.lastIndexOf('.') + 1);
-							break;
-
-							//Get ID of foldername
-						case 'yeelight-2':
-							deviceName = shortCurrDeviceString.slice(shortCurrDeviceString.lastIndexOf('.') + 1);
-							break;
+	 * @param {object} id - deviceID
+	 * @param {object} i - each Device
+	 */
+	async getDeviceName(id, i) {
+		const currDeviceString = id.slice(0, (id.lastIndexOf('.') + 1) - 1);
+		const shortCurrDeviceString = currDeviceString.slice(0, (currDeviceString.lastIndexOf('.') + 1) - 1);
+		const shortshortCurrDeviceString = shortCurrDeviceString.slice(0, (shortCurrDeviceString.lastIndexOf('.') + 1) - 1);
+
+		// Get device name
+		const deviceObject = await this.getForeignObjectAsync(currDeviceString);
+		const shortDeviceObject = await this.getForeignObjectAsync(shortCurrDeviceString);
+		const shortshortDeviceObject = await this.getForeignObjectAsync(shortshortCurrDeviceString);
+		let deviceName;
+
+		// Get ID with currDeviceString from datapoint
+		switch (this.arrDev[i].adapter) {
+			// Get ID for Switchbot and ESPHome Devices
+			case 'switchbotBle':
+			case 'esphome':
+				deviceName = await this.getInitValue(currDeviceString + this.arrDev[i].id);
+				break;
+
+			// Get ID with short currDeviceString from objectjson
+			case 'hue-extended':
+			case 'hmrpc':
+			case 'nuki-extended':
+			case 'wled':
+				if (shortDeviceObject && typeof shortDeviceObject === 'object') {
+					deviceName = shortDeviceObject.common.name;
+				}
+				break;
 
-							// Get ID with main selektor from objectjson
-						default:
-							if (deviceObject && typeof deviceObject === 'object') {
-								deviceName = deviceObject.common.name;
-							}
-							break;
+			// Get ID with short short currDeviceString from objectjson (HMiP Devices)
+			case 'hmiP':
+				if (shortshortDeviceObject && typeof shortshortDeviceObject === 'object') {
+					deviceName = shortshortDeviceObject.common.name;
+				}
+				break;
+
+			// Get ID with short currDeviceString from datapoint
+			case 'mihomeVacuum':
+			case 'roomba':
+				deviceName = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].id);
+				break;
+
+			//Get ID of foldername
+			case 'tado':
+				deviceName = currDeviceString.slice(currDeviceString.lastIndexOf('.') + 1);
+				break;
+
+			//Get ID of foldername
+			case 'yeelight-2':
+				deviceName = shortCurrDeviceString.slice(shortCurrDeviceString.lastIndexOf('.') + 1);
+				break;
+
+			// Get ID with main selektor from objectjson
+			default:
+				if (deviceObject && typeof deviceObject === 'object') {
+					if (deviceObject.common.name['de'] != undefined) {
+						deviceName = deviceObject.common.name['de'];
+					} else if (deviceObject.common.name['en'] != undefined) {
+						deviceName = deviceObject.common.name['en'];
+					} else {
+						deviceName = deviceObject.common.name;
 					}
+				}
+				break;
+		}
+		return deviceName;
+	}
 
-					const deviceMainSelector = await this.getForeignStateAsync(id);
-					const deviceStateSelector = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].stateValue); // for homematic devices
-
-					// Get battery states
-					const deviceBatteryState = await this.getInitValue(currDeviceString + this.arrDev[i].battery);
-					const shortDeviceBatteryState = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].battery);
-					const shortDeviceBatteryState2 = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].battery2);
-
-					// Get link quality
-					let deviceQualityState;
-					let linkQuality;
-
-					switch (this.arrDev[i].adapter) {
-						case 'sonoff':
-						case 'hmiP':
-						case 'homematic':
-						case 'wled':
-						case 'shelly':
-							deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiState);
-							break;
+	/**
+	 * Create Lists
+	 */
+	async createLists() {
+		this.linkQualityDevices = [];
+		this.batteryPowered = [];
+		this.batteryLowPowered = [];
+		this.listAllDevices = [];
+		this.offlineDevices = [];
 
-						case 'mihomeVacuum':
-							deviceQualityState = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].rssiState);
-							break;
+		for (const device of this.listAllDevicesRaw) {
+			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['Battery'] != ' - ') {
+					this.batteryPowered.push(
+						{
+							'Device': device['Device'],
+							'Adapter': device['Adapter'],
+							'Battery': device['Battery']
+						}
+					);
+				}
+				// Low Bat lists
+				if (device['LowBat']) {
+					this.batteryLowPowered.push(
+						{
+							'Device': device['Device'],
+							'Adapter': device['Adapter'],
+							'Battery': device['Battery']
+						}
+					);
+				}
 
-						case 'tradfri':
-						case 'ham':
-						case 'meross':
-						case 'nut':
-						case 'miHome':
-						case 'unifi':
-							deviceQualityState;
-							break;
+				// Offline List
+				if (device['Status'] === 'Offline') {
+					this.offlineDevices.push(
+						{
+							'Device': device['Device'],
+							'Adapter': device['Adapter'],
+							'Last contact': device['Last contact']
+						}
+					);
+				}
+			}
+		}
+	}
 
-						case 'netatmo':
-							deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiState);
-							if (!deviceQualityState) {
-								deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rfState);
-							}
-							break;
+	/**
+	 * Count devices for each type
+	 */
+	async countDevices() {
+		// Count how many devices with link Quality
+		this.linkQualityCount = this.linkQualityDevices.length;
 
-						default:
-							deviceQualityState = await this.getForeignStateAsync(id);
-							break;
-					}
+		// Count how many devcies are offline
+		this.offlineDevicesCount = this.offlineDevices.length;
 
-					if ((deviceQualityState) && (typeof deviceQualityState.val === 'number')) {
-						if (this.config.trueState) {
-							linkQuality = deviceQualityState.val;
-						} else {
-						// If Quality State is already an percent value
-							switch (this.arrDev[i].adapter) {
-								case 'roomba':
-									linkQuality = deviceQualityState.val + '%';
-									break;
+		// Count how many devices are with battery
+		this.batteryPoweredCount = this.batteryPowered.length;
 
-								default:
-								// If Quality State is an RSSI vaulue calculate in percent:
-									if (deviceQualityState.val == -255) {
-										linkQuality = ' - ';
-									} else if (deviceQualityState.val < 0) {
-										linkQuality = Math.min(Math.max(2 * (deviceQualityState.val + 100), 0), 100) + '%';
+		// 3d. Count how many devices are with low battery
+		this.lowBatteryPoweredCount = this.batteryLowPowered.length;
 
-										// 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;
-							}
+		// Count how many devices are exists
+		this.deviceCounter = this.listAllDevices.length;
+	}
 
-						}
-						if (this.config.listOnlyBattery) {
-							if (deviceBatteryState || shortDeviceBatteryState) {
-								this.linkQualityDevices.push(
-									{
-										'Device': deviceName,
-										'Adapter': deviceAdapterName,
-										'Signal strength': linkQuality
-									}
-								);
-							}
-						} else {
-							this.linkQualityDevices.push(
-								{
-									'Device': deviceName,
-									'Adapter': deviceAdapterName,
-									'Signal strength': linkQuality
-								}
-							);
-						}
-					} else if ((deviceQualityState) && (typeof deviceQualityState.val === 'string')) {
-						switch (this.arrDev[i].adapter) {
-							case 'netatmo':
-								// for Netatmo devices
-								linkQuality = deviceQualityState.val;
-								break;
-							case 'nuki-extended':
-								linkQuality = ' - ';
-								break;
-						}
+	/**
+	 * @param {object} i - Device Object
+	 */
+	async createData(i) {
+		const devices = await this.getForeignStatesAsync(this.arrDev[i].Selektor);
+		const deviceAdapterName = await this.capitalize(this.arrDev[i].adapter);
 
-						if (this.config.listOnlyBattery) {
-							if (deviceBatteryState || shortDeviceBatteryState) {
-								this.linkQualityDevices.push(
-									{
-										'Device': deviceName,
-										'Adapter': deviceAdapterName,
-										'Signal strength': linkQuality
-									}
-								);
-							}
-						} else {
-							this.linkQualityDevices.push(
-								{
-									'Device': deviceName,
-									'Adapter': deviceAdapterName,
-									'Signal strength': linkQuality
-								}
-							);
-						}
-					}
-					else {
-						linkQuality = ' - '; // no linkQuality available for powered devices
-					}
+		/*----------  Start of second main loop  ----------*/
+		for (const [id] of Object.entries(devices)) {
+			if (!isUnloaded) {
 
-					// Count how many devices with link Quality
-					this.linkQualityCount = this.linkQualityDevices.length;
 
-					// When was the last contact to the device?
-					let lastContactString;
 
-					let deviceState = 'Online';
-					if (deviceMainSelector) {
-						try {
-							const time = new Date();
-							const lastContact = Math.round((time.getTime() - deviceMainSelector.ts) / 1000 / 60);
-							const lastStateChange = Math.round((time.getTime() - deviceMainSelector.lc) / 1000 / 60);
-							const deviceUnreachState = await this.getInitValue(currDeviceString + this.arrDev[i].reach);
-							const shortDeviceUnreachState = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].reach);
+				const deviceName = await this.getDeviceName(id, i);
 
+				const currDeviceString = id.slice(0, (id.lastIndexOf('.') + 1) - 1);
+				const shortCurrDeviceString = currDeviceString.slice(0, (currDeviceString.lastIndexOf('.') + 1) - 1);
 
-							const getLastContact = async () => {
-								lastContactString = this.formatDate(new Date((deviceMainSelector.ts)), 'hh:mm') + ' Uhr';
-								if (Math.round(lastContact) > 100) {
-									lastContactString = Math.round(lastContact / 60) + ' Stunden';
-								}
-								if (Math.round(lastContact / 60) > 48) {
-									lastContactString = Math.round(lastContact / 60 / 24) + ' Tagen';
-								}
-								return lastContactString;
-							};
+				// Get battery states
+				const deviceBatteryState = await this.getInitValue(currDeviceString + this.arrDev[i].battery);
+				const shortDeviceBatteryState = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].battery);
+				const shortDeviceBatteryState2 = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].battery2);
 
-							const getLastStateChange = async () => {
-								lastContactString = this.formatDate(new Date((deviceMainSelector.lc)), 'hh:mm') + ' Uhr';
-								if (Math.round(lastStateChange) > 100) {
-									lastContactString = Math.round(lastStateChange / 60) + ' Stunden';
-								}
-								if (Math.round(lastStateChange / 60) > 48) {
-									lastContactString = Math.round(lastStateChange / 60 / 24) + ' Tagen';
-								}
-								return lastContactString;
-							};
 
+				//this.devices[deviceName] = currDeviceString + 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':
-									await getLastContact();
-									break;
+				/*for (const [value] of Object.entries(this.devices)) {
+						this.log.warn(`${value}`);
+						this.subscribeForeignStatesAsync(value);
+					}*/
+				//this.subscribeForeignStatesAsync(currDeviceString + this.arrDev[i].reach);
+				// <--- END TEST
 
-								default:
-								//State changed
-									if  (this.arrDev[i].adapter == 'homematic') {
-										if (linkQuality != ' - ') {
-											if (deviceUnreachState) {
-												await getLastStateChange();
-											} else {
-												await getLastContact();
-											}
-										} else {
-											if (deviceStateSelector) { // because old hm devices don't send rssi states
-												const lastContactOfState = Math.round((time.getTime() - deviceStateSelector.ts) / 1000 / 60);
-												const getLastContactOfState = async () => {
-													lastContactString = this.formatDate(new Date((deviceStateSelector.ts)), 'hh:mm') + ' Uhr';
-													if (Math.round(lastContactOfState) > 100) {
-														lastContactString = Math.round(lastContactOfState / 60) + ' Stunden';
-													}
-													if (Math.round(lastContactOfState / 60) > 48) {
-														lastContactString = Math.round(lastContactOfState / 60 / 24) + ' Tagen';
-													}
-													return lastContactString;
-												};
-												await getLastContactOfState();
-											}
-										}
+				// Get link quality
+				let deviceQualityState;
+				let linkQuality;
 
-									} else {
-										if ((!deviceUnreachState)) {
-											await getLastStateChange();
-										} else {
-											await getLastContact();
-										}
-										break;
-									}
-							}
+				switch (this.arrDev[i].adapter) {
+					case 'mihomeVacuum':
+						deviceQualityState = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].rssiState);
+						break;
 
-							const pushOfflineDevice = async () => {
-								if (this.config.listOnlyBattery) {	//if checked, list only battery devices
-									if (deviceBatteryState || shortDeviceBatteryState) {
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
-									}
-								} else {
-									this.offlineDevices.push( 	//else push all devices
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
-								}
-							};
+					case 'netatmo':
+						deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiState);
+						if (!deviceQualityState) {
+							deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rfState);
+						}
+						break;
 
-							switch (this.arrDev[i].adapter) {
-								case 'alexa2':
-									if (this.config.alexa2MaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.alexa2MaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'ble':
-									if (this.config.bleMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.bleMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'deconz':
-									if (this.config.deconzMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.deconzMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'enocean':
-									if (this.config.enoceanMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.enoceanMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'esphome':
-									if (this.config.esphomeMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.esphomeMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'fritzDect':
-									if (this.config.fritzdectMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.fritzdectMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'harmony':
-									if (this.config.harmonyMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.harmonyMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'ham':
-									if (this.config.hamMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.hamMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'hmiP':
-									if (this.config.hmiPMaxMinutes === -1) {
-										if (deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.hmiPMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'homematic':
-									if (this.config.homematicMaxMinutes === -1) {
-										if (deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.homematicMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'hue':
-									if (this.config.hueMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.hueMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'hue-extended':
-									if (this.config.hueextMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.hueextMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'jeelink':
-									if (this.config.jeelinkMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.jeelinkMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'meross':
-									if (this.config.merossMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.merossMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'miHome':
-									if (this.config.mihomeMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.mihomeMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'mihomeVacuum':
-									if (this.config.mihomeVacuumMaxMinutes === -1) {
-										if (!shortDeviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
+					default:
+						deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiState);
+						break;
+				}
+
+				if (deviceQualityState != null) {
+					switch (typeof deviceQualityState.val) {
+						case 'number':
+							if (this.config.trueState) {
+								linkQuality = deviceQualityState.val;
+							} else {
+								switch (this.arrDev[i].adapter) {
+									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)) + '%';
 										}
-									} else if (lastContact > this.config.mihomeVacuumMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
+										break;
+								}
+							}
+							break;
+
+						case 'string':
+							switch (this.arrDev[i].adapter) {
 								case 'netatmo':
-									if (this.config.netatmoMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.netatmoMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
+									// for Netatmo devices
+									linkQuality = deviceQualityState.val;
 									break;
 								case 'nuki-extended':
-									if (this.config.nukiextendMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.nukiextendMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'nut':
-									if (this.config.nutMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.nutMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'ping':
-									if (this.config.pingMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if ((lastStateChange > this.config.pingMaxMinutes) && (!deviceUnreachState)) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'roomba':
-									if (this.config.roombaMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.roombaMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
+									linkQuality = ' - ';
 									break;
-								case 'shelly':
-									if (this.config.shellyMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
+							}
+							break;
+					}
+				} else {
+					linkQuality = ' - ';
+				}
+
+				// When was the last contact to the device?
+				let lastContactString;
+				let deviceState = 'Online';
+				let lastDeviceUnreachStateChange;
+
+				const deviceMainSelector = await this.getForeignStateAsync(id);
+				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 lastStateChange = await this.getTimestamp(deviceMainSelector.lc);
+						const deviceUnreachState = await this.getInitValue(currDeviceString + this.arrDev[i].reach);
+						const deviceUnreachSelector = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].reach);
+						if (deviceUnreachSelector) {lastDeviceUnreachStateChange = await this.getTimestamp(deviceUnreachSelector.lc);}
+						const shortDeviceUnreachState = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].reach);
+
+						const getLastContact = async () => {
+							lastContactString = this.formatDate(new Date((deviceMainSelector.ts)), 'hh:mm') + ' Uhr';
+							if (Math.round(lastContact) > 100) {
+								lastContactString = Math.round(lastContact / 60) + ' Stunden';
+							}
+							if (Math.round(lastContact / 60) > 48) {
+								lastContactString = Math.round(lastContact / 60 / 24) + ' Tagen';
+							}
+							return lastContactString;
+						};
+
+						const getLastStateChange = async () => {
+							lastContactString = this.formatDate(new Date((deviceMainSelector.lc)), 'hh:mm') + ' Uhr';
+							if (Math.round(lastStateChange) > 100) {
+								lastContactString = Math.round(lastStateChange / 60) + ' Stunden';
+							}
+							if (Math.round(lastStateChange / 60) > 48) {
+								lastContactString = Math.round(lastStateChange / 60 / 24) + ' Tagen';
+							}
+							return lastContactString;
+						};
+
+						//  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':
+								await getLastContact();
+								break;
+
+							default:
+								//State changed
+								if  (this.arrDev[i].adapter === 'hmrpc') {
+									if (linkQuality != ' - ') {
+										if (deviceUnreachState) {
+											await getLastStateChange();
+										} else {
+											await getLastContact();
 										}
-									} else if (lastContact > this.config.shellyMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
-									}
-									break;
-								case 'sonoff':
-									if (this.config.sonoffMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
+									} else {
+										if (deviceStateSelector) { // because old hm devices don't send rssi states
+											const lastContactOfState = await this.getTimestamp(deviceStateSelector.ts);
+											const getLastContactOfState = async () => {
+												lastContactString = this.formatDate(new Date((deviceStateSelector.ts)), 'hh:mm') + ' Uhr';
+												if (Math.round(lastContactOfState) > 100) {
+													lastContactString = Math.round(lastContactOfState / 60) + ' Stunden';
+												}
+												if (Math.round(lastContactOfState / 60) > 48) {
+													lastContactString = Math.round(lastContactOfState / 60 / 24) + ' Tagen';
+												}
+												return lastContactString;
+											};
+											await getLastContactOfState();
+										} else if (rssiPeerSelector) { // because old hm sensors don't send rssi/state values
+											const lastContactOfState = await this.getTimestamp(rssiPeerSelector.ts);
+											const getLastContactOfState = async () => {
+												lastContactString = this.formatDate(new Date((rssiPeerSelector.ts)), 'hh:mm') + ' Uhr';
+												if (Math.round(lastContactOfState) > 100) {
+													lastContactString = Math.round(lastContactOfState / 60) + ' Stunden';
+												}
+												if (Math.round(lastContactOfState / 60) > 48) {
+													lastContactString = Math.round(lastContactOfState / 60 / 24) + ' Tagen';
+												}
+												return lastContactString;
+											};
+											await getLastContactOfState();
 										}
-									} else if (lastContact > this.config.sonoffMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
 									}
-									break;
-								case 'sonos':
-									if (this.config.sonosMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.sonosMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
+
+								} else {
+									if (!deviceUnreachState) {
+										await getLastStateChange();
+									} else {
+										await getLastContact();
 									}
 									break;
-								case 'switchbotBle':
-									if (this.config.switchbotMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.switchbotMaxMinutes) {
+								}
+						}
+
+						const adapterID = this.arrDev[i].adapter;
+
+						switch (adapterID) {
+							case 'hmrpc':
+							case 'hmiP':
+							case 'maxcube':
+								if ((this.maxMinutes !== undefined) && (this.maxMinutes[adapterID] === -1)) {
+									if (deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
 									}
-									break;
-								case 'tado':
-									if (this.config.tadoMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.tadoMaxMinutes) {
+								} else if ((this.maxMinutes !== undefined) && (lastContact > this.maxMinutes[adapterID])) {
+									deviceState = 'Offline'; //set online state to offline
+								}
+								break;
+							case 'ping':
+								if ((this.maxMinutes !== undefined) && (this.maxMinutes[adapterID] === -1)) {
+									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
 									}
-									break;
-								case 'tradfri':
-									if (this.config.tradfriMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.tradfriMaxMinutes) {
+								} else if ((this.maxMinutes !== undefined) && (lastContact > this.maxMinutes[adapterID]) && (!deviceUnreachState)) {
+									deviceState = 'Offline'; //set online state to offline
+								}
+								break;
+							case 'unifi':
+								if ((this.maxMinutes !== undefined) && (this.maxMinutes[adapterID] === -1)) {
+									if (deviceUnreachState === 0) {
 										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
 									}
-									break;
-								case 'unifi':
-									if (this.config.unifiMaxMinutes === -1) {
-										if (deviceUnreachState === 0) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.unifiMaxMinutes) {
+								} else if ((this.maxMinutes !== undefined) && (lastContact > this.maxMinutes[adapterID])) {
+									deviceState = 'Offline'; //set online state to offline
+
+								}
+								break;
+							case 'shelly':
+							case 'sonoff':
+								if ((this.maxMinutes !== undefined) && (this.maxMinutes[adapterID] === -1)) {
+									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
 									}
-									break;
-								case 'wled':
-									if (this.config.wledMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.wledMaxMinutes) {
+								} else if ((!deviceUnreachState) && (typeof lastDeviceUnreachStateChange !== 'undefined') && (this.maxMinutes !== undefined) && (lastContact > this.maxMinutes[adapterID])) {
+									deviceState = 'Offline'; //set online state to offline
+								}
+								break;
+							case 'mihomeVacuum':
+								if ((this.maxMinutes !== undefined) && (this.maxMinutes[adapterID] === -1)) {
+									if (!shortDeviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
 									}
-									break;
-								case 'yeelight-2':
-									if (this.config.yeelightMaxMinutes === -1) {
+								} else if ((this.maxMinutes !== undefined) && (lastContact > this.maxMinutes[adapterID])) {
+									deviceState = 'Offline'; //set online state to offline
+								}
+								break;
+							case 'miHome':
+								if (this.arrDev[i].battery === 'none') {
+									if ((this.maxMinutes !== undefined) && (this.maxMinutes[adapterID] === -1)) {
 										if (!deviceUnreachState) {
 											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
 										}
-									} else if (lastContact > this.config.yeelightMaxMinutes) {
+									} else if ((this.maxMinutes !== undefined) && (lastContact > this.maxMinutes[adapterID])) {
 										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
 									}
-									break;
-								case 'zigbee':
-									if (this.config.zigbeeMaxMinutes === -1) {
-										if (!deviceUnreachState) {
+								} else {
+									if (this.config.mihomeMaxMinutes === -1) {
+										if ((this.maxMinutes !== undefined) && (this.maxMinutes[adapterID] === -1)) {
 											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
 										}
-									} else if (lastContact > this.config.zigbeeMaxMinutes) {
+									} else if ((this.maxMinutes !== undefined) && (lastContact > this.maxMinutes[adapterID])) {
 										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
 									}
-									break;
-								case 'zwave':
-									if (this.config.zwaveMaxMinutes === -1) {
-										if (!deviceUnreachState) {
-											deviceState = 'Offline'; //set online state to offline
-											await pushOfflineDevice();
-										}
-									} else if (lastContact > this.config.zwaveMaxMinutes) {
-										deviceState = 'Offline'; //set online state to offline
-										await pushOfflineDevice();
+								}
+								break;
+							default:
+								if ((this.maxMinutes !== undefined) && (this.maxMinutes[adapterID] === -1)) {
+									if (!deviceUnreachState) {
+										deviceState = 'Offline';  //set online state to offline
 									}
-									break;
-							}
-						} catch (error) {
-							this.errorReporting('[getLastContact]', error);
+								} else if ((this.maxMinutes !== undefined) && (lastContact > this.maxMinutes[adapterID])) {
+									deviceState = 'Offline'; //set online state to offline
+								}
+								break;
 						}
+					} catch (error) {
+						this.errorReporting('[getLastContact]', error);
 					}
+				}
 
+				// Get battery states
+				let batteryHealth;
+				let lowBatIndicator;
+				let deviceLowBatState = await this.getInitValue(currDeviceString + this.arrDev[i].isLowBat);
+				if (deviceLowBatState === undefined) {
+					deviceLowBatState = await this.getInitValue(currDeviceString + this.arrDev[i].isLowBat2);
+				}
 
-
-					// Count how many devcies are offline
-					this.offlineDevicesCount = this.offlineDevices.length;
-
-					// Get battery states
-					let batteryHealth;
-					const deviceLowBatState = await this.getInitValue(currDeviceString + this.arrDev[i].isLowBat);
-					const deviceLowBatStateHM = await this.getInitValue(currDeviceString + this.arrDev[i].isLowBat2);
-
-					if ((!deviceBatteryState) && (!shortDeviceBatteryState) && (!shortDeviceBatteryState2)) {
-						if ((deviceLowBatState !== undefined) || (deviceLowBatState !== undefined) || (deviceLowBatStateHM !== undefined)) {
-							switch (this.arrDev[i].isLowBat) {
-								case 'none':
-									batteryHealth = ' - ';
-									break;
-								default:
-									if ((!deviceLowBatState) || (deviceLowBatState == 'NORMAL')) {
-										batteryHealth = 'ok';
-									} else {
-										batteryHealth = 'low';
-									}
-									break;
-							}
-							switch (this.arrDev[i].isLowBat2) {
-								case 'none':
-									batteryHealth = ' - ';
-									break;
-								default:
-									if ((!deviceLowBatState) || (deviceLowBatState == 'NORMAL')) {
-										batteryHealth = 'ok';
-									} else {
-										batteryHealth = 'low';
-									}
-									break;
-							}
-							this.batteryPowered.push(
-								{
-									'Device': deviceName,
-									'Adapter': deviceAdapterName,
-									'Battery': batteryHealth
-								}
-							);
-						} else {
-							batteryHealth = ' - ';
-						}
-					} else {
-						switch (this.arrDev[i].adapter) {
-							case 'homematic':
-								if (deviceBatteryState === 0) {
-									batteryHealth = ' - ';
-								} else {
-									batteryHealth = deviceBatteryState + 'V';
-								}
-
-								this.batteryPowered.push(
-									{
-										'Device': deviceName,
-										'Adapter': deviceAdapterName,
-										'Battery': batteryHealth
-									}
-								);
-								break;
-							case 'hue-extended':
-								if (shortDeviceBatteryState) {
-									batteryHealth = shortDeviceBatteryState + '%';
-									this.batteryPowered.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Battery': batteryHealth
-										}
-									);
-								}
+				if ((!deviceBatteryState) && (!shortDeviceBatteryState) && (!shortDeviceBatteryState2)) {
+					if (deviceLowBatState !== undefined) {
+						switch (this.arrDev[i].isLowBat || this.arrDev[i].isLowBat2) {
+							case 'none':
+								batteryHealth = ' - ';
 								break;
-							case 'mihomeVacuum':
-								if (shortDeviceBatteryState) {
-									batteryHealth = shortDeviceBatteryState + '%';
-									this.batteryPowered.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Battery': batteryHealth
-										}
-									);
-								} else if (shortDeviceBatteryState2) {
-									batteryHealth = shortDeviceBatteryState2 + '%';
-									this.batteryPowered.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Battery': batteryHealth
-										}
-									);
+							default:
+								if ((deviceLowBatState === false) || (deviceLowBatState === 'NORMAL') || (deviceLowBatState === 1)) {
+									batteryHealth = 'ok';
+								} else {
+									batteryHealth = 'low';
 								}
 								break;
-							default:
-								batteryHealth = (deviceBatteryState) + '%';
-								this.batteryPowered.push(
-									{
-										'Device': deviceName,
-										'Adapter': deviceAdapterName,
-										'Battery': batteryHealth
-									}
-								);
 						}
+					} else {
+						batteryHealth = ' - ';
 					}
-
-					// Count how many devices are with battery
-					this.batteryPoweredCount = this.batteryPowered.length;
-
-					// Count how many devices are with low battery
-					const batteryWarningMin = this.config.minWarnBatterie;
-
-					// fill list with low battery devices
+				} else {
 					switch (this.arrDev[i].adapter) {
-						case 'homematic': // there are differnt low bat states between hm and hmIp devices
-							if (deviceLowBatState || deviceLowBatStateHM) {
-								this.batteryLowPowered.push(
-									{
-										'Device': deviceName,
-										'Adapter': deviceAdapterName,
-										'Battery': batteryHealth
-									}
-								);
+						case 'hmrpc':
+							if (deviceBatteryState === 0) {
+								batteryHealth = ' - ';
+							} else {
+								batteryHealth = deviceBatteryState + 'V';
 							}
 							break;
 
-						case 'tado': // there is an string as indicator
-							if (deviceLowBatState != 'NORMAL') {
-								this.batteryLowPowered.push(
-									{
-										'Device': deviceName,
-										'Adapter': deviceAdapterName,
-										'Battery': batteryHealth
-									}
-								);
+						case 'hue-extended':
+							if (shortDeviceBatteryState) {
+								batteryHealth = shortDeviceBatteryState + '%';
 							}
 							break;
-
-						default: // for all other devices with low bat states
-							if (deviceLowBatState) {
-								this.batteryLowPowered.push(
-									{
-										'Device': deviceName,
-										'Adapter': deviceAdapterName,
-										'Battery': batteryHealth
-									}
-								);
-							} else if (deviceBatteryState && (deviceBatteryState < batteryWarningMin)) { // if the battery state is under the set limit
-								this.batteryLowPowered.push(
-									{
-										'Device': deviceName,
-										'Adapter': deviceAdapterName,
-										'Battery': batteryHealth
-									}
-								);
+						case 'mihomeVacuum':
+							if (shortDeviceBatteryState) {
+								batteryHealth = shortDeviceBatteryState + '%';
+							} else if (shortDeviceBatteryState2) {
+								batteryHealth = shortDeviceBatteryState2 + '%';
 							}
+							break;
+						default:
+							batteryHealth = (deviceBatteryState) + '%';
 					}
+				}
 
-					// 3d. Count how many devices are with low battery
-					this.lowBatteryPoweredCount = this.batteryLowPowered.length;
-
-					if (this.config.listOnlyBattery) {   // 4. Add only devices with battery in the list
-						if (deviceBatteryState || shortDeviceBatteryState) {
-							this.listAllDevices.push(
-								{
-									'Device': deviceName,
-									'Adapter': deviceAdapterName,
-									'Battery': batteryHealth,
-									'Signal strength': linkQuality,
-									'Last contact': lastContactString,
-									'Status': deviceState
-								}
-							);
+				// fill list with low battery devices
+				switch (this.arrDev[i].adapter) {
+					case 'hmrpc': // there are differnt low bat states between hm and hmIp devices
+						if (deviceLowBatState) {
+							lowBatIndicator = true;
+						}
+						break;
+					case 'tado': // there is an string as indicator
+						if (deviceLowBatState != 'NORMAL') {
+							lowBatIndicator = true;
+						}
+						break;
+
+					default: // for all other devices with low bat states
+						if ((deviceLowBatState === true) || (deviceLowBatState === 0)) {
+							lowBatIndicator = true;
+						} else if (deviceBatteryState && (deviceBatteryState < this.config.minWarnBatterie)) { // if the battery state is under the set limit
+							lowBatIndicator = true;
 						}
-					} else if (!this.config.listOnlyBattery) { // 4. Add all devices
-						this.listAllDevices.push(
+				}
+				if (this.listOnlyBattery) {   // Add only devices with battery in the list
+					if (deviceBatteryState || shortDeviceBatteryState) {
+						this.listAllDevicesRaw.push(
 							{
+								'Path': id,
 								'Device': deviceName,
 								'Adapter': deviceAdapterName,
 								'Battery': batteryHealth,
+								'LowBat': lowBatIndicator,
 								'Signal strength': linkQuality,
 								'Last contact': lastContactString,
 								'Status': deviceState
 							}
 						);
 					}
-
-
-					// 4a. Count how many devices are exists
-					this.deviceCounter = this.listAllDevices.length;
+				} else { // Add all devices
+					this.listAllDevicesRaw.push(
+						{
+							'Path': id,
+							'Device': deviceName,
+							'Adapter': deviceAdapterName,
+							'Battery': batteryHealth,
+							'LowBat': lowBatIndicator,
+							'Signal strength': linkQuality,
+							'Last contact': lastContactString,
+							'Status': deviceState
+						}
+					);
 				}
 			} else {
 				return; // cancel run if unloaded was called.
 			}
 		} // <-- end of loop
+		await this.createLists();
+		await this.countDevices();
 	} // <-- end of createData
 
 
@@ -1396,8 +933,6 @@ class DeviceWatcher extends utils.Adapter {
 		this.log.debug(`Function started: ${this.createDataForEachAdapter.name}`);
 
 		try {
-			await this.resetVars(); // reset the arrays and counts
-
 			for (let i = 0; i < this.arrDev.length; i++) {
 
 				if (this.arrDev[i].adapter.includes(adptName)) { // list device only if selected adapter matched with device
@@ -1405,6 +940,8 @@ class DeviceWatcher extends utils.Adapter {
 				}
 			}
 			await this.writeDatapoints(adptName); // fill the datapoints
+			await this.resetVars(); // reset the arrays and counts
+
 		} catch (error) {
 			this.errorReporting('[createDataForEachAdapter]', error);
 		}
@@ -1427,10 +964,11 @@ class DeviceWatcher extends utils.Adapter {
 				}
 			}
 
-			if (this.config.checkSendOfflineMsg) await this.sendOfflineNotifications(); // send message if new devices are offline
-			if (this.config.checkSendOfflineMsgDaily) await this.sendDailyOfflineNotifications(); // send daily overview of offline devices
-			if (this.config.checkSendBatteryMsg) await this.sendBatteryNotifications(); // send message for low battery devices
+			// 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);
 		}
@@ -1442,7 +980,7 @@ class DeviceWatcher extends utils.Adapter {
 	/**
 	 * Notification service
 	 * @param {string} text - Text which should be send
-	 **/
+	 */
 	async sendNotification(text) {
 
 		// Pushover
@@ -1560,6 +1098,55 @@ class DeviceWatcher extends utils.Adapter {
 		}
 	} // <-- End of sendNotification function
 
+	async sendBatteryNotifyShedule() {
+		// send message for low battery devices
+
+		const time = (this.config.checkSendBatteryTime).split(':');
+
+		const checkDays = []; // list of selected days
+
+		// push the selected days in list
+		if (this.config.checkMonday) checkDays.push(1);
+		if (this.config.checkTuesday) checkDays.push(2);
+		if (this.config.checkWednesday) checkDays.push(3);
+		if (this.config.checkThursday) checkDays.push(4);
+		if (this.config.checkFriday) checkDays.push(5);
+		if (this.config.checkSaturday) checkDays.push(6);
+		if (this.config.checkSunday) checkDays.push(0);
+
+		if (checkDays.length >= 1) { // check if an day is selected
+			this.log.debug(`Number of selected days for daily battery message: ${checkDays.length}. Send Message on: ${(checkDays).join(', ')} ...`);
+		} else {
+			this.log.warn(`No days selected for daily battery 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.batteryLowPowered) {
+						if (!this.blacklistNotify.includes(id['Device'])) {
+							deviceList = `${deviceList}\n${id['Device']} (${id['Battery']})`;
+						}
+					}
+
+					if ((this.lowBatteryPoweredCount > 0) && (deviceList.length > 0)) {
+						this.log.info(`Niedrige Batteriezustände: ${deviceList}`);
+						this.setStateAsync('lastNotification', `Niedrige Batteriezustände: ${deviceList}`, true);
+
+						this.sendNotification(`Niedriege Batteriezustände: ${deviceList}`);
+
+					}
+
+				} catch (error) {
+					this.errorReporting('[sendBatteryNotifyShedule]', error);
+				}
+			});
+		}
+	} //<--End of battery notification
 
 	async sendOfflineNotifications() {
 		// send message if an device is offline
@@ -1568,24 +1155,30 @@ class DeviceWatcher extends utils.Adapter {
 
 		try {
 			let msg = '';
+			let deviceList = '';
 			const offlineDevicesCountOld = await this.getOwnInitValue('offlineCount');
 
 			if ((this.offlineDevicesCount !== offlineDevicesCountOld)) {
-				if (this.offlineDevicesCount == 0) {
-					msg = 'Alle Geräte sind Online.';
-				} else if (this.offlineDevicesCount == 1) {	// make singular if it is only one device
-					msg = 'Folgendes Gerät ist seit einiger Zeit nicht erreichbar: \n';
-				} else if (this.offlineDevicesCount >= 2) {		//make plural if it is more than one device
-					msg = `Folgende ${this.offlineDevicesCount} Geräte sind seit einiger Zeit nicht erreichbar: \n`;
-				}
 
 				for (const id of this.offlineDevices) {
-					msg = `${msg}\n${id['Device']} (${id['Last contact']})`;
+					if (!this.blacklistNotify.includes(id['Device'])) {
+						deviceList = `${deviceList}\n${id['Device']} (${id['Last contact']})`;
+					}
+				}
+				if (deviceList.length > 0) {
+					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);
+					await this.setStateAsync('lastNotification', msg + deviceList, true);
+					await this.sendNotification(msg + deviceList);
 				}
 
-				this.log.info(msg);
-				await this.setStateAsync('lastNotification', msg, true);
-				await this.sendNotification(msg);
 			}
 		} catch (error) {
 			this.errorReporting('[sendOfflineMessage]', error);
@@ -1593,107 +1186,54 @@ class DeviceWatcher extends utils.Adapter {
 		this.log.debug(`Finished the function: ${this.sendOfflineNotifications.name}`);
 	}//<--End of offline notification
 
-	async sendDailyOfflineNotifications() {
+	async sendOfflineNotificationsShedule() {
 		// send daily an overview with offline devices
 
-		this.log.debug(`Start the function: ${this.sendDailyOfflineNotifications.name}`);
+		const time = (this.config.checkSendOfflineTime).split(':');
 
-		try {
-			// Check if the daily message for offline devices was already sent today
-			const lastOfflineNotifyIndicator = await this.getOwnInitValue('info.lastOfflineNotification');
-			const now = new Date(); // get date
-
-			// set indicator for send message first to 'false', after sending to 'true'
-			if (now.getHours() < 11) await this.setStateAsync('info.lastOfflineNotification', false, true);
-
-			// if time is > 11 (12:00 pm create message for offline devices devices)
-			if ((now.getHours() > 11) && (!lastOfflineNotifyIndicator)) {
-				let msg = '';
-
-				for (const id of this.offlineDevices) {
-					msg = `${msg}\n${id['Device']} (${id['Last contact']})`;
-				}
+		const checkDays = []; // list of selected days
 
-				if (this.offlineDevicesCount > 0) {
-					this.log.info(`Geräte Offline: ${msg}`);
-					await this.setStateAsync('lastNotification', `Geräte Offline: ${msg}`, true);
+		// push the selected days in list
+		if (this.config.checkOfflineMonday) checkDays.push(1);
+		if (this.config.checkOfflineTuesday) checkDays.push(2);
+		if (this.config.checkOfflineWednesday) checkDays.push(3);
+		if (this.config.checkOfflineThursday) checkDays.push(4);
+		if (this.config.checkOfflineFriday) checkDays.push(5);
+		if (this.config.checkOfflineSaturday) checkDays.push(6);
+		if (this.config.checkOfflineSunday) checkDays.push(0);
 
-					await this.sendNotification(`Geräte Offline: ${msg}`);
-
-					await this.setStateAsync('info.lastOfflineNotification', true, true);
-				}
-			}
-		} catch (error) {
-			this.errorReporting('[sendDailyOfflineNotifications]', error);
+		if (checkDays.length >= 1) { // check if an day is selected
+			this.log.debug(`Number of selected days for daily offline message: ${checkDays.length}. Send Message on: ${(checkDays).join(', ')} ...`);
+		} else {
+			this.log.warn(`No days selected for daily offline message. Please check the instance configuration!`);
+			return; // cancel function if no day is selected
 		}
-		this.log.debug(`Finished the function: ${this.sendDailyOfflineNotifications.name}`);
-	}//<--End of daily offline notification
 
-	async sendBatteryNotifications() {
-		// send message for low battery devices
+		if (!isUnloaded) {
+			const cron = '10 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
+			schedule.scheduleJob(cron, () => {
+				try {
+					let deviceList = '';
+
+					for (const id of this.offlineDevices) {
+						if (!this.blacklistNotify.includes(id['Device'])) {
+							deviceList = `${deviceList}\n${id['Device']} (${id['Last contact']})`;
+						}
+					}
 
-		this.log.debug(`Start the function: ${this.sendBatteryNotifications.name}`);
+					if (deviceList.length > 0) {
+						this.log.info(`Geräte Offline: ${deviceList}`);
+						this.setStateAsync('lastNotification', `Geräte Offline: ${deviceList}`, true);
 
-		try {
+						this.sendNotification(`Geräte Offline: ${deviceList}`);
+					}
 
-			const now = new Date(); // get date
-			const today = now.getDay();
-			const checkDays = []; // list of selected days
-			let checkToday; // indicator if selected day is today
-
-			// push the selected days in list
-			if (this.config.checkMonday) checkDays.push(1);
-			if (this.config.checkTuesday) checkDays.push(2);
-			if (this.config.checkWednesday) checkDays.push(3);
-			if (this.config.checkThursday) checkDays.push(4);
-			if (this.config.checkFriday) checkDays.push(5);
-			if (this.config.checkSaturday) checkDays.push(6);
-			if (this.config.checkSunday) checkDays.push(0);
-
-			//Check if the message should be send today
-			checkDays.forEach(object => {
-				if ((object >= 0) && today == object) {
-					checkToday = true;
+				} catch (error) {
+					this.errorReporting('[sendOfflineNotificationsShedule]', error);
 				}
 			});
-
-			if (checkDays.length >= 1) { // check if an day is selected
-				this.log.debug(`Number of selected days: ${checkDays.length}. Send Message on: ${(checkDays).join(', ')} ...`);
-			} else {
-				this.log.warn(`No days selected. Please check the instance configuration!`);
-				return; // cancel function if no day is selected
-			}
-
-			// Check if the message for low battery was already sent today
-			const lastBatteryNotifyIndicator = await this.getOwnInitValue('info.lastBatteryNotification');
-
-			// set indicator for send message first to 'false', after sending to 'true'
-			if (now.getHours() < 11) await this.setStateAsync('info.lastBatteryNotification', false, true);
-
-			// if time is > 11 (12:00 pm create message for low battery devices)
-			if ((now.getHours() > 11) && (!lastBatteryNotifyIndicator) && (checkToday != undefined)) {
-				let msg = '';
-
-				for (const id of this.batteryLowPowered) {
-					msg = `${msg}\n${id['Device']} (${id['Battery']})`;
-				}
-
-				if (this.lowBatteryPoweredCount > 0) {
-					this.log.info(`Niedrige Batteriezustände: ${msg}`);
-					await this.setStateAsync('lastNotification', `Niedrige Batteriezustände: ${msg}`, true);
-
-					await this.sendNotification(`Niedriege Batteriezustände: ${msg}`);
-
-					await this.setStateAsync('info.lastBatteryNotification', true, true);
-				}
-			}
-		} catch (error) {
-			this.errorReporting('[sendOfflineMessage]', error);
 		}
-
-		this.log.debug(`Finished the function: ${this.sendBatteryNotifications.name}`);
-	}//<--End of battery notification
-
+	}//<--End of daily offline notification
 
 	async resetVars() {
 		//Reset all arrays and counts
@@ -1705,7 +1245,7 @@ class DeviceWatcher extends utils.Adapter {
 		this.batteryPowered = [];
 		this.batteryLowPowered = [];
 		this.listAllDevices = [];
-
+		this.listAllDevicesRaw = [];
 		// counts
 		this.offlineDevicesCount = 0;
 		this.deviceCounter = 0;
@@ -1713,8 +1253,6 @@ class DeviceWatcher extends utils.Adapter {
 		this.batteryPoweredCount = 0;
 		this.lowBatteryPoweredCount = 0;
 
-		this.deviceReachable = '';
-
 		this.log.debug(`Function finished: ${this.resetVars.name}`);
 	} // <-- end of resetVars
 
@@ -1900,7 +1438,7 @@ class DeviceWatcher extends utils.Adapter {
 	// create datapoints for each adapter
 	/**
 	 * @param {object} adptName - Adaptername of devices
-	 **/
+	 */
 	async createDPsForEachAdapter(adptName) {
 
 		await this.setObjectNotExistsAsync(`${adptName}`, {