iobroker.device-watcher 0.2.2 → 1.0.0

package/main.js

@@ -7,6 +7,9 @@
 const utils = require('@iobroker/adapter-core');
 const adapterName = require('./package.json').name.split('.').pop();
 
+// Sentry error reporting, disable when testing code!
+const enableSendSentry = true;
+
 class DeviceWatcher extends utils.Adapter {
 
 	constructor(options) {
@@ -16,246 +19,384 @@ class DeviceWatcher extends utils.Adapter {
 			useFormatDate: true,
 		});
 
-		this.on('ready', this.onReady.bind(this));
-		//this.on('stateChange', this.onStateChange.bind(this));
-		// this.on('objectChange', this.onObjectChange.bind(this));
-		// this.on('message', this.onMessage.bind(this));
-		this.on('unload', this.onUnload.bind(this));
-
 		// arrays
-		this.offlineDevices 		= [],
-		this.linkQualityDevices 	= [];
-		this.batteryPowered 		= [];
-		this.batteryLowPowered 		= [];
-		this.listAllDevices 		= [];
-		this.blacklistArr			= [];
-		this.arrDev					= [];
-		this.adapterSelected		= [];
+		this.offlineDevices = [];
+		this.linkQualityDevices = [];
+		this.batteryPowered = [];
+		this.batteryLowPowered = [];
+		this.listAllDevices = [];
+		this.blacklistArr = [];
+		this.arrDev = [];
+		this.adapterSelected = [];
 
 		// counts
-		this.offlineDevicesCount		= 0;
-		this.deviceCounter				= 0;
-		this.linkQualityCount			= 0;
-		this.batteryPoweredCount 		= 0;
-		this.lowBatteryPoweredCount		= 0;
+		this.offlineDevicesCount = 0;
+		this.deviceCounter = 0;
+		this.linkQualityCount = 0;
+		this.batteryPoweredCount = 0;
+		this.lowBatteryPoweredCount = 0;
 
-		this.deviceReachable	= '';
+		this.deviceReachable = '';
+
+		// Interval timer
+		this.refreshDataTimeout = null;
 
 		// arrays of supported adapters
 		this.arrApart = {
-			alexa2: 			{
-				'Selektor':'alexa2.*.online',
-				'adapter':'alexa2',
-				'battery':'none',
-				'reach':'.online',
-				'isLowBat':'none'
+			alexa2: {
+				'Selektor': 'alexa2.*.online',
+				'adapter': 'alexa2',
+				'battery': 'none',
+				'reach': '.online',
+				'isLowBat': 'none'
+			},
+			ble: {
+				'Selektor': 'ble.*.rssi',
+				'adapter': 'ble',
+				'battery': '.battery',
+				'reach': 'none',
+				'isLowBat': 'none'
 			},
-			ble: 			{
-				'Selektor':'ble.*.rssi',
-				'adapter':'ble',
-				'battery':'.battery',
-				'reach':'none',
-				'isLowBat':'none'
+			deconz: {
+				'Selektor': 'deconz.*.reachable',
+				'adapter': 'deconz',
+				'battery': '.battery',
+				'reach': '.reachable',
+				'isLowBat': 'none'
 			},
-			esphome: 			{
-				'Selektor':'esphome.*._online',
-				'adapter':'esphome',
-				'battery':'none',
-				'reach':'._online',
-				'isLowBat':'none',
-				'id':'.name'
+			enocean: {
+				'Selektor': 'enocean.*.rssi',
+				'adapter': 'enocean',
+				'battery': '.BS',
+				'reach': 'none',
+				'isLowBat': 'none'
 			},
-			zigbee: 		{
-				'Selektor':'zigbee.*.link_quality',
-				'adapter':'zigbee',
-				'battery':'.battery',
-				'reach':'.available',
-				'isLowBat':'none'
+			esphome: {
+				'Selektor': 'esphome.*._online',
+				'adapter': 'esphome',
+				'battery': 'none',
+				'reach': '._online',
+				'isLowBat': 'none',
+				'id': '.name'
 			},
-			sonoff: 		{
-				'Selektor':'sonoff.*.Uptime',
-				'adapter':'sonoff',
-				'rssiState': '.Wifi_RSSI',
-				'battery':'.battery',
-				'reach':'.alive',
-				'isLowBat':'none'
+			fritzdect: {
+				'Selektor': 'fritzdect.*.present',
+				'adapter': 'fritzDect',
+				'battery': '.battery',
+				'reach': '.present',
+				'isLowBat': '.batterylow'
 			},
-			shelly: 		{
-				'Selektor':'shelly.*.rssi',
-				'adapter':'shelly',
-				'battery':'.sensor.battery',
-				'reach':'.online',
-				'isLowBat':'none'
+			harmony: {
+				'Selektor': 'harmony.*.hubConnected',
+				'adapter': 'harmony',
+				'battery': 'none',
+				'reach': '.hubConnected',
+				'isLowBat': 'none'
 			},
-			homematic: 		{
-				'Selektor':'hm-rpc.*.UNREACH',
-				'adapter':'homematic',
-				'rssiState':'.RSSI_DEVICE',
-				'battery':'.OPERATING_VOLTAGE',
-				'reach':'.UNREACH',
-				'isLowBat':'.LOW_BAT',
-				'isLowBat2':'.LOWBAT'
+			homematic: {
+				'Selektor': 'hm-rpc.*.UNREACH',
+				'adapter': 'homematic',
+				'rssiState': '.RSSI_DEVICE',
+				'battery': '.OPERATING_VOLTAGE',
+				'reach': '.UNREACH',
+				'isLowBat': '.LOW_BAT',
+				'isLowBat2': '.LOWBAT'
 			},
-			deconz: 		{
-				'Selektor':'deconz.*.reachable',
-				'adapter':'deconz',
-				'battery':'.battery',
-				'reach':'.reachable',
-				'isLowBat':'none'
+			hue: {
+				'Selektor': 'hue.*.reachable',
+				'adapter': 'hue',
+				'battery': '.battery',
+				'reach': '.reachable',
+				'isLowBat': 'none'
 			},
-			zwave: 			{
-				'Selektor':'zwave2.*.ready',
-				'adapter':'zwave',
-				'battery':'.Battery.level',
-				'reach':'.ready',
-				'isLowBat':'.Battery.isLow'
+			hueExt: {
+				'Selektor': 'hue-extended.*.reachable',
+				'adapter': 'hue-extended',
+				'battery': '.config.battery',
+				'reach': '.reachable',
+				'isLowBat': 'none'
 			},
-			dect: 			{
-				'Selektor':'fritzdect.*.present',
-				'adapter':'fritzDect',
-				'battery':'.battery',
-				'reach':'.present',
-				'isLowBat':'.batterylow'
+			jeelink: {
+				'Selektor': 'jeelink.*.lowBatt',
+				'adapter': 'jeelink',
+				'battery': 'none',
+				'reach': 'none',
+				'isLowBat': '.lowBatt'
 			},
-			hue: 			{
-				'Selektor':'hue.*.reachable',
-				'adapter':'hue',
-				'battery':'.battery',
-				'reach':'.reachable',
-				'isLowBat':'none'
+			mihome: {
+				'Selektor': 'mihome.*.percent',
+				'adapter': 'miHome',
+				'battery': '.percent',
+				'reach': 'none',
+				'isLowBat': 'none'
 			},
-			hueExt: 		{
-				'Selektor':'hue-extended.*.reachable',
-				'adapter':'hue-extended',
-				'battery':'.config.battery',
-				'reach':'.reachable',
-				'isLowBat':'none'
+			mihomeGW: {
+				'Selektor': 'mihome.*.connected',
+				'adapter': 'miHome',
+				'battery': 'none',
+				'reach': '.connected',
+				'isLowBat': 'none'
 			},
-			ping: 			{
-				'Selektor':'ping.*.alive',
-				'adapter':'ping',
-				'battery':'none',
-				'reach':'.alive',
-				'isLowBat':'none'
+			mihomeVacuum: {
+				'Selektor': 'mihome-vacuum.*.connection',
+				'adapter': 'mihomeVacuum',
+				'rssiState': '.deviceInfo.wifi_signal',
+				'battery': '.info.battery',
+				'battery2': '.control.battary_life',
+				'reach': '.info.connection',
+				'isLowBat': 'none',
+				'id': '.deviceInfo.model'
 			},
-			switchbotBle: 	{
-				'Selektor':'switchbot-ble.*.rssi',
-				'adapter':'switchbotBle',
-				'battery':'.battery',
-				'reach':'none',
-				'isLowBat':'none',
-				'id':'.id'
+			nukiExt: {
+				'Selektor': 'nuki-extended.*.lastDataUpdate',
+				'adapter': 'nuki-extended',
+				'rssiState': 'none',
+				'battery': '.batteryChargeState',
+				'reach': 'none',
+				'isLowBat': '.batteryCritical'
 			},
-			sonos: 			{
-				'Selektor':'sonos.*.alive',
-				'adapter':'sonos',
-				'battery':'none',
-				'reach':'.alive',
-				'isLowBat':'none'
+			ping: {
+				'Selektor': 'ping.*.alive',
+				'adapter': 'ping',
+				'battery': 'none',
+				'reach': '.alive',
+				'isLowBat': 'none'
 			},
-			mihome: 		{
-				'Selektor':'mihome.*.percent',
-				'adapter':'miHome',
-				'battery':'.percent',
-				'reach':'none',
-				'isLowBat':'none'
+			shelly: {
+				'Selektor': 'shelly.*.rssi',
+				'adapter': 'shelly',
+				'battery': '.sensor.battery',
+				'reach': '.online',
+				'isLowBat': 'none'
 			},
-			mihomeGW:		{
-				'Selektor':'mihome.*.connected',
-				'adapter':'miHome',
-				'battery':'none',
-				'reach':'.connected',
-				'isLowBat':'none'
+			sonoff: {
+				'Selektor': 'sonoff.*.Uptime',
+				'adapter': 'sonoff',
+				'rssiState': '.Wifi_Signal',
+				'battery': '.battery',
+				'reach': '.alive',
+				'isLowBat': 'none'
 			},
-			nukiExt:		{
-				'Selektor':'nuki-extended.*.batteryCritical',
-				'adapter':'nuki-extended',
-				'battery':'.batteryCharge',
-				'reach':'none',
-				'isLowBat':'.batteryCritical'
+			sonos: {
+				'Selektor': 'sonos.*.alive',
+				'adapter': 'sonos',
+				'battery': 'none',
+				'reach': '.alive',
+				'isLowBat': 'none'
+			},
+			switchbotBle: {
+				'Selektor': 'switchbot-ble.*.rssi',
+				'adapter': 'switchbotBle',
+				'battery': '.battery',
+				'reach': 'none',
+				'isLowBat': 'none',
+				'id': '.id'
+			},
+			zigbee: {
+				'Selektor': 'zigbee.*.link_quality',
+				'adapter': 'zigbee',
+				'battery': '.battery',
+				'reach': '.available',
+				'isLowBat': '.battery_low'
+			},
+			zwave: {
+				'Selektor': 'zwave2.*.ready',
+				'adapter': 'zwave',
+				'battery': '.Battery.level',
+				'reach': '.ready',
+				'isLowBat': '.Battery.isLow'
+			},
+			test: { // Only for Dev
+				'Selektor': '0_userdata.*.UNREACH',
+				'adapter': 'homematic',
+				'rssiState': '.RSSI_DEVICE',
+				'battery': '.OPERATING_VOLTAGE',
+				'reach': '.UNREACH',
+				'isLowBat': '.LOW_BAT',
+				'isLowBat2': '.LOWBAT'
 			}
 		};
+
+		this.on('ready', this.onReady.bind(this));
+		this.on('stateChange', this.onStateChange.bind(this));
+		// this.on('objectChange', this.onObjectChange.bind(this));
+		// this.on('message', this.onMessage.bind(this));
+		this.on('unload', this.onUnload.bind(this));
+
 	}
 
 	async onReady() {
 		this.log.debug(`Adapter ${adapterName} was started`);
 
 		try {
+			this.supAdapter = {
+				alexa2: this.config.alexa2Devices,
+				ble: this.config.bleDevices,
+				deconz: this.config.deconzDevices,
+				enocean: this.config.enoceanDevices,
+				esphome: this.config.esphomeDevices,
+				fritzdect: this.config.fritzdectDevices,
+				harmony: this.config.harmonyDevices,
+				homematic: this.config.homematicDevices,
+				hue: this.config.hueDevices,
+				hueExt: this.config.hueExtDevices,
+				jeelink: this.config.jeelinkDevices,
+				mihome: this.config.mihomeDevices,
+				mihomeGW: this.config.mihomeDevices,
+				mihomeVacuum: this.config.mihomeVacuumDevices,
+				nukiExt: this.config.nukiExtDevices,
+				ping: this.config.pingDevices,
+				shelly: this.config.shellyDevices,
+				sonoff: this.config.sonoffDevices,
+				sonos: this.config.sonosDevices,
+				switchbotBle: this.config.switchbotBleDevices,
+				zigbee: this.config.zigbeeDevices,
+				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));
+				}
+			}
+
+			//Check if an Adapter is selected.
+			if (this.adapterSelected.length >= 1) {
+				// show list in debug log
+				this.log.debug(JSON.stringify(this.arrDev));
+
+				this.log.info(`Number of selected adapters: ${this.adapterSelected.length}. Loading data from: ${(this.adapterSelected).join(', ')} ...`);
+			} else {
+				this.log.warn(`No adapter selected. Please check the instance configuration!`);
+				return; // cancel run if no adapter is selected
+			}
+
+			//create Blacklist
+			try {
+				await this.createBlacklist();
+			} catch (error) {
+				this.errorReporting('[onReady - create blacklist]', error);
+			}
+
+			// update data now
 			await this.main();
-			if (this.config.checkSendOfflineMsg) await this.sendOfflineNotifications();
-			if (this.config.checkSendBatteryMsg) await this.sendBatteryNotifications();
-			await this.writeDatapoints();
-			this.log.debug('all done, exiting');
-			this.terminate ? this.terminate('Everything done. Going to terminate till next schedule', 11) : process.exit(0);
-		} catch (e) {
-			this.log.error(`Error while running Device-Watcher. Error Message: ${e}`);
+
+			// update data in interval
+			await this.refreshData();
+
+		} catch (error) {
+			this.errorReporting('[onReady]', error);
 			this.terminate ? this.terminate(15) : process.exit(15);
 		}
 	}
 
-	//Helpfunctions
-	async capitalize(sentence)
-	{
+	/**
+     * Is called if a subscribed state changes
+     * @param {string} id
+     * @param {ioBroker.State | null | undefined} state
+     */
+	async onStateChange(id, state) {
+		if (state) {
+			// The state was changed
+			this.log.debug(`state ${id} changed: ${state.val} (ack = ${state.ack})`);
+			await this.main();
+		} else {
+			// The state was deleted
+			this.log.debug(`state ${id} deleted`);
+		}
+	}
+
+	async refreshData() {
+		const nextTimeout = this.config.updateinterval * 1000;
+
+		await this.main();
+
+		// Clear existing timeout
+		if (this.refreshDataTimeout) {
+			this.log.debug('clearing old refresh timeout');
+			this.clearTimeout(this.refreshDataTimeout);
+		}
+
+		this.refreshDataTimeout = this.setTimeout(() => {
+			this.log.debug('Updating Data');
+
+			this.refreshDataTimeout = null;
+			this.refreshData();
+		}, nextTimeout);
+	}
+
+	async main() {
+		this.log.debug(`Function started: ${this.main.name}`);
+
+		try {
+
+			//create and 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`);
+						}
+					}
+				}
+			} catch (error) {
+				this.errorReporting('[main - create and fill datapoints for each adapter]', error);
+			}
+
+			// creating 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) {
+				this.errorReporting('[main - create data of all adapter]', error);
+			}
+
+		} catch (error) {
+			this.errorReporting('[main]', error);
+		}
+
+		this.log.debug(`Function finished: ${this.main.name}`);
+	} //<--End of main function
+
+
+	/**
+	 * @param {string} sentence - Word which should be capitalize
+	 **/
+	async capitalize(sentence) {
 		//make the first letter uppercase
 		return sentence && sentence[0].toUpperCase() + sentence.slice(1);
 	}
 
+	/**
+	 * @param {object} obj - State of datapoint
+	 **/
 	async getInitValue(obj) {
 		//state can be null or undefinded
 		const foreignState = await this.getForeignStateAsync(obj);
 		if (foreignState) return foreignState.val;
 	}
 
+	/**
+	 * @param {object} obj - State of own datapoint
+	 **/
 	async getOwnInitValue(obj) {
 		//state can be null or undefinded for own states
 		const stateVal = await this.getStateAsync(obj);
 		if (stateVal) return stateVal.val;
 	}
 
-	//Notification services
-	async sendPushover(text) {
-		await this.sendToAsync(this.config.instancePushover, 'send', {
-			message: text,
-			title: this.config.titlePushover,
-			device: this.config.devicePushover,
-			priority: this.config.prioPushover
-		});
-	}
-
-	async sendTelegram(text) {
-		await this.sendToAsync(this.config.instanceTelegram, 'send', {
-			text: text,
-			user: this.config.deviceTelegram,
-			chatId: this.config.chatIdTelegram
-		});
-	}
-
-	async sendWhatsapp(text) {
-		await this.sendToAsync(this.config.instanceWhatsapp, 'send', {
-			text: text,
-			phone: this.config.phoneWhatsapp
-		});
-	}
-
-	async sendEmail(text) {
-		await this.sendToAsync(this.config.instanceEmail, 'send', {
-			sendTo: this.config.sendToEmail,
-			text: text,
-			subject: this.config.subjectEmail
-		});
-	}
-
-	async sendJarvis(text) {
-		await this.setForeignStateAsync(`${this.config.instanceJarvis}.addNotification`, text);
-
-	}
-
-	async sendLovelace(text) {
-		await this.setForeignStateAsync(`${this.config.instanceLovelace}.notifications.add`, text);
-
-	}
-
 	//create datapoints for each adapter
+	/**
+	 * @param {object} adptName - Adaptername of devices
+	 **/
 	async createDPsForEachAdapter(adptName) {
 
 		await this.setObjectNotExistsAsync(`${adptName}`, {
@@ -288,6 +429,7 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			'native': {}
 		});
+
 		await this.setObjectNotExistsAsync(`${adptName}.offlineList`, {
 			'type': 'state',
 			'common': {
@@ -310,6 +452,7 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			'native': {}
 		});
+
 		await this.setObjectNotExistsAsync(`${adptName}.listAll`, {
 			'type': 'state',
 			'common': {
@@ -332,6 +475,7 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			'native': {}
 		});
+
 		await this.setObjectNotExistsAsync(`${adptName}.linkQualityList`, {
 			'type': 'state',
 			'common': {
@@ -354,6 +498,7 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			'native': {}
 		});
+
 		await this.setObjectNotExistsAsync(`${adptName}.countAll`, {
 			'type': 'state',
 			'common': {
@@ -376,6 +521,7 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			'native': {}
 		});
+
 		await this.setObjectNotExistsAsync(`${adptName}.batteryList`, {
 			'type': 'state',
 			'common': {
@@ -398,6 +544,7 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			'native': {}
 		});
+
 		await this.setObjectNotExistsAsync(`${adptName}.lowBatteryList`, {
 			'type': 'state',
 			'common': {
@@ -420,6 +567,7 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			'native': {}
 		});
+
 		await this.setObjectNotExistsAsync(`${adptName}.lowBatteryCount`, {
 			'type': 'state',
 			'common': {
@@ -442,6 +590,7 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			'native': {}
 		});
+
 		await this.setObjectNotExistsAsync(`${adptName}.batteryCount`, {
 			'type': 'state',
 			'common': {
@@ -466,41 +615,161 @@ class DeviceWatcher extends utils.Adapter {
 		});
 	}
 
-	async createData(i) {
-		const devices 			= await this.getForeignStatesAsync(this.arrDev[i].Selektor);
-		const deviceAdapterName = await this.capitalize(this.arrDev[i].adapter);
-		const myBlacklist 		= this.config.tableBlacklist;
+	/**
+	 * @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': {}
+		});
 
-		/*----------  Loop for blacklist ----------*/
-		for(const i in myBlacklist){
+		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': {}
+		});
+	}
+
+	async createBlacklist() {
+		this.log.debug(`Function started: ${this.createBlacklist.name}`);
+
+		const myBlacklist = this.config.tableBlacklist;
+
+		for (const i in myBlacklist) {
 			this.blacklistArr.push(myBlacklist[i].device);
-			this.log.debug(`Found items on the blacklist: ${this.blacklistArr}`);
 		}
+		this.log.info(`Found items on the blacklist: ${this.blacklistArr}`);
+		this.log.debug(`Function finished: ${this.createBlacklist.name}`);
+	}
+
+	/**
+	 * @param {object} i - Device Object
+	 **/
+	async createData(i) {
+		const devices = await this.getForeignStatesAsync(this.arrDev[i].Selektor);
+		const deviceAdapterName = await this.capitalize(this.arrDev[i].adapter);
 
 		/*----------  Start of second main loop  ----------*/
-		for(const [id] of Object.entries(devices)) {
+		for (const [id] of Object.entries(devices)) {
 			if (!this.blacklistArr.includes(id)) {
 
-				const currDeviceString    	= id.slice(0, (id.lastIndexOf('.') + 1) - 1);
+				const currDeviceString = id.slice(0, (id.lastIndexOf('.') + 1) - 1);
 				const shortCurrDeviceString = currDeviceString.slice(0, (currDeviceString.lastIndexOf('.') + 1) - 1);
 
-				//Get device name
+				// 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 'switchbotBle':	// Get ID for Switchbot and ESPHome Devices
 					case 'esphome':
 						deviceName = await this.getInitValue(currDeviceString + this.arrDev[i].id);
 						break;
 
 					case 'hue-extended':
-						if  (shortDeviceObject && typeof shortDeviceObject === 'object') {
+					case 'homematic':
+					case 'nuki-extended':
+						if (shortDeviceObject && typeof shortDeviceObject === 'object') {
 							deviceName = shortDeviceObject.common.name;
 						}
 						break;
 
+					case 'mihomeVacuum':
+						deviceName = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].id);
+						break;
+
 					default:
 						if (deviceObject && typeof deviceObject === 'object') {
 							deviceName = deviceObject.common.name;
@@ -508,48 +777,71 @@ class DeviceWatcher extends utils.Adapter {
 						break;
 				}
 
-				// 1. Get link quality
+				const deviceMainSelector = await this.getForeignStateAsync(id);
+
+				// Get battery states
+				const deviceBatteryState = await this.getInitValue(currDeviceString + this.arrDev[i].battery);
+				const shortDeviceBatteryState = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].battery);
+				const shortDeviceBatteryState2 = await this.getInitValue(shortCurrDeviceString + this.arrDev[i].battery2);
+
+				// Get link quality
 				let deviceQualityState;
 				let linkQuality;
 
 				switch (this.arrDev[i].adapter) {
-					case 'homematic':
 					case 'sonoff':
+					case 'homematic':
 						deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiState);
 						break;
+
+					case 'mihomeVacuum':
+						deviceQualityState = await this.getForeignStateAsync(shortCurrDeviceString + this.arrDev[i].rssiState);
+						break;
+
 					default:
 						deviceQualityState = await this.getForeignStateAsync(id);
+						break;
 				}
 
-				if ((deviceQualityState) && (typeof deviceQualityState.val === 'number')){
+				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)) + '%';
+							linkQuality = parseFloat((100 / 255 * deviceQualityState.val).toFixed(0)) + '%';
 						}
 					}
-					this.linkQualityDevices.push(
-						{
-							'Device': deviceName,
-							'Adapter': deviceAdapterName,
-							'Signal strength': linkQuality
+					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 {
-				// no linkQuality available for powered devices
-					linkQuality = ' - ';
+					linkQuality = ' - '; // no linkQuality available for powered devices
 				}
 
-				// 1b. Count how many devices with link Quality
+				// Count how many devices with link Quality
 				this.linkQualityCount = this.linkQualityDevices.length;
 
-				// 2. When was the last contact to the device?
+				// When was the last contact to the device?
 				let lastContactString;
 
-				const deviceMainSelector = await this.getForeignStateAsync(id);
 				let deviceState = 'Online';
 				if (deviceMainSelector) {
 					try {
@@ -557,15 +849,15 @@ class DeviceWatcher extends utils.Adapter {
 						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';
+								lastContactString = Math.round(lastContact / 60) + ' Stunden';
 							}
-							if (Math.round(lastContact/60) > 48) {
-								lastContactString = Math.round(lastContact/60/24) + ' Tagen';
+							if (Math.round(lastContact / 60) > 48) {
+								lastContactString = Math.round(lastContact / 60 / 24) + ' Tagen';
 							}
 							return lastContactString;
 						};
@@ -573,47 +865,42 @@ class DeviceWatcher extends utils.Adapter {
 						const getLastStateChange = async () => {
 							lastContactString = this.formatDate(new Date((deviceMainSelector.lc)), 'hh:mm') + ' Uhr';
 							if (Math.round(lastStateChange) > 100) {
-								lastContactString = Math.round(lastStateChange/60) + ' Stunden';
+								lastContactString = Math.round(lastStateChange / 60) + ' Stunden';
 							}
-							if (Math.round(lastStateChange/60) > 48) {
-								lastContactString = Math.round(lastStateChange/60/24) + ' Tagen';
+							if (Math.round(lastStateChange / 60) > 48) {
+								lastContactString = Math.round(lastStateChange / 60 / 24) + ' Tagen';
 							}
 							return lastContactString;
 						};
 
-						// 2b. wenn seit X Minuten kein Kontakt mehr besteht, nimm Gerät in Liste auf
-						//Rechne auf Tage um, wenn mehr als 48 Stunden seit letztem Kontakt vergangen sind
-						//lastContactString = Math.round(lastContact) + ' Minuten';
-						switch (this.arrDev[i].adapter) {
-							case 'ping':
-								//State changed
-								if (!deviceUnreachState) {
-									await getLastStateChange();
-								} else {
-									await getLastContact();
-								}
+						//  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:
-								await getLastContact();
-								break;
+								//State changed
+								if  (this.arrDev[i].adapter == 'homematic') {
+									if (deviceUnreachState) {
+										await getLastStateChange();
+									} else {
+										await getLastContact();
+									}
+								} else {
+									if ((!deviceUnreachState)) {
+										await getLastStateChange();
+									} else {
+										await getLastContact();
+									}
+									break;
+								}
 						}
 
-						switch (this.arrDev[i].adapter) {
-							case 'alexa2':
-								if (this.config.alexa2MaxMinutes === -1) {
-									if (!deviceUnreachState) {
-										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
-									}
-								} else if (lastContact > this.config.alexa2MaxMinutes) {
-									deviceState = 'Offline'; //set online state to offline
+						const pushOfflineDevice = async () => {
+							if (this.config.listOnlyBattery) {	//if checked, list only battery devices
+								if (deviceBatteryState || shortDeviceBatteryState) {
 									this.offlineDevices.push(
 										{
 											'Device': deviceName,
@@ -622,395 +909,304 @@ class DeviceWatcher extends utils.Adapter {
 										}
 									);
 								}
+							} else {
+								this.offlineDevices.push( 	//else push all devices
+									{
+										'Device': deviceName,
+										'Adapter': deviceAdapterName,
+										'Last contact': lastContactString
+									}
+								);
+							}
+						};
+
+						// await this.subscribeForeignStatesAsync(currDeviceString + this.arrDev[i].reach);
+
+						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 ((lastStateChange > this.config.alexa2MaxMinutes) && (!deviceUnreachState)) {
+									deviceState = 'Offline'; //set online state to offline
+									await pushOfflineDevice();
+								}
 								break;
 							case 'ble':
 								if (this.config.bleMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
 								} else if (lastContact > this.config.bleMaxMinutes) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'deconz':
 								if (this.config.deconzMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.deconzMaxMinutes) {
+								} else if ((lastStateChange > this.config.deconzMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									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
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.esphomeMaxMinutes) {
+								} else if ((lastStateChange > this.config.esphomeMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'fritzDect':
 								if (this.config.fritzdectMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.fritzdectMaxMinutes) {
+								} else if ((lastStateChange > this.config.fritzdectMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
+								}
+								break;
+							case 'harmony':
+								if (this.config.harmonyMaxMinutes === -1) {
+									if (!deviceUnreachState) {
+										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) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.homematicMaxMinutes) {
+								} else if ((lastStateChange > this.config.homematicMaxMinutes) && (deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'hue':
 								if (this.config.hueMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.hueMaxMinutes) {
+								} else if ((lastStateChange > this.config.hueMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'hue-extended':
 								if (this.config.hueextMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.hueextMaxMinutes) {
+								} else if ((lastStateChange > this.config.hueextMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
+								}
+								break;
+							case 'jeelink':
+								if (this.config.jeelinkMaxMinutes === -1) {
+									if (!deviceUnreachState) {
+										deviceState = 'Offline'; //set online state to offline
+										await pushOfflineDevice();
+									}
+								} else if (lastContact > this.config.jeelinkMaxMinutes) {
+									deviceState = 'Offline'; //set online state to offline
+									await pushOfflineDevice();
 								}
 								break;
 							case 'miHome':
 								if (this.config.mihomeMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.mihomeMaxMinutes) {
+								} else if ((lastStateChange > this.config.mihomeMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
+								}
+								break;
+							case 'mihomeVacuum':
+								if (this.config.mihomeVacuumMaxMinutes === -1) {
+									if (!shortDeviceUnreachState) {
+										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) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
 								} else if (lastContact > this.config.nukiextendMaxMinutes) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'ping':
 								if (this.config.pingMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
 								} else if ((lastStateChange > this.config.pingMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'shelly':
 								if (this.config.shellyMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.shellyMaxMinutes) {
+								} else if ((lastStateChange > this.config.shellyMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'sonoff':
 								if (this.config.sonoffMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.sonoffMaxMinutes) {
+								} else if ((lastStateChange > this.config.sonoffMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'sonos':
 								if (this.config.sonosMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.sonosMaxMinutes) {
+								} else if ((lastStateChange > this.config.sonosMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'switchbotBle':
 								if (this.config.switchbotMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
 								} else if (lastContact > this.config.switchbotMaxMinutes) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'zigbee':
 								if (this.config.zigbeeMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.zigbeeMaxMinutes) {
+								} else if ((lastStateChange > this.config.zigbeeMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 							case 'zwave':
 								if (this.config.zwaveMaxMinutes === -1) {
 									if (!deviceUnreachState) {
 										deviceState = 'Offline'; //set online state to offline
-										this.offlineDevices.push(
-											{
-												'Device': deviceName,
-												'Adapter': deviceAdapterName,
-												'Last contact': lastContactString
-											}
-										);
+										await pushOfflineDevice();
 									}
-								} else if (lastContact > this.config.zwaveMaxMinutes) {
+								} else if ((lastStateChange > this.config.zwaveMaxMinutes) && (!deviceUnreachState)) {
 									deviceState = 'Offline'; //set online state to offline
-									this.offlineDevices.push(
-										{
-											'Device': deviceName,
-											'Adapter': deviceAdapterName,
-											'Last contact': lastContactString
-										}
-									);
+									await pushOfflineDevice();
 								}
 								break;
 						}
-					} catch (e) {
-						this.log.error(`(03) Error while getting timestate ${e}`);
+					} catch (error) {
+						this.errorReporting('[getLastContact]', error);
 					}
 				}
 
 
 
-				// 2c. Count how many devcies are offline
+				// Count how many devcies are offline
 				this.offlineDevicesCount = this.offlineDevices.length;
 
-				// 3. Get battery states
-				const deviceBatteryState		= await this.getInitValue(currDeviceString + this.arrDev[i].battery);
-				const shortDeviceBatteryState	= await this.getInitValue(shortCurrDeviceString + this.arrDev[i].battery);
+				// 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)) {
-					batteryHealth = ' - ';
+				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
+							}
+						);
+					} else {
+						batteryHealth = ' - ';
+					}
 				} else {
-
 					switch (this.arrDev[i].adapter) {
 						case 'homematic':
 							if (deviceBatteryState === 0) {
@@ -1039,6 +1235,27 @@ class DeviceWatcher extends utils.Adapter {
 								);
 							}
 							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(
@@ -1051,43 +1268,51 @@ class DeviceWatcher extends utils.Adapter {
 					}
 				}
 
-				// 3b. Count how many devices are with battery
+				// Count how many devices are with battery
 				this.batteryPoweredCount = this.batteryPowered.length;
 
-				// 3c. Count how many devices are with low battery
-				const batteryWarningMin 		= this.config.minWarnBatterie;
-				const deviceLowBatState			= await this.getInitValue(currDeviceString + this.arrDev[i].isLowBat);
-				const deviceLowBatStateHM		= await this.getInitValue(currDeviceString + this.arrDev[i].isLowBat2);
+				// 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,
+									'Battery': batteryHealth
+								}
+							);
+						}
+						break;
 
-				if (this.arrDev[i].isLowBat === 'none') {
-					if (deviceBatteryState && (deviceBatteryState < batteryWarningMin)) {
-						this.batteryLowPowered.push(
-							{
-								'Device': deviceName,
-								'Adapter': deviceAdapterName,
-								'Battery': batteryHealth
-							}
-						);
-					}
-				} else {
-					if (deviceLowBatState || deviceLowBatStateHM) {
-						this.batteryLowPowered.push(
-							{
-								'Device': deviceName,
-								'Adapter': deviceAdapterName,
-								'Battery': batteryHealth
-							}
-						);
-					}
+					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
+								}
+							);
+						}
 				}
 
 				// 3d. Count how many devices are with low battery
 				this.lowBatteryPoweredCount = this.batteryLowPowered.length;
 
-				// 4. Add all devices in the list
-				if (this.config.listOnlyBattery) {
-					if (deviceBatteryState !== null || shortDeviceBatteryState !== null) {
+				if (this.config.listOnlyBattery) {   // 4. Add only devices with battery in the list
+					if (deviceBatteryState || shortDeviceBatteryState) {
 						this.listAllDevices.push(
 							{
 								'Device': deviceName,
@@ -1099,7 +1324,7 @@ class DeviceWatcher extends utils.Adapter {
 							}
 						);
 					}
-				} else if (!this.config.listOnlyBattery) {
+				} else if (!this.config.listOnlyBattery) { // 4. Add all devices
 					this.listAllDevices.push(
 						{
 							'Device': deviceName,
@@ -1116,129 +1341,183 @@ class DeviceWatcher extends utils.Adapter {
 				// 4a. Count how many devices are exists
 				this.deviceCounter = this.listAllDevices.length;
 			}
-		} //<--End of second loop
-	}
+		} // <-- end of loop
+	} // <-- end of createData
 
-	async createDataForEachAdpt(adptName) {
-		this.log.debug(`Function started: ${this.createDataForEachAdpt.name}`);
-		await this.resetVars();
 
-		for (let i = 0; i < this.arrDev.length; i++) {
+	/**
+	 * @param {string} adptName - Adapter name
+	 */
+	async createDataForEachAdapter(adptName) {
+		// create Data for each Adapter in own lists
+		this.log.debug(`Function started: ${this.createDataForEachAdapter.name}`);
 
-			if (this.arrDev[i].adapter.includes(adptName)) {
-				await this.createData(i);
-			}
+		try {
+			await this.resetVars(); // reset the arrays and counts
 
+			for (let i = 0; i < this.arrDev.length; i++) {
+
+				if (this.arrDev[i].adapter.includes(adptName)) { // list device only if selected adapter matched with device
+					await this.createData(i);
+				}
+			}
+			await this.writeDatapoints(adptName); // fill the datapoints
+		} catch (error) {
+			this.errorReporting('[createDataForEachAdapter]', error);
 		}
-		await this.writeDatapoints(adptName);
 
-		this.log.debug(`Function finished: ${this.createDataForEachAdpt.name}`);
-	}
+		this.log.debug(`Function finished: ${this.createDataForEachAdapter.name}`);
+	} // <-- end of createDataForEachAdapter
+
+	async createDataOfAllAdapter() {
+		// create Data of all selected adapter in one list
+		this.log.debug(`Function started: ${this.createDataOfAllAdapter.name}`);
+
+		try {
+			await this.resetVars(); // reset the arrays and counts
 
-	async createDataOfAll() {
-		this.log.debug(`Function started: ${this.createDataOfAll.name}`);
-		await this.resetVars();
+			for (let i = 0; i < this.arrDev.length; i++) {
 
-		for (let i = 0; i < this.arrDev.length; i++) {
+				await this.createData(i);
 
-			await this.createData(i);
+			}
 
+			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
+		} catch (error) {
+			this.errorReporting('[createDataOfAllAdapter]', error);
 		}
-		await this.writeDatapoints();
 
-		this.log.debug(`Function finished: ${this.createDataOfAll.name}`);
-	}
+		this.log.debug(`Function finished: ${this.createDataOfAllAdapter.name}`);
+	} // <-- end of createDataOfAllAdapter
 
-	async resetVars() {
-		// arrays
-		this.offlineDevices 		= [],
-		this.linkQualityDevices 	= [];
-		this.batteryPowered 		= [];
-		this.batteryLowPowered 		= [];
-		this.listAllDevices 		= [];
 
-		// counts
-		this.offlineDevicesCount		= 0;
-		this.deviceCounter				= 0;
-		this.linkQualityCount			= 0;
-		this.batteryPoweredCount 		= 0;
-		this.lowBatteryPoweredCount		= 0;
+	/**
+	 * Notification service
+	 * @param {string} text - Text which should be send
+	 **/
+	async sendNotification(text) {
 
-		this.deviceReachable	= '';
-	}
+		// Pushover
+		try {
+			if (this.config.instancePushover) {
+				//first check if instance is living
+				const pushoverAliveState = await this.getInitValue('system.adapter.' + this.config.instancePushover + '.alive');
 
-	async main() {
-		this.log.debug(`Function started: ${this.main.name}`);
+				if (!pushoverAliveState) {
+					this.log.warn('Pushover instance is not running. Message could not be sent. Please check your instance configuration.');
+				} else {
+					await this.sendToAsync(this.config.instancePushover, 'send', {
+						message: text,
+						title: this.config.titlePushover,
+						device: this.config.devicePushover,
+						priority: this.config.prioPushover
+					});
+				}
+			}
+		} catch (error) {
+			this.errorReporting('[sendNotification Pushover]', error);
+		}
 
-		this.supAdapter = {
-			alexa2:			this.config.alexa2Devices,
-			esphome:		this.config.esphomeDevices,
-			zigbee: 		this.config.zigbeeDevices,
-			ble: 			this.config.bleDevices,
-			sonoff: 		this.config.sonoffDevices,
-			shelly: 		this.config.shellyDevices,
-			homematic: 		this.config.homematicDevices,
-			deconz:			this.config.deconzDevices,
-			zwave: 			this.config.zwaveDevices,
-			dect: 			this.config.dectDevices,
-			hue: 			this.config.hueDevices,
-			hueExt: 		this.config.hueExtDevices,
-			nukiExt: 		this.config.nukiExtDevices,
-			ping: 			this.config.pingDevices,
-			switchbotBle: 	this.config.switchbotBleDevices,
-			sonos: 			this.config.sonosDevices,
-			mihome:			this.config.mihomeDevices,
-			mihomeGW:		this.config.mihomeDevices,
-		};
+		// Telegram
+		try {
+			if (this.config.instanceTelegram) {
+				//first check if instance is living
+				const telegramAliveState = await this.getInitValue('system.adapter.' + this.config.instanceTelegram + '.alive');
 
-		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));
-				this.log.debug(JSON.stringify(this.arrDev));
+				if (!telegramAliveState) {
+					this.log.warn('Telegram instance is not running. Message could not be sent. Please check your instance configuration.');
+				} else {
+					await this.sendToAsync(this.config.instanceTelegram, 'send', {
+						text: text,
+						user: this.config.deviceTelegram,
+						chatId: this.config.chatIdTelegram
+					});
+				}
+			}
+		} catch (error) {
+			this.errorReporting('[sendNotification Telegram]', error);
+		}
 
-				//create and fill datapoints for each adapter if selected
-				if (this.config.createOwnFolder) {
-					try {
-						await this.createDPsForEachAdapter(id);
-						this.log.debug(`Created datapoints for ${await this.capitalize(id)}`);
-						await this.createDataForEachAdpt(id);
-						this.log.debug(`Created and filled data for each adapter`);
-					} catch (e) {
-						this.log.warn(`Error at creating/filling datapoints for each adapter: ${e}`);
-						return;
-					}
+		// Whatsapp
+		try {
+			if (this.config.instanceWhatsapp) {
+				//first check if instance is living
+				const whatsappAliveState = await this.getInitValue('system.adapter.' + this.config.instanceWhatsapp + '.alive');
+
+				if (!whatsappAliveState) {
+					this.log.warn('Whatsapp instance is not running. Message could not be sent. Please check your instance configuration.');
+				} else {
+					await this.sendToAsync(this.config.instanceWhatsapp, 'send', {
+						text: text,
+						phone: this.config.phoneWhatsapp
+					});
 				}
 			}
+		} catch (error) {
+			this.errorReporting('[sendNotification Whatsapp]', error);
 		}
 
-		//Check if an Adapter is selected.
-		if (this.adapterSelected.length >= 1) {
-			this.log.info(`Number of selected adapters: ${this.adapterSelected.length}. Loading data from: ${(this.adapterSelected).join(', ')} ...`);
-		} else {
-			this.log.warn(`No adapter selected. Please check the instance configuration!`);
-			return;
+		// Email
+		try {
+			if (this.config.instanceEmail) {
+				//first check if instance is living
+				const eMailAliveState = await this.getInitValue('system.adapter.' + this.config.instanceEmail + '.alive');
+
+				if (!eMailAliveState) {
+					this.log.warn('eMail instance is not running. Message could not be sent. Please check your instance configuration.');
+				} else {
+					await this.sendToAsync(this.config.instanceEmail, 'send', {
+						sendTo: this.config.sendToEmail,
+						text: text,
+						subject: this.config.subjectEmail
+					});
+				}
+			}
+		} catch (error) {
+			this.errorReporting('[sendNotification eMail]', error);
 		}
 
-		/*=============================================
-		=            Start of main loop    		   	  =
-		=============================================*/
+		// Jarvis Notification
 		try {
-			await this.createDataOfAll();
-			this.log.debug(`Created and filled data for all adapters`);
-		} catch (e) {
-			this.log.warn(`Error at creating/filling datapoints for all adapters: ${e}`);
-			return;
+			if (this.config.instanceJarvis) {
+				//first check if instance is living
+				const jarvisAliveState = await this.getInitValue('system.adapter.' + this.config.instanceJarvis + '.alive');
+
+				if (!jarvisAliveState) {
+					this.log.warn('Jarvis instance is not running. Message could not be sent. Please check your instance configuration.');
+				} else {
+					const jsonText = JSON.stringify(text);
+					await this.setForeignStateAsync(`${this.config.instanceJarvis}.addNotification`, '{"title":"' + this.config.titleJarvis + ' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')","message": ' + jsonText + ',"display": "drawer"}');
+				}
+			}
+		} catch (error) {
+			this.errorReporting('[sendNotification Jarvis]', error);
 		}
 
-		this.log.debug(`Function finished: ${this.main.name}`);
-	} //<--End of main function
+		// Lovelace Notification
+		try {
+			if (this.config.instanceLovelace) {
+				//first check if instance is living
+				const lovelaceAliveState = await this.getInitValue('system.adapter.' + this.config.instanceLovelace + '.alive');
+
+				if (!lovelaceAliveState) {
+					this.log.warn('Lovelace instance is not running. Message could not be sent. Please check your instance configuration.');
+				} else {
+					const jsonText = JSON.stringify(text);
+					await this.setForeignStateAsync(`${this.config.instanceLovelace}.notifications.add`, '{"message":' + jsonText + ', "title":"' + this.config.titleLovelace + ' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')"}');
+				}
+			}
+		} catch (error) {
+			this.errorReporting('[sendNotification Lovelace]', error);
+		}
+	} // <-- End of sendNotification function
 
 
 	async sendOfflineNotifications() {
-		/*=============================================
-		=        	send offline notification		  =
-		=============================================*/
+		// send message if an device is offline
 
 		this.log.debug(`Start the function: ${this.sendOfflineNotifications.name}`);
 
@@ -1246,8 +1525,10 @@ class DeviceWatcher extends utils.Adapter {
 			let msg = '';
 			const offlineDevicesCountOld = await this.getOwnInitValue('offlineCount');
 
-			if ((this.offlineDevicesCount != offlineDevicesCountOld)) {
-				if (this.offlineDevicesCount == 1) {	// make singular if it is only one device
+			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`;
@@ -1256,246 +1537,385 @@ class DeviceWatcher extends utils.Adapter {
 				for (const id of this.offlineDevices) {
 					msg = `${msg} \n ${id['Device']} (${id['Last contact']})`;
 				}
+
 				this.log.info(msg);
 				await this.setStateAsync('lastNotification', msg, true);
-				if (this.config.instancePushover) {
-					try {
-						await this.sendPushover(msg);
-					} catch (e) {
-						this.log.warn (`Getting error at sending pushover notification ${e}`);
-					}
-				}
-				if (this.config.instanceTelegram) {
-					try {
-						await this.sendTelegram(msg);
-					} catch (e) {
-						this.log.warn (`Getting error at sending telegram notification ${e}`);
-					}
-				}
-				if (this.config.instanceWhatsapp) {
-					try {
-						await this.sendWhatsapp(msg);
-					} catch (e) {
-						this.log.warn (`Getting error at sending whatsapp notification ${e}`);
-					}
-				}
-				if (this.config.instanceEmail) {
-					try {
-						await this.sendEmail(msg);
-					} catch (e) {
-						this.log.warn (`Getting error at sending email notification ${e}`);
-					}
-				}
-				if (this.config.instanceJarvis) {
-					try {
-						await this.sendJarvis('{"title":"'+ this.config.titleJarvis +' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')","message":" ' + this.offlineDevicesCount + ' Geräte sind nicht erreichbar","display": "drawer"}');
-					} catch (e) {
-						this.log.warn (`Getting error at sending jarvis notification ${e}`);
+				await this.sendNotification(msg);
+			}
+		} catch (error) {
+			this.errorReporting('[sendOfflineMessage]', error);
+		}
+
+		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)) {
+					let msg = '';
+
+					for (const id of this.offlineDevices) {
+						msg = `${msg} \n ${id['Device']} (${id['Last contact']})`;
 					}
-				}
-				if (this.config.instanceLovelace) {
-					try {
-						await this.sendLovelace('{"message":" ' + this.offlineDevicesCount + ' Geräte sind nicht erreichbar", "title":"'+ this.config.titleLovelace +' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')"}');
-					} catch (e) {
-						this.log.warn (`Getting error at sending lovelace notification ${e}`);
+
+					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);
 					}
 				}
 			}
-		} catch (e) {
-			this.log.debug(`Getting error at sending offline notification ${e}`);
+		} catch (error) {
+			this.errorReporting('[sendOfflineMessage - daily message]', error);
 		}
 		this.log.debug(`Finished the function: ${this.sendOfflineNotifications.name}`);
 	}//<--End of offline notification
 
+	async sendDailyOfflineNotifications() {
+		// send daily an overview with offline devices
 
-	async sendBatteryNotifications() {
-		/*=============================================
-		=        send low battery notification		  =
-		=============================================*/
+		this.log.debug(`Start the function: ${this.sendDailyOfflineNotifications.name}`);
 
-		this.log.debug(`Start the function: ${this.sendBatteryNotifications.name}`);
-		const now = new Date();
-		const today = now.getDay();
-		const checkDays = [];
-		let checkToday;
-
-		const choosedDays = {
-			monday: this.config.checkMonday,
-			tuesday: this.config.checkTuesday,
-			wednesday: this.config.checkWednesday,
-			thursday: this.config.checkThursday,
-			friday: this.config.checkFriday,
-			saturday: this.config.checkSaturday,
-			sunday: this.config.checkSunday,
-		};
+		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
 
-		if (choosedDays.monday) checkDays.push(1);
-		if (choosedDays.tuesday) checkDays.push(2);
-		if (choosedDays.wednesday) checkDays.push(3);
-		if (choosedDays.thursday) checkDays.push(4);
-		if (choosedDays.friday) checkDays.push(5);
-		if (choosedDays.saturday) checkDays.push(6);
-		if (choosedDays.sunday) checkDays.push(0);
-
-		//Check if the message should be send today
-		checkDays.forEach(object => {
-			if((object >= 0) && today == object){
-				checkToday = true;
-			}
-		});
+			// set indicator for send message first to 'false', after sending to 'true'
+			if (now.getHours() < 11) await this.setStateAsync('info.lastOfflineNotification', false, true);
 
-		//Check first if a day is selected
-		if (checkDays.length >= 1) {
-			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;
+			// if time is > 11 (12:00 pm create message for offline devices devices)
+			if ((now.getHours() > 11) && (!lastOfflineNotifyIndicator)) {
+				let msg = '';
+
+				for (const id of this.offlineDevices) {
+					msg = `${msg} \n ${id['Device']} (${id['Last contact']})`;
+				}
+
+				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);
+				}
+			}
+		} catch (error) {
+			this.errorReporting('[sendDailyOfflineNotifications]', 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}`);
 
 		try {
-			//Check if the message for low battery was already sent today
+
+			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;
+				}
+			});
+
+			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
+			}
+
+			// Check if the message for low battery was already sent today
 			const lastBatteryNotifyIndicator = await this.getOwnInitValue('info.lastBatteryNotification');
 
-			if (now.getHours() < 11) {await this.setStateAsync('info.lastBatteryNotification', false, true);} //set indicator for send message first to 'false' later after sending to 'true'
-			if ((now.getHours() > 11) && (!lastBatteryNotifyIndicator) && (checkToday != undefined)){
-				let infotext = '';
+			// set indicator for send message first to 'false', after sending to 'true'
+			if (now.getHours() < 11) await this.setStateAsync('info.lastBatteryNotification', false, true);
+
+			// if time is > 11 (12:00 pm create message for low battery devices)
+			if ((now.getHours() > 11) && (!lastBatteryNotifyIndicator) && (checkToday != undefined)) {
+				let msg = '';
 
 				for (const id of this.batteryLowPowered) {
-					infotext = '\n' + id['Device'] + ' (' + id['Battery'] + ')'.split(', ');
+					msg = '\n' + id['Device'] + ' (' + id['Battery'] + ')'.split(', ');
 				}
 
 				if (this.lowBatteryPoweredCount > 0) {
-					this.log.info(`Niedrige Batteriezustände: ${infotext}`);
-					await this.setStateAsync('lastNotification', `Niedrige Batteriezustände: ${infotext}`, true);
-
-					if (this.config.instancePushover) {
-						try {
-							await this.sendPushover(`Niedrige Batteriezustände: ${infotext}`);
-						} catch (e) {
-							this.log.warn (`Getting error at sending pushover notification ${e}`);
-						}
-					}
-					if (this.config.instanceTelegram) {
-						try {
-							await this.sendTelegram(`Niedrige Batteriezustände: ${infotext}`);
-						} catch (e) {
-							this.log.warn (`Getting error at sending telegram notification ${e}`);
-						}
-					}
-					if (this.config.instanceWhatsapp) {
-						try {
-							await this.sendWhatsapp(`Niedrige Batteriezustände: ${infotext}`);
-						} catch (e) {
-							this.log.warn (`Getting error at sending whatsapp notification ${e}`);
-						}
-					}
-					if (this.config.instanceEmail) {
-						try {
-							await this.sendEmail(`Niedrige Batteriezustände: ${infotext}`);
-						} catch (e) {
-							this.log.warn (`Getting error at sending email notification ${e}`);
-						}
-					}
-					if (this.config.instanceJarvis) {
-						try {
-							await this.sendJarvis('{"title":"'+ this.config.titleJarvis +' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')","message":" ' + this.lowBatteryPoweredCount + ' Geräte mit schwacher Batterie","display": "drawer"}');
-						} catch (e) {
-							this.log.warn (`Getting error at sending jarvis notification ${e}`);
-						}
-					}
-					if (this.config.instanceLovelace) {
-						try {
-							await this.sendLovelace('{"message":" ' + this.lowBatteryPoweredCount + ' Geräte mit schwacher Batterie", "title":"'+ this.config.titleLovelace +' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')"}');
-						} catch (e) {
-							this.log.warn (`Getting error at sending lovelace notification ${e}`);
-						}
-					}
+					this.log.info(`Niedrige Batteriezustände: ${msg}`);
+					await this.setStateAsync('lastNotification', `Niedrige Batteriezustände: ${msg}`, true);
+
+					await this.sendNotification(`Niedriege Batteriezustände: ${msg}`);
 
 					await this.setStateAsync('info.lastBatteryNotification', true, true);
 				}
 			}
-		} catch (e) {
-			this.log.debug(`Getting error at sending battery notification ${e}`);
+		} catch (error) {
+			this.errorReporting('[sendOfflineMessage]', error);
 		}
+
 		this.log.debug(`Finished the function: ${this.sendBatteryNotifications.name}`);
 	}//<--End of battery notification
 
+
+	async resetVars() {
+		//Reset all arrays and counts
+		this.log.debug(`Function started: ${this.resetVars.name}`);
+
+		// arrays
+		this.offlineDevices = [];
+		this.linkQualityDevices = [];
+		this.batteryPowered = [];
+		this.batteryLowPowered = [];
+		this.listAllDevices = [];
+
+		// counts
+		this.offlineDevicesCount = 0;
+		this.deviceCounter = 0;
+		this.linkQualityCount = 0;
+		this.batteryPoweredCount = 0;
+		this.lowBatteryPoweredCount = 0;
+
+		this.deviceReachable = '';
+
+		this.log.debug(`Function finished: ${this.resetVars.name}`);
+	} // <-- end of resetVars
+
+
+	/**
+	 * @param {string} [adptName] - Adaptername
+	 */
 	async writeDatapoints(adptName) {
-		/*=============================================
-		=            	Write Datapoints 		      =
-		=============================================*/
+		// fill the datapoints
 
 		this.log.debug(`Start the function: ${this.writeDatapoints.name}`);
 
 		try {
 
 			let dpSubFolder;
-			if (adptName) { //write the datapoints in subfolders with the adaptername otherwise write the dP's in the root folder
+			//write the datapoints in subfolders with the adaptername otherwise write the dP's in the root folder
+			if (adptName) {
 				dpSubFolder = adptName + '.';
 			} else {
-				dpSubFolder = '';}
+				dpSubFolder = '';
+			}
 
-			await this.setStateAsync(`${dpSubFolder}offlineCount`, {val: this.offlineDevicesCount, ack: true});
-			await this.setStateAsync(`${dpSubFolder}countAll`, {val: this.deviceCounter, ack: true});
-			await this.setStateAsync(`${dpSubFolder}batteryCount`, {val: this.batteryPoweredCount, ack: true});
-			await this.setStateAsync(`${dpSubFolder}lowBatteryCount`, {val: this.lowBatteryPoweredCount, ack: true});
+			await this.setStateAsync(`${dpSubFolder}offlineCount`, { val: this.offlineDevicesCount, ack: true });
+			await this.setStateAsync(`${dpSubFolder}countAll`, { val: this.deviceCounter, ack: true });
+			await this.setStateAsync(`${dpSubFolder}batteryCount`, { val: this.batteryPoweredCount, ack: true });
+			await this.setStateAsync(`${dpSubFolder}lowBatteryCount`, { val: this.lowBatteryPoweredCount, ack: true });
 
 			if (this.deviceCounter == 0) {
-				this.listAllDevices       = [{'Device': '--none--', 'Adapter': '', 'Battery': '', 'Last contact': '', 'Signal strength': ''}]; //JSON-Info Gesamtliste mit Info je Gerät
-
-				await this.setStateAsync(`${dpSubFolder}listAll`, {val: JSON.stringify(this.listAllDevices), ack: true});
-			} else {
-				await this.setStateAsync(`${dpSubFolder}listAll`, {val: JSON.stringify(this.listAllDevices), ack: true});
+				// if no device is count, write the JSON List with default value
+				this.listAllDevices = [{ 'Device': '--none--', 'Adapter': '', 'Battery': '', 'Last contact': '', 'Signal strength': '' }];
 			}
+			await this.setStateAsync(`${dpSubFolder}listAll`, { val: JSON.stringify(this.listAllDevices), ack: true });
 
 			if (this.linkQualityCount == 0) {
-				this.linkQualityDevices	= [{'Device': '--none--', 'Adapter': '', 'Signal strength': ''}]; //JSON-Info alle mit LinkQuality
-
-				await this.setStateAsync(`${dpSubFolder}linkQualityList`, {val: JSON.stringify(this.linkQualityDevices), ack: true});
-			} else {
-				await this.setStateAsync(`${dpSubFolder}linkQualityList`, {val: JSON.stringify(this.linkQualityDevices), ack: true});
+				// if no device is count, write the JSON List with default value
+				this.linkQualityDevices = [{ 'Device': '--none--', 'Adapter': '', 'Signal strength': '' }];
 			}
-
+			//write JSON list
+			await this.setStateAsync(`${dpSubFolder}linkQualityList`, { val: JSON.stringify(this.linkQualityDevices), ack: true });
+			//write HTML list
+			if (this.config.createHtmlList) await this.setStateAsync(`${dpSubFolder}linkQualityListHTML`, { val: await this.creatLinkQualityListHTML(this.linkQualityDevices, this.linkQualityCount), ack: true });
 
 			if (this.offlineDevicesCount == 0) {
-				this.offlineDevices	= [{'Device': '--none--', 'Adapter': '', 'Last contact': ''}]; //JSON-Info alle offline-Geräte = 0
-
-				await this.setStateAsync(`${dpSubFolder}offlineList`, {val: JSON.stringify(this.offlineDevices), ack: true});
-			} else {
-				await this.setStateAsync(`${dpSubFolder}offlineList`, {val: JSON.stringify(this.offlineDevices), ack: true});
+				// if no device is count, write the JSON List with default value
+				this.offlineDevices = [{ 'Device': '--none--', 'Adapter': '', 'Last contact': '' }];
 			}
+			//write JSON list
+			await this.setStateAsync(`${dpSubFolder}offlineList`, { val: JSON.stringify(this.offlineDevices), ack: true });
+			//write HTML list
+			if (this.config.createHtmlList) await this.setStateAsync(`${dpSubFolder}offlineListHTML`, { val: await this.createOfflineListHTML(this.offlineDevices, this.offlineDevicesCount), ack: true });
 
 			if (this.batteryPoweredCount == 0) {
-				this.batteryPowered	= [{'Device': '--none--', 'Adapter': '', 'Battery': ''}]; //JSON-Info alle batteriebetriebenen Geräte
-
-				await this.setStateAsync(`${dpSubFolder}batteryList`, {val: JSON.stringify(this.batteryPowered), ack: true});
-			} else {
-				await this.setStateAsync(`${dpSubFolder}batteryList`, {val: JSON.stringify(this.batteryPowered), ack: true});
+				// if no device is count, write the JSON List with default value
+				this.batteryPowered = [{ 'Device': '--none--', 'Adapter': '', 'Battery': '' }];
 			}
+			//write JSON list
+			await this.setStateAsync(`${dpSubFolder}batteryList`, { val: JSON.stringify(this.batteryPowered), ack: true });
+			//write HTML list
+			if (this.config.createHtmlList) await this.setStateAsync(`${dpSubFolder}batteryListHTML`, { val: await this.createBatteryListHTML(this.batteryPowered, this.batteryPoweredCount, false), ack: true });
 
 			if (this.lowBatteryPoweredCount == 0) {
-				this.batteryLowPowered	= [{'Device': '--none--', 'Adapter': '', 'Battery': ''}]; //JSON-Info alle batteriebetriebenen Geräte
-
-				await this.setStateAsync(`${dpSubFolder}lowBatteryList`, {val: JSON.stringify(this.batteryLowPowered), ack: true});
-			} else {
-				await this.setStateAsync(`${dpSubFolder}lowBatteryList`, {val: JSON.stringify(this.batteryLowPowered), ack: true});
+				// if no device is count, write the JSON List with default value
+				this.batteryLowPowered = [{ 'Device': '--none--', 'Adapter': '', 'Battery': '' }];
 			}
+			//write JSON list
+			await this.setStateAsync(`${dpSubFolder}lowBatteryList`, { val: JSON.stringify(this.batteryLowPowered), ack: true });
+			//write HTML list
+			if (this.config.createHtmlList) await this.setStateAsync(`${dpSubFolder}lowBatteryListHTML`, { val: await this.createBatteryListHTML(this.batteryLowPowered, this.lowBatteryPoweredCount, true), ack: true });
 
-			//Zeitstempel wann die Datenpunkte zuletzt gecheckt wurden
+			// create timestamp of last run
 			const lastCheck = this.formatDate(new Date(), 'DD.MM.YYYY') + ' - ' + this.formatDate(new Date(), 'hh:mm:ss');
 			await this.setStateAsync('lastCheck', lastCheck, true);
 		}
-		catch (e) {
-			this.log.error(`(05) Error while writing the states ${e}`);
+		catch (error) {
+			this.errorReporting('[writeDatapoints]', error);
 		}
 		this.log.debug(`Function finished: ${this.writeDatapoints.name}`);
 	}//<--End  of writing Datapoints
 
+	/**
+	 * @param {object} devices - Device
+	 * @param {number} deviceCount - Counted devices
+	 */
+	async creatLinkQualityListHTML(devices, deviceCount) {
+		devices = devices.sort((a, b) => { return a.Device.localeCompare(b.Device); });
+		let html = `<center>
+		<b>Link Quality Devices:<font> ${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=right>Link Quality</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=right><font>${device['Signal strength']}</font></td>
+			</tr>`;
+		}
+
+		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;
+	}
+
+	/**
+	 * @param {string} codePart - Message Prefix
+	 * @param {object} error - Sentry message
+	 */
+	errorReporting(codePart, error) {
+		const msg = `[${codePart}] error: ${error.message}`;
+		if (enableSendSentry) {
+			if (this.supportsFeature && this.supportsFeature('PLUGINS')) {
+				const sentryInstance = this.getPluginInstance('sentry');
+				if (sentryInstance) {
+					this.log.warn(`Error catched and sent to Sentry, error: ${msg}`);
+					sentryInstance.getSentryObject().captureException(msg);
+				}
+			}
+		} else {
+			this.log.error(`Sentry disabled, error catched : ${msg}`);
+		}
+	} // <-- end of errorReporting
 
 
+	/**
+     * @param {() => void} callback
+     */
 	onUnload(callback) {
 		try {
 			this.log.info('cleaned everything up...');
+
+			if (this.refreshDataTimeout) {
+				this.log.debug('clearing refresh timeout');
+				this.clearTimeout(this.refreshDataTimeout);
+			}
+
 			callback();
 		} catch (e) {
 			callback();
@@ -1503,6 +1923,7 @@ class DeviceWatcher extends utils.Adapter {
 	}
 }
 
+// @ts-ignore parent is a valid property on module
 if (require.main !== module) {
 	// Export the constructor in compact mode
 	/**