iobroker.device-watcher 2.4.1 → 2.6.0

package/main.js

@@ -8,6 +8,7 @@ const utils = require('@iobroker/adapter-core');
 const adapterName = require('./package.json').name.split('.').pop();
 const schedule = require('node-schedule');
 const arrApart = require('./lib/arrApart.js'); // list of supported adapters
+const cronParser = require('cron-parser');
 
 // Sentry error reporting, disable when testing code!
 const enableSendSentry = true;
@@ -23,25 +24,41 @@ class DeviceWatcher extends utils.Adapter {
 			useFormatDate: true,
 		});
 
+		// instances and adapters
+		// raw arrays
+		this.listInstanceRaw = new Map();
+		this.adapterUpdatesJsonRaw = [];
+		this.listErrorInstanceRaw = [];
+
+		// user arrays
+		this.listAllInstances = [];
+		this.listDeactivatedInstances = [];
+		this.listAdapterUpdates = [];
+		this.listErrorInstance = [];
+
+		//counts
+		this.countAllInstances = 0;
+		this.countDeactivatedInstances = 0;
+		this.countAdapterUpdates = 0;
+		this.countErrorInstance = 0;
+
+		// devices
+		// raw arrays
+		this.listAllDevicesRaw = new Map();
+		this.batteryLowPoweredRaw = [];
+		this.offlineDevicesRaw = [];
+		this.upgradableDevicesRaw = [];
+
 		// arrays
 		this.offlineDevices = [];
 		this.linkQualityDevices = [];
 		this.batteryPowered = [];
 		this.batteryLowPowered = [];
 		this.listAllDevices = [];
-		this.blacklistLists = [];
-		this.blacklistAdapterLists = [];
-		this.blacklistNotify = [];
 		this.selAdapter = [];
 		this.adapterSelected = [];
 		this.upgradableList = [];
 
-		// raw arrays
-		this.listAllDevicesRaw = [];
-		this.batteryLowPoweredRaw = [];
-		this.offlineDevicesRaw = [];
-		this.upgradableDevicesRaw = [];
-
 		// counts
 		this.offlineDevicesCount = 0;
 		this.deviceCounter = 0;
@@ -50,12 +67,22 @@ class DeviceWatcher extends utils.Adapter {
 		this.lowBatteryPoweredCount = 0;
 		this.upgradableDevicesCount = 0;
 
+		// Blacklist
+		// Instances
+		this.blacklistInstancesLists = [];
+		this.blacklistInstancesNotify = [];
+
+		// Devices
+		this.blacklistLists = [];
+		this.blacklistAdapterLists = [];
+		this.blacklistNotify = [];
+
 		// Interval timer
 		this.refreshDataTimeout = null;
 
 		this.on('ready', this.onReady.bind(this));
 		this.on('stateChange', this.onStateChange.bind(this));
-		// this.on('objectChange', this.onObjectChange.bind(this));
+		this.on('objectChange', this.onObjectChange.bind(this));
 		this.on('message', this.onMessage.bind(this));
 		this.on('unload', this.onUnload.bind(this));
 	}
