iobroker.device-watcher 1.0.0 → 1.1.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');
 
 // Sentry error reporting, disable when testing code!
 const enableSendSentry = true;
 
+let isUnloaded = false;
+
 class DeviceWatcher extends utils.Adapter {
 
 	constructor(options) {
@@ -41,6 +44,19 @@ class DeviceWatcher extends utils.Adapter {
 		// Interval timer
 		this.refreshDataTimeout = null;
 
+		this.devices = new Map();
+
+		// 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: {
@@ -93,6 +109,22 @@ class DeviceWatcher extends utils.Adapter {
 				'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',
@@ -100,7 +132,8 @@ class DeviceWatcher extends utils.Adapter {
 				'battery': '.OPERATING_VOLTAGE',
 				'reach': '.UNREACH',
 				'isLowBat': '.LOW_BAT',
-				'isLowBat2': '.LOWBAT'
+				'isLowBat2': '.LOWBAT',
+				'stateValue': '.1.STATE'
 			},
 			hue: {
 				'Selektor': 'hue.*.reachable',
@@ -123,6 +156,13 @@ class DeviceWatcher extends utils.Adapter {
 				'reach': 'none',
 				'isLowBat': '.lowBatt'
 			},
+			meross: {
+				'Selektor': 'meross.*.online',
+				'adapter': 'meross',
+				'battery': '.battery',
+				'reach': '.online',
+				'isLowBat': 'none'
+			},
 			mihome: {
 				'Selektor': 'mihome.*.percent',
 				'adapter': 'miHome',
@@ -147,6 +187,15 @@ class DeviceWatcher extends utils.Adapter {
 				'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',
@@ -155,6 +204,13 @@ class DeviceWatcher extends utils.Adapter {
 				'reach': 'none',
 				'isLowBat': '.batteryCritical'
 			},
+			nut: {
+				'Selektor': 'nut.*.charge',
+				'adapter': 'nut',
+				'battery': '.charge',
+				'reach': 'none',
+				'isLowBat': 'none'
+			},
 			ping: {
 				'Selektor': 'ping.*.alive',
 				'adapter': 'ping',
@@ -162,15 +218,24 @@ class DeviceWatcher extends utils.Adapter {
 				'reach': '.alive',
 				'isLowBat': 'none'
 			},
+			roomba: {
+				'Selektor': 'roomba.*.signal',
+				'adapter': 'roomba',
+				'battery': '.battery',
+				'reach': '._connected',
+				'isLowBat': 'none',
+				'id': '.device.name'
+			},
 			shelly: {
-				'Selektor': 'shelly.*.rssi',
+				'Selektor': 'shelly.*.uptime',
 				'adapter': 'shelly',
+				'rssiState': '.rssi',
 				'battery': '.sensor.battery',
 				'reach': '.online',
 				'isLowBat': 'none'
 			},
 			sonoff: {
-				'Selektor': 'sonoff.*.Uptime',
+				'Selektor': 'sonoff.*.alive',
 				'adapter': 'sonoff',
 				'rssiState': '.Wifi_Signal',
 				'battery': '.battery',
@@ -192,6 +257,48 @@ class DeviceWatcher extends utils.Adapter {
 				'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',
@@ -199,21 +306,19 @@ class DeviceWatcher extends utils.Adapter {
 				'reach': '.available',
 				'isLowBat': '.battery_low'
 			},
+			zigbee2mqtt: {
+				'Selektor': 'zigbee2mqtt.*.link_quality',
+				'adapter': 'zigbee2MQTT',
+				'battery': '.battery',
+				'reach': '.available',
+				'isLowBat': '.battery_low'
+			},
 			zwave: {
 				'Selektor': 'zwave2.*.ready',
 				'adapter': 'zwave',
 				'battery': '.Battery.level',
 				'reach': '.ready',
 				'isLowBat': '.Battery.isLow'
-			},
-			test: { // Only for Dev
-				'Selektor': '0_userdata.*.UNREACH',
-				'adapter': 'homematic',
-				'rssiState': '.RSSI_DEVICE',
-				'battery': '.OPERATING_VOLTAGE',
-				'reach': '.UNREACH',
-				'isLowBat': '.LOW_BAT',
-				'isLowBat2': '.LOWBAT'
 			}
 		};
 
@@ -228,6 +333,8 @@ class DeviceWatcher extends utils.Adapter {
 	async onReady() {
 		this.log.debug(`Adapter ${adapterName} was started`);
 
+		isUnloaded = false;
+
 		try {
 			this.supAdapter = {
 				alexa2: this.config.alexa2Devices,
@@ -236,29 +343,44 @@ class DeviceWatcher extends utils.Adapter {
 				enocean: this.config.enoceanDevices,
 				esphome: this.config.esphomeDevices,
 				fritzdect: this.config.fritzdectDevices,
+				ham: this.config.hamDevices,
 				harmony: this.config.harmonyDevices,
+				hmiP : this.config.hmiPDevices,
 				homematic: this.config.homematicDevices,
 				hue: this.config.hueDevices,
 				hueExt: this.config.hueExtDevices,
 				jeelink: this.config.jeelinkDevices,
+				meross: this.config.merossDevices,
 				mihome: this.config.mihomeDevices,
 				mihomeGW: this.config.mihomeDevices,
 				mihomeVacuum: this.config.mihomeVacuumDevices,
+				netatmo: this.config.netatmoDevices,
 				nukiExt: this.config.nukiExtDevices,
+				nut: this.config.nutDevices,
 				ping: this.config.pingDevices,
+				roomba: this.config.roombaDevices,
 				shelly: this.config.shellyDevices,
 				sonoff: this.config.sonoffDevices,
 				sonos: this.config.sonosDevices,
 				switchbotBle: this.config.switchbotBleDevices,
+				tado: this.config.tadoDevices,
+				tradfri: this.config.tradfriDevices,
+				unifi: this.config.unifiDevices,
+				wled: this.config.wledDevices,
+				yeelight: this.config.yeelightDevices,
 				zigbee: this.config.zigbeeDevices,
+				zigbee2mqtt: this.config.zigbee2mqttDevices,
 				zwave: this.config.zwaveDevices,
-				test: false // Only for Dev
 			};
 
 			for (const [id] of Object.entries(this.arrApart)) {
-				if (this.supAdapter[id]) {
-					this.arrDev.push(this.arrApart[id]);
-					this.adapterSelected.push(await this.capitalize(id));
+				if (!isUnloaded) {
+					if (this.supAdapter[id]) {
+						this.arrDev.push(this.arrApart[id]);
+						this.adapterSelected.push(await this.capitalize(id));
+					}
+				} else {
+					return; // cancel run if unloaded was called.
 				}
 			}
 
@@ -280,17 +402,51 @@ class DeviceWatcher extends utils.Adapter {
 				this.errorReporting('[onReady - create blacklist]', error);
 			}
 
-			// update data now
-			await this.main();
+			//create and 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.createDPsForEachAdapter(id);
+								if (this.config.createHtmlList) await this.createHtmlListDatapoints(id);
+								this.log.debug(`Created datapoints for ${await this.capitalize(id)}`);
+							}
+						}
+					} else {
+						return; // cancel run if unloaded was called.
+					}
+				}
+			} 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();
 
+			// 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);
 		}
-	}
+
+		/*
+		this.devices.forEach((value, key) => {
+			this.log.warn(`${key}: ${value}`);
+			this.subscribeStates(value);
+			this.onStateChange(key, value);
+		});
+		*/
+	} // <-- onReady end
 
 	/**
      * Is called if a subscribed state changes
@@ -300,11 +456,11 @@ class DeviceWatcher extends utils.Adapter {
 	async onStateChange(id, state) {
 		if (state) {
 			// The state was changed
-			this.log.debug(`state ${id} changed: ${state.val} (ack = ${state.ack})`);
-			await this.main();
+			this.log.warn(`state ${id} changed: ${state.val} (ack = ${state.ack})`);
+			// await this.main();
 		} else {
 			// The state was deleted
-			this.log.debug(`state ${id} deleted`);
+			this.log.warn(`state ${id} deleted`);
 		}
 	}
 
@@ -319,40 +475,46 @@ class DeviceWatcher extends utils.Adapter {
 			this.clearTimeout(this.refreshDataTimeout);
 		}
 
-		this.refreshDataTimeout = this.setTimeout(() => {
-			this.log.debug('Updating Data');
+		if (!isUnloaded) {
+			this.refreshDataTimeout = this.setTimeout(() => {
+				this.log.debug('Updating Data');
 
-			this.refreshDataTimeout = null;
-			this.refreshData();
-		}, nextTimeout);
-	}
+				this.refreshDataTimeout = null;
+				this.refreshData();
+			}, nextTimeout);
+		} else {
+			return; // cancel run if unloaded was called.
+		}
+
+	} // <-- refreshData end
 
 	async main() {
 		this.log.debug(`Function started: ${this.main.name}`);
 
 		try {
 
-			//create and fill datapoints for each adapter if selected
+			// fill datapoints for each adapter if selected
 			try {
 				for (const [id] of Object.entries(this.arrApart)) {
-					if ((this.supAdapter !== undefined) && (this.supAdapter[id])) {
-
-						if (this.config.createOwnFolder) {
-							await this.createDPsForEachAdapter(id);
-							if (this.config.createHtmlList) await this.createHtmlListDatapoints(id);
-							this.log.debug(`Created datapoints for ${await this.capitalize(id)}`);
-							await this.createDataForEachAdapter(id);
-							this.log.debug(`Created and filled data for each adapter`);
+					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`);
+							}
 						}
+					} 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);
 			}
 
-			// creating counts and lists of all selected adapter
+			// fill counts and lists of all selected adapter
 			try {
-				if (this.config.createHtmlList) await this.createHtmlListDatapoints();
 				await this.createDataOfAllAdapter();
 				this.log.debug(`Created and filled data for all adapters`);
 			} catch (error) {
@@ -393,428 +555,182 @@ class DeviceWatcher extends utils.Adapter {
 		if (stateVal) return stateVal.val;
 	}
 
-	//create datapoints for each adapter
+	async createBlacklist() {
+		this.log.debug(`Function started: ${this.createBlacklist.name}`);
+
+		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.
+			}
+		}
+		this.log.info(`Found items on the blacklist: ${this.blacklistArr}`);
+		this.log.debug(`Function finished: ${this.createBlacklist.name}`);
+	}
+
 	/**
-	 * @param {object} adptName - Adaptername of devices
+	 * @param {object} i - Device Object
 	 **/
-	async createDPsForEachAdapter(adptName) {
+	async createData(i) {
+		const devices = await this.getForeignStatesAsync(this.arrDev[i].Selektor);
+		const deviceAdapterName = await this.capitalize(this.arrDev[i].adapter);
 
-		await this.setObjectNotExistsAsync(`${adptName}`, {
-			type: 'channel',
-			common: {
-				name: adptName,
-			},
-			native: {},
-		});
+		/*----------  Start of second main loop  ----------*/
+		for (const [id] of Object.entries(devices)) {
+			if (!isUnloaded) {
+				if (!this.blacklistArr.includes(id)) {
 
-		await this.setObjectNotExistsAsync(`${adptName}.offlineCount`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'Number of devices offline',
-					'de': 'Anzahl der Geräte offline',
-					'ru': 'Количество устройств offline',
-					'pt': 'Número de dispositivos offline',
-					'nl': 'Nummer van apparatuur offline',
-					'fr': 'Nombre de dispositifs hors ligne',
-					'it': 'Numero di dispositivi offline',
-					'es': 'Número de dispositivos sin conexión',
-					'pl': 'Ilość urządzeń offline',
-					'zh-cn': '线内装置数量'
-				},
-				'type': 'number',
-				'role': 'value',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
+					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);
 
-		await this.setObjectNotExistsAsync(`${adptName}.offlineList`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'List of offline devices',
-					'de': 'Liste der Offline-Geräte',
-					'ru': 'Список оффлайн устройств',
-					'pt': 'Lista de dispositivos off-line',
-					'nl': 'List van offline apparatuur',
-					'fr': 'Liste des dispositifs hors ligne',
-					'it': 'Elenco dei dispositivi offline',
-					'es': 'Lista de dispositivos sin conexión',
-					'pl': 'Lista urządzeń offline',
-					'zh-cn': '线装置清单'
-				},
-				'type': 'array',
-				'role': 'json',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
+					// Get device name
+					const deviceObject = await this.getForeignObjectAsync(currDeviceString);
+					const shortDeviceObject = await this.getForeignObjectAsync(shortCurrDeviceString);
+					const shortshortDeviceObject = await this.getForeignObjectAsync(shortshortCurrDeviceString);
+					let deviceName;
 
-		await this.setObjectNotExistsAsync(`${adptName}.listAll`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'List of all devices',
-					'de': 'Liste aller Geräte',
-					'ru': 'Список всех устройств',
-					'pt': 'Lista de todos os dispositivos',
-					'nl': 'List van alle apparaten',
-					'fr': 'Liste de tous les dispositifs',
-					'it': 'Elenco di tutti i dispositivi',
-					'es': 'Lista de todos los dispositivos',
-					'pl': 'Lista wszystkich urządzeń',
-					'zh-cn': '所有装置清单'
-				},
-				'type': 'array',
-				'role': 'json',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
+					// 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;
 
-		await this.setObjectNotExistsAsync(`${adptName}.linkQualityList`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'List of devices with signal strength',
-					'de': 'Liste der Geräte mit Signalstärke',
-					'ru': 'Список устройств с силой сигнала',
-					'pt': 'Lista de dispositivos com força de sinal',
-					'nl': 'List van apparaten met signaalkracht',
-					'fr': 'Liste des dispositifs avec force de signal',
-					'it': 'Elenco dei dispositivi con forza del segnale',
-					'es': 'Lista de dispositivos con fuerza de señal',
-					'pl': 'Lista urządzeń z siłą sygnałową',
-					'zh-cn': '具有信号实力的装置清单'
-				},
-				'type': 'array',
-				'role': 'json',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
+							// 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;
 
-		await this.setObjectNotExistsAsync(`${adptName}.countAll`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'Number of all devices',
-					'de': 'Anzahl aller Geräte',
-					'ru': 'Количество всех устройств',
-					'pt': 'Número de todos os dispositivos',
-					'nl': 'Nummer van alle apparaten',
-					'fr': 'Nombre de tous les appareils',
-					'it': 'Numero di tutti i dispositivi',
-					'es': 'Número de todos los dispositivos',
-					'pl': 'Ilość wszystkich urządzeń',
-					'zh-cn': '所有装置的数目'
-				},
-				'type': 'number',
-				'role': 'value',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
+							// Get ID with short short currDeviceString vom objectjson
+						case 'hmiP':
+							if (shortshortDeviceObject && typeof shortshortDeviceObject === 'object') {
+								deviceName = shortshortDeviceObject.common.name;
+							}
+							break;
 
-		await this.setObjectNotExistsAsync(`${adptName}.batteryList`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'List of devices with battery state',
-					'de': 'Liste der Geräte mit Batteriezustand',
-					'ru': 'Список устройств с состоянием батареи',
-					'pt': 'Lista de dispositivos com estado da bateria',
-					'nl': 'List van apparaten met batterij staat',
-					'fr': 'Liste des appareils avec état de batterie',
-					'it': 'Elenco dei dispositivi con stato della batteria',
-					'es': 'Lista de dispositivos con estado de batería',
-					'pl': 'Lista urządzeń z baterią stanową',
-					'zh-cn': '电池国装置清单'
-				},
-				'type': 'array',
-				'role': 'json',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
+							// Get ID with short currDeviceString from datapoint
+						case 'mihomeVacuum':
+						case 'roomba':
+							deviceName = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].id);
+							break;
 
-		await this.setObjectNotExistsAsync(`${adptName}.lowBatteryList`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'List of devices with low battery state',
-					'de': 'Liste der Geräte mit niedrigem Batteriezustand',
-					'ru': 'Список устройств с низким состоянием батареи',
-					'pt': 'Lista de dispositivos com baixo estado da bateria',
-					'nl': 'List van apparaten met lage batterij staat',
-					'fr': 'Liste des appareils à faible état de batterie',
-					'it': 'Elenco di dispositivi con stato di batteria basso',
-					'es': 'Lista de dispositivos con estado de batería bajo',
-					'pl': 'Lista urządzeń o niskim stanie baterii',
-					'zh-cn': '低电池国家装置清单'
-				},
-				'type': 'array',
-				'role': 'json',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
-
-		await this.setObjectNotExistsAsync(`${adptName}.lowBatteryCount`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'Number of devices with low battery',
-					'de': 'Anzahl der Geräte mit niedriger Batterie',
-					'ru': 'Количество устройств c низкой батареей',
-					'pt': 'Número de dispositivos com bateria baixa',
-					'nl': 'Nummer van apparaten met lage batterij',
-					'fr': 'Nombre de dispositifs avec batterie basse',
-					'it': 'Numero di dispositivi con batteria bassa',
-					'es': 'Número de dispositivos con batería baja',
-					'pl': 'Liczba urządzeń z niską baterią',
-					'zh-cn': '低电池的装置数量'
-				},
-				'type': 'number',
-				'role': 'value',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
-
-		await this.setObjectNotExistsAsync(`${adptName}.batteryCount`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'Number of devices with battery',
-					'de': 'Anzahl der Geräte mit Batterie',
-					'ru': 'Количество устройств c батареей',
-					'pt': 'Número de dispositivos com bateria',
-					'nl': 'Nummer van apparaten met batterij',
-					'fr': 'Nombre de dispositifs avec batterie',
-					'it': 'Numero di dispositivi con batteria',
-					'es': 'Número de dispositivos con batería',
-					'pl': 'Liczba urządzeń z baterią',
-					'zh-cn': '电池的装置数量'
-				},
-				'type': 'number',
-				'role': 'value',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
-	}
-
-	/**
-	 * @param {object} [adptName] - Adaptername of devices
-	 **/
-	async createHtmlListDatapoints(adptName) {
-
-		let dpSubFolder;
-		//write the datapoints in subfolders with the adaptername otherwise write the dP's in the root folder
-		if (adptName) {
-			dpSubFolder = `${adptName}.`;
-		} else {
-			dpSubFolder = '';
-		}
-
-		await this.setObjectNotExistsAsync(`${dpSubFolder}offlineListHTML`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'HTML List of offline devices',
-					'de': 'HTML Liste der Offline-Geräte',
-					'ru': 'HTML Список оффлайн устройств',
-					'pt': 'HTML Lista de dispositivos off-line',
-					'nl': 'HTML List van offline apparatuur',
-					'fr': 'HTML Liste des dispositifs hors ligne',
-					'it': 'HTML Elenco dei dispositivi offline',
-					'es': 'HTML Lista de dispositivos sin conexión',
-					'pl': 'HTML Lista urządzeń offline',
-					'zh-cn': 'HTML 线装置清单'
-				},
-				'type': 'string',
-				'role': 'html',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
-
-		await this.setObjectNotExistsAsync(`${dpSubFolder}linkQualityListHTML`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'HTML List of devices with signal strength',
-					'de': 'HTML Liste der Geräte mit Signalstärke',
-					'ru': 'HTML Список устройств с силой сигнала',
-					'pt': 'HTML Lista de dispositivos com força de sinal',
-					'nl': 'HTML List van apparaten met signaalkracht',
-					'fr': 'HTML Liste des dispositifs avec force de signal',
-					'it': 'HTML Elenco dei dispositivi con forza del segnale',
-					'es': 'HTML Lista de dispositivos con fuerza de señal',
-					'pl': 'HTML Lista urządzeń z siłą sygnałową',
-					'zh-cn': 'HTML 具有信号实力的装置清单'
-				},
-				'type': 'string',
-				'role': 'value',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
-
-		await this.setObjectNotExistsAsync(`${dpSubFolder}batteryListHTML`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'HTML List of devices with battery state',
-					'de': 'HTML Liste der Geräte mit Batteriezustand',
-					'ru': 'HTML Список устройств с состоянием батареи',
-					'pt': 'HTML Lista de dispositivos com estado da bateria',
-					'nl': 'HTML List van apparaten met batterij staat',
-					'fr': 'HTML Liste des appareils avec état de batterie',
-					'it': 'HTML Elenco dei dispositivi con stato della batteria',
-					'es': 'HTML Lista de dispositivos con estado de batería',
-					'pl': 'HTML Lista urządzeń z baterią stanową',
-					'zh-cn': 'HTML 电池国装置清单'
-				},
-				'type': 'string',
-				'role': 'html',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
+							//Get ID of foldername
+						case 'tado':
+							deviceName = currDeviceString.slice(currDeviceString.lastIndexOf('.') + 1);
+							break;
 
-		await this.setObjectNotExistsAsync(`${dpSubFolder}lowBatteryListHTML`, {
-			'type': 'state',
-			'common': {
-				'name': {
-					'en': 'HTML List of devices with low battery state',
-					'de': 'HTML Liste der Geräte mit niedrigem Batteriezustand',
-					'ru': 'HTML Список устройств с низким состоянием батареи',
-					'pt': 'HTML Lista de dispositivos com baixo estado da bateria',
-					'nl': 'HTML List van apparaten met lage batterij staat',
-					'fr': 'HTML Liste des appareils à faible état de batterie',
-					'it': 'HTML Elenco di dispositivi con stato di batteria basso',
-					'es': 'HTML Lista de dispositivos con estado de batería bajo',
-					'pl': 'HTML Lista urządzeń o niskim stanie baterii',
-					'zh-cn': 'HTML 低电池国家装置清单'
-				},
-				'type': 'string',
-				'role': 'html',
-				'read': true,
-				'write': false,
-			},
-			'native': {}
-		});
-	}
+							//Get ID of foldername
+						case 'yeelight-2':
+							deviceName = shortCurrDeviceString.slice(shortCurrDeviceString.lastIndexOf('.') + 1);
+							break;
 
-	async createBlacklist() {
-		this.log.debug(`Function started: ${this.createBlacklist.name}`);
+							// Get ID with main selektor from objectjson
+						default:
+							if (deviceObject && typeof deviceObject === 'object') {
+								deviceName = deviceObject.common.name;
+							}
+							break;
+					}
 
-		const myBlacklist = this.config.tableBlacklist;
+					const deviceMainSelector = await this.getForeignStateAsync(id);
+					const deviceStateSelector = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].stateValue); // for homematic devices
 
-		for (const i in myBlacklist) {
-			this.blacklistArr.push(myBlacklist[i].device);
-		}
-		this.log.info(`Found items on the blacklist: ${this.blacklistArr}`);
-		this.log.debug(`Function finished: ${this.createBlacklist.name}`);
-	}
+					// 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);
 
-	/**
-	 * @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);
+					this.devices.set(deviceName, currDeviceString + this.arrDev[i].reach);
+					// List all entries
+					//let text = '';
+					//this.devices.forEach (function(value, key) {
+					//	text += key + ' : ' + value;
+					// });
+					// this.log.warn(text);
 
-		/*----------  Start of second main loop  ----------*/
-		for (const [id] of Object.entries(devices)) {
-			if (!this.blacklistArr.includes(id)) {
-
-				const currDeviceString = id.slice(0, (id.lastIndexOf('.') + 1) - 1);
-				const shortCurrDeviceString = currDeviceString.slice(0, (currDeviceString.lastIndexOf('.') + 1) - 1);
-
-				// Get device name
-				const deviceObject = await this.getForeignObjectAsync(currDeviceString);
-				const shortDeviceObject = await this.getForeignObjectAsync(shortCurrDeviceString);
-				let deviceName;
-
-				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;
-
-					case 'hue-extended':
-					case 'homematic':
-					case 'nuki-extended':
-						if (shortDeviceObject && typeof shortDeviceObject === 'object') {
-							deviceName = shortDeviceObject.common.name;
-						}
-						break;
+					// Get link quality
+					let deviceQualityState;
+					let linkQuality;
 
-					case 'mihomeVacuum':
-						deviceName = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].id);
-						break;
+					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;
 
-					default:
-						if (deviceObject && typeof deviceObject === 'object') {
-							deviceName = deviceObject.common.name;
-						}
-						break;
-				}
+						case 'mihomeVacuum':
+							deviceQualityState = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].rssiState);
+							break;
 
-				const deviceMainSelector = await this.getForeignStateAsync(id);
+						case 'tradfri':
+						case 'ham':
+						case 'meross':
+						case 'nut':
+						case 'miHome':
+						case 'unifi':
+							deviceQualityState;
+							break;
 
-				// 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);
+						case 'netatmo':
+							deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiState);
+							if (!deviceQualityState) {
+								deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rfState);
+							}
+							break;
 
-				// Get link quality
-				let deviceQualityState;
-				let linkQuality;
+						default:
+							deviceQualityState = await this.getForeignStateAsync(id);
+							break;
+					}
 
-				switch (this.arrDev[i].adapter) {
-					case 'sonoff':
-					case 'homematic':
-						deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiState);
-						break;
+					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;
 
-					case 'mihomeVacuum':
-						deviceQualityState = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].rssiState);
-						break;
+								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) + '%';
 
-					default:
-						deviceQualityState = await this.getForeignStateAsync(id);
-						break;
-				}
+										// 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;
+							}
 
-				if ((deviceQualityState) && (typeof deviceQualityState.val === 'number')) {
-					if (this.config.trueState) {
-						linkQuality = deviceQualityState.val;
-					} else {
-						if (deviceQualityState.val < 0) {
-							linkQuality = Math.min(Math.max(2 * (deviceQualityState.val + 100), 0), 100) + '%';
-						} else if ((deviceQualityState.val) >= 0) {
-							linkQuality = parseFloat((100 / 255 * deviceQualityState.val).toFixed(0)) + '%';
 						}
-					}
-					if (this.config.listOnlyBattery) {
-						if (deviceBatteryState || shortDeviceBatteryState) {
+						if (this.config.listOnlyBattery) {
+							if (deviceBatteryState || shortDeviceBatteryState) {
+								this.linkQualityDevices.push(
+									{
+										'Device': deviceName,
+										'Adapter': deviceAdapterName,
+										'Signal strength': linkQuality
+									}
+								);
+							}
+						} else {
 							this.linkQualityDevices.push(
 								{
 									'Device': deviceName,
@@ -823,85 +739,136 @@ class DeviceWatcher extends utils.Adapter {
 								}
 							);
 						}
-					} 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;
+						}
+
+						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
 					}
-				} else {
-					linkQuality = ' - '; // no linkQuality available for powered devices
-				}
 
-				// 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 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;
-						};
+					// Count how many devices with link Quality
+					this.linkQualityCount = this.linkQualityDevices.length;
 
-						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;
+					// When was the last contact to the device?
+					let lastContactString;
 
-							default:
+					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 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 == 'homematic') {
-									if (deviceUnreachState) {
-										await getLastStateChange();
-									} else {
-										await getLastContact();
-									}
-								} else {
-									if ((!deviceUnreachState)) {
-										await getLastStateChange();
+									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();
+											}
+										}
+
 									} else {
-										await getLastContact();
+										if ((!deviceUnreachState)) {
+											await getLastStateChange();
+										} else {
+											await getLastContact();
+										}
+										break;
 									}
-									break;
-								}
-						}
+							}
 
-						const pushOfflineDevice = async () => {
-							if (this.config.listOnlyBattery) {	//if checked, list only battery devices
-								if (deviceBatteryState || shortDeviceBatteryState) {
-									this.offlineDevices.push(
+							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,
@@ -909,312 +876,414 @@ class DeviceWatcher extends utils.Adapter {
 										}
 									);
 								}
-							} else {
-								this.offlineDevices.push( 	//else push all devices
-									{
-										'Device': deviceName,
-										'Adapter': deviceAdapterName,
-										'Last contact': lastContactString
+							};
+
+							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();
 									}
-								);
-							}
-						};
-
-						// await this.subscribeForeignStatesAsync(currDeviceString + this.arrDev[i].reach);
-
-						switch (this.arrDev[i].adapter) {
-							case 'alexa2':
-								if (this.config.alexa2MaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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();
 									}
-								} else if ((lastStateChange > this.config.alexa2MaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'ble':
-								if (this.config.bleMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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();
 									}
-								} 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) {
+									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();
 									}
-								} else if ((lastStateChange > this.config.deconzMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'enocean':
-								if (this.config.enoceanMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									break;
+								case 'mihomeVacuum':
+									if (this.config.mihomeVacuumMaxMinutes === -1) {
+										if (!shortDeviceUnreachState) {
+											deviceState = 'Offline'; //set online state to offline
+											await pushOfflineDevice();
+										}
+									} else if (lastContact > this.config.mihomeVacuumMaxMinutes) {
 										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) {
+									break;
+								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();
 									}
-								} else if ((lastStateChange > this.config.esphomeMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'fritzDect':
-								if (this.config.fritzdectMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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();
 									}
-								} else if ((lastStateChange > this.config.fritzdectMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'harmony':
-								if (this.config.harmonyMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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();
 									}
-								} else if ((lastStateChange > this.config.harmonyMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'homematic':
-								if (this.config.homematicMaxMinutes === -1) {
-									if (deviceUnreachState) {
+									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();
 									}
-								} else if ((lastStateChange > this.config.homematicMaxMinutes) && (deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'hue':
-								if (this.config.hueMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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();
 									}
-								} else if ((lastStateChange > this.config.hueMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'hue-extended':
-								if (this.config.hueextMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									break;
+								case 'shelly':
+									if (this.config.shellyMaxMinutes === -1) {
+										if (!deviceUnreachState) {
+											deviceState = 'Offline'; //set online state to offline
+											await pushOfflineDevice();
+										}
+									} else if (lastContact > this.config.shellyMaxMinutes) {
 										deviceState = 'Offline'; //set online state to offline
 										await pushOfflineDevice();
 									}
-								} else if ((lastStateChange > this.config.hueextMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'jeelink':
-								if (this.config.jeelinkMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									break;
+								case 'sonoff':
+									if (this.config.sonoffMaxMinutes === -1) {
+										if (!deviceUnreachState) {
+											deviceState = 'Offline'; //set online state to offline
+											await pushOfflineDevice();
+										}
+									} else if (lastContact > this.config.sonoffMaxMinutes) {
 										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 'miHome':
-								if (this.config.mihomeMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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 ((lastStateChange > this.config.mihomeMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'mihomeVacuum':
-								if (this.config.mihomeVacuumMaxMinutes === -1) {
-									if (!shortDeviceUnreachState) {
+									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) {
 										deviceState = 'Offline'; //set online state to offline
 										await pushOfflineDevice();
 									}
-								} else if ((lastStateChange > this.config.mihomeVacuumMaxMinutes) && (!shortDeviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'nuki-extended':
-								if (this.config.nukiextendMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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) {
 										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 'ping':
-								if (this.config.pingMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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) {
 										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 'shelly':
-								if (this.config.shellyMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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) {
 										deviceState = 'Offline'; //set online state to offline
 										await pushOfflineDevice();
 									}
-								} else if ((lastStateChange > this.config.shellyMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'sonoff':
-								if (this.config.sonoffMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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) {
 										deviceState = 'Offline'; //set online state to offline
 										await pushOfflineDevice();
 									}
-								} else if ((lastStateChange > this.config.sonoffMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'sonos':
-								if (this.config.sonosMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									break;
+								case 'yeelight-2':
+									if (this.config.yeelightMaxMinutes === -1) {
+										if (!deviceUnreachState) {
+											deviceState = 'Offline'; //set online state to offline
+											await pushOfflineDevice();
+										}
+									} else if (lastContact > this.config.yeelightMaxMinutes) {
 										deviceState = 'Offline'; //set online state to offline
 										await pushOfflineDevice();
 									}
-								} else if ((lastStateChange > this.config.sonosMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'switchbotBle':
-								if (this.config.switchbotMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									break;
+								case 'zigbee':
+									if (this.config.zigbeeMaxMinutes === -1) {
+										if (!deviceUnreachState) {
+											deviceState = 'Offline'; //set online state to offline
+											await pushOfflineDevice();
+										}
+									} else if (lastContact > this.config.zigbeeMaxMinutes) {
 										deviceState = 'Offline'; //set online state to offline
 										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.switchbotMaxMinutes) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'zigbee':
-								if (this.config.zigbeeMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									break;
+								case 'zigbee2MQTT':
+									if (this.config.zigbee2mqttMaxMinutes === -1) {
+										if (!deviceUnreachState) {
+											deviceState = 'Offline'; //set online state to offline
+											await pushOfflineDevice();
+										}
+									} else if (lastContact > this.config.zigbee2mqttMaxMinutes) {
 										deviceState = 'Offline'; //set online state to offline
 										await pushOfflineDevice();
 									}
-								} else if ((lastStateChange > this.config.zigbeeMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
-							case 'zwave':
-								if (this.config.zwaveMaxMinutes === -1) {
-									if (!deviceUnreachState) {
+									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();
 									}
-								} else if ((lastStateChange > this.config.zwaveMaxMinutes) && (!deviceUnreachState)) {
-									deviceState = 'Offline'; //set online state to offline
-									await pushOfflineDevice();
-								}
-								break;
+									break;
+							}
+						} catch (error) {
+							this.errorReporting('[getLastContact]', error);
 						}
-					} catch (error) {
-						this.errorReporting('[getLastContact]', error);
 					}
-				}
 
 
 
-				// Count how many devcies are offline
-				this.offlineDevicesCount = this.offlineDevices.length;
+					// 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);
+					// 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) {
-									batteryHealth = 'ok';
-								} else {
-									batteryHealth = 'low';
-								}
-								break;
-						}
-						switch (this.arrDev[i].isLowBat2) {
-							case 'none':
-								batteryHealth = ' - ';
-								break;
-							default:
-								if (!deviceLowBatState) {
-									batteryHealth = 'ok';
-								} else {
-									batteryHealth = 'low';
-								}
-								break;
-						}
-						this.batteryPowered.push(
-							{
-								'Device': deviceName,
-								'Adapter': deviceAdapterName,
-								'Battery': batteryHealth
+					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;
 							}
-						);
-					} else {
-						batteryHealth = ' - ';
-					}
-				} else {
-					switch (this.arrDev[i].adapter) {
-						case 'homematic':
-							if (deviceBatteryState === 0) {
-								batteryHealth = ' - ';
-							} else {
-								batteryHealth = deviceBatteryState + 'V';
+							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,
@@ -1222,10 +1291,18 @@ class DeviceWatcher extends utils.Adapter {
 									'Battery': batteryHealth
 								}
 							);
-							break;
-						case 'hue-extended':
-							if (shortDeviceBatteryState) {
-								batteryHealth = shortDeviceBatteryState + '%';
+						} else {
+							batteryHealth = ' - ';
+						}
+					} else {
+						switch (this.arrDev[i].adapter) {
+							case 'homematic':
+								if (deviceBatteryState === 0) {
+									batteryHealth = ' - ';
+								} else {
+									batteryHealth = deviceBatteryState + 'V';
+								}
+
 								this.batteryPowered.push(
 									{
 										'Device': deviceName,
@@ -1233,11 +1310,42 @@ class DeviceWatcher extends utils.Adapter {
 										'Battery': batteryHealth
 									}
 								);
-							}
-							break;
-						case 'mihomeVacuum':
-							if (shortDeviceBatteryState) {
-								batteryHealth = shortDeviceBatteryState + '%';
+								break;
+							case 'hue-extended':
+								if (shortDeviceBatteryState) {
+									batteryHealth = shortDeviceBatteryState + '%';
+									this.batteryPowered.push(
+										{
+											'Device': deviceName,
+											'Adapter': deviceAdapterName,
+											'Battery': 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
+										}
+									);
+								}
+								break;
+							default:
+								batteryHealth = (deviceBatteryState) + '%';
 								this.batteryPowered.push(
 									{
 										'Device': deviceName,
@@ -1245,9 +1353,20 @@ class DeviceWatcher extends utils.Adapter {
 										'Battery': batteryHealth
 									}
 								);
-							} else if (shortDeviceBatteryState2) {
-								batteryHealth = shortDeviceBatteryState2 + '%';
-								this.batteryPowered.push(
+						}
+					}
+
+					// 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
+					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,
@@ -1256,63 +1375,56 @@ class DeviceWatcher extends utils.Adapter {
 								);
 							}
 							break;
-						default:
-							batteryHealth = (deviceBatteryState) + '%';
-							this.batteryPowered.push(
-								{
-									'Device': deviceName,
-									'Adapter': deviceAdapterName,
-									'Battery': batteryHealth
-								}
-							);
-					}
-				}
 
-				// Count how many devices are with battery
-				this.batteryPoweredCount = this.batteryPowered.length;
+						case 'tado': // there is an string as indicator
+							if (deviceLowBatState != 'NORMAL') {
+								this.batteryLowPowered.push(
+									{
+										'Device': deviceName,
+										'Adapter': deviceAdapterName,
+										'Battery': batteryHealth
+									}
+								);
+							}
+							break;
 
-				// Count how many devices are with low battery
-				const batteryWarningMin = this.config.minWarnBatterie;
+						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
+									}
+								);
+							}
+					}
 
-				// fill list with low battery devices
-				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
-								}
-							);
-						}
-						break;
+					// 3d. Count how many devices are with low battery
+					this.lowBatteryPoweredCount = this.batteryLowPowered.length;
 
-					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(
+					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
+									'Battery': batteryHealth,
+									'Signal strength': linkQuality,
+									'Last contact': lastContactString,
+									'Status': deviceState
 								}
 							);
 						}
-				}
-
-				// 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) {
+					} else if (!this.config.listOnlyBattery) { // 4. Add all devices
 						this.listAllDevices.push(
 							{
 								'Device': deviceName,
@@ -1324,22 +1436,13 @@ class DeviceWatcher extends utils.Adapter {
 							}
 						);
 					}
-				} else if (!this.config.listOnlyBattery) { // 4. Add all devices
-					this.listAllDevices.push(
-						{
-							'Device': deviceName,
-							'Adapter': deviceAdapterName,
-							'Battery': batteryHealth,
-							'Signal strength': linkQuality,
-							'Last contact': lastContactString,
-							'Status': deviceState
-						}
-					);
-				}
 
 
-				// 4a. Count how many devices are exists
-				this.deviceCounter = this.listAllDevices.length;
+					// 4a. Count how many devices are exists
+					this.deviceCounter = this.listAllDevices.length;
+				}
+			} else {
+				return; // cancel run if unloaded was called.
 			}
 		} // <-- end of loop
 	} // <-- end of createData
@@ -1377,15 +1480,18 @@ class DeviceWatcher extends utils.Adapter {
 			await this.resetVars(); // reset the arrays and counts
 
 			for (let i = 0; i < this.arrDev.length; i++) {
-
-				await this.createData(i);
-
+				if (!isUnloaded) {
+					await this.createData(i);
+				} else {
+					return; // cancel run if unloaded was called.
+				}
 			}
 
-			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
-			await this.writeDatapoints(); // fill the datapoints
+			// send message if new devices are offline
+			if (this.config.checkSendOfflineMsg) await this.sendOfflineNotifications();
+
+			// fill the datapoints
+			await this.writeDatapoints();
 		} catch (error) {
 			this.errorReporting('[createDataOfAllAdapter]', error);
 		}
@@ -1515,172 +1621,132 @@ class DeviceWatcher extends utils.Adapter {
 		}
 	} // <-- End of sendNotification function
 
+	async sendBatteryNotifyShedule() {
+		// send message for low battery devices
 
-	async sendOfflineNotifications() {
-		// send message if an device is offline
-
-		this.log.debug(`Start the function: ${this.sendOfflineNotifications.name}`);
-
-		try {
-			let msg = '';
-			const offlineDevicesCountOld = await this.getOwnInitValue('offlineCount');
+		const time = (this.config.checkSendBatteryTime).split(':');
 
-			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`;
-				}
+		const checkDays = []; // list of selected days
 
-				for (const id of this.offlineDevices) {
-					msg = `${msg} \n ${id['Device']} (${id['Last contact']})`;
-				}
+		// 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);
 
-				this.log.info(msg);
-				await this.setStateAsync('lastNotification', msg, true);
-				await this.sendNotification(msg);
-			}
-		} catch (error) {
-			this.errorReporting('[sendOfflineMessage]', error);
+		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
 		}
 
-		try {
-			// send daily an overview with offline devices
-			if (this.config.checkSendOfflineMsgDaily) {
-				// 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)) {
+		if (!isUnloaded) {
+			const cron = '10 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
+			schedule.scheduleJob(cron, () => {
+				try {
 					let msg = '';
 
-					for (const id of this.offlineDevices) {
-						msg = `${msg} \n ${id['Device']} (${id['Last contact']})`;
+					for (const id of this.batteryLowPowered) {
+						msg = `${msg}\n${id['Device']} (${id['Battery']})`;
 					}
 
-					if (this.offlineDevicesCount > 0) {
-						this.log.info(`Geräte Offline: ${msg}`);
-						await this.setStateAsync('lastNotification', `Geräte Offline: ${msg}`, true);
+					if (this.lowBatteryPoweredCount > 0) {
+						this.log.info(`Niedrige Batteriezustände: ${msg}`);
+						this.setStateAsync('lastNotification', `Niedrige Batteriezustände: ${msg}`, true);
 
-						await this.sendNotification(`Geräte Offline: ${msg}`);
+						this.sendNotification(`Niedriege Batteriezustände: ${msg}`);
 
-						await this.setStateAsync('info.lastOfflineNotification', true, true);
 					}
+
+				} catch (error) {
+					this.errorReporting('[sendBatteryNotifyShedule]', error);
 				}
-			}
-		} catch (error) {
-			this.errorReporting('[sendOfflineMessage - daily message]', error);
+			});
 		}
-		this.log.debug(`Finished the function: ${this.sendOfflineNotifications.name}`);
-	}//<--End of offline notification
+	} //<--End of battery notification
 
-	async sendDailyOfflineNotifications() {
-		// send daily an overview with offline devices
+	async sendOfflineNotifications() {
+		// send message if an device is offline
 
-		this.log.debug(`Start the function: ${this.sendDailyOfflineNotifications.name}`);
+		this.log.debug(`Start the function: ${this.sendOfflineNotifications.name}`);
 
 		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);
+			let msg = '';
+			const offlineDevicesCountOld = await this.getOwnInitValue('offlineCount');
 
-			// if time is > 11 (12:00 pm create message for offline devices devices)
-			if ((now.getHours() > 11) && (!lastOfflineNotifyIndicator)) {
-				let msg = '';
+			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']})`;
+					msg = `${msg}\n${id['Device']} (${id['Last contact']})`;
 				}
 
-				if (this.offlineDevicesCount > 0) {
-					this.log.info(`Geräte Offline: ${msg}`);
-					await this.setStateAsync('lastNotification', `Geräte Offline: ${msg}`, true);
-
-					await this.sendNotification(`Geräte Offline: ${msg}`);
-
-					await this.setStateAsync('info.lastOfflineNotification', true, true);
-				}
+				this.log.info(msg);
+				await this.setStateAsync('lastNotification', msg, true);
+				await this.sendNotification(msg);
 			}
 		} catch (error) {
-			this.errorReporting('[sendDailyOfflineNotifications]', error);
+			this.errorReporting('[sendOfflineMessage]', error);
 		}
-		this.log.debug(`Finished the function: ${this.sendDailyOfflineNotifications.name}`);
-	}//<--End of daily offline notification
-
-	async sendBatteryNotifications() {
-		// send message for low battery devices
-
-		this.log.debug(`Start the function: ${this.sendBatteryNotifications.name}`);
+		this.log.debug(`Finished the function: ${this.sendOfflineNotifications.name}`);
+	}//<--End of offline notification
 
-		try {
+	async sendOfflineNotificationsShedule() {
+		// send daily an overview with offline devices
 
-			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;
-				}
-			});
+		const time = (this.config.checkSendOfflineTime).split(':');
 
-			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; // break off function if no day is selected
-			}
+		const checkDays = []; // list of selected days
 
-			// Check if the message for low battery was already sent today
-			const lastBatteryNotifyIndicator = await this.getOwnInitValue('info.lastBatteryNotification');
+		// 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);
 
-			// set indicator for send message first to 'false', after sending to 'true'
-			if (now.getHours() < 11) await this.setStateAsync('info.lastBatteryNotification', false, true);
+		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
+		}
 
-			// if time is > 11 (12:00 pm create message for low battery devices)
-			if ((now.getHours() > 11) && (!lastBatteryNotifyIndicator) && (checkToday != undefined)) {
-				let msg = '';
+		if (!isUnloaded) {
+			const cron = '10 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
+			schedule.scheduleJob(cron, () => {
+				try {
+					let msg = '';
 
-				for (const id of this.batteryLowPowered) {
-					msg = '\n' + id['Device'] + ' (' + id['Battery'] + ')'.split(', ');
-				}
+					for (const id of this.offlineDevices) {
+						msg = `${msg}\n${id['Device']} (${id['Last contact']})`;
+					}
 
-				if (this.lowBatteryPoweredCount > 0) {
-					this.log.info(`Niedrige Batteriezustände: ${msg}`);
-					await this.setStateAsync('lastNotification', `Niedrige Batteriezustände: ${msg}`, true);
+					if (this.offlineDevicesCount > 0) {
+						this.log.info(`Geräte Offline: ${msg}`);
+						this.setStateAsync('lastNotification', `Geräte Offline: ${msg}`, true);
 
-					await this.sendNotification(`Niedriege Batteriezustände: ${msg}`);
+						this.sendNotification(`Geräte Offline: ${msg}`);
+					}
 
-					await this.setStateAsync('info.lastBatteryNotification', true, true);
+				} catch (error) {
+					this.errorReporting('[sendOfflineNotificationsShedule]', error);
 				}
-			}
-		} 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
@@ -1809,79 +1875,407 @@ class DeviceWatcher extends utils.Adapter {
 			</tr>`;
 		}
 
-		html += '</table>';
-		return html;
-	}
+		html += '</table>';
+		return html;
+	}
+
+	/**
+	 * @param {object} devices - Device
+	 * @param {number} deviceCount - Counted devices
+	 */
+	async createOfflineListHTML(devices, deviceCount) {
+		devices = devices.sort((a, b) => { return a.Device.localeCompare(b.Device); });
+		let html = `<center>
+		<b>Offline Devices: <font color=${deviceCount == 0 ? '#3bcf0e' : 'orange'}>${deviceCount}</b><small></small></font>
+		<p></p>
+		</center>   
+		<table width=100%>
+		<tr>
+		<th align=left>Device</th>
+		<th align=center width=120>Adapter</th>
+		<th align=center>Letzter Kontakt</th>
+		</tr>
+		<tr>
+		<td colspan="5"><hr></td>
+		</tr>`;
+
+		for (const device of devices) {
+			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>
+			</tr>`;
+		}
+
+		html += '</table>';
+		return html;
+	}
+
+	/**
+	 * @param {object} [devices] - Device
+	 * @param {object} [deviceCount] - Counted devices
+	 * @param {object} [isLowBatteryList] - list Low Battery Devices
+	 */
+	async createBatteryListHTML(devices, deviceCount, isLowBatteryList) {
+		devices = devices.sort((a, b) => { return a.Device.localeCompare(b.Device); });
+		let html = `<center>
+		<b>${isLowBatteryList == true ? 'Schwache ' : ''}Batterie Devices: <font color=${isLowBatteryList == true ? (deviceCount > 0 ? 'orange' : '#3bcf0e') : ''}>${deviceCount}</b></font>
+		<p></p>
+		</center>   
+		<table width=100%>
+		<tr>
+		<th align=left>Device</th>
+		<th align=center width=120>Adapter</th>
+		<th align=${isLowBatteryList ? 'center' : 'right'}>Batterie</th>
+		</tr>
+		<tr>
+		<td colspan="5"><hr></td>
+		</tr>`;
+
+		for (const device of devices) {
+			html += `<tr>
+			<td><font>${device.Device}</font></td>
+			<td align=center><font>${device.Adapter}</font></td>`;
+
+			if (isLowBatteryList) {
+				html += `<td align=center><font color=orange>${device.Battery}</font></td>`;
+			} else {
+				html += `<td align=right><font color=#3bcf0e>${device.Battery}</font></td>`;
+			}
+
+			html += `</tr>`;
+		}
+
+		html += '</table>';
+		return html;
+	}
+
+	// create datapoints for each adapter
+	/**
+	 * @param {object} adptName - Adaptername of devices
+	 **/
+	async createDPsForEachAdapter(adptName) {
+
+		await this.setObjectNotExistsAsync(`${adptName}`, {
+			type: 'channel',
+			common: {
+				name: adptName,
+			},
+			native: {},
+		});
+
+		await this.setObjectNotExistsAsync(`${adptName}.offlineCount`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'Number of devices offline',
+					'de': 'Anzahl der Geräte offline',
+					'ru': 'Количество устройств offline',
+					'pt': 'Número de dispositivos offline',
+					'nl': 'Nummer van apparatuur offline',
+					'fr': 'Nombre de dispositifs hors ligne',
+					'it': 'Numero di dispositivi offline',
+					'es': 'Número de dispositivos sin conexión',
+					'pl': 'Ilość urządzeń offline',
+					'zh-cn': '线内装置数量'
+				},
+				'type': 'number',
+				'role': 'value',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
+
+		await this.setObjectNotExistsAsync(`${adptName}.offlineList`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'List of offline devices',
+					'de': 'Liste der Offline-Geräte',
+					'ru': 'Список оффлайн устройств',
+					'pt': 'Lista de dispositivos off-line',
+					'nl': 'List van offline apparatuur',
+					'fr': 'Liste des dispositifs hors ligne',
+					'it': 'Elenco dei dispositivi offline',
+					'es': 'Lista de dispositivos sin conexión',
+					'pl': 'Lista urządzeń offline',
+					'zh-cn': '线装置清单'
+				},
+				'type': 'array',
+				'role': 'json',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
+
+		await this.setObjectNotExistsAsync(`${adptName}.listAll`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'List of all devices',
+					'de': 'Liste aller Geräte',
+					'ru': 'Список всех устройств',
+					'pt': 'Lista de todos os dispositivos',
+					'nl': 'List van alle apparaten',
+					'fr': 'Liste de tous les dispositifs',
+					'it': 'Elenco di tutti i dispositivi',
+					'es': 'Lista de todos los dispositivos',
+					'pl': 'Lista wszystkich urządzeń',
+					'zh-cn': '所有装置清单'
+				},
+				'type': 'array',
+				'role': 'json',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
+
+		await this.setObjectNotExistsAsync(`${adptName}.linkQualityList`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'List of devices with signal strength',
+					'de': 'Liste der Geräte mit Signalstärke',
+					'ru': 'Список устройств с силой сигнала',
+					'pt': 'Lista de dispositivos com força de sinal',
+					'nl': 'List van apparaten met signaalkracht',
+					'fr': 'Liste des dispositifs avec force de signal',
+					'it': 'Elenco dei dispositivi con forza del segnale',
+					'es': 'Lista de dispositivos con fuerza de señal',
+					'pl': 'Lista urządzeń z siłą sygnałową',
+					'zh-cn': '具有信号实力的装置清单'
+				},
+				'type': 'array',
+				'role': 'json',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
+
+		await this.setObjectNotExistsAsync(`${adptName}.countAll`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'Number of all devices',
+					'de': 'Anzahl aller Geräte',
+					'ru': 'Количество всех устройств',
+					'pt': 'Número de todos os dispositivos',
+					'nl': 'Nummer van alle apparaten',
+					'fr': 'Nombre de tous les appareils',
+					'it': 'Numero di tutti i dispositivi',
+					'es': 'Número de todos los dispositivos',
+					'pl': 'Ilość wszystkich urządzeń',
+					'zh-cn': '所有装置的数目'
+				},
+				'type': 'number',
+				'role': 'value',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
+
+		await this.setObjectNotExistsAsync(`${adptName}.batteryList`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'List of devices with battery state',
+					'de': 'Liste der Geräte mit Batteriezustand',
+					'ru': 'Список устройств с состоянием батареи',
+					'pt': 'Lista de dispositivos com estado da bateria',
+					'nl': 'List van apparaten met batterij staat',
+					'fr': 'Liste des appareils avec état de batterie',
+					'it': 'Elenco dei dispositivi con stato della batteria',
+					'es': 'Lista de dispositivos con estado de batería',
+					'pl': 'Lista urządzeń z baterią stanową',
+					'zh-cn': '电池国装置清单'
+				},
+				'type': 'array',
+				'role': 'json',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
 
-	/**
-	 * @param {object} devices - Device
-	 * @param {number} deviceCount - Counted devices
-	 */
-	async createOfflineListHTML(devices, deviceCount) {
-		devices = devices.sort((a, b) => { return a.Device.localeCompare(b.Device); });
-		let html = `<center>
-		<b>Offline Devices: <font color=${deviceCount == 0 ? '#3bcf0e' : 'orange'}>${deviceCount}</b><small></small></font>
-		<p></p>
-		</center>   
-		<table width=100%>
-		<tr>
-		<th align=left>Device</th>
-		<th align=center width=120>Adapter</th>
-		<th align=center>Letzter Kontakt</th>
-		</tr>
-		<tr>
-		<td colspan="5"><hr></td>
-		</tr>`;
+		await this.setObjectNotExistsAsync(`${adptName}.lowBatteryList`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'List of devices with low battery state',
+					'de': 'Liste der Geräte mit niedrigem Batteriezustand',
+					'ru': 'Список устройств с низким состоянием батареи',
+					'pt': 'Lista de dispositivos com baixo estado da bateria',
+					'nl': 'List van apparaten met lage batterij staat',
+					'fr': 'Liste des appareils à faible état de batterie',
+					'it': 'Elenco di dispositivi con stato di batteria basso',
+					'es': 'Lista de dispositivos con estado de batería bajo',
+					'pl': 'Lista urządzeń o niskim stanie baterii',
+					'zh-cn': '低电池国家装置清单'
+				},
+				'type': 'array',
+				'role': 'json',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
 
-		for (const device of devices) {
-			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>
-			</tr>`;
-		}
+		await this.setObjectNotExistsAsync(`${adptName}.lowBatteryCount`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'Number of devices with low battery',
+					'de': 'Anzahl der Geräte mit niedriger Batterie',
+					'ru': 'Количество устройств c низкой батареей',
+					'pt': 'Número de dispositivos com bateria baixa',
+					'nl': 'Nummer van apparaten met lage batterij',
+					'fr': 'Nombre de dispositifs avec batterie basse',
+					'it': 'Numero di dispositivi con batteria bassa',
+					'es': 'Número de dispositivos con batería baja',
+					'pl': 'Liczba urządzeń z niską baterią',
+					'zh-cn': '低电池的装置数量'
+				},
+				'type': 'number',
+				'role': 'value',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
 
-		html += '</table>';
-		return html;
+		await this.setObjectNotExistsAsync(`${adptName}.batteryCount`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'Number of devices with battery',
+					'de': 'Anzahl der Geräte mit Batterie',
+					'ru': 'Количество устройств c батареей',
+					'pt': 'Número de dispositivos com bateria',
+					'nl': 'Nummer van apparaten met batterij',
+					'fr': 'Nombre de dispositifs avec batterie',
+					'it': 'Numero di dispositivi con batteria',
+					'es': 'Número de dispositivos con batería',
+					'pl': 'Liczba urządzeń z baterią',
+					'zh-cn': '电池的装置数量'
+				},
+				'type': 'number',
+				'role': 'value',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
 	}
 
 	/**
-	 * @param {object} [devices] - Device
-	 * @param {object} [deviceCount] - Counted devices
-	 * @param {object} [isLowBatteryList] - list Low Battery Devices
-	 */
-	async createBatteryListHTML(devices, deviceCount, isLowBatteryList) {
-		devices = devices.sort((a, b) => { return a.Device.localeCompare(b.Device); });
-		let html = `<center>
-		<b>${isLowBatteryList == true ? 'Schwache ' : ''}Batterie Devices: <font color=${isLowBatteryList == true ? (deviceCount > 0 ? 'orange' : '#3bcf0e') : ''}>${deviceCount}</b></font>
-		<p></p>
-		</center>   
-		<table width=100%>
-		<tr>
-		<th align=left>Device</th>
-		<th align=center width=120>Adapter</th>
-		<th align=${isLowBatteryList ? 'center' : 'right'}>Batterie</th>
-		</tr>
-		<tr>
-		<td colspan="5"><hr></td>
-		</tr>`;
+	 * @param {object} [adptName] - Adaptername of devices
+	 **/
+	async createHtmlListDatapoints(adptName) {
 
-		for (const device of devices) {
-			html += `<tr>
-			<td><font>${device.Device}</font></td>
-			<td align=center><font>${device.Adapter}</font></td>`;
+		let dpSubFolder;
+		//write the datapoints in subfolders with the adaptername otherwise write the dP's in the root folder
+		if (adptName) {
+			dpSubFolder = `${adptName}.`;
+		} else {
+			dpSubFolder = '';
+		}
 
-			if (isLowBatteryList) {
-				html += `<td align=center><font color=orange>${device.Battery}</font></td>`;
-			} else {
-				html += `<td align=right><font color=#3bcf0e>${device.Battery}</font></td>`;
-			}
+		await this.setObjectNotExistsAsync(`${dpSubFolder}offlineListHTML`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'HTML List of offline devices',
+					'de': 'HTML Liste der Offline-Geräte',
+					'ru': 'HTML Список оффлайн устройств',
+					'pt': 'HTML Lista de dispositivos off-line',
+					'nl': 'HTML List van offline apparatuur',
+					'fr': 'HTML Liste des dispositifs hors ligne',
+					'it': 'HTML Elenco dei dispositivi offline',
+					'es': 'HTML Lista de dispositivos sin conexión',
+					'pl': 'HTML Lista urządzeń offline',
+					'zh-cn': 'HTML 线装置清单'
+				},
+				'type': 'string',
+				'role': 'html',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
 
-			html += `</tr>`;
-		}
+		await this.setObjectNotExistsAsync(`${dpSubFolder}linkQualityListHTML`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'HTML List of devices with signal strength',
+					'de': 'HTML Liste der Geräte mit Signalstärke',
+					'ru': 'HTML Список устройств с силой сигнала',
+					'pt': 'HTML Lista de dispositivos com força de sinal',
+					'nl': 'HTML List van apparaten met signaalkracht',
+					'fr': 'HTML Liste des dispositifs avec force de signal',
+					'it': 'HTML Elenco dei dispositivi con forza del segnale',
+					'es': 'HTML Lista de dispositivos con fuerza de señal',
+					'pl': 'HTML Lista urządzeń z siłą sygnałową',
+					'zh-cn': 'HTML 具有信号实力的装置清单'
+				},
+				'type': 'string',
+				'role': 'value',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
 
-		html += '</table>';
-		return html;
+		await this.setObjectNotExistsAsync(`${dpSubFolder}batteryListHTML`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'HTML List of devices with battery state',
+					'de': 'HTML Liste der Geräte mit Batteriezustand',
+					'ru': 'HTML Список устройств с состоянием батареи',
+					'pt': 'HTML Lista de dispositivos com estado da bateria',
+					'nl': 'HTML List van apparaten met batterij staat',
+					'fr': 'HTML Liste des appareils avec état de batterie',
+					'it': 'HTML Elenco dei dispositivi con stato della batteria',
+					'es': 'HTML Lista de dispositivos con estado de batería',
+					'pl': 'HTML Lista urządzeń z baterią stanową',
+					'zh-cn': 'HTML 电池国装置清单'
+				},
+				'type': 'string',
+				'role': 'html',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
+
+		await this.setObjectNotExistsAsync(`${dpSubFolder}lowBatteryListHTML`, {
+			'type': 'state',
+			'common': {
+				'name': {
+					'en': 'HTML List of devices with low battery state',
+					'de': 'HTML Liste der Geräte mit niedrigem Batteriezustand',
+					'ru': 'HTML Список устройств с низким состоянием батареи',
+					'pt': 'HTML Lista de dispositivos com baixo estado da bateria',
+					'nl': 'HTML List van apparaten met lage batterij staat',
+					'fr': 'HTML Liste des appareils à faible état de batterie',
+					'it': 'HTML Elenco di dispositivi con stato di batteria basso',
+					'es': 'HTML Lista de dispositivos con estado de batería bajo',
+					'pl': 'HTML Lista urządzeń o niskim stanie baterii',
+					'zh-cn': 'HTML 低电池国家装置清单'
+				},
+				'type': 'string',
+				'role': 'html',
+				'read': true,
+				'write': false,
+			},
+			'native': {}
+		});
 	}
 
 	/**
@@ -1909,12 +2303,13 @@ class DeviceWatcher extends utils.Adapter {
      */
 	onUnload(callback) {
 		try {
-			this.log.info('cleaned everything up...');
-
 			if (this.refreshDataTimeout) {
 				this.log.debug('clearing refresh timeout');
 				this.clearTimeout(this.refreshDataTimeout);
 			}
+			isUnloaded = true;
+
+			this.log.info('cleaned everything up...');
 
 			callback();
 		} catch (e) {