@@ -104,6 +131,7 @@ class DeviceWatcher extends utils.Adapter {
 				nukiExt: this.config.nukiExtDevices,
 				nut: this.config.nutDevices,
 				ping: this.config.pingDevices,
+				proxmox: this.config.proxmoxDevices,
 				roomba: this.config.roombaDevices,
 				shelly: this.config.shellyDevices,
 				smartgarden: this.config.smartgardenDevices,
@@ -155,6 +183,7 @@ class DeviceWatcher extends utils.Adapter {
 				nukiExt: this.config.nukiextendMaxMinutes,
 				nut: this.config.nutMaxMinutes,
 				ping: this.config.pingMaxMinutes,
+				proxmox: this.config.proxmoxMaxMinutes,
 				roomba: this.config.roombaMaxMinutes,
 				shelly: this.config.shellyMaxMinutes,
 				smartgarden: this.config.smartgardenMaxMinutes,
@@ -192,19 +221,23 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			//create Blacklist
-			try {
-				await this.createBlacklist();
-			} catch (error) {
-				this.errorReporting('[onReady - create blacklist]', error);
-			}
+			await this.createBlacklist();
 
-			//create and fill datapoints for each adapter if selected
-			if (this.createOwnFolder) {
+			//create datapoints for each adapter if selected
+			for (const [id] of Object.entries(arrApart)) {
 				try {
-					for (const [id] of Object.entries(arrApart)) {
-						if (this.configSetAdapter !== undefined && this.configSetAdapter[id]) {
+					if (!this.createOwnFolder) {
+						await this.deleteDPsForEachAdapter(id);
+						await this.deleteHtmlListDatapoints(id);
+					} else {
+						if (this.configSetAdapter && this.configSetAdapter[id]) {
 							await this.createDPsForEachAdapter(id);
-							if (this.createHtmlList) await this.createHtmlListDatapoints(id);
+							// create HTML list datapoints
+							if (!this.createHtmlList) {
+								await this.deleteHtmlListDatapoints(id);
+							} else {
+								await this.createHtmlListDatapoints(id);
+							}
 							this.log.debug(`Created datapoints for ${this.capitalize(id)}`);
 						}
 					}
@@ -214,28 +247,84 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			// create HTML list datapoints
-			if (this.createHtmlList) await this.createHtmlListDatapoints();
+			if (!this.createHtmlList) {
+				await this.deleteHtmlListDatapoints();
+			} else {
+				await this.createHtmlListDatapoints();
+			}
 
-			//read data first at start
+			// read data first at start
+			// devices
 			await this.main();
 
+			// instances and adapters
+			if (!this.config.checkAdapterInstances) {
+				await this.deleteDPsForInstances();
+			} else {
+				// instances
+				await this.createDPsForInstances();
+				await this.getAllInstanceData();
+				// adapter updates
+				await this.createAdapterUpdateData();
+			}
+
 			// update last contact data in interval
 			await this.refreshData();
 
 			// send overview for low battery devices
-			if (this.config.checkSendBatteryMsgDaily) await this.sendBatteryNotifyShedule();
+			if (this.config.checkSendBatteryMsgDaily) this.sendScheduleNotifications('lowBatteryDevices');
 
 			// send overview of offline devices
-			if (this.config.checkSendOfflineMsgDaily) await this.sendOfflineNotificationsShedule();
+			if (this.config.checkSendOfflineMsgDaily) this.sendScheduleNotifications('offlineDevices');
 
 			// send overview of upgradeable devices
-			if (this.config.checkSendUpgradeMsgDaily) await this.sendUpgradeNotificationsShedule();
+			if (this.config.checkSendUpgradeMsgDaily) this.sendScheduleNotifications('updateDevices');
+
+			// send overview of updatable adapters
+			if (this.config.checkSendAdapterUpdateMsgDaily) this.sendScheduleNotifications('updateAdapter');
+
+			// send overview of instances with error
+			if (this.config.checkSendInstanceFailedDaily) this.sendScheduleNotifications('errorInstance');
 		} catch (error) {
 			this.errorReporting('[onReady]', error);
 			this.terminate ? this.terminate(15) : process.exit(15);
 		}
 	} // <-- onReady end
 
+	// If you need to react to object changes, uncomment the following block and the corresponding line in the constructor.
+	// You also need to subscribe to the objects with `this.subscribeObjects`, similar to `this.subscribeStates`.
+	//
+	/**
+	 * Is called if a subscribed object changes
+	 * @param {string} id
+	 * @param {ioBroker.Object | null | undefined} obj
+	 */
+	async onObjectChange(id, obj) {
+		if (obj) {
+			// The object was changed
+			//this.log.warn(`object ${id} changed: ${JSON.stringify(obj)}`);
+
+			//read new instance data and add it to the lists
+			await this.getInstanceData(id);
+
+			//read devices data and renew the lists
+			await this.main();
+		} else {
+			// The object was deleted
+			//this.log.warn(`object ${id} deleted`);
+
+			// delete instance data in map
+			this.listInstanceRaw.delete(id);
+
+			// delete device data in map
+			this.listAllDevicesRaw.delete(id);
+
+			//unsubscribe of Objects and states
+			this.unsubscribeForeignObjects(id);
+			this.unsubscribeForeignStates(id);
+		}
+	}
+
 	/**
 	 * Is called if a subscribed state changes
 	 * @param {string} id
@@ -244,124 +333,196 @@ class DeviceWatcher extends utils.Adapter {
 	async onStateChange(id, state) {
 		// Admin JSON for Adapter updates
 		if (id && state) {
-			this.log.debug(`State changed: ${id} changed ${state.val}`);
+			// this.log.debug(`State changed: ${id} changed ${state.val}`);
 			let batteryData;
 			let oldLowBatState;
 			let contactData;
 			let oldStatus;
 			let isLowBatValue;
-			let instanceDeviceConnectionDpTS;
-			const instanceDeviceConnectionDpTSminTime = 5;
+			let instanceStatusRaw;
+			let oldInstanceHostState;
+			let oldInstanceDeviceState;
+
+			for (const adapter of this.adapterUpdatesJsonRaw) {
+				switch (id) {
+					case adapter.Path:
+						await this.getAdapterUpdateData(id);
+						await this.createAdapterUpdateList();
+						if (this.config.checkSendAdapterUpdateMsg) {
+							await this.sendStateNotifications('updateAdapter', null);
+						}
+				}
+			}
 
-			// Wait if the conection to device was lost to avoid multiple messages.
-			// const delay = (n) => new Promise((r) => setTimeout(r, n * 100));
+			for (const [instance, instanceData] of this.listInstanceRaw) {
+				switch (id) {
+					case instanceData.instanceAlivePath:
+						if (state.val !== instanceData.isAlive) {
+							instanceStatusRaw = await this.setInstanceStatus(
+								instanceData.instanceMode,
+								instanceData.schedule,
+								instanceData.instanceAlivePath,
+								instanceData.connectedHostPath,
+								instanceData.connectedDevicePath,
+							);
+							instanceData.isAlive = instanceStatusRaw[1];
+							instanceData.status = instanceStatusRaw[0];
+							instanceData.isHealthy = instanceStatusRaw[2];
+						}
+						break;
+					case instanceData.connectedHostPath:
+						oldInstanceHostState = instanceData.isConnectedHost;
+						instanceData.isConnectedHost = state.val;
+						if (oldInstanceHostState !== instanceData.isConnectedHost) {
+							instanceStatusRaw = await this.setInstanceStatus(
+								instanceData.instanceMode,
+								instanceData.schedule,
+								instanceData.instanceAlivePath,
+								instanceData.connectedHostPath,
+								instanceData.connectedDevicePath,
+							);
+							instanceData.isAlive = instanceStatusRaw[1];
+							instanceData.status = instanceStatusRaw[0];
+							instanceData.isHealthy = instanceStatusRaw[2];
+
+							if (!instanceData.isAlive) continue;
+							if (this.config.checkSendInstanceFailedMsg && !this.blacklistInstancesNotify.includes(instanceData.instanceAlivePath)) {
+								if (!instanceData.isHealthy) {
+									await this.sendStateNotifications('errorInstance', instance);
+								}
+							}
+						}
+						break;
+					case instanceData.connectedDevicePath:
+						oldInstanceDeviceState = instanceData.isConnectedDevice;
+						instanceData.isConnectedDevice = state.val;
+						if (oldInstanceDeviceState !== instanceData.isConnectedDevice) {
+							instanceStatusRaw = await this.setInstanceStatus(
+								instanceData.instanceMode,
+								instanceData.schedule,
+								instanceData.instanceAlivePath,
+								instanceData.connectedHostPath,
+								instanceData.connectedDevicePath,
+							);
+							instanceData.isAlive = instanceStatusRaw[1];
+							instanceData.status = instanceStatusRaw[0];
+							instanceData.isHealthy = instanceStatusRaw[2];
+
+							if (!instanceData.isAlive) continue;
+							if (this.config.checkSendInstanceFailedMsg && !this.blacklistInstancesNotify.includes(instanceData.instanceAlivePath)) {
+								if (!instanceData.isHealthy) {
+									await this.sendStateNotifications('errorInstance', instance);
+								}
+							}
+						}
+						break;
+				}
+			}
 
-			for (const device of this.listAllDevicesRaw) {
+			for (const [device, deviceData] of this.listAllDevicesRaw) {
 				// On statechange update available datapoint
 				switch (id) {
-					case device.instanceDeviceConnectionDP:
-						if (state.val !== device.instancedeviceConnected) {
-							device.instancedeviceConnected = state.val;
+					case deviceData.instanceDeviceConnectionDP:
+						if (state.val !== deviceData.instancedeviceConnected) {
+							deviceData.instancedeviceConnected = state.val;
 						}
 						break;
 
-					case device.UpdateDP:
-						if (state.val !== device.Upgradable) {
-							device.Upgradable = state.val;
+					case deviceData.UpdateDP:
+						if (state.val !== deviceData.Upgradable) {
+							deviceData.Upgradable = state.val;
 							if (state.val) {
-								if (!this.blacklistNotify.includes(device.Path)) {
-									await this.sendDeviceUpdatesNotification(device.Device, device.Adapter);
+								if (this.config.checkSendDeviceUpgrade && !this.blacklistNotify.includes(deviceData.Path)) {
+									await this.sendStateNotifications('updateDevice', device);
 								}
 							}
 						}
 						break;
 
-					case device.SignalStrengthDP:
-						device.SignalStrength = await this.calculateSignalStrength(state, device.adapterID);
+					case deviceData.SignalStrengthDP:
+						deviceData.SignalStrength = await this.calculateSignalStrength(state, deviceData.adapterID);
 						break;
 
-					case device.batteryDP:
-						if (device.isBatteryDevice) {
-							oldLowBatState = device.LowBat;
-							batteryData = await this.getBatteryData(state.val, oldLowBatState, device.adapterID);
+					case deviceData.batteryDP:
+						if (deviceData.isBatteryDevice) {
+							oldLowBatState = deviceData.LowBat;
+							batteryData = await this.getBatteryData(state.val, oldLowBatState, deviceData.adapterID);
 
-							device.Battery = batteryData[0];
-							device.BatteryRaw = batteryData[2];
-							if (device.LowBatDP !== 'none') {
-								isLowBatValue = await this.getInitValue(device.LowBatDP);
+							deviceData.Battery = batteryData[0];
+							deviceData.BatteryRaw = batteryData[2];
+							if (deviceData.LowBatDP !== 'none') {
+								isLowBatValue = await this.getInitValue(deviceData.LowBatDP);
 							} else {
 								isLowBatValue = undefined;
 							}
-							device.LowBat = await this.setLowbatIndicator(state.val, isLowBatValue, device.faultReport, device.adapterID);
+							deviceData.LowBat = await this.setLowbatIndicator(state.val, isLowBatValue, deviceData.faultReport, deviceData.adapterID);
 
-							if (device.LowBat && oldLowBatState !== device.LowBat) {
-								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(device.Path)) {
-									await this.sendLowBatNoticiation(device.Device, device.Adapter, device.Battery);
+							if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
+								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
+									await this.sendStateNotifications('lowBatDevice', device);
 								}
 							}
 						}
 						break;
 
-					case device.LowBatDP:
-						if (device.isBatteryDevice) {
-							oldLowBatState = device.LowBat;
-							batteryData = await this.getBatteryData(device.BatteryRaw, state.val, device.adapterID);
-							device.Battery = batteryData[0];
-							device.BatteryRaw = batteryData[2];
-							device.LowBat = await this.setLowbatIndicator(device.BatteryRaw, state.val, device.faultReport, device.adapterID);
-
-							if (device.LowBat && oldLowBatState !== device.LowBat) {
-								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(device.Path)) {
-									await this.sendLowBatNoticiation(device.Device, device.Adapter, device.Battery);
+					case deviceData.LowBatDP:
+						if (deviceData.isBatteryDevice) {
+							oldLowBatState = deviceData.LowBat;
+							batteryData = await this.getBatteryData(deviceData.BatteryRaw, state.val, deviceData.adapterID);
+							deviceData.Battery = batteryData[0];
+							deviceData.BatteryRaw = batteryData[2];
+							deviceData.LowBat = await this.setLowbatIndicator(deviceData.BatteryRaw, state.val, deviceData.faultReport, deviceData.adapterID);
+
+							if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
+								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
+									await this.sendStateNotifications('lowBatDevice', device);
 								}
 							}
 						}
 						break;
 
-					case device.faultReportDP:
-						if (device.isBatteryDevice) {
-							oldLowBatState = device.LowBat;
-							batteryData = await this.getBatteryData(device.BatteryRaw, oldLowBatState, device.adapterID);
+					case deviceData.faultReportDP:
+						if (deviceData.isBatteryDevice) {
+							oldLowBatState = deviceData.LowBat;
+							batteryData = await this.getBatteryData(deviceData.BatteryRaw, oldLowBatState, deviceData.adapterID);
 
-							device.Battery = batteryData[0];
-							device.BatteryRaw = batteryData[2];
-							device.LowBat = await this.setLowbatIndicator(device.BatteryRaw, undefined, state.val, device.adapterID);
+							deviceData.Battery = batteryData[0];
+							deviceData.BatteryRaw = batteryData[2];
+							deviceData.LowBat = await this.setLowbatIndicator(deviceData.BatteryRaw, undefined, state.val, deviceData.adapterID);
 
-							if (device.LowBat && oldLowBatState !== device.LowBat) {
-								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(device.Path)) {
-									await this.sendLowBatNoticiation(device.Device, device.Adapter, device.Battery);
+							if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
+								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
+									await this.sendStateNotifications('lowBatDevice', device);
 								}
 							}
 						}
 						break;
 
-					case device.UnreachDP:
-						oldStatus = device.Status;
-						device.UnreachState = await this.getInitValue(device.UnreachDP);
+					case deviceData.UnreachDP:
+						oldStatus = deviceData.Status;
+						deviceData.UnreachState = await this.getInitValue(deviceData.UnreachDP);
 						contactData = await this.getOnlineState(
-							device.timeSelector,
-							device.adapterID,
-							device.UnreachDP,
-							device.SignalStrength,
-							device.UnreachState,
-							device.DeviceStateSelectorDP,
-							device.rssiPeerSelectorDP,
+							deviceData.timeSelector,
+							deviceData.adapterID,
+							deviceData.UnreachDP,
+							deviceData.SignalStrength,
+							deviceData.UnreachState,
+							deviceData.DeviceStateSelectorDP,
+							deviceData.rssiPeerSelectorDP,
 						);
 						if (contactData !== undefined) {
-							device.LastContact = contactData[0];
-							device.Status = contactData[1];
-							device.SignalStrength = contactData[2];
+							deviceData.LastContact = contactData[0];
+							deviceData.Status = contactData[1];
+							deviceData.SignalStrength = contactData[2];
 						}
-						if (device.instanceDeviceConnectionDP !== undefined) {
-							instanceDeviceConnectionDpTS = await this.getTimestampConnectionDP(device.instanceDeviceConnectionDP);
-							if (device.instancedeviceConnected !== false && instanceDeviceConnectionDpTS && instanceDeviceConnectionDpTS >= instanceDeviceConnectionDpTSminTime) {
-								if (this.config.checkSendOfflineMsg && oldStatus !== device.Status && !this.blacklistNotify.includes(device.Path)) {
-									await this.sendOfflineNotifications(device.Device, device.Adapter, device.Status, device.LastContact);
+						if (this.config.checkSendOfflineMsg && oldStatus !== deviceData.Status && !this.blacklistNotify.includes(deviceData.Path)) {
+							if (deviceData.instanceDeviceConnectionDP !== undefined) {
+								// check if the generally deviceData connected state is for a while true
+								if (await this.getTimestampConnectionDP(deviceData.instanceDeviceConnectionDP, 20000)) {
+									await this.sendStateNotifications('onlineStateDevice', device);
 								}
-							}
-						} else {
-							if (this.config.checkSendOfflineMsg && oldStatus !== device.Status && !this.blacklistNotify.includes(device.Path)) {
-								await this.sendOfflineNotifications(device.Device, device.Adapter, device.Status, device.LastContact);
+							} else {
+								await this.sendStateNotifications('onlineStateDevice', device);
 							}
 						}
 						break;
@@ -375,23 +536,23 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	onMessage(obj) {
 		const devices = [];
-		let myCount = 0;
-		let result;
+		const instances = [];
+		let countDevices = 0;
+		let countInstances = 0;
 
 		switch (obj.command) {
 			case 'devicesList':
 				if (obj.message) {
 					try {
-						result = this.listAllDevicesRaw;
-						for (const element in result) {
-							const label = `${result[element].Adapter}: ${result[element].Device}`;
-							const myValueObject = {
-								deviceName: result[element].Device,
-								adapter: result[element].Adapter,
-								path: result[element].Path,
+						for (const deviceData of this.listAllDevicesRaw.values()) {
+							const label = `${deviceData.Adapter}: ${deviceData.Device}`;
+							const valueObjectDevices = {
+								deviceName: deviceData.Device,
+								adapter: deviceData.Adapter,
+								path: deviceData.Path,
 							};
-							devices[myCount] = { label: label, value: JSON.stringify(myValueObject) };
-							myCount++;
+							devices[countDevices] = { label: label, value: JSON.stringify(valueObjectDevices) };
+							countDevices++;
 						}
 						const sortDevices = devices.slice(0);
 						sortDevices.sort(function (a, b) {
@@ -407,6 +568,34 @@ class DeviceWatcher extends utils.Adapter {
 					this.sendTo(obj.from, obj.command, obj.callback);
 				}
 				break;
+
+			case 'instancesList':
+				if (obj.message) {
+					try {
+						for (const instanceData of this.listInstanceRaw.values()) {
+							const label = `${instanceData.Adapter}: ${instanceData.InstanceName}`;
+							const valueObjectInstances = {
+								adapter: instanceData.Adapter,
+								instanceName: instanceData.InstanceName,
+								path: instanceData.instanceAlivePath,
+							};
+							instances[countInstances] = { label: label, value: JSON.stringify(valueObjectInstances) };
+							countInstances++;
+						}
+						const sortInstances = instances.slice(0);
+						sortInstances.sort(function (a, b) {
+							const x = a.label;
+							const y = b.label;
+							return x < y ? -1 : x > y ? 1 : 0;
+						});
+						this.sendTo(obj.from, obj.command, sortInstances, obj.callback);
+					} catch (error) {
+						this.sendTo(obj.from, obj.command, obj.callback);
+					}
+				} else {
+					this.sendTo(obj.from, obj.command, obj.callback);
+				}
+				break;
 		}
 	}
 
@@ -418,7 +607,11 @@ class DeviceWatcher extends utils.Adapter {
 
 		// fill counts and lists of all selected adapter
 		try {
-			await this.createDataOfAllAdapter();
+			for (let i = 0; i < this.selAdapter.length; i++) {
+				await this.createData(i);
+				await this.createLists();
+			}
+			await this.writeDatapoints(); // fill the datapoints
 			this.log.debug(`Created and filled data for all adapters`);
 		} catch (error) {
 			this.errorReporting('[main - create data of all adapter]', error);
@@ -428,8 +621,13 @@ class DeviceWatcher extends utils.Adapter {
 		if (this.createOwnFolder) {
 			try {
 				for (const [id] of Object.entries(arrApart)) {
-					if (this.configSetAdapter !== undefined && this.configSetAdapter[id]) {
-						await this.createDataForEachAdapter(id);
+					if (this.configSetAdapter && this.configSetAdapter[id]) {
+						for (const deviceData of this.listAllDevicesRaw.values()) {
+							// list device only if selected adapter matched with device
+							if (!deviceData.adapterID.includes(id)) continue;
+							await this.createLists(id);
+						}
+						await this.writeDatapoints(id); // fill the datapoints
 						this.log.debug(`Created and filled data for ${this.capitalize(id)}`);
 					}
 				}
@@ -454,7 +652,7 @@ class DeviceWatcher extends utils.Adapter {
 
 		if (this.createOwnFolder) {
 			for (const [id] of Object.entries(arrApart)) {
-				if (this.configSetAdapter !== undefined && this.configSetAdapter[id]) {
+				if (this.configSetAdapter && this.configSetAdapter[id]) {
 					await this.createLists(id);
 					await this.writeDatapoints(id);
 					this.log.debug(`Created and filled data for ${this.capitalize(id)}`);
@@ -462,6 +660,11 @@ class DeviceWatcher extends utils.Adapter {
 			}
 		}
 
+		if (this.config.checkAdapterInstances) {
+			await this.createInstanceList();
+			await this.writeInstanceDPs();
+		}
+
 		// Clear existing timeout
 		if (this.refreshDataTimeout) {
 			this.log.debug('clearing old refresh timeout');
@@ -485,11 +688,12 @@ class DeviceWatcher extends utils.Adapter {
 	async createBlacklist() {
 		this.log.debug(`Function started: ${this.createBlacklist.name}`);
 
+		// DEVICES
 		const myBlacklist = this.config.tableBlacklist;
 
 		for (const i in myBlacklist) {
 			try {
-				const blacklistParse = await this.parseData(myBlacklist[i].devices);
+				const blacklistParse = this.parseData(myBlacklist[i].devices);
 				// push devices in list to ignor device in lists
 				if (myBlacklist[i].checkIgnorLists) {
 					this.blacklistLists.push(blacklistParse.path);
@@ -508,7 +712,29 @@ class DeviceWatcher extends utils.Adapter {
 
 		if (this.blacklistLists.length >= 1) this.log.info(`Found items on blacklist for lists: ${this.blacklistLists}`);
 		if (this.blacklistAdapterLists.length >= 1) this.log.info(`Found items on blacklist for lists: ${this.blacklistAdapterLists}`);
-		if (this.blacklistNotify.length >= 1) this.log.info(`Found items on blacklist for notificatioons: ${this.blacklistNotify}`);
+		if (this.blacklistNotify.length >= 1) this.log.info(`Found items on blacklist for notifications: ${this.blacklistNotify}`);
+
+		// INSTANCES
+		const myBlacklistInstances = this.config.tableBlacklistInstances;
+
+		for (const i in myBlacklistInstances) {
+			try {
+				const blacklistParse = this.parseData(myBlacklistInstances[i].instances);
+				// push devices in list to ignor device in lists
+				if (myBlacklistInstances[i].checkIgnorLists) {
+					this.blacklistInstancesLists.push(blacklistParse.path);
+				}
+				// push devices in list to ignor device in notifications
+				if (myBlacklistInstances[i].checkIgnorNotify) {
+					this.blacklistInstancesNotify.push(blacklistParse.path);
+				}
+			} catch (error) {
+				this.errorReporting('[createBlacklist]', error);
+			}
+		}
+
+		if (this.blacklistInstancesLists.length >= 1) this.log.info(`Found items on blacklist for lists: ${this.blacklistInstancesLists}`);
+		if (this.blacklistInstancesNotify.length >= 1) this.log.info(`Found items on blacklist for notifications: ${this.blacklistInstancesNotify}`);
 
 		this.log.debug(`Function finished: ${this.createBlacklist.name}`);
 	}
@@ -529,6 +755,7 @@ class DeviceWatcher extends utils.Adapter {
 			const instanceDeviceConnectionDP = `${instance}.info.connection`;
 			const instancedeviceConnected = await this.getInitValue(instanceDeviceConnectionDP);
 			this.subscribeForeignStates(instanceDeviceConnectionDP);
+			this.subscribeForeignObjectsAsync(`${this.selAdapter[i].Selektor}`);
 
 			/*=============================================
 				=              Get device name		          =
@@ -546,6 +773,9 @@ class DeviceWatcher extends utils.Adapter {
 			const currDeviceString = id.slice(0, id.lastIndexOf('.') + 1 - 1);
 			const shortCurrDeviceString = currDeviceString.slice(0, currDeviceString.lastIndexOf('.') + 1 - 1);
 
+			// subscribe to object device path
+			this.subscribeForeignObjectsAsync(currDeviceString);
+
 			/*=============================================
 				=            Get signal strength              =
 				=============================================*/
@@ -672,8 +902,8 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			/*=============================================
-				=            Get update data	              =
-				=============================================*/
+			=            Get update data	              =
+			=============================================*/
 			const deviceUpdateDP = currDeviceString + this.selAdapter[i].upgrade;
 			let isUpgradable;
 
@@ -692,41 +922,8 @@ class DeviceWatcher extends utils.Adapter {
 			/*=============================================
 				=          		  Fill Raw Lists          	  =
 				=============================================*/
-
-			/* Add only devices with battery in the rawlist */
-			if (this.listOnlyBattery) {
-				if (isBatteryDevice) {
-					this.listAllDevicesRaw.push({
-						Path: id,
-						instanceDeviceConnectionDP: instanceDeviceConnectionDP,
-						instancedeviceConnected: instancedeviceConnected,
-						Device: deviceName,
-						adapterID: adapterID,
-						Adapter: adapter,
-						timeSelector: timeSelector,
-						isBatteryDevice: isBatteryDevice,
-						Battery: batteryHealth,
-						BatteryRaw: batteryHealthRaw,
-						batteryDP: deviceBatteryStateDP,
-						LowBat: lowBatIndicator,
-						LowBatDP: isLowBatDP,
-						faultReport: faultReportingState,
-						faultReportDP: faultReportingDP,
-						SignalStrengthDP: deviceQualityDP,
-						SignalStrength: linkQuality,
-						UnreachState: deviceUnreachState,
-						UnreachDP: unreachDP,
-						DeviceStateSelectorDP: deviceStateSelectorDP,
-						rssiPeerSelectorDP: rssiPeerSelectorDP,
-						LastContact: lastContactString,
-						Status: deviceState,
-						UpdateDP: deviceUpdateDP,
-						Upgradable: isUpgradable,
-					});
-				}
-			} else {
-				/* Add all devices */
-				this.listAllDevicesRaw.push({
+			const setupList = () => {
+				this.listAllDevicesRaw.set(currDeviceString, {
 					Path: id,
 					instanceDeviceConnectionDP: instanceDeviceConnectionDP,
 					instancedeviceConnected: instancedeviceConnected,
@@ -753,6 +950,15 @@ class DeviceWatcher extends utils.Adapter {
 					UpdateDP: deviceUpdateDP,
 					Upgradable: isUpgradable,
 				});
+			};
+
+			if (!this.listOnlyBattery) {
+				// Add all devices
+				setupList();
+			} else {
+				// Add only devices with battery in the rawlist
+				if (!isBatteryDevice) continue;
+				setupList();
 			}
 		} // <-- end of loop
 	} // <-- end of createData
@@ -1028,7 +1234,7 @@ class DeviceWatcher extends utils.Adapter {
 	 * @param {object} selector - Selector
 	 */
 	async getLastContact(selector) {
-		const lastContact = await this.getTimestamp(selector);
+		const lastContact = this.getTimestamp(selector);
 		let lastContactString;
 
 		lastContactString = this.formatDate(new Date(selector), 'hh:mm') + ' Uhr';
@@ -1061,8 +1267,8 @@ class DeviceWatcher extends utils.Adapter {
 				const deviceUnreachSelector = await this.getForeignStateAsync(unreachDP);
 				const deviceStateSelector = await this.getForeignStateAsync(deviceStateSelectorDP); // for hmrpc devices
 				const rssiPeerSelector = await this.getForeignStateAsync(rssiPeerSelectorDP);
-				const lastContact = await this.getTimestamp(deviceTimeSelector.ts);
-				const lastDeviceUnreachStateChange = deviceUnreachSelector != undefined ? await this.getTimestamp(deviceUnreachSelector.lc) : await this.getTimestamp(timeSelector.ts);
+				const lastContact = this.getTimestamp(deviceTimeSelector.ts);
+				const lastDeviceUnreachStateChange = deviceUnreachSelector != undefined ? this.getTimestamp(deviceUnreachSelector.lc) : this.getTimestamp(timeSelector.ts);
 				//  If there is no contact since user sets minutes add device in offline list
 				// calculate to days after 48 hours
 				switch (unreachDP) {
@@ -1114,6 +1320,16 @@ class DeviceWatcher extends utils.Adapter {
 								linkQuality = '0%'; // set linkQuality to nothing
 							}
 							break;
+						case 'proxmox':
+							if (this.configMaxMinutes[adapterID] <= 0) {
+								if (deviceUnreachState !== 'running' && deviceUnreachState !== 'online') {
+									deviceState = 'Offline'; //set online state to offline
+								}
+							} else if (lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID] && deviceUnreachState !== 'running' && deviceUnreachState !== 'online') {
+								deviceState = 'Offline'; //set online state to offline
+								linkQuality = '0%'; // set linkQuality to nothing
+							}
+							break;
 						case 'hmiP':
 						case 'maxcube':
 							if (this.configMaxMinutes[adapterID] <= 0) {
@@ -1215,26 +1431,26 @@ class DeviceWatcher extends utils.Adapter {
 	 * when was last contact of device
 	 */
 	async checkLastContact() {
-		for (const device of this.listAllDevicesRaw) {
-			if (device.instancedeviceConnected !== false) {
-				const oldContactState = device.Status;
-				device.UnreachState = await this.getInitValue(device.UnreachDP);
+		for (const [device, deviceData] of this.listAllDevicesRaw) {
+			if (deviceData.instancedeviceConnected !== false) {
+				const oldContactState = deviceData.Status;
+				deviceData.UnreachState = await this.getInitValue(deviceData.UnreachDP);
 				const contactData = await this.getOnlineState(
-					device.timeSelector,
-					device.adapterID,
-					device.UnreachDP,
-					device.SignalStrength,
-					device.UnreachState,
-					device.DeviceStateSelectorDP,
-					device.rssiPeerSelectorDP,
+					deviceData.timeSelector,
+					deviceData.adapterID,
+					deviceData.UnreachDP,
+					deviceData.SignalStrength,
+					deviceData.UnreachState,
+					deviceData.DeviceStateSelectorDP,
+					deviceData.rssiPeerSelectorDP,
 				);
 				if (contactData !== undefined) {
-					device.LastContact = contactData[0];
-					device.Status = contactData[1];
-					device.linkQuality = contactData[2];
+					deviceData.LastContact = contactData[0];
+					deviceData.Status = contactData[1];
+					deviceData.linkQuality = contactData[2];
 				}
-				if (this.config.checkSendOfflineMsg && oldContactState !== device.Status && !this.blacklistNotify.includes(device.Path)) {
-					await this.sendOfflineNotifications(device.Device, device.Adapter, device.Status, device.LastContact);
+				if (this.config.checkSendOfflineMsg && oldContactState !== deviceData.Status && !this.blacklistNotify.includes(deviceData.Path)) {
+					await this.sendStateNotifications('onlineStateDevice', device);
 				}
 			}
 		}
@@ -1258,47 +1474,45 @@ class DeviceWatcher extends utils.Adapter {
 			adptName = '';
 		}
 
-		for (const device of this.listAllDevicesRaw) {
+		for (const deviceData of this.listAllDevicesRaw.values()) {
 			/*----------  fill raw lists  ----------*/
 			// low bat list
-			if (device.LowBat && device.Status !== 'Offline') {
+			if (deviceData.LowBat && deviceData.Status !== 'Offline') {
 				this.batteryLowPoweredRaw.push({
-					Path: device.Path,
-					Device: device.Device,
-					Adapter: device.Adapter,
-					Battery: device.Battery,
+					Path: deviceData.Path,
+					Device: deviceData.Device,
+					Adapter: deviceData.Adapter,
+					Battery: deviceData.Battery,
 				});
 			}
 			// offline raw list
-			if (device.Status === 'Offline') {
+			if (deviceData.Status === 'Offline') {
 				this.offlineDevicesRaw.push({
-					Path: device.Path,
-					Device: device.Device,
-					Adapter: device.Adapter,
-					LastContact: device.LastContact,
+					Path: deviceData.Path,
+					Device: deviceData.Device,
+					Adapter: deviceData.Adapter,
+					LastContact: deviceData.LastContact,
 				});
 			}
 
 			// upgradable raw list
-			if (device.Upgradable) {
+			if (deviceData.Upgradable) {
 				this.upgradableDevicesRaw.push({
-					Path: device.Path,
-					Device: device.Device,
-					Adapter: device.Adapter,
+					Path: deviceData.Path,
+					Device: deviceData.Device,
+					Adapter: deviceData.Adapter,
 				});
 			}
 
-			if (adptName === '' && !this.blacklistLists.includes(device.Path)) {
-				await this.theLists(device);
+			if (adptName === '' && !this.blacklistLists.includes(deviceData.Path)) {
+				await this.theLists(deviceData);
 			}
 
 			if (this.config.createOwnFolder && adptName !== '') {
-				if (device.adapterID.includes(adptName)) {
-					/*----------  fill user lists for each adapter  ----------*/
-					if (!this.blacklistAdapterLists.includes(device.Path)) {
-						await this.theLists(device);
-					}
-				}
+				if (!deviceData.adapterID.includes(adptName)) continue;
+				/*----------  fill user lists for each adapter  ----------*/
+				if (this.blacklistAdapterLists.includes(deviceData.Path)) continue;
+				await this.theLists(deviceData);
 			}
 		}
 		await this.countDevices();
@@ -1388,47 +1602,6 @@ class DeviceWatcher extends utils.Adapter {
 		this.upgradableDevicesCount = this.upgradableList.length;
 	}
 
-	/**
-	 * @param {string} adptName - Adapter name
-	 */
-	async createDataForEachAdapter(adptName) {
-		// create Data for each Adapter in own lists
-		this.log.debug(`Function started: ${this.createDataForEachAdapter.name}`);
-
-		try {
-			for (const device of this.listAllDevicesRaw) {
-				if (device.adapterID.includes(adptName)) {
-					// list device only if selected adapter matched with device
-					await this.createLists(adptName);
-				}
-			}
-			await this.writeDatapoints(adptName); // fill the datapoints
-		} catch (error) {
-			this.errorReporting('[createDataForEachAdapter]', error);
-		}
-
-		this.log.debug(`Function finished: ${this.createDataForEachAdapter.name}`);
-	} // <-- end of createDataForEachAdapter
-
-	/**
-	 * create Data of all selected adapter in one list
-	 */
-	async createDataOfAllAdapter() {
-		this.log.debug(`Function started: ${this.createDataOfAllAdapter.name}`);
-
-		try {
-			for (let i = 0; i < this.selAdapter.length; i++) {
-				await this.createData(i);
-				await this.createLists();
-			}
-			await this.writeDatapoints(); // fill the datapoints
-		} catch (error) {
-			this.errorReporting('[createDataOfAllAdapter]', error);
-		}
-
-		this.log.debug(`Function finished: ${this.createDataOfAllAdapter.name}`);
-	} // <-- end of createDataOfAllAdapter
-
 	/**
 	 * @param {string} [adptName] - Adaptername
 	 */
@@ -1447,18 +1620,18 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			// Write Datapoints for counts
-			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}upgradableCount`, { val: this.upgradableDevicesCount, ack: true });
+			await this.setStateAsync(`devices.${dpSubFolder}offlineCount`, { val: this.offlineDevicesCount, ack: true });
+			await this.setStateAsync(`devices.${dpSubFolder}countAll`, { val: this.deviceCounter, ack: true });
+			await this.setStateAsync(`devices.${dpSubFolder}batteryCount`, { val: this.batteryPoweredCount, ack: true });
+			await this.setStateAsync(`devices.${dpSubFolder}lowBatteryCount`, { val: this.lowBatteryPoweredCount, ack: true });
+			await this.setStateAsync(`devices.${dpSubFolder}upgradableCount`, { val: this.upgradableDevicesCount, ack: true });
 
 			// List all devices
 			if (this.deviceCounter === 0) {
 				// if no device is count, write the JSON List with default value
 				this.listAllDevices = [{ Device: '--none--', Adapter: '', Battery: '', 'Last contact': '', 'Signal strength': '' }];
 			}
-			await this.setStateAsync(`${dpSubFolder}listAll`, { val: JSON.stringify(this.listAllDevices), ack: true });
+			await this.setStateAsync(`devices.${dpSubFolder}listAll`, { val: JSON.stringify(this.listAllDevices), ack: true });
 
 			// List link quality
 			if (this.linkQualityCount === 0) {
@@ -1466,7 +1639,7 @@ class DeviceWatcher extends utils.Adapter {
 				this.linkQualityDevices = [{ Device: '--none--', Adapter: '', 'Signal strength': '' }];
 			}
 			//write JSON list
-			await this.setStateAsync(`${dpSubFolder}linkQualityList`, {
+			await this.setStateAsync(`devices.${dpSubFolder}linkQualityList`, {
 				val: JSON.stringify(this.linkQualityDevices),
 				ack: true,
 			});
@@ -1477,7 +1650,7 @@ class DeviceWatcher extends utils.Adapter {
 				this.offlineDevices = [{ Device: '--none--', Adapter: '', 'Last contact': '' }];
 			}
 			//write JSON list
-			await this.setStateAsync(`${dpSubFolder}offlineList`, {
+			await this.setStateAsync(`devices.${dpSubFolder}offlineList`, {
 				val: JSON.stringify(this.offlineDevices),
 				ack: true,
 			});
@@ -1488,7 +1661,7 @@ class DeviceWatcher extends utils.Adapter {
 				this.upgradableList = [{ Device: '--none--', Adapter: '', 'Last contact': '' }];
 			}
 			//write JSON list
-			await this.setStateAsync(`${dpSubFolder}upgradableList`, {
+			await this.setStateAsync(`devices.${dpSubFolder}upgradableList`, {
 				val: JSON.stringify(this.upgradableList),
 				ack: true,
 			});
@@ -1499,7 +1672,7 @@ class DeviceWatcher extends utils.Adapter {
 				this.batteryPowered = [{ Device: '--none--', Adapter: '', Battery: '' }];
 			}
 			//write JSON list
-			await this.setStateAsync(`${dpSubFolder}batteryList`, {
+			await this.setStateAsync(`devices.${dpSubFolder}batteryList`, {
 				val: JSON.stringify(this.batteryPowered),
 				ack: true,
 			});
@@ -1510,43 +1683,43 @@ class DeviceWatcher extends utils.Adapter {
 				this.batteryLowPowered = [{ Device: '--none--', Adapter: '', Battery: '' }];
 			}
 			//write JSON list
-			await this.setStateAsync(`${dpSubFolder}lowBatteryList`, {
+			await this.setStateAsync(`devices.${dpSubFolder}lowBatteryList`, {
 				val: JSON.stringify(this.batteryLowPowered),
 				ack: true,
 			});
 
 			// set booleans datapoints
 			if (this.offlineDevicesCount === 0) {
-				await this.setStateAsync(`${dpSubFolder}oneDeviceOffline`, {
+				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceOffline`, {
 					val: false,
 					ack: true,
 				});
 			} else {
-				await this.setStateAsync(`${dpSubFolder}oneDeviceOffline`, {
+				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceOffline`, {
 					val: true,
 					ack: true,
 				});
 			}
 
 			if (this.lowBatteryPoweredCount === 0) {
-				await this.setStateAsync(`${dpSubFolder}oneDeviceLowBat`, {
+				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceLowBat`, {
 					val: false,
 					ack: true,
 				});
 			} else {
-				await this.setStateAsync(`${dpSubFolder}oneDeviceLowBat`, {
+				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceLowBat`, {
 					val: true,
 					ack: true,
 				});
 			}
 
 			if (this.upgradableDevicesCount === 0) {
-				await this.setStateAsync(`${dpSubFolder}oneDeviceUpdatable`, {
+				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceUpdatable`, {
 					val: false,
 					ack: true,
 				});
 			} else {
-				await this.setStateAsync(`${dpSubFolder}oneDeviceUpdatable`, {
+				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceUpdatable`, {
 					val: true,
 					ack: true,
 				});
@@ -1554,20 +1727,20 @@ class DeviceWatcher extends utils.Adapter {
 
 			//write HTML list
 			if (this.createHtmlList) {
-				await this.setStateAsync(`${dpSubFolder}linkQualityListHTML`, {
-					val: await this.creatLinkQualityListHTML(this.linkQualityDevices, this.linkQualityCount),
+				await this.setStateAsync(`devices.${dpSubFolder}linkQualityListHTML`, {
+					val: await this.createListHTML('linkQualityList', this.linkQualityDevices, this.linkQualityCount, null),
 					ack: true,
 				});
-				await this.setStateAsync(`${dpSubFolder}offlineListHTML`, {
-					val: await this.createOfflineListHTML(this.offlineDevices, this.offlineDevicesCount),
+				await this.setStateAsync(`devices.${dpSubFolder}offlineListHTML`, {
+					val: await this.createListHTML('offlineList', this.offlineDevices, this.offlineDevicesCount, null),
 					ack: true,
 				});
-				await this.setStateAsync(`${dpSubFolder}batteryListHTML`, {
-					val: await this.createBatteryListHTML(this.batteryPowered, this.batteryPoweredCount, false),
+				await this.setStateAsync(`devices.${dpSubFolder}batteryListHTML`, {
+					val: await this.createListHTML('batteryList', this.batteryPowered, this.batteryPoweredCount, false),
 					ack: true,
 				});
-				await this.setStateAsync(`${dpSubFolder}lowBatteryListHTML`, {
-					val: await this.createBatteryListHTML(this.batteryLowPowered, this.lowBatteryPoweredCount, true),
+				await this.setStateAsync(`devices.${dpSubFolder}lowBatteryListHTML`, {
+					val: await this.createListHTML('batteryList', this.batteryLowPowered, this.lowBatteryPoweredCount, true),
 					ack: true,
 				});
 			}
@@ -1581,109 +1754,680 @@ class DeviceWatcher extends utils.Adapter {
 		this.log.debug(`Function finished: ${this.writeDatapoints.name}`);
 	} //<--End  of writing Datapoints
 
-	/*=============================================
-	=       functions to send notifications       =
-	=============================================*/
-
 	/**
-	 * Notification service
-	 * @param {string} text - Text which should be send
+	 * get all Instances at start
 	 */
-	async sendNotification(text) {
-		// Pushover
+	async getAllInstanceData() {
 		try {
-			if (this.config.instancePushover) {
-				//first check if instance is living
-				const pushoverAliveState = await this.getInitValue('system.adapter.' + this.config.instancePushover + '.alive');
-
-				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,
-					});
-				}
-			}
+			const allInstances = `system.adapter.*`;
+			await this.getInstanceData(allInstances);
 		} catch (error) {
-			this.errorReporting('[sendNotification Pushover]', error);
+			this.errorReporting('[getInstance]', error);
 		}
+	}
 
-		// Telegram
-		try {
-			if (this.config.instanceTelegram) {
-				//first check if instance is living
-				const telegramAliveState = await this.getInitValue('system.adapter.' + this.config.instanceTelegram + '.alive');
+	/**
+	 * get instance data
+	 *@param {string} instanceObject
+	 */
+	async getInstanceData(instanceObject) {
+		const instanceAliveDP = await this.getForeignStatesAsync(`${instanceObject}.alive`);
 
-				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);
-		}
+		for (const [id] of Object.entries(instanceAliveDP)) {
+			if (!(typeof id === 'string' && id.startsWith(`system.adapter.`))) continue;
 
-		// Whatsapp
-		try {
-			if (this.config.instanceWhatsapp) {
-				//first check if instance is living
-				const whatsappAliveState = await this.getInitValue('system.adapter.' + this.config.instanceWhatsapp + '.alive');
+			// get instance name
+			const instanceName = await this.getInstanceName(id);
 
-				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,
-					});
+			// get instance connected to host data
+			const instanceConnectedHostDP = `system.adapter.${instanceName}.connected`;
+			const instanceConnectedHostVal = await this.getInitValue(instanceConnectedHostDP);
+
+			// get instance connected to device data
+			const instanceConnectedDeviceDP = `${instanceName}.info.connection`;
+			let instanceConnectedDeviceVal;
+			if (instanceConnectedDeviceDP !== undefined && typeof instanceConnectedDeviceDP === 'boolean') {
+				instanceConnectedDeviceVal = await this.getInitValue(instanceConnectedDeviceDP);
+			} else {
+				instanceConnectedDeviceVal = 'N/A';
+			}
+
+			// get adapter version
+			const instanceObjectPath = `system.adapter.${instanceName}`;
+			let adapterName;
+			let adapterVersion;
+			let instanceMode;
+			let scheduleTime = 'N/A';
+			const instanceObjectData = await this.getForeignObjectAsync(instanceObjectPath);
+			if (instanceObjectData) {
+				// @ts-ignore
+				adapterName = this.capitalize(instanceObjectData.common.name);
+				adapterVersion = instanceObjectData.common.version;
+				instanceMode = instanceObjectData.common.mode;
+
+				if (instanceMode === 'schedule') {
+					scheduleTime = instanceObjectData.common.schedule;
 				}
 			}
-		} catch (error) {
-			this.errorReporting('[sendNotification Whatsapp]', error);
+
+			//const adapterVersionVal = await this.getInitValue(adapterVersionDP);
+			const instanceStatusRaw = await this.setInstanceStatus(instanceMode, scheduleTime, id, instanceConnectedHostDP, instanceConnectedDeviceDP);
+			const isAlive = instanceStatusRaw[1];
+			const instanceStatus = instanceStatusRaw[0];
+			const isHealthy = instanceStatusRaw[2];
+
+			//subscribe to statechanges
+			this.subscribeForeignStatesAsync(id);
+			this.subscribeForeignStatesAsync(instanceConnectedHostDP);
+			this.subscribeForeignStatesAsync(instanceConnectedDeviceDP);
+			this.subscribeForeignObjectsAsync(instanceObjectPath);
+
+			// create raw list
+			this.listInstanceRaw.set(instanceObjectPath, {
+				Adapter: adapterName,
+				InstanceName: instanceName,
+				instanceObjectPath: instanceObjectPath,
+				instanceAlivePath: id,
+				instanceMode: instanceMode,
+				schedule: scheduleTime,
+				adapterVersion: adapterVersion,
+				isAlive: isAlive,
+				isHealthy: isHealthy,
+				connectedHostPath: instanceConnectedHostDP,
+				isConnectedHost: instanceConnectedHostVal,
+				connectedDevicePath: instanceConnectedDeviceDP,
+				isConnectedDevice: instanceConnectedDeviceVal,
+				status: instanceStatus,
+			});
 		}
+		await this.createInstanceList();
+		await this.writeInstanceDPs();
+	}
 
-		// Email
-		try {
-			if (this.config.instanceEmail) {
-				//first check if instance is living
-				const eMailAliveState = await this.getInitValue('system.adapter.' + this.config.instanceEmail + '.alive');
+	/**
+	 * get Instances
+	 * @param {string} id - Path of alive datapoint
+	 */
+	async getInstanceName(id) {
+		let instance = id;
+		instance = instance.slice(15); // remove "system.adapter."
+		instance = instance.slice(0, instance.lastIndexOf('.') + 1 - 1); // remove ".alive"
+		return instance;
+	}
 
-				if (!eMailAliveState) {
-					this.log.warn('eMail instance is not running. Message could not be sent. Please check your instance configuration.');
+	/**
+	 * set status for instance
+	 * @param {string} instanceMode
+	 * @param {string} scheduleTime
+	 * @param {object} instanceAlivePath
+	 * @param {string} hostConnectedPath
+	 * @param {string} isDeviceConnctedPath
+	 */
+	async setInstanceStatus(instanceMode, scheduleTime, instanceAlivePath, hostConnectedPath, isDeviceConnctedPath) {
+		const isAliveSchedule = await this.getForeignStateAsync(instanceAlivePath);
+		let isHostConnected = await this.getInitValue(hostConnectedPath);
+		let isAlive = await this.getInitValue(instanceAlivePath);
+		let isDeviceConnected = await this.getInitValue(isDeviceConnctedPath);
+		let instanceStatusString = 'Instance deactivated';
+		let lastUpdate;
+		let lastCronRun;
+		let diff;
+		let previousCronRun = null;
+		let isHealthy = false;
+
+		switch (instanceMode) {
+			case 'schedule':
+				if (isAliveSchedule) {
+					lastUpdate = Math.round((Date.now() - isAliveSchedule.lc) / 1000); // Last state change in seconds
+					previousCronRun = this.getPreviousCronRun(scheduleTime); // When was the last cron run
+					if (previousCronRun) {
+						lastCronRun = Math.round(previousCronRun / 1000); // change distance to last run in seconds
+						diff = lastCronRun - lastUpdate;
+						if (diff > -300) {
+							// if 5 minutes difference exceeded, instance is not alive
+							isAlive = true;
+							isHealthy = true;
+							instanceStatusString = 'Instanz okay';
+						}
+					}
+				}
+				break;
+			case 'daemon':
+				if (!isAlive) return ['Instanz deaktiviert', false, null]; // if instance is turned off
+				if (isDeviceConnected === undefined) isDeviceConnected = true;
+				// In case of (re)start, connection may take some time. We take 3 attempts.
+				// Attempt 1/3 - immediately
+				if (isHostConnected && isDeviceConnected) {
+					isHealthy = true;
+					instanceStatusString = 'Instanz okay';
 				} else {
-					await this.sendToAsync(this.config.instanceEmail, 'send', {
-						sendTo: this.config.sendToEmail,
-						text: text,
-						subject: this.config.subjectEmail,
-					});
+					// Attempt 2/3 - after 10 seconds
+					await this.wait(10000);
+					isDeviceConnected = await this.getInitValue(isDeviceConnctedPath);
+					isHostConnected = await this.getInitValue(hostConnectedPath);
+
+					if (isHostConnected && isDeviceConnected) {
+						isHealthy = true;
+						instanceStatusString = 'Instanz okay';
+					} else {
+						// Attempt 3/3 - after 20 seconds in total
+						await this.wait(10000);
+						isDeviceConnected = await this.getInitValue(isDeviceConnctedPath);
+						isHostConnected = await this.getInitValue(hostConnectedPath);
+
+						if (isHostConnected && isDeviceConnected) {
+							isHealthy = true;
+							instanceStatusString = 'Instanz okay';
+						} else {
+							if (!isDeviceConnected) {
+								instanceStatusString = 'Nicht verbunden mit Gerät oder Dienst';
+								isHealthy = false;
+							} else if (!isHostConnected) {
+								instanceStatusString = 'Nicht verbunden mit Host';
+								isHealthy = false;
+							}
+						}
+					}
 				}
-			}
-		} catch (error) {
-			this.errorReporting('[sendNotification eMail]', error);
+				break;
 		}
 
-		// Jarvis Notification
-		try {
-			if (this.config.instanceJarvis) {
-				//first check if instance is living
-				const jarvisAliveState = await this.getInitValue('system.adapter.' + this.config.instanceJarvis + '.alive');
+		return [instanceStatusString, isAlive, isHealthy];
+	}
 
-				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"}',
-					);
+	/**
+	 * create adapter update data
+	 */
+	async createAdapterUpdateData() {
+		const adapterUpdateListDP = `admin.*.info.updatesJson`;
+
+		// subscribe to datapoint
+		this.subscribeForeignStates(adapterUpdateListDP);
+
+		await this.getAdapterUpdateData(adapterUpdateListDP);
+
+		await this.createAdapterUpdateList();
+	}
+
+	/**
+	 * create adapter update raw lists
+	 * @param {string} adapterUpdateListDP
+	 */
+	async getAdapterUpdateData(adapterUpdateListDP) {
+		this.adapterUpdatesJsonRaw = [];
+		const adapterUpdatesListVal = await this.getForeignStatesAsync(adapterUpdateListDP);
+
+		let adapterJsonList;
+		let adapterUpdatesJsonPath;
+
+		for (const [id] of Object.entries(adapterUpdatesListVal)) {
+			adapterJsonList = this.parseData(adapterUpdatesListVal[id].val);
+			adapterUpdatesJsonPath = id;
+		}
+
+		for (const [id] of Object.entries(adapterJsonList)) {
+			this.adapterUpdatesJsonRaw.push({
+				Path: adapterUpdatesJsonPath,
+				Adapter: this.capitalize(id),
+				newVersion: adapterJsonList[id].availableVersion,
+				oldVersion: adapterJsonList[id].installedVersion,
+			});
+		}
+		return this.adapterUpdatesJsonRaw;
+	}
+
+	/**
+	 * create instanceList
+	 */
+	async createAdapterUpdateList() {
+		this.listAdapterUpdates = [];
+		this.countAdapterUpdates = 0;
+
+		for (const adapter of this.adapterUpdatesJsonRaw) {
+			this.listAdapterUpdates.push({
+				Adapter: adapter.Adapter,
+				'Available Version': adapter.newVersion,
+				'Installed Version': adapter.oldVersion,
+			});
+		}
+		this.countAdapterUpdates = this.listAdapterUpdates.length;
+		await this.writeAdapterUpdatesDPs();
+	}
+
+	/**
+	 * write datapoints for adapter with updates
+	 */
+	async writeAdapterUpdatesDPs() {
+		// Write Datapoints for counts
+		await this.setStateAsync(`adapterAndInstances.countAdapterUpdates`, { val: this.countAdapterUpdates, ack: true });
+
+		// list deactivated instances
+		if (this.countAdapterUpdates === 0) {
+			this.listAdapterUpdates = [{ Adapter: '--none--', 'Available Version': '', 'Installed Version': '' }];
+		}
+		await this.setStateAsync(`adapterAndInstances.listAdapterUpdates`, { val: JSON.stringify(this.listAdapterUpdates), ack: true });
+	}
+
+	/**
+	 * create instanceList
+	 */
+	async createInstanceList() {
+		this.listAllInstances = [];
+		this.listDeactivatedInstances = [];
+		this.listErrorInstanceRaw = [];
+		this.listErrorInstance = [];
+
+		for (const instance of this.listInstanceRaw.values()) {
+			// fill raw list
+			if (instance.isAlive && !instance.isHealthy) {
+				this.listErrorInstanceRaw.push({
+					Adapter: instance.Adapter,
+					Instance: instance.InstanceName,
+					Mode: instance.instanceMode,
+					Status: instance.status,
+				});
+			}
+
+			if (this.blacklistInstancesLists.includes(instance.instanceAlivePath)) continue;
+			this.listAllInstances.push({
+				Adapter: instance.Adapter,
+				Instance: instance.InstanceName,
+				Mode: instance.instanceMode,
+				Schedule: instance.schedule,
+				Version: instance.adapterVersion,
+				Status: instance.status,
+			});
+			if (!instance.isAlive) {
+				this.listDeactivatedInstances.push({
+					Adapter: instance.Adapter,
+					Instance: instance.InstanceName,
+					Status: instance.status,
+				});
+			}
+
+			// fill List for User
+			if (instance.isAlive && !instance.isHealthy) {
+				this.listErrorInstance.push({
+					Adapter: instance.Adapter,
+					Instance: instance.InstanceName,
+					Mode: instance.instanceMode,
+					Status: instance.status,
+				});
+			}
+		}
+		await this.countInstances();
+	}
+
+	/**
+	 * count instanceList
+	 */
+	async countInstances() {
+		this.countAllInstances = 0;
+		this.countDeactivatedInstances = 0;
+		this.countErrorInstance = 0;
+
+		this.countAllInstances = this.listAllInstances.length;
+		this.countDeactivatedInstances = this.listDeactivatedInstances.length;
+		this.countErrorInstance = this.listErrorInstance.length;
+	}
+
+	/**
+	 * write datapoints for instances list and counts
+	 */
+	async writeInstanceDPs() {
+		// Write Datapoints for counts
+		await this.setStateAsync(`adapterAndInstances.countAllInstances`, { val: this.countAllInstances, ack: true });
+		await this.setStateAsync(`adapterAndInstances.countDeactivatedInstances`, { val: this.countDeactivatedInstances, ack: true });
+
+		// List all instances
+		await this.setStateAsync(`adapterAndInstances.listAllInstances`, { val: JSON.stringify(this.listAllInstances), ack: true });
+
+		// list deactivated instances
+		if (this.countDeactivatedInstances === 0) {
+			this.listDeactivatedInstances = [{ Instance: '--none--', Version: '', Status: '' }];
+		}
+		await this.setStateAsync(`adapterAndInstances.listDeactivatedInstances`, { val: JSON.stringify(this.listDeactivatedInstances), ack: true });
+		await this.setStateAsync(`adapterAndInstances.countDeactivatedInstances`, { val: this.countDeactivatedInstances, ack: true });
+
+		// list error instances
+		if (this.countErrorInstance === 0) {
+			this.listErrorInstance = [{ Instance: '--none--', Mode: '', Status: '' }];
+		}
+		await this.setStateAsync(`adapterAndInstances.listInstancesError`, { val: JSON.stringify(this.listErrorInstance), ack: true });
+		await this.setStateAsync(`adapterAndInstances.countInstancesError`, { val: this.countErrorInstance, ack: true });
+	}
+
+	/**
+	 * create Datapoints for Instances
+	 */
+	async createDPsForInstances() {
+		await this.setObjectNotExistsAsync(`adapterAndInstances`, {
+			type: 'channel',
+			common: {
+				name: {
+					en: 'Adapter and Instances',
+					de: 'Adapter und Instanzen',
+					ru: 'Адаптер и Instances',
+					pt: 'Adaptador e instâncias',
+					nl: 'Adapter en Instance',
+					fr: 'Adaptateur et instances',
+					it: 'Adattatore e istanze',
+					es: 'Adaptador e instalaciones',
+					pl: 'Adapter and Instances',
+					uk: 'Адаптер та інстанції',
+					'zh-cn': '道歉和案',
+				},
+			},
+			native: {},
+		});
+
+		// Instances
+		await this.setObjectNotExistsAsync(`adapterAndInstances.listAllInstances`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'JSON List of all instances',
+					de: 'JSON Liste aller Instanzen',
+					ru: 'ДЖСОН Список всех инстанций',
+					pt: 'J. Lista de todas as instâncias',
+					nl: 'JSON List van alle instanties',
+					fr: 'JSON Liste de tous les cas',
+					it: 'JSON Elenco di tutte le istanze',
+					es: 'JSON Lista de todos los casos',
+					pl: 'JSON Lista wszystkich instancji',
+					uk: 'Сонце Список всіх екземплярів',
+					'zh-cn': '附 件 所有事例一览表',
+				},
+				type: 'array',
+				role: 'json',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+		await this.setObjectNotExistsAsync(`adapterAndInstances.countAllInstances`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'Number of all instances',
+					de: 'Anzahl aller Instanzen',
+					ru: 'Количество всех инстанций',
+					pt: 'Número de todas as instâncias',
+					nl: 'Nummer van alle gevallen',
+					fr: 'Nombre de cas',
+					it: 'Numero di tutte le istanze',
+					es: 'Número de casos',
+					pl: 'Liczba wszystkich instancji',
+					uk: 'Кількість всіх екземплярів',
+					'zh-cn': '各类案件数目',
+				},
+				type: 'number',
+				role: 'value',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+		await this.setObjectNotExistsAsync(`adapterAndInstances.listDeactivatedInstances`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'JSON List of deactivated instances',
+					de: 'JSON Liste der deaktivierten Instanzen',
+					ru: 'ДЖСОН Список деактивированных инстанций',
+					pt: 'J. Lista de instâncias desativadas',
+					nl: 'JSON List van gedeactiveerde instanties',
+					fr: 'JSON Liste des cas désactivés',
+					it: 'JSON Elenco delle istanze disattivate',
+					es: 'JSON Lista de casos desactivados',
+					pl: 'JSON Lista przypadków deaktywowanych',
+					uk: 'Сонце Перелік деактивованих екземплярів',
+					'zh-cn': '附 件 被动事例清单',
+				},
+				type: 'array',
+				role: 'json',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+		await this.setObjectNotExistsAsync(`adapterAndInstances.countDeactivatedInstances`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'Number of deactivated instances',
+					de: 'Anzahl deaktivierter Instanzen',
+					ru: 'Количество деактивированных инстанций',
+					pt: 'Número de instâncias desativadas',
+					nl: 'Nummer van gedeactiveerde instanties',
+					fr: 'Nombre de cas désactivés',
+					it: 'Numero di istanze disattivate',
+					es: 'Número de casos desactivados',
+					pl: 'Liczba deaktywowanych instancji',
+					uk: 'Кількість деактивованих екземплярів',
+					'zh-cn': 'A. 递解事件的数目',
+				},
+				type: 'number',
+				role: 'value',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+		await this.setObjectNotExistsAsync(`adapterAndInstances.listInstancesError`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'JSON list of instances with error',
+					de: 'JSON-Liste von Instanzen mit Fehler',
+					ru: 'JSON список инстанций с ошибкой',
+					pt: 'Lista de instâncias JSON com erro',
+					nl: 'JSON lijst met fouten',
+					fr: 'Liste des instances avec erreur',
+					it: 'Elenco JSON delle istanze con errore',
+					es: 'JSON lista de casos con error',
+					pl: 'Lista błędów JSON',
+					uk: 'JSON список екземплярів з помилкою',
+					'zh-cn': '联合工作组办公室错误事件清单',
+				},
+				type: 'array',
+				role: 'json',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+		await this.setObjectNotExistsAsync(`adapterAndInstances.countInstancesError`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'Count of instances with error',
+					de: 'Anzahl der Instanzen mit Fehler',
+					ru: 'Количество инстанций с ошибкой',
+					pt: 'Contagem de instâncias com erro',
+					nl: 'Graaf van instoringen met fouten',
+					fr: 'Nombre de cas avec erreur',
+					it: 'Conteggio di istanze con errore',
+					es: 'Cuenta de casos con error',
+					pl: 'Liczba przykładów w przypadku błędów',
+					uk: 'Кількість екземплярів з помилкою',
+					'zh-cn': '发生错误的情况',
+				},
+				type: 'number',
+				role: 'value',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+
+		// Adapter
+		await this.setObjectNotExistsAsync(`adapterAndInstances.listAdapterUpdates`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'JSON list of adapters with available updates',
+					de: 'JSON-Liste der Adapter mit verfügbaren Updates',
+					ru: 'JSON список адаптеров с доступными обновлениями',
+					pt: 'Lista de adaptadores JSON com atualizações disponíveis',
+					nl: 'JSON lijst met beschikbare updates',
+					fr: 'Liste JSON des adaptateurs avec mises à jour disponibles',
+					it: 'Elenco di adattatori JSON con aggiornamenti disponibili',
+					es: 'JSON lista de adaptadores con actualizaciones disponibles',
+					pl: 'JSON lista adapterów z dostępnymi aktualizacjami',
+					uk: 'JSON список адаптерів з доступними оновленнями',
+					'zh-cn': '附录A',
+				},
+				type: 'array',
+				role: 'json',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+		await this.setObjectNotExistsAsync(`adapterAndInstances.countAdapterUpdates`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'Number of adapters with available updates',
+					de: 'Anzahl der Adapter mit verfügbaren Updates',
+					ru: 'Количество адаптеров с доступными обновлениями',
+					pt: 'Número de adaptadores com atualizações disponíveis',
+					nl: 'Nummer van adapters met beschikbare updates',
+					fr: "Nombre d'adaptateurs avec mises à jour disponibles",
+					it: 'Numero di adattatori con aggiornamenti disponibili',
+					es: 'Número de adaptadores con actualizaciones disponibles',
+					pl: 'Liczba adapterów z dostępną aktualizacją',
+					uk: 'Кількість адаптерів з доступними оновленнями',
+					'zh-cn': '更新的适应者人数',
+				},
+				type: 'number',
+				role: 'value',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+	}
+
+	/**
+	 * delete Datapoints for Instances
+	 */
+	async deleteDPsForInstances() {
+		await this.delObjectAsync(`adapterAndInstances`);
+		await this.delObjectAsync(`adapterAndInstances.listAllInstances`);
+		await this.delObjectAsync(`adapterAndInstances.countAllInstances`);
+		await this.delObjectAsync(`adapterAndInstances.listDeactivatedInstances`);
+		await this.delObjectAsync(`adapterAndInstances.countDeactivatedInstances`);
+		await this.delObjectAsync(`adapterAndInstances.listInstancesError`);
+		await this.delObjectAsync(`adapterAndInstances.countInstancesError`);
+		await this.delObjectAsync(`adapterAndInstances.listAdapterUpdates`);
+		await this.delObjectAsync(`adapterAndInstances.countAdapterUpdates`);
+	}
+
+	/*=============================================
+	=       functions to send notifications       =
+	=============================================*/
+
+	/**
+	 * Notification service
+	 * @param {string} text - Text which should be send
+	 */
+	async sendNotification(text) {
+		// Pushover
+		try {
+			if (this.config.instancePushover) {
+				//first check if instance is living
+				const pushoverAliveState = await this.getInitValue('system.adapter.' + this.config.instancePushover + '.alive');
+
+				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);
+		}
+
+		// Telegram
+		try {
+			if (this.config.instanceTelegram) {
+				//first check if instance is living
+				const telegramAliveState = await this.getInitValue('system.adapter.' + this.config.instanceTelegram + '.alive');
+
+				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);
+		}
+
+		// 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);
+		}
+
+		// 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);
+		}
+
+		// Jarvis Notification
+		try {
+			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) {
@@ -1731,376 +2475,379 @@ class DeviceWatcher extends utils.Adapter {
 		}
 	} // <-- End of sendNotification function
 
+	/*---------- Notifications ----------*/
 	/**
-	 * send shedule message for low battery devices
+	 * Notifications on state changes
+	 * @param {string} type
+	 * @param {object} id
 	 */
-	async sendBatteryNotifyShedule() {
-		const time = this.config.checkSendBatteryTime.split(':');
-
-		const checkDays = []; // list of selected days
-
-		// push the selected days in list
-		if (this.config.checkMonday) checkDays.push(1);
-		if (this.config.checkTuesday) checkDays.push(2);
-		if (this.config.checkWednesday) checkDays.push(3);
-		if (this.config.checkThursday) checkDays.push(4);
-		if (this.config.checkFriday) checkDays.push(5);
-		if (this.config.checkSaturday) checkDays.push(6);
-		if (this.config.checkSunday) checkDays.push(0);
-
-		if (checkDays.length >= 1) {
-			// check if an day is selected
-			this.log.debug(`Number of selected days for daily battery message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
-		} else {
-			this.log.warn(`No days selected for daily battery message. Please check the instance configuration!`);
-			return; // cancel function if no day is selected
-		}
-
-		if (!isUnloaded) {
-			const cron = '10 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
-			schedule.scheduleJob(cron, () => {
-				try {
-					let deviceList = '';
-
-					for (const id of this.batteryLowPoweredRaw) {
-						if (!this.blacklistNotify.includes(id.Path)) {
-							if (!this.config.showAdapterNameinMsg) {
-								deviceList = `${deviceList}\n${id.Device} (${id.Battery})`;
-							} else {
-								// Add adaptername if checkbox is checked true in options by user
-								deviceList = `${deviceList}\n${id.Adapter}: ${id.Device} (${id.Battery})`;
-							}
+	async sendStateNotifications(type, id) {
+		if (isUnloaded) return;
+		let objectData;
+		let list = '';
+		let message = '';
+		const setMessage = async (message) => {
+			this.log.info(`${message}`);
+			await this.setStateAsync('lastNotification', `${message}`, true);
+			await this.sendNotification(`${message}`);
+			return (message = '');
+		};
+		switch (type) {
+			case 'lowBatDevice':
+				objectData = this.listAllDevicesRaw.get(id);
+				if (!this.config.showAdapterNameinMsg) {
+					message = `Gerät mit geringer Batterie erkannt: \n${objectData.Device} (${objectData.Battery})`;
+				} else {
+					message = `Gerät mit geringer Batterie erkannt: \n${objectData.Adapter}: ${objectData.Device} (${objectData.Battery})`;
+				}
+				setMessage(message);
+				break;
+			case 'onlineStateDevice':
+				objectData = this.listAllDevicesRaw.get(id);
+				switch (objectData.Status) {
+					case 'Online':
+						if (!this.config.showAdapterNameinMsg) {
+							message = `Folgendes Gerät ist wieder erreichbar: \n${objectData.Device} (${objectData.LastContact})`;
+						} else {
+							message = `Folgendes Gerät ist wieder erreichbar: \n${objectData.Adapter}: ${objectData.Device} (${objectData.LastContact})`;
 						}
-					}
-					if (deviceList.length > 0) {
-						this.log.info(`Niedrige Batteriezustände: ${deviceList}`);
-						this.setStateAsync('lastNotification', `Niedrige Batteriezustände: ${deviceList}`, true);
-
-						this.sendNotification(`Niedrige Batteriezustände: ${deviceList}`);
-					}
-				} catch (error) {
-					this.errorReporting('[sendBatteryNotifyShedule]', error);
+						break;
+					case 'Offline':
+						if (!this.config.showAdapterNameinMsg) {
+							message = `Folgendes Gerät ist seit einiger Zeit nicht erreichbar: \n${objectData.Device} (${objectData.LastContact})`;
+						} else {
+							message = `Folgendes Gerät ist seit einiger Zeit nicht erreichbar: \n${objectData.Adapter}: ${objectData.Device} (${objectData.LastContact})`;
+						}
+						break;
 				}
-			});
-		}
-	} //<--End of battery notification
-
-	/**
-	 * check if device updates are available and send notification
-	 * @param {string} deviceName
-	 * @param {string} adapter
-	 * @param {string} battery
-	 **/
-	async sendLowBatNoticiation(deviceName, adapter, battery) {
-		this.log.debug(`Start the function: ${this.sendLowBatNoticiation.name}`);
-
-		try {
-			let msg = '';
-			let deviceList = '';
-
-			if (!this.config.showAdapterNameinMsg) {
-				deviceList = `${deviceList}\n${deviceName} (${battery})`;
-			} else {
-				deviceList = `${deviceList}\n${adapter}: ${deviceName} (${battery})`;
-			}
-			msg = `Gerät mit geringer Batterie erkannt: \n`;
+				setMessage(message);
+				break;
+			case 'updateDevice':
+				objectData = this.listAllDevicesRaw.get(id);
+				if (!this.config.showAdapterNameinMsg) {
+					message = `Neue Geräte Updates vorhanden: \n${objectData.Device}`;
+				} else {
+					message = `Neue Geräte Updates vorhanden: \n${objectData.Adapter}: ${objectData.Device}`;
+				}
+				setMessage(message);
+				break;
+			case 'updateAdapter':
+				objectData = this.listAdapterUpdates;
+				list = '';
 
-			this.log.info(msg + deviceList);
-			await this.setStateAsync('lastNotification', msg + deviceList, true);
-			await this.sendNotification(msg + deviceList);
-		} catch (error) {
-			this.errorReporting('[sendLowBatNoticiation]', error);
+				for (const id of objectData) {
+					list = `${list}\n${id.Adapter}: v${id['Available Version']}`;
+				}
+				if (list.length === 0) return;
+				message = `Neue Adapter Updates vorhanden: ${list}`;
+				setMessage(message);
+				break;
+			case 'errorInstance':
+				objectData = this.listInstanceRaw.get(id);
+				message = `Instanz Watchdog:\n${objectData.InstanceName}: ${objectData.status}`;
+				setMessage(message);
+				break;
 		}
-		this.log.debug(`Finished the function: ${this.sendLowBatNoticiation.name}`);
 	}
 
 	/**
-	 * send message if an device is offline
-	 * @param {string} deviceName
-	 * @param {string} adapter
-	 * @param {string} status
-	 * @param {string} lastContact
+	 * Notifications per user defined schedule
+	 * @param {string} type
 	 */
-	async sendOfflineNotifications(deviceName, adapter, status, lastContact) {
-		this.log.debug(`Start the function: ${this.sendOfflineNotifications.name}`);
-
-		try {
-			let msg = '';
-			let deviceList = '';
-
-			if (!this.config.showAdapterNameinMsg) {
-				deviceList = `${deviceList}\n${deviceName} (${lastContact})`;
-			} else {
-				deviceList = `${deviceList}\n${adapter}: ${deviceName} (${lastContact})`;
-			}
-
-			if (status === 'Online') {
-				// make singular if it is only one device
-				msg = 'Folgendes Gerät ist wieder erreichbar: \n';
-			} else if (status === 'Offline') {
-				//make plural if it is more than one device
-				msg = `Folgendes Gerät ist seit einiger Zeit nicht erreichbar: \n`;
-			}
-
-			this.log.info(msg + deviceList);
-			await this.setStateAsync('lastNotification', msg + deviceList, true);
-			await this.sendNotification(msg + deviceList);
-		} catch (error) {
-			this.errorReporting('[sendOfflineMessage]', error);
-		}
-		this.log.debug(`Finished the function: ${this.sendOfflineNotifications.name}`);
-	} //<--End of offline notification
+	sendScheduleNotifications(type) {
+		if (isUnloaded) return;
+
+		let time;
+		let cron;
+		let list = '';
+		let message = '';
+		const checkDays = [];
+		const setMessage = async (message) => {
+			this.log.info(`${message}`);
+			await this.setStateAsync('lastNotification', `${message}`, true);
+			await this.sendNotification(`${message}`);
+			return (message = '');
+		};
+
+		switch (type) {
+			case 'lowBatteryDevices':
+				// 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);
+
+				time = this.config.checkSendBatteryTime.split(':');
+
+				if (checkDays.length === 0) {
+					this.log.warn(`No days selected for daily low battery devices message. Please check the instance configuration!`);
+					return; // cancel function if no day is selected
+				}
+				this.log.debug(`Number of selected days for daily low battery devices message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
 
-	/**
-	 * send shedule message with offline devices
-	 */
-	async sendOfflineNotificationsShedule() {
-		const time = this.config.checkSendOfflineTime.split(':');
-
-		const checkDays = []; // list of selected days
-
-		// 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);
-
-		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
-		}
+				cron = '1 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
+				schedule.scheduleJob(cron, () => {
+					list = '';
+					for (const id of this.batteryLowPoweredRaw) {
+						if (this.blacklistNotify.includes(id.Path)) continue;
+						if (!this.config.showAdapterNameinMsg) {
+							list = `${list}\n${id.Device} (${id.Battery})`;
+						} else {
+							// Add adaptername if checkbox is checked true in options by user
+							list = `${list}\n${id.Adapter}: ${id.Device} (${id.Battery})`;
+						}
+					}
+					if (list.length === 0) return;
+					message = `Tägliche Meldung über Geräte mit niedrigen Batteriezuständen: ${list}`;
+					setMessage(message);
+				});
+				break;
+			case 'offlineDevices':
+				// 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);
+
+				time = this.config.checkSendOfflineTime.split(':');
+
+				if (checkDays.length === 0) {
+					this.log.warn(`No days selected for daily offline devices message. Please check the instance configuration!`);
+					return; // cancel function if no day is selected
+				}
+				this.log.debug(`Number of selected days for daily offline devices message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
 
-		if (!isUnloaded) {
-			const cron = '10 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
-			schedule.scheduleJob(cron, () => {
-				try {
-					let deviceList = '';
+				cron = '2 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
+				schedule.scheduleJob(cron, () => {
+					list = '';
 
 					for (const id of this.offlineDevicesRaw) {
-						if (!this.blacklistNotify.includes(id.Path)) {
-							if (!this.config.showAdapterNameinMsg) {
-								deviceList = `${deviceList}\n${id.Device} (${id.LastContact})`;
-							} else {
-								deviceList = `${deviceList}\n${id.Adapter}: ${id.Device} (${id.LastContact})`;
-							}
+						if (this.blacklistNotify.includes(id.Path)) continue;
+						if (!this.config.showAdapterNameinMsg) {
+							list = `${list}\n${id.Device} (${id.LastContact})`;
+						} else {
+							list = `${list}\n${id.Adapter}: ${id.Device} (${id.LastContact})`;
 						}
 					}
 
-					if (deviceList.length > 0) {
-						this.log.info(`Geräte Offline: ${deviceList}`);
-						this.setStateAsync('lastNotification', `Geräte Offline: ${deviceList}`, true);
-
-						this.sendNotification(`Geräte Offline: ${deviceList}`);
-					}
-				} catch (error) {
-					this.errorReporting('[sendOfflineNotificationsShedule]', error);
+					if (list.length === 0) return;
+					message = `Tägliche Meldung über offline Geräte: ${list}`;
+					setMessage(message);
+				});
+				break;
+			case 'updateDevices':
+				// push the selected days in list
+				if (this.config.checkUpgradeMonday) checkDays.push(1);
+				if (this.config.checkUpgradeTuesday) checkDays.push(2);
+				if (this.config.checkUpgradeWednesday) checkDays.push(3);
+				if (this.config.checkUpgradeThursday) checkDays.push(4);
+				if (this.config.checkUpgradeFriday) checkDays.push(5);
+				if (this.config.checkUpgradeSaturday) checkDays.push(6);
+				if (this.config.checkUpgradeSunday) checkDays.push(0);
+
+				time = this.config.checkSendUpgradeTime.split(':');
+
+				if (checkDays.length === 0) {
+					this.log.warn(`No days selected for daily updatable devices message. Please check the instance configuration!`);
+					return; // cancel function if no day is selected
 				}
-			});
-		}
-	} //<--End of daily offline notification
-
-	/**
-	 * check if device updates are available and send notification
-	 * @param {string} deviceName
-	 * @param {string} adapter
-	 **/
-	async sendDeviceUpdatesNotification(deviceName, adapter) {
-		this.log.debug(`Start the function: ${this.sendDeviceUpdatesNotification.name}`);
-
-		try {
-			let msg = '';
-			let deviceList = '';
-
-			if (!this.config.showAdapterNameinMsg) {
-				deviceList = `${deviceList}\n${deviceName}`;
-			} else {
-				deviceList = `${deviceList}\n${adapter}: ${deviceName}`;
-			}
-
-			msg = `Neue Geräte Updates vorhanden: \n`;
-
-			this.log.info(msg + deviceList);
-			await this.setStateAsync('lastNotification', msg + deviceList, true);
-			await this.sendNotification(msg + deviceList);
-		} catch (error) {
-			this.errorReporting('[sendDeviceUpdatesNotification]', error);
-		}
-		this.log.debug(`Finished the function: ${this.sendDeviceUpdatesNotification.name}`);
-	}
-
-	/**
-	 * send shedule message with offline devices
-	 */
-	async sendUpgradeNotificationsShedule() {
-		const time = this.config.checkSendUpgradeTime.split(':');
-
-		const checkDays = []; // list of selected days
-
-		// push the selected days in list
-		if (this.config.checkUpgradeMonday) checkDays.push(1);
-		if (this.config.checkUpgradeTuesday) checkDays.push(2);
-		if (this.config.checkUpgradeWednesday) checkDays.push(3);
-		if (this.config.checkUpgradeThursday) checkDays.push(4);
-		if (this.config.checkUpgradeFriday) checkDays.push(5);
-		if (this.config.checkUpgradeSaturday) checkDays.push(6);
-		if (this.config.checkUpgradeSunday) checkDays.push(0);
-
-		if (checkDays.length >= 1) {
-			// check if an day is selected
-			this.log.debug(`Number of selected days for daily Upgrade message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
-		} else {
-			this.log.warn(`No days selected for daily Upgrade message. Please check the instance configuration!`);
-			return; // cancel function if no day is selected
-		}
+				this.log.debug(`Number of selected days for daily updatable devices message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
 
-		if (!isUnloaded) {
-			const cron = '10 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
-			schedule.scheduleJob(cron, () => {
-				try {
-					let deviceList = '';
+				cron = '3 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
+				schedule.scheduleJob(cron, () => {
+					list = '';
 
 					for (const id of this.upgradableDevicesRaw) {
-						if (!this.blacklistNotify.includes(id.Path)) {
-							if (!this.config.showAdapterNameinMsg) {
-								deviceList = `${deviceList}\n${id.Device}`;
-							} else {
-								deviceList = `${deviceList}\n${id.Adapter}: ${id.Device}`;
-							}
+						if (this.blacklistNotify.includes(id.Path)) continue;
+						if (!this.config.showAdapterNameinMsg) {
+							list = `${list}\n${id.Device}`;
+						} else {
+							list = `${list}\n${id.Adapter}: ${id.Device}`;
 						}
 					}
-					if (deviceList.length > 0) {
-						this.log.info(`Geräte Upgrade: ${deviceList}`);
-						this.setStateAsync('lastNotification', `Geräte Upgrade: ${deviceList}`, true);
+					if (list.length === 0) return;
+					message = `Tägliche Meldung über verfügbare Geräte Updates: ${list}`;
+					setMessage(message);
+				});
+				break;
+			case 'updateAdapter':
+				// push the selected days in list
+				if (this.config.checkAdapterUpdateMonday) checkDays.push(1);
+				if (this.config.checkAdapterUpdateTuesday) checkDays.push(2);
+				if (this.config.checkAdapterUpdateWednesday) checkDays.push(3);
+				if (this.config.checkAdapterUpdateThursday) checkDays.push(4);
+				if (this.config.checkAdapterUpdateFriday) checkDays.push(5);
+				if (this.config.checkAdapterUpdateSaturday) checkDays.push(6);
+				if (this.config.checkAdapterUpdateSunday) checkDays.push(0);
+
+				time = this.config.checkSendAdapterUpdateTime.split(':');
+
+				if (checkDays.length === 0) {
+					this.log.warn(`No days selected for daily adapter update message. Please check the instance configuration!`);
+					return; // cancel function if no day is selected
+				}
+				this.log.debug(`Number of selected days for daily adapter update message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
+
+				cron = '4 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
+				schedule.scheduleJob(cron, () => {
+					list = '';
 
-						this.sendNotification(`Geräte Upgrade:\n${deviceList}`);
+					for (const id of this.listAdapterUpdates) {
+						list = `${list}\n${id.Adapter}: v${id['Available Version']}`;
 					}
-				} catch (error) {
-					this.errorReporting('[sendUpgradeNotificationsShedule]', error);
+					if (list.length === 0) return;
+					message = `Tägliche Meldung über verfügbare Adapter Updates: ${list}`;
+					setMessage(message);
+				});
+				break;
+			case 'errorInstance':
+				// push the selected days in list
+				if (this.config.checkFailedInstancesMonday) checkDays.push(1);
+				if (this.config.checkFailedInstancesTuesday) checkDays.push(2);
+				if (this.config.checkFailedInstancesWednesday) checkDays.push(3);
+				if (this.config.checkFailedInstancesThursday) checkDays.push(4);
+				if (this.config.checkFailedInstancesFriday) checkDays.push(5);
+				if (this.config.checkFailedInstancesSaturday) checkDays.push(6);
+				if (this.config.checkFailedInstancesSunday) checkDays.push(0);
+
+				time = this.config.checkSendInstanceFailedTime.split(':');
+
+				if (checkDays.length === 0) {
+					this.log.warn(`No days selected for daily instance error message. Please check the instance configuration!`);
+					return; // cancel function if no day is selected
 				}
-			});
+				this.log.debug(`Number of selected days for daily instance error message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
+				cron = '5 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
+				schedule.scheduleJob(cron, () => {
+					list = '';
+
+					for (const id of this.listErrorInstanceRaw) {
+						if (this.blacklistInstancesNotify.includes(id.instanceAlivePath)) continue;
+						list = `${list}\n${id.Instance}: ${id.Status}`;
+					}
+					if (list.length === 0) return;
+					message = `Tägliche Meldung über fehlerhafte Instanzen: ${list}`;
+					setMessage(message);
+				});
+				break;
 		}
-	} //<--End of daily offline notification
+	}
 
 	/*=============================================
 	=       functions to create html lists        =
 	=============================================*/
-
 	/**
+	 * @param {string} type - type of list
 	 * @param {object} devices - Device
 	 * @param {number} deviceCount - Counted devices
+	 * @param {object} isLowBatteryList - list Low Battery Devices
 	 */
-	async creatLinkQualityListHTML(devices, deviceCount) {
-		devices = devices.sort((a, b) => {
-			a = a.Device || '';
-			b = b.Device || '';
-			return a.localeCompare(b);
-		});
-		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>
+	async createListHTML(type, devices, deviceCount, isLowBatteryList) {
+		let html;
+		switch (type) {
+			case 'linkQualityList':
+				devices = devices.sort((a, b) => {
+					a = a.Device || '';
+					b = b.Device || '';
+					return a.localeCompare(b);
+				});
+				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>`;
-		}
 
-		html += '</table>';
-		return html;
-	}
+				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>`;
+				}
 
-	/**
-	 * @param {object} devices - Device
-	 * @param {number} deviceCount - Counted devices
-	 */
-	async createOfflineListHTML(devices, deviceCount) {
-		devices = devices.sort((a, b) => {
-			a = a.Device || '';
-			b = b.Device || '';
-			return a.localeCompare(b);
-		});
-		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>
+				html += '</table>';
+				break;
+
+			case 'offlineList':
+				devices = devices.sort((a, b) => {
+					a = a.Device || '';
+					b = b.Device || '';
+					return a.localeCompare(b);
+				});
+				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>`;
-		}
 
-		html += '</table>';
-		return html;
-	}
+				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>`;
+				}
 
-	/**
-	 * @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) => {
-			a = a.Device || '';
-			b = b.Device || '';
-			return a.localeCompare(b);
-		});
-		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>';
+				break;
 
-		html += '</table>';
+			case 'batteryList':
+				devices = devices.sort((a, b) => {
+					a = a.Device || '';
+					b = b.Device || '';
+					return a.localeCompare(b);
+				});
+				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>';
+				break;
+		}
 		return html;
 	}
 
@@ -2112,7 +2859,7 @@ class DeviceWatcher extends utils.Adapter {
 	 * @param {object} adptName - Adaptername of devices
 	 */
 	async createDPsForEachAdapter(adptName) {
-		await this.setObjectNotExistsAsync(`${adptName}`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}`, {
 			type: 'channel',
 			common: {
 				name: adptName,
@@ -2120,7 +2867,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.offlineCount`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.offlineCount`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2143,7 +2890,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.offlineList`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.offlineList`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2166,7 +2913,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.oneDeviceOffline`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.oneDeviceOffline`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2191,7 +2938,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.listAll`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.listAll`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2214,7 +2961,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.linkQualityList`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.linkQualityList`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2237,7 +2984,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.countAll`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.countAll`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2260,7 +3007,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.batteryList`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.batteryList`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2283,7 +3030,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.lowBatteryList`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.lowBatteryList`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2306,7 +3053,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.lowBatteryCount`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.lowBatteryCount`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2329,7 +3076,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.oneDeviceLowBat`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.oneDeviceLowBat`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2354,7 +3101,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.batteryCount`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.batteryCount`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2377,7 +3124,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.upgradableCount`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.upgradableCount`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2401,7 +3148,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.upgradableList`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.upgradableList`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2425,7 +3172,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${adptName}.oneDeviceUpdatable`, {
+		await this.setObjectNotExistsAsync(`devices.${adptName}.oneDeviceUpdatable`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2452,6 +3199,29 @@ class DeviceWatcher extends utils.Adapter {
 	}
 
 	/**
+	 * delete datapoints for each adapter
+	 * @param {object} adptName - Adaptername of devices
+	 */
+	async deleteDPsForEachAdapter(adptName) {
+		await this.delObjectAsync(`devices.${adptName}`);
+		await this.delObjectAsync(`devices.${adptName}.offlineCount`);
+		await this.delObjectAsync(`devices.${adptName}.offlineList`);
+		await this.delObjectAsync(`devices.${adptName}.oneDeviceOffline`);
+		await this.delObjectAsync(`devices.${adptName}.listAll`);
+		await this.delObjectAsync(`devices.${adptName}.linkQualityList`);
+		await this.delObjectAsync(`devices.${adptName}.countAll`);
+		await this.delObjectAsync(`devices.${adptName}.batteryList`);
+		await this.delObjectAsync(`devices.${adptName}.lowBatteryList`);
+		await this.delObjectAsync(`devices.${adptName}.lowBatteryCount`);
+		await this.delObjectAsync(`devices.${adptName}.oneDeviceLowBat`);
+		await this.delObjectAsync(`devices.${adptName}.batteryCount`);
+		await this.delObjectAsync(`devices.${adptName}.upgradableCount`);
+		await this.delObjectAsync(`devices.${adptName}.upgradableList`);
+		await this.delObjectAsync(`devices.${adptName}.oneDeviceUpdatable`);
+	}
+
+	/**
+	 * create HTML list datapoints
 	 * @param {object} [adptName] - Adaptername of devices
 	 **/
 	async createHtmlListDatapoints(adptName) {
@@ -2463,7 +3233,7 @@ class DeviceWatcher extends utils.Adapter {
 			dpSubFolder = '';
 		}
 
-		await this.setObjectNotExistsAsync(`${dpSubFolder}offlineListHTML`, {
+		await this.setObjectNotExistsAsync(`devices.${dpSubFolder}offlineListHTML`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2486,7 +3256,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${dpSubFolder}linkQualityListHTML`, {
+		await this.setObjectNotExistsAsync(`devices.${dpSubFolder}linkQualityListHTML`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2509,7 +3279,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${dpSubFolder}batteryListHTML`, {
+		await this.setObjectNotExistsAsync(`devices.${dpSubFolder}batteryListHTML`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2532,7 +3302,7 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
-		await this.setObjectNotExistsAsync(`${dpSubFolder}lowBatteryListHTML`, {
+		await this.setObjectNotExistsAsync(`devices.${dpSubFolder}lowBatteryListHTML`, {
 			type: 'state',
 			common: {
 				name: {
@@ -2556,6 +3326,25 @@ class DeviceWatcher extends utils.Adapter {
 		});
 	}
 
+	/**
+	 * delete html datapoints
+	 * @param {object} [adptName] - Adaptername of devices
+	 **/
+	async deleteHtmlListDatapoints(adptName) {
+		// delete the datapoints in subfolders with the adaptername otherwise delete the dP's in the root folder
+		let dpSubFolder;
+		if (adptName) {
+			dpSubFolder = `${adptName}.`;
+		} else {
+			dpSubFolder = '';
+		}
+
+		await this.delObjectAsync(`devices.${dpSubFolder}offlineListHTML`);
+		await this.delObjectAsync(`devices.${dpSubFolder}linkQualityListHTML`);
+		await this.delObjectAsync(`devices.${dpSubFolder}batteryListHTML`);
+		await this.delObjectAsync(`devices.${dpSubFolder}lowBatteryListHTML`);
+	}
+
 	/*=============================================
 	=            	help functions   	          =
 	=============================================*/
@@ -2571,20 +3360,27 @@ class DeviceWatcher extends utils.Adapter {
 	/**
 	 * @param {number} dpValue - get Time of this datapoint
 	 */
-	async getTimestamp(dpValue) {
+	getTimestamp(dpValue) {
 		const time = new Date();
 		return (dpValue = Math.round((time.getTime() - dpValue) / 1000 / 60));
 	}
 
 	/**
 	 * @param {string} dp - get Time of this datapoint
+	 * @param {number} ms - milliseconds
 	 */
-	async getTimestampConnectionDP(dp) {
+	async getTimestampConnectionDP(dp, ms) {
 		const time = new Date();
 		const dpValue = await this.getForeignStateAsync(dp);
-		if (dpValue !== null && dpValue !== undefined) {
-			const dpLastStateChange = Math.round((time.getTime() - dpValue.lc) / 1000);
-			return dpLastStateChange;
+		if (dpValue) {
+			if (!dpValue.val) return false;
+
+			const dpLastStateChange = Math.round(time.getTime() - dpValue.lc); // calculate in ms
+			if (dpLastStateChange >= ms) {
+				return true;
+			} else {
+				return false;
+			}
 		}
 	}
 
@@ -2609,13 +3405,39 @@ class DeviceWatcher extends utils.Adapter {
 	/**
 	 * @param {object} data - object
 	 */
-	async parseData(data) {
+	parseData(data) {
 		if (!data) return {};
 		if (typeof data === 'object') return data;
 		if (typeof data === 'string') return JSON.parse(data);
 		return {};
 	}
 
+	/**
+	 * @param {number} time
+	 */
+	wait(time) {
+		return new Promise(function (resolve) {
+			setTimeout(resolve, time);
+		});
+	}
+
+	/**
+	 * Get previous run of cron job schedule
+	 * Requires cron-parser!
+	 * Inspired by https://stackoverflow.com/questions/68134104/
+	 * @param {string} lastCronRun
+	 */
+	getPreviousCronRun(lastCronRun) {
+		try {
+			const interval = cronParser.parseExpression(lastCronRun);
+			const previous = interval.prev();
+			return Math.floor(Date.now() - previous.getTime()); // in ms
+		} catch (error) {
+			this.log.warn(error);
+			return;
+		}
+	}
+
 	/**
 	 * @param {string} codePart - Message Prefix
 	 * @param {object} error - Sentry message