iobroker.device-watcher 2.5.0 → 2.6.1

package/main.js

@@ -26,13 +26,11 @@ class DeviceWatcher extends utils.Adapter {
 
 		// instances and adapters
 		// raw arrays
-		this.adapterUpdatesJsonRaw = [];
-		this.listInstanceRaw = [];
+		this.listInstanceRaw = new Map();
+		this.adapterUpdatesJsonRaw = new Map();
 		this.listErrorInstanceRaw = [];
 
 		// user arrays
-		this.blacklistInstancesLists = [];
-		this.blacklistInstancesNotify = [];
 		this.listAllInstances = [];
 		this.listDeactivatedInstances = [];
 		this.listAdapterUpdates = [];
@@ -45,25 +43,23 @@ class DeviceWatcher extends utils.Adapter {
 		this.countErrorInstance = 0;
 
 		// devices
+		// raw arrays
+		this.listAllDevicesRaw = new Map();
+		this.batteryLowPoweredRaw = [];
+		this.offlineDevicesRaw = [];
+		this.upgradableDevicesRaw = [];
+
 		// arrays
+		this.listAllDevicesUserRaw = [];
+		this.listAllDevices = [];
 		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;
@@ -72,12 +68,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));
 	}
@@ -88,117 +94,122 @@ class DeviceWatcher extends utils.Adapter {
 	async onReady() {
 		this.log.debug(`Adapter ${adapterName} was started`);
 
-		try {
-			this.listOnlyBattery = this.config.listOnlyBattery;
-			this.createOwnFolder = this.config.createOwnFolder;
-			this.createHtmlList = this.config.createHtmlList;
-
-			this.configSetAdapter = {
-				alexa2: this.config.alexa2Devices,
-				apcups: this.config.apcupsDevices,
-				ble: this.config.bleDevices,
-				deconz: this.config.deconzDevices,
-				enocean: this.config.enoceanDevices,
-				esphome: this.config.esphomeDevices,
-				eusec: this.config.eusecDevices,
-				fritzdect: this.config.fritzdectDevices,
-				fullybrowser: this.config.fullybrowserDevices,
-				ham: this.config.hamDevices,
-				harmony: this.config.harmonyDevices,
-				hmiP: this.config.hmiPDevices,
-				hmrpc: this.config.hmrpcDevices,
-				homeconnect: this.config.homeconnectDevices,
-				hs100: this.config.hs100Devices,
-				hue: this.config.hueDevices,
-				hueExt: this.config.hueExtDevices,
-				innogy: this.config.innogyDevices,
-				jeelink: this.config.jeelinkDevices,
-				lupusec: this.config.lupusecDevices,
-				maxcube: this.config.maxcubeDevices,
-				meross: this.config.merossDevices,
-				mihome: this.config.mihomeDevices,
-				mihomeGW: this.config.mihomeDevices,
-				mihomeVacuum: this.config.mihomeVacuumDevices,
-				mqttClientZigbee2Mqtt: this.config.mqttClientZigbee2MqttDevices,
-				mqttNuki: this.config.mqttNukiDevices,
-				musiccast: this.config.musiccastDevices,
-				netatmo: this.config.netatmoDevices,
-				nukiExt: this.config.nukiExtDevices,
-				nut: this.config.nutDevices,
-				ping: this.config.pingDevices,
-				roomba: this.config.roombaDevices,
-				shelly: this.config.shellyDevices,
-				smartgarden: this.config.smartgardenDevices,
-				sonoff: this.config.sonoffDevices,
-				sonos: this.config.sonosDevices,
-				sureflap: this.config.sureflapDevices,
-				switchbotBle: this.config.switchbotBleDevices,
-				tado: this.config.tadoDevices,
-				tapo: this.config.tapoDevices,
-				tradfri: this.config.tradfriDevices,
-				unifi: this.config.unifiDevices,
-				wled: this.config.wledDevices,
-				yeelight: this.config.yeelightDevices,
-				zigbee: this.config.zigbeeDevices,
-				zigbee2MQTT: this.config.zigbee2mqttDevices,
-				zwave: this.config.zwaveDevices,
-			};
-
-			this.configMaxMinutes = {
-				alexa2: this.config.alexa2MaxMinutes,
-				apcups: this.config.apcupsMaxMinutes,
-				ble: this.config.bleMaxMinutes,
-				deconz: this.config.deconzMaxMinutes,
-				enocean: this.config.enoceanMaxMinutes,
-				esphome: this.config.esphomeMaxMinutes,
-				eusec: this.config.eusecMaxMinutes,
-				fritzdect: this.config.fritzdectMaxMinutes,
-				fullybrowser: this.config.fullybrowserMaxMinutes,
-				ham: this.config.hamMaxMinutes,
-				harmony: this.config.harmonyMaxMinutes,
-				hmiP: this.config.hmiPMaxMinutes,
-				hmrpc: this.config.hmrpcMaxMinutes,
-				homeconnect: this.config.homeconnectMaxMinutes,
-				hs100: this.config.hs100MaxMinutes,
-				hue: this.config.hueMaxMinutes,
-				hueExt: this.config.hueextMaxMinutes,
-				innogy: this.config.innogyMaxMinutes,
-				jeelink: this.config.jeelinkMaxMinutes,
-				lupusec: this.config.lupusecMaxMinutes,
-				maxcube: this.config.maxcubeMaxMinutes,
-				meross: this.config.merossMaxMinutes,
-				mihome: this.config.mihomeMaxMinutes,
-				mihomeGW: this.config.mihomeMaxMinutes,
-				mihomeVacuum: this.config.mihomeVacuumMaxMinutes,
-				mqttClientZigbee2Mqtt: this.config.mqttClientZigbee2MqttMaxMinutes,
-				mqttNuki: this.config.mqttNukiMaxMinutes,
-				musiccast: this.config.musiccastMaxMinutes,
-				netatmo: this.config.netatmoMaxMinutes,
-				nukiExt: this.config.nukiextendMaxMinutes,
-				nut: this.config.nutMaxMinutes,
-				ping: this.config.pingMaxMinutes,
-				roomba: this.config.roombaMaxMinutes,
-				shelly: this.config.shellyMaxMinutes,
-				smartgarden: this.config.smartgardenMaxMinutes,
-				sonoff: this.config.sonoffMaxMinutes,
-				sonos: this.config.sonosMaxMinutes,
-				sureflap: this.config.sureflapMaxMinutes,
-				switchbotBle: this.config.switchbotMaxMinutes,
-				tado: this.config.tadoMaxMinutes,
-				tapo: this.config.tapoMaxMinutes,
-				tradfri: this.config.tradfriMaxMinutes,
-				unifi: this.config.unifiMaxMinutes,
-				wled: this.config.wledMaxMinutes,
-				yeelight: this.config.yeelightMaxMinutes,
-				zigbee: this.config.zigbeeMaxMinutes,
-				zigbee2MQTT: this.config.zigbee2mqttMaxMinutes,
-				zwave: this.config.zwaveMaxMinutes,
-			};
+		this.configCreateInstanceList = this.config.checkAdapterInstances;
+		this.configListOnlyBattery = this.config.listOnlyBattery;
+		this.configCreateOwnFolder = this.config.createOwnFolder;
+		this.configCreateHtmlList = this.config.createHtmlList;
+
+		this.configSetAdapter = {
+			alexa2: this.config.alexa2Devices,
+			apcups: this.config.apcupsDevices,
+			ble: this.config.bleDevices,
+			deconz: this.config.deconzDevices,
+			enocean: this.config.enoceanDevices,
+			esphome: this.config.esphomeDevices,
+			eusec: this.config.eusecDevices,
+			fhemTFAsensors: this.config.fhemTFAsensorsDevices,
+			fritzdect: this.config.fritzdectDevices,
+			fullybrowser: this.config.fullybrowserDevices,
+			ham: this.config.hamDevices,
+			harmony: this.config.harmonyDevices,
+			hmiP: this.config.hmiPDevices,
+			hmrpc: this.config.hmrpcDevices,
+			homeconnect: this.config.homeconnectDevices,
+			hs100: this.config.hs100Devices,
+			hue: this.config.hueDevices,
+			hueExt: this.config.hueExtDevices,
+			innogy: this.config.innogyDevices,
+			jeelink: this.config.jeelinkDevices,
+			lupusec: this.config.lupusecDevices,
+			maxcube: this.config.maxcubeDevices,
+			meross: this.config.merossDevices,
+			mihome: this.config.mihomeDevices,
+			mihomeGW: this.config.mihomeDevices,
+			mihomeVacuum: this.config.mihomeVacuumDevices,
+			mqttClientZigbee2Mqtt: this.config.mqttClientZigbee2MqttDevices,
+			mqttNuki: this.config.mqttNukiDevices,
+			musiccast: this.config.musiccastDevices,
+			netatmo: this.config.netatmoDevices,
+			nukiExt: this.config.nukiExtDevices,
+			nut: this.config.nutDevices,
+			ping: this.config.pingDevices,
+			proxmox: this.config.proxmoxDevices,
+			roomba: this.config.roombaDevices,
+			shelly: this.config.shellyDevices,
+			smartgarden: this.config.smartgardenDevices,
+			sonoff: this.config.sonoffDevices,
+			sonos: this.config.sonosDevices,
+			sureflap: this.config.sureflapDevices,
+			switchbotBle: this.config.switchbotBleDevices,
+			tado: this.config.tadoDevices,
+			tapo: this.config.tapoDevices,
+			tradfri: this.config.tradfriDevices,
+			unifi: this.config.unifiDevices,
+			wled: this.config.wledDevices,
+			yeelight: this.config.yeelightDevices,
+			zigbee: this.config.zigbeeDevices,
+			zigbee2MQTT: this.config.zigbee2mqttDevices,
+			zwave: this.config.zwaveDevices,
+		};
+
+		this.configMaxMinutes = {
+			alexa2: this.config.alexa2MaxMinutes,
+			apcups: this.config.apcupsMaxMinutes,
+			ble: this.config.bleMaxMinutes,
+			deconz: this.config.deconzMaxMinutes,
+			enocean: this.config.enoceanMaxMinutes,
+			esphome: this.config.esphomeMaxMinutes,
+			eusec: this.config.eusecMaxMinutes,
+			fhemTFAsensors: this.config.fhemTFAsensorsMaxMinutes,
+			fritzdect: this.config.fritzdectMaxMinutes,
+			fullybrowser: this.config.fullybrowserMaxMinutes,
+			ham: this.config.hamMaxMinutes,
+			harmony: this.config.harmonyMaxMinutes,
+			hmiP: this.config.hmiPMaxMinutes,
+			hmrpc: this.config.hmrpcMaxMinutes,
+			homeconnect: this.config.homeconnectMaxMinutes,
+			hs100: this.config.hs100MaxMinutes,
+			hue: this.config.hueMaxMinutes,
+			hueExt: this.config.hueextMaxMinutes,
+			innogy: this.config.innogyMaxMinutes,
+			jeelink: this.config.jeelinkMaxMinutes,
+			lupusec: this.config.lupusecMaxMinutes,
+			maxcube: this.config.maxcubeMaxMinutes,
+			meross: this.config.merossMaxMinutes,
+			mihome: this.config.mihomeMaxMinutes,
+			mihomeGW: this.config.mihomeMaxMinutes,
+			mihomeVacuum: this.config.mihomeVacuumMaxMinutes,
+			mqttClientZigbee2Mqtt: this.config.mqttClientZigbee2MqttMaxMinutes,
+			mqttNuki: this.config.mqttNukiMaxMinutes,
+			musiccast: this.config.musiccastMaxMinutes,
+			netatmo: this.config.netatmoMaxMinutes,
+			nukiExt: this.config.nukiextendMaxMinutes,
+			nut: this.config.nutMaxMinutes,
+			ping: this.config.pingMaxMinutes,
+			proxmox: this.config.proxmoxMaxMinutes,
+			roomba: this.config.roombaMaxMinutes,
+			shelly: this.config.shellyMaxMinutes,
+			smartgarden: this.config.smartgardenMaxMinutes,
+			sonoff: this.config.sonoffMaxMinutes,
+			sonos: this.config.sonosMaxMinutes,
+			sureflap: this.config.sureflapMaxMinutes,
+			switchbotBle: this.config.switchbotMaxMinutes,
+			tado: this.config.tadoMaxMinutes,
+			tapo: this.config.tapoMaxMinutes,
+			tradfri: this.config.tradfriMaxMinutes,
+			unifi: this.config.unifiMaxMinutes,
+			wled: this.config.wledMaxMinutes,
+			yeelight: this.config.yeelightMaxMinutes,
+			zigbee: this.config.zigbeeMaxMinutes,
+			zigbee2MQTT: this.config.zigbee2mqttMaxMinutes,
+			zwave: this.config.zwaveMaxMinutes,
+		};
 
+		try {
 			for (const [id] of Object.entries(arrApart)) {
 				if (this.configSetAdapter[id]) {
 					this.selAdapter.push(arrApart[id]);
-					this.adapterSelected.push(await this.capitalize(id));
+					this.adapterSelected.push(this.capitalize(id));
 				}
 			}
 
@@ -214,19 +225,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.configCreateOwnFolder) {
+						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.configCreateHtmlList) {
+								await this.deleteHtmlListDatapoints(id);
+							} else {
+								await this.createHtmlListDatapoints(id);
+							}
 							this.log.debug(`Created datapoints for ${this.capitalize(id)}`);
 						}
 					}
@@ -236,36 +251,98 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			// create HTML list datapoints
-			if (this.createHtmlList) await this.createHtmlListDatapoints();
+			if (!this.configCreateHtmlList) {
+				await this.deleteHtmlListDatapoints();
+			} else {
+				await this.createHtmlListDatapoints();
+			}
 
-			//read data first at start
+			// read data first at start
+			// devices
 			await this.main();
 
-			if (this.config.checkAdapterInstances) {
-				await this.getInstanceData();
+			// instances and adapters
+			if (this.configCreateInstanceList) {
+				// instances
+				await this.createDPsForInstances();
+				await this.getAllInstanceData();
+				// adapter updates
 				await this.createAdapterUpdateData();
+			} else {
+				await this.deleteDPsForInstances();
 			}
 
 			// 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.sendDeviceUpdateNotificationsShedule();
+			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) await this.sendInstanceErrorNotificationShedule();
+			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) {
+			try {
+				// The object was changed
+				//this.log.debug(`object ${id} changed: ${JSON.stringify(obj)}`);
+
+				if (id.startsWith('system.adapter.')) {
+					//read new instance data and add it to the lists
+					await this.getInstanceData(id);
+				} else {
+					//read devices data and renew the lists
+					await this.main();
+				}
+			} catch (error) {
+				this.log.error(`Issue at object change: ${error}`);
+			}
+		} else {
+			try {
+				// The object was deleted
+				this.log.info(`object ${id} deleted`);
+
+				// delete instance data in map
+				if (this.listInstanceRaw.has(id)) {
+					this.listInstanceRaw.delete(id);
+				}
+
+				// delete device data in map
+				if (this.listAllDevicesRaw.has(id)) {
+					this.listAllDevicesRaw.delete(id);
+				}
+
+				//unsubscribe of Objects and states
+				this.unsubscribeForeignObjects(id);
+				this.unsubscribeForeignStates(id);
+			} catch (error) {
+				this.log.error(`Issue at object deletion: ${error}`);
+			}
+		}
+	}
+
 	/**
 	 * Is called if a subscribed state changes
 	 * @param {string} id
@@ -273,199 +350,221 @@ 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}`);
+		if (state) {
+			// this.log.debug(`State changed: ${id} changed ${state.val}`);
 			let batteryData;
+			let signalData;
 			let oldLowBatState;
 			let contactData;
 			let oldStatus;
 			let isLowBatValue;
 			let instanceStatusRaw;
-			let instanceDeviceConnectionDpTS;
-			const instanceDeviceConnectionDpTSminTime = 10;
+			let oldInstanceHostState;
+			let oldInstanceDeviceState;
 
-			/*
-			if (this.config.checkAdapterInstances) {
-				for (const adapter of this.adapterUpdatesJsonRaw) {
-					switch (id) {
-						case adapter.Path:
-
-							this.sendAdapterUpdatesNotification(id, state);
+			try {
+				if (id.endsWith('updatesJson')) {
+					await this.getAdapterUpdateData(id);
+					await this.createAdapterUpdateList();
+					if (this.config.checkSendAdapterUpdateMsg) {
+						await this.sendStateNotifications('updateAdapter', null);
 					}
-				}
-			}*/
-
-			for (const instance of this.listInstanceRaw) {
-				switch (id) {
-					case instance.instanceAlivePath:
-						if (state.val !== instance.isAlive) {
-							instanceStatusRaw = await this.setInstanceStatus(
-								instance.instanceMode,
-								instance.schedule,
-								instance.instanceAlivePath,
-								state.val,
-								instance.isConnectedHost,
-								instance.isConnectedDevice,
-							);
-							instance.isAlive = instanceStatusRaw[1];
-							instance.status = instanceStatusRaw[0];
-							instance.isHealthy = instanceStatusRaw[2];
-						}
-						break;
-					case instance.connectedHostPath:
-						if (instance.isAlive && state.val !== instance.isConnectedHost) {
-							instance.isConnectedHost = state.val;
-							instanceStatusRaw = await this.setInstanceStatus(
-								instance.instanceMode,
-								instance.schedule,
-								instance.instanceAlivePath,
-								instance.isAlive,
-								state.val,
-								instance.isConnectedDevice,
-							);
-							instance.isAlive = instanceStatusRaw[1];
-							instance.status = instanceStatusRaw[0];
-							instance.isHealthy = instanceStatusRaw[2];
-
-							if (this.config.checkSendInstanceFailedMsg && !instance.isHealthy && !this.blacklistNotify.includes(instance.instanceAlivePath)) {
-								await this.sendInstanceErrorNotification(instance.InstanceName, instance.status);
+					for (const instance of this.listInstanceRaw.values()) {
+						if (this.adapterUpdatesJsonRaw.has(instance.Adapter)) {
+							for (const adapter of this.adapterUpdatesJsonRaw.values()) {
+								instance.updateAvailable = adapter.newVersion;
 							}
+						} else {
+							instance.updateAvailable = ' - ';
 						}
-						break;
-					case instance.connectedDevicePath:
-						if (instance.isAlive && state.val !== instance.isConnectedDevice) {
-							instance.isConnectedDevice = state.val;
-							instanceStatusRaw = await this.setInstanceStatus(
-								instance.instanceMode,
-								instance.schedule,
-								instance.instanceAlivePath,
-								instance.isAlive,
-								instance.isConnectedHost,
-								state.val,
-							);
-							instance.isAlive = instanceStatusRaw[1];
-							instance.status = instanceStatusRaw[0];
-							instance.isHealthy = instanceStatusRaw[2];
+					}
+				}
 
-							if (this.config.checkSendInstanceFailedMsg && !instance.isHealthy && !this.blacklistNotify.includes(instance.instanceAlivePath)) {
-								await this.sendInstanceErrorNotification(instance.InstanceName, instance.status);
+				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;
+							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) {
-				// On statechange update available datapoint
-				switch (id) {
-					case device.instanceDeviceConnectionDP:
-						if (state.val !== device.instancedeviceConnected) {
-							device.instancedeviceConnected = state.val;
-						}
-						break;
+				for (const [device, deviceData] of this.listAllDevicesRaw) {
+					// On statechange update available datapoint
+					switch (id) {
+						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;
-							if (state.val) {
-								if (this.config.checkSendDeviceUpgrade && !this.blacklistNotify.includes(device.Path)) {
-									await this.sendDeviceUpdatesNotification(device.Device, device.Adapter);
+						case deviceData.UpdateDP:
+							if (state.val !== deviceData.Upgradable) {
+								deviceData.Upgradable = state.val;
+								if (state.val) {
+									if (this.config.checkSendDeviceUpgrade && !this.blacklistNotify.includes(deviceData.Path)) {
+										await this.sendStateNotifications('updateDevice', device);
+									}
 								}
 							}
-						}
-						break;
+							break;
 
-					case device.SignalStrengthDP:
-						device.SignalStrength = await this.calculateSignalStrength(state, device.adapterID);
-						break;
+						case deviceData.SignalStrengthDP:
+							signalData = await this.calculateSignalStrength(state, deviceData.adapterID);
+							deviceData.SignalStrength = signalData[0];
 
-					case device.batteryDP:
-						if (device.isBatteryDevice) {
-							oldLowBatState = device.LowBat;
-							batteryData = await this.getBatteryData(state.val, oldLowBatState, device.adapterID);
+							break;
 
-							device.Battery = batteryData[0];
-							device.BatteryRaw = batteryData[2];
-							if (device.LowBatDP !== 'none') {
-								isLowBatValue = await this.getInitValue(device.LowBatDP);
-							} else {
-								isLowBatValue = undefined;
-							}
-							device.LowBat = await this.setLowbatIndicator(state.val, isLowBatValue, device.faultReport, device.adapterID);
+						case deviceData.batteryDP:
+							if (deviceData.isBatteryDevice) {
+								oldLowBatState = deviceData.LowBat;
+								batteryData = await this.getBatteryData(state.val, oldLowBatState, deviceData.faultReport, deviceData.adapterID);
+
+								deviceData.Battery = batteryData[0];
+								deviceData.BatteryRaw = batteryData[2];
+								deviceData.BatteryUnitRaw = batteryData[3];
+								if (deviceData.LowBatDP !== 'none') {
+									isLowBatValue = await this.getInitValue(deviceData.LowBatDP);
+								} else {
+									isLowBatValue = undefined;
+								}
+								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;
+							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.faultReport, deviceData.adapterID);
+								deviceData.Battery = batteryData[0];
+								deviceData.BatteryRaw = batteryData[2];
+								deviceData.BatteryUnitRaw = batteryData[3];
+								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;
+							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, state.val, 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.BatteryUnitRaw = batteryData[3];
+								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;
+							break;
 
-					case device.UnreachDP:
-						oldStatus = device.Status;
-						device.UnreachState = await this.getInitValue(device.UnreachDP);
-						contactData = await this.getOnlineState(
-							device.timeSelector,
-							device.adapterID,
-							device.UnreachDP,
-							device.SignalStrength,
-							device.UnreachState,
-							device.DeviceStateSelectorDP,
-							device.rssiPeerSelectorDP,
-						);
-						if (contactData !== undefined) {
-							device.LastContact = contactData[0];
-							device.Status = contactData[1];
-							device.SignalStrength = contactData[2];
-						}
-						if (device.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);
-								}
+						case deviceData.UnreachDP:
+							oldStatus = deviceData.Status;
+							deviceData.UnreachState = await this.getInitValue(deviceData.UnreachDP);
+							contactData = await this.getOnlineState(
+								deviceData.timeSelector,
+								deviceData.adapterID,
+								deviceData.UnreachDP,
+								deviceData.SignalStrength,
+								deviceData.UnreachState,
+								deviceData.DeviceStateSelectorDP,
+								deviceData.rssiPeerSelectorDP,
+							);
+							if (contactData !== undefined) {
+								deviceData.LastContact = contactData[0];
+								deviceData.Status = contactData[1];
+								deviceData.SignalStrength = contactData[2];
 							}
-						} else {
-							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 {
+									await this.sendStateNotifications('onlineStateDevice', device);
+								}
 							}
-						}
-						break;
+							break;
+					}
 				}
+			} catch (error) {
+				this.log.error(`Issue at state change: ${error}`);
 			}
+		} else {
+			// The state was deleted
+			this.log.debug(`state ${id} deleted`);
 		}
 	}
 
@@ -474,26 +573,23 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	onMessage(obj) {
 		const devices = [];
-		let myCount = 0;
-		let result;
 		const instances = [];
-		let myCountInstances = 0;
-		let resultInstances;
+		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) {
@@ -503,7 +599,7 @@ class DeviceWatcher extends utils.Adapter {
 						});
 						this.sendTo(obj.from, obj.command, sortDevices, obj.callback);
 					} catch (error) {
-						this.sendTo(obj.from, obj.command, obj.callback);
+						this.errorReporting('[onMessage - deviceList for blacklisttable]', error);
 					}
 				} else {
 					this.sendTo(obj.from, obj.command, obj.callback);
@@ -513,16 +609,15 @@ class DeviceWatcher extends utils.Adapter {
 			case 'instancesList':
 				if (obj.message) {
 					try {
-						resultInstances = this.listInstanceRaw;
-						for (const element in resultInstances) {
-							const label = `${resultInstances[element].Adapter}: ${resultInstances[element].InstanceName}`;
-							const myValueObject = {
-								adapter: resultInstances[element].Adapter,
-								instanceName: resultInstances[element].InstanceName,
-								path: resultInstances[element].instanceAlivePath,
+						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[myCountInstances] = { label: label, value: JSON.stringify(myValueObject) };
-							myCountInstances++;
+							instances[countInstances] = { label: label, value: JSON.stringify(valueObjectInstances) };
+							countInstances++;
 						}
 						const sortInstances = instances.slice(0);
 						sortInstances.sort(function (a, b) {
@@ -532,7 +627,7 @@ class DeviceWatcher extends utils.Adapter {
 						});
 						this.sendTo(obj.from, obj.command, sortInstances, obj.callback);
 					} catch (error) {
-						this.sendTo(obj.from, obj.command, obj.callback);
+						this.errorReporting('[onMessage - instanceList for blacklisttable]', error);
 					}
 				} else {
 					this.sendTo(obj.from, obj.command, obj.callback);
@@ -549,18 +644,27 @@ 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);
 		}
 
 		// fill datapoints for each adapter if selected
-		if (this.createOwnFolder) {
+		if (this.configCreateOwnFolder) {
 			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)}`);
 					}
 				}
@@ -577,15 +681,18 @@ class DeviceWatcher extends utils.Adapter {
 	 * is neccessary to refresh lastContact data, especially of devices without state changes
 	 */
 	async refreshData() {
+		if (isUnloaded) return; // cancel run if unloaded was called.
 		const nextTimeout = this.config.updateinterval * 1000;
 
+		// devices data
 		await this.checkLastContact();
 		await this.createLists();
 		await this.writeDatapoints();
 
-		if (this.createOwnFolder) {
+		// devices data in own adapter folder
+		if (this.configCreateOwnFolder) {
 			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)}`);
@@ -593,26 +700,22 @@ class DeviceWatcher extends utils.Adapter {
 			}
 		}
 
-		if (this.config.checkAdapterInstances) {
+		// instance and adapter data
+		if (this.configCreateInstanceList) {
 			await this.createInstanceList();
 			await this.writeInstanceDPs();
 		}
 
 		// Clear existing timeout
 		if (this.refreshDataTimeout) {
-			this.log.debug('clearing old refresh timeout');
-			this.clearTimeout(this.refreshDataTimeout);
+			clearTimeout(this.refreshDataTimeout);
+			this.refreshDataTimeout = null;
 		}
-		if (!isUnloaded) {
-			this.refreshDataTimeout = this.setTimeout(() => {
-				this.log.debug('Updating Data');
 
-				this.refreshDataTimeout = null;
-				this.refreshData();
-			}, nextTimeout);
-		} else {
-			return; // cancel run if unloaded was called.
-		}
+		this.refreshDataTimeout = setTimeout(() => {
+			this.log.debug('Updating Data');
+			this.refreshData();
+		}, nextTimeout);
 	} // <-- refreshData end
 
 	/**
@@ -626,7 +729,7 @@ class DeviceWatcher extends utils.Adapter {
 
 		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);
@@ -645,14 +748,14 @@ 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 = await this.parseData(myBlacklistInstances[i].instances);
+				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);
@@ -667,7 +770,7 @@ class DeviceWatcher extends utils.Adapter {
 		}
 
 		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 notificatioons: ${this.blacklistInstancesNotify}`);
+		if (this.blacklistInstancesNotify.length >= 1) this.log.info(`Found items on blacklist for notifications: ${this.blacklistInstancesNotify}`);
 
 		this.log.debug(`Function finished: ${this.createBlacklist.name}`);
 	}
@@ -676,189 +779,209 @@ class DeviceWatcher extends utils.Adapter {
 	 * @param {object} i - Device Object
 	 */
 	async createData(i) {
-		const devices = await this.getForeignStatesAsync(this.selAdapter[i].Selektor);
-		const adapterID = this.selAdapter[i].adapterID;
+		try {
+			const devices = await this.getForeignStatesAsync(this.selAdapter[i].Selektor);
+			const adapterID = this.selAdapter[i].adapterID;
 
-		/*----------  Start of loop  ----------*/
-		for (const [id] of Object.entries(devices)) {
-			/*=============================================
+			/*----------  Start of loop  ----------*/
+			for (const [id] of Object.entries(devices)) {
+				/*=============================================
 				=              get Instanz		          =
 				=============================================*/
-			const instance = id.slice(0, id.indexOf('.') + 2);
-			const instanceDeviceConnectionDP = `${instance}.info.connection`;
-			const instancedeviceConnected = await this.getInitValue(instanceDeviceConnectionDP);
-			this.subscribeForeignStates(instanceDeviceConnectionDP);
+				const instance = id.slice(0, id.indexOf('.') + 2);
+				const instanceDeviceConnectionDP = `${instance}.info.connection`;
+				const instancedeviceConnected = await this.getInitValue(instanceDeviceConnectionDP);
+				this.subscribeForeignStates(instanceDeviceConnectionDP);
+				this.subscribeForeignObjects(`${this.selAdapter[i].Selektor}`);
 
-			/*=============================================
+				/*=============================================
 				=              Get device name		          =
 				=============================================*/
-			const deviceName = await this.getDeviceName(id, i);
+				const deviceName = await this.getDeviceName(id, i);
 
-			/*=============================================
+				/*=============================================
 				=              Get adapter name		          =
 				=============================================*/
-			const adapter = this.selAdapter[i].adapter;
+				const adapter = this.selAdapter[i].adapter;
 
-			/*=============================================
+				/*=============================================
 				=            Get path to datapoints	   	      =
 				=============================================*/
-			const currDeviceString = id.slice(0, id.lastIndexOf('.') + 1 - 1);
-			const shortCurrDeviceString = currDeviceString.slice(0, currDeviceString.lastIndexOf('.') + 1 - 1);
+				const currDeviceString = id.slice(0, id.lastIndexOf('.') + 1 - 1);
+				const shortCurrDeviceString = currDeviceString.slice(0, currDeviceString.lastIndexOf('.') + 1 - 1);
 
-			/*=============================================
+				// subscribe to object device path
+				this.subscribeForeignObjects(currDeviceString);
+
+				/*=============================================
 				=            Get signal strength              =
 				=============================================*/
-			let deviceQualityDP = currDeviceString + this.selAdapter[i].rssiState;
-			let deviceQualityState;
+				let deviceQualityDP = currDeviceString + this.selAdapter[i].rssiState;
+				let deviceQualityState;
 
-			switch (adapterID) {
-				case 'mihomeVacuum':
-					deviceQualityDP = shortCurrDeviceString + this.selAdapter[i].rssiState;
-					deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
-					break;
+				switch (adapterID) {
+					case 'mihomeVacuum':
+						deviceQualityDP = shortCurrDeviceString + this.selAdapter[i].rssiState;
+						deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
+						break;
 
-				case 'netatmo':
-					deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
-					if (!deviceQualityState) {
-						deviceQualityDP = currDeviceString + this.selAdapter[i].rfState;
+					case 'netatmo':
 						deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
-					}
-					break;
+						if (!deviceQualityState) {
+							deviceQualityDP = currDeviceString + this.selAdapter[i].rfState;
+							deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
+						}
+						break;
 
-				default:
-					deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
-					break;
-			}
-			//subscribe to states
-			this.subscribeForeignStates(deviceQualityDP);
+					default:
+						deviceQualityState = await this.getForeignStateAsync(deviceQualityDP);
+						break;
+				}
+				//subscribe to states
+				this.subscribeForeignStates(deviceQualityDP);
 
-			let linkQuality = await this.calculateSignalStrength(deviceQualityState, adapterID);
+				const signalData = await this.calculateSignalStrength(deviceQualityState, adapterID);
+				let linkQuality = signalData[0];
+				const linkQualityRaw = signalData[1];
 
-			/*=============================================
+				/*=============================================
 				=         	    Get battery data       	      =
 				=============================================*/
-			let deviceBatteryStateDP;
-			let deviceBatteryState;
-			let batteryHealth;
-			let batteryHealthRaw;
-			let lowBatIndicator;
-			let isBatteryDevice;
-			let isLowBatDP;
-			let faultReportingDP;
-			let faultReportingState;
-
-			const deviceChargerStateDP = currDeviceString + this.selAdapter[i].charger;
-			const deviceChargerState = await this.getInitValue(deviceChargerStateDP);
-
-			if (deviceChargerState === undefined || deviceChargerState === false) {
-				// Get battery states
-				switch (adapterID) {
-					case 'hueExt':
-					case 'mihomeVacuum':
-					case 'mqttNuki':
-						deviceBatteryStateDP = shortCurrDeviceString + this.selAdapter[i].battery;
-						deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
-						if (deviceBatteryState === undefined) {
-							deviceBatteryStateDP = shortCurrDeviceString + this.selAdapter[i].battery2;
+				let deviceBatteryStateDP;
+				let deviceBatteryState;
+				let batteryHealth;
+				let batteryHealthRaw;
+				let batteryUnitRaw;
+				let lowBatIndicator;
+				let isBatteryDevice;
+				let isLowBatDP;
+				let faultReportingDP;
+				let faultReportingState;
+
+				const deviceChargerStateDP = currDeviceString + this.selAdapter[i].charger;
+				const deviceChargerState = await this.getInitValue(deviceChargerStateDP);
+
+				if (deviceChargerState === undefined || deviceChargerState === false) {
+					// Get battery states
+					switch (adapterID) {
+						case 'hmrpc':
+							deviceBatteryStateDP = currDeviceString + this.selAdapter[i].battery;
 							deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
-						}
-						break;
-					default:
-						deviceBatteryStateDP = currDeviceString + this.selAdapter[i].battery;
-						deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
-						if (deviceBatteryState === undefined) {
-							deviceBatteryStateDP = currDeviceString + this.selAdapter[i].battery2;
+							if (deviceBatteryState === undefined) {
+								deviceBatteryStateDP = shortCurrDeviceString + this.selAdapter[i].hmDNBattery;
+								deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
+							}
+							break;
+						case 'hueExt':
+						case 'mihomeVacuum':
+						case 'mqttNuki':
+							deviceBatteryStateDP = shortCurrDeviceString + this.selAdapter[i].battery;
 							deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
-						}
-						break;
-				}
+							if (deviceBatteryState === undefined) {
+								deviceBatteryStateDP = shortCurrDeviceString + this.selAdapter[i].battery2;
+								deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
+							}
+							break;
+						default:
+							deviceBatteryStateDP = currDeviceString + this.selAdapter[i].battery;
+							deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
+							if (deviceBatteryState === undefined) {
+								deviceBatteryStateDP = currDeviceString + this.selAdapter[i].battery2;
+								deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
+							}
+							break;
+					}
 
-				// Get low bat states
-				isLowBatDP = currDeviceString + this.selAdapter[i].isLowBat;
-				let deviceLowBatState = await this.getInitValue(isLowBatDP);
-				if (deviceLowBatState === undefined) {
-					isLowBatDP = currDeviceString + this.selAdapter[i].isLowBat2;
-					deviceLowBatState = await this.getInitValue(isLowBatDP);
-				}
-				if (deviceLowBatState === undefined) isLowBatDP = 'none';
+					// Get low bat states
+					isLowBatDP = currDeviceString + this.selAdapter[i].isLowBat;
+					let deviceLowBatState = await this.getInitValue(isLowBatDP);
+					if (deviceLowBatState === undefined) {
+						isLowBatDP = currDeviceString + this.selAdapter[i].isLowBat2;
+						deviceLowBatState = await this.getInitValue(isLowBatDP);
+					}
+					if (deviceLowBatState === undefined) isLowBatDP = 'none';
 
-				faultReportingDP = shortCurrDeviceString + this.selAdapter[i].faultReporting;
-				faultReportingState = await this.getInitValue(faultReportingDP);
+					faultReportingDP = shortCurrDeviceString + this.selAdapter[i].faultReporting;
+					faultReportingState = await this.getInitValue(faultReportingDP);
 
-				//subscribe to states
-				this.subscribeForeignStates(deviceBatteryStateDP);
-				this.subscribeForeignStates(isLowBatDP);
-				this.subscribeForeignStates(faultReportingDP);
+					//subscribe to states
+					this.subscribeForeignStates(deviceBatteryStateDP);
+					this.subscribeForeignStates(isLowBatDP);
+					this.subscribeForeignStates(faultReportingDP);
 
-				const batteryData = await this.getBatteryData(deviceBatteryState, deviceLowBatState, adapterID);
-				batteryHealth = batteryData[0];
-				batteryHealthRaw = batteryData[2];
-				isBatteryDevice = batteryData[1];
+					const batteryData = await this.getBatteryData(deviceBatteryState, deviceLowBatState, faultReportingState, adapterID);
+					batteryHealth = batteryData[0];
+					batteryHealthRaw = batteryData[2];
+					batteryUnitRaw = batteryData[3];
+					isBatteryDevice = batteryData[1];
 
-				if (isBatteryDevice) {
-					lowBatIndicator = await this.setLowbatIndicator(deviceBatteryState, deviceLowBatState, faultReportingState, adapterID);
+					if (isBatteryDevice) {
+						lowBatIndicator = await this.setLowbatIndicator(deviceBatteryState, deviceLowBatState, faultReportingState, adapterID);
+					}
 				}
-			}
 
-			/*=============================================
+				/*=============================================
 				=          Get last contact of device         =
 				=============================================*/
-			let unreachDP = currDeviceString + this.selAdapter[i].reach;
-			const deviceStateSelectorDP = shortCurrDeviceString + this.selAdapter[i].stateValue;
-			const rssiPeerSelectorDP = currDeviceString + this.selAdapter[i].rssiPeerState;
-			const timeSelector = currDeviceString + this.selAdapter[i].timeSelector;
-
-			let deviceUnreachState = await this.getInitValue(unreachDP);
-			if (deviceUnreachState === undefined) {
-				unreachDP = shortCurrDeviceString + this.selAdapter[i].reach;
-				deviceUnreachState = await this.getInitValue(shortCurrDeviceString + this.selAdapter[i].reach);
-			}
-
-			// subscribe to states
-			this.subscribeForeignStates(timeSelector);
-			this.subscribeForeignStates(unreachDP);
-			this.subscribeForeignStates(deviceStateSelectorDP);
-			this.subscribeForeignStates(rssiPeerSelectorDP);
+				let unreachDP = currDeviceString + this.selAdapter[i].reach;
+				const deviceStateSelectorDP = shortCurrDeviceString + this.selAdapter[i].stateValue;
+				const rssiPeerSelectorDP = currDeviceString + this.selAdapter[i].rssiPeerState;
+				const timeSelector = currDeviceString + this.selAdapter[i].timeSelector;
+
+				let deviceUnreachState = await this.getInitValue(unreachDP);
+				if (deviceUnreachState === undefined) {
+					unreachDP = shortCurrDeviceString + this.selAdapter[i].reach;
+					deviceUnreachState = await this.getInitValue(shortCurrDeviceString + this.selAdapter[i].reach);
+				}
 
-			const onlineState = await this.getOnlineState(timeSelector, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP);
-			let deviceState;
-			let lastContactString;
+				// subscribe to states
+				this.subscribeForeignStates(timeSelector);
+				this.subscribeForeignStates(unreachDP);
+				this.subscribeForeignStates(deviceStateSelectorDP);
+				this.subscribeForeignStates(rssiPeerSelectorDP);
+
+				const onlineState = await this.getOnlineState(timeSelector, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP);
+				let deviceState;
+				let lastContactString;
+
+				if (onlineState) {
+					lastContactString = onlineState[0];
+					deviceState = onlineState[1];
+					linkQuality = onlineState[2];
+				}
 
-			if (onlineState) {
-				lastContactString = onlineState[0];
-				deviceState = onlineState[1];
-				linkQuality = onlineState[2];
-			}
+				/*=============================================
+			=            Get update data	              =
+			=============================================*/
+				const deviceUpdateDP = currDeviceString + this.selAdapter[i].upgrade;
+				let isUpgradable;
 
-			/*=============================================
-				=            Get update data	              =
-				=============================================*/
-			const deviceUpdateDP = currDeviceString + this.selAdapter[i].upgrade;
-			let isUpgradable;
+				if (this.config.checkSendDeviceUpgrade) {
+					const deviceUpdateSelector = await this.getInitValue(deviceUpdateDP);
 
-			if (this.config.checkSendDeviceUpgrade) {
-				const deviceUpdateSelector = await this.getInitValue(deviceUpdateDP);
+					if (deviceUpdateSelector !== undefined) {
+						if (deviceUpdateSelector) {
+							isUpgradable = true;
+						} else if (!deviceUpdateSelector) {
+							isUpgradable = false;
+						}
+					} else {
+						isUpgradable = ' - ';
+					}
 
-				if (deviceUpdateSelector) {
-					isUpgradable = true;
-				} else if (!deviceUpdateSelector) {
-					isUpgradable = false;
+					// subscribe to states
+					this.subscribeForeignStates(deviceUpdateDP);
 				}
-				// subscribe to states
-				this.subscribeForeignStates(deviceUpdateDP);
-			}
 
-			/*=============================================
+				/*=============================================
 				=          		  Fill Raw Lists          	  =
 				=============================================*/
-
-			/* Add only devices with battery in the rawlist */
-			if (this.listOnlyBattery) {
-				if (isBatteryDevice) {
-					this.listAllDevicesRaw.push({
+				const setupList = () => {
+					this.listAllDevicesRaw.set(currDeviceString, {
 						Path: id,
 						instanceDeviceConnectionDP: instanceDeviceConnectionDP,
 						instancedeviceConnected: instancedeviceConnected,
+						instance: instance,
 						Device: deviceName,
 						adapterID: adapterID,
 						Adapter: adapter,
@@ -866,6 +989,7 @@ class DeviceWatcher extends utils.Adapter {
 						isBatteryDevice: isBatteryDevice,
 						Battery: batteryHealth,
 						BatteryRaw: batteryHealthRaw,
+						BatteryUnitRaw: batteryUnitRaw,
 						batteryDP: deviceBatteryStateDP,
 						LowBat: lowBatIndicator,
 						LowBatDP: isLowBatDP,
@@ -873,6 +997,7 @@ class DeviceWatcher extends utils.Adapter {
 						faultReportDP: faultReportingDP,
 						SignalStrengthDP: deviceQualityDP,
 						SignalStrength: linkQuality,
+						SignalStrengthRaw: linkQualityRaw,
 						UnreachState: deviceUnreachState,
 						UnreachDP: unreachDP,
 						DeviceStateSelectorDP: deviceStateSelectorDP,
@@ -882,38 +1007,20 @@ class DeviceWatcher extends utils.Adapter {
 						UpdateDP: deviceUpdateDP,
 						Upgradable: isUpgradable,
 					});
+				};
+
+				if (!this.configListOnlyBattery) {
+					// Add all devices
+					setupList();
+				} else {
+					// Add only devices with battery in the rawlist
+					if (!isBatteryDevice) continue;
+					setupList();
 				}
-			} else {
-				/* Add all devices */
-				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,
-				});
-			}
-		} // <-- end of loop
+			} // <-- end of loop
+		} catch (error) {
+			this.errorReporting('[createData - create data of devices]', error);
+		}
 	} // <-- end of createData
 
 	/*=============================================
@@ -1015,6 +1122,7 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	async calculateSignalStrength(deviceQualityState, adapterID) {
 		let linkQuality;
+		let linkQualityRaw;
 		let mqttNukiValue;
 
 		if (deviceQualityState != null) {
@@ -1028,6 +1136,7 @@ class DeviceWatcher extends utils.Adapter {
 							case 'sonoff':
 							case 'smartgarden':
 								linkQuality = deviceQualityState.val + '%'; // If quality state is already an percent value
+								linkQualityRaw = deviceQualityState.val;
 								break;
 							case 'lupusec':
 								linkQuality = deviceQualityState.val;
@@ -1039,9 +1148,12 @@ class DeviceWatcher extends utils.Adapter {
 									linkQuality = ' - ';
 								} else if (deviceQualityState.val < 0) {
 									linkQuality = Math.min(Math.max(2 * (deviceQualityState.val + 100), 0), 100) + '%';
+									linkQualityRaw = Math.min(Math.max(2 * (deviceQualityState.val + 100), 0), 100);
+
 									// If Quality State is an value between 0-255 (zigbee) calculate in percent:
 								} else if (deviceQualityState.val >= 0) {
 									linkQuality = parseFloat(((100 / 255) * deviceQualityState.val).toFixed(0)) + '%';
+									linkQualityRaw = parseFloat(((100 / 255) * deviceQualityState.val).toFixed(0));
 								}
 								break;
 						}
@@ -1064,7 +1176,7 @@ class DeviceWatcher extends utils.Adapter {
 								linkQuality = deviceQualityState.val;
 							} else if (mqttNukiValue < 0) {
 								linkQuality = Math.min(Math.max(2 * (mqttNukiValue + 100), 0), 100) + '%';
-								// If Quality State is an value between 0-255 (zigbee) calculate in percent:
+								linkQualityRaw = Math.min(Math.max(2 * (mqttNukiValue + 100), 0), 100);
 							}
 					}
 					break;
@@ -1072,24 +1184,33 @@ class DeviceWatcher extends utils.Adapter {
 		} else {
 			linkQuality = ' - ';
 		}
-		return linkQuality;
+		return [linkQuality, linkQualityRaw];
 	}
 
 	/**
 	 * get battery data
 	 * @param {object} deviceBatteryState - State value
 	 * @param {object} deviceLowBatState - State value
+	 * @param {object} faultReportingState - State value
 	 * @param {object} adapterID - adapter name
 	 */
-	async getBatteryData(deviceBatteryState, deviceLowBatState, adapterID) {
+	async getBatteryData(deviceBatteryState, deviceLowBatState, faultReportingState, adapterID) {
 		let batteryHealthRaw;
+		let batteryHealthUnitRaw;
 		let batteryHealth;
 		let isBatteryDevice;
 
 		switch (adapterID) {
 			case 'hmrpc':
 				if (deviceBatteryState === undefined) {
-					if (deviceLowBatState !== undefined) {
+					if (faultReportingState !== undefined) {
+						if (faultReportingState !== 6) {
+							batteryHealth = 'ok';
+						} else {
+							batteryHealth = 'low';
+						}
+						isBatteryDevice = true;
+					} else if (deviceLowBatState !== undefined) {
 						if (deviceLowBatState !== 1) {
 							batteryHealth = 'ok';
 						} else {
@@ -1105,6 +1226,7 @@ class DeviceWatcher extends utils.Adapter {
 					} else {
 						batteryHealth = deviceBatteryState + 'V';
 						batteryHealthRaw = deviceBatteryState;
+						batteryHealthUnitRaw = 'V';
 						isBatteryDevice = true;
 					}
 				}
@@ -1124,12 +1246,13 @@ class DeviceWatcher extends utils.Adapter {
 				} else {
 					batteryHealth = deviceBatteryState + '%';
 					batteryHealthRaw = deviceBatteryState;
+					batteryHealthUnitRaw = '%';
 					isBatteryDevice = true;
 				}
 				break;
 		}
 
-		return [batteryHealth, isBatteryDevice, batteryHealthRaw];
+		return [batteryHealth, isBatteryDevice, batteryHealthRaw, batteryHealthUnitRaw];
 	}
 
 	/**
@@ -1187,7 +1310,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';
@@ -1220,8 +1343,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) {
@@ -1273,6 +1396,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) {
@@ -1374,26 +1507,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);
 				}
 			}
 		}
@@ -1406,6 +1539,7 @@ class DeviceWatcher extends utils.Adapter {
 		this.linkQualityDevices = [];
 		this.batteryPowered = [];
 		this.batteryLowPowered = [];
+		this.listAllDevicesUserRaw = [];
 		this.listAllDevices = [];
 		this.offlineDevices = [];
 		this.batteryLowPoweredRaw = [];
@@ -1417,47 +1551,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 === true) {
 				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();
@@ -1468,6 +1600,24 @@ class DeviceWatcher extends utils.Adapter {
 	 * @param {object} device
 	 */
 	async theLists(device) {
+		// Raw List with all devices for user
+		this.listAllDevicesUserRaw.push({
+			Device: device.Device,
+			Adapter: device.Adapter,
+			Instance: device.instance,
+			'Instance connected': device.instancedeviceConnected,
+			isBatteryDevice: device.isBatteryDevice,
+			Battery: device.Battery,
+			BatteryRaw: device.BatteryRaw,
+			BatteryUnitRaw: device.BatteryUnitRaw,
+			isLowBat: device.LowBat,
+			'Signal strength': device.SignalStrength,
+			'Signal strength Raw': device.SignalStrengthRaw,
+			'Last contact': device.LastContact,
+			'Update Available': device.Upgradable,
+			Status: device.Status,
+		});
+
 		// List with all devices
 		this.listAllDevices.push({
 			Device: device.Device,
@@ -1516,7 +1666,7 @@ class DeviceWatcher extends utils.Adapter {
 		}
 
 		// Device update List
-		if (device.Upgradable) {
+		if (device.Upgradable === true) {
 			this.upgradableList.push({
 				Device: device.Device,
 				Adapter: device.Adapter,
@@ -1547,47 +1697,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
 	 */
@@ -1606,26 +1715,58 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			// Write Datapoints for counts
-			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 });
+			await this.setStateChangedAsync(`devices.${dpSubFolder}offlineCount`, { val: this.offlineDevicesCount, ack: true });
+			await this.setStateChangedAsync(`devices.${dpSubFolder}countAll`, { val: this.deviceCounter, ack: true });
+			await this.setStateChangedAsync(`devices.${dpSubFolder}batteryCount`, { val: this.batteryPoweredCount, ack: true });
+			await this.setStateChangedAsync(`devices.${dpSubFolder}lowBatteryCount`, { val: this.lowBatteryPoweredCount, ack: true });
+			await this.setStateChangedAsync(`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': '' }];
+				this.listAllDevices = [
+					{
+						Device: '--none--',
+						Adapter: '',
+						Battery: '',
+						'Signal strength': '',
+						'Last contact': '',
+						Status: '',
+					},
+				];
+				this.listAllDevicesUserRaw = [
+					{
+						Device: '--none--',
+						Adapter: '',
+						Instance: '',
+						'Instance connected': '',
+						isBatteryDevice: '',
+						Battery: '',
+						BatteryRaw: '',
+						isLowBat: '',
+						'Signal strength': '',
+						'Last contact': '',
+						UpdateAvailable: '',
+						Status: '',
+					},
+				];
 			}
-			await this.setStateAsync(`devices.${dpSubFolder}listAll`, { val: JSON.stringify(this.listAllDevices), ack: true });
+			await this.setStateChangedAsync(`devices.${dpSubFolder}listAll`, { val: JSON.stringify(this.listAllDevices), ack: true });
+			await this.setStateChangedAsync(`devices.${dpSubFolder}listAllRawJSON`, { val: JSON.stringify(this.listAllDevicesUserRaw), ack: true });
 
 			// List link quality
 			if (this.linkQualityCount === 0) {
 				// if no device is count, write the JSON List with default value
-				this.linkQualityDevices = [{ Device: '--none--', Adapter: '', 'Signal strength': '' }];
+				this.linkQualityDevices = [
+					{
+						Device: '--none--',
+						Adapter: '',
+						'Signal strength': '',
+					},
+				];
 			}
 			//write JSON list
-			await this.setStateAsync(`devices.${dpSubFolder}linkQualityList`, {
+			await this.setStateChangedAsync(`devices.${dpSubFolder}linkQualityList`, {
 				val: JSON.stringify(this.linkQualityDevices),
 				ack: true,
 			});
@@ -1633,10 +1774,16 @@ class DeviceWatcher extends utils.Adapter {
 			// List offline devices
 			if (this.offlineDevicesCount === 0) {
 				// if no device is count, write the JSON List with default value
-				this.offlineDevices = [{ Device: '--none--', Adapter: '', 'Last contact': '' }];
+				this.offlineDevices = [
+					{
+						Device: '--none--',
+						Adapter: '',
+						'Last contact': '',
+					},
+				];
 			}
 			//write JSON list
-			await this.setStateAsync(`devices.${dpSubFolder}offlineList`, {
+			await this.setStateChangedAsync(`devices.${dpSubFolder}offlineList`, {
 				val: JSON.stringify(this.offlineDevices),
 				ack: true,
 			});
@@ -1644,10 +1791,16 @@ class DeviceWatcher extends utils.Adapter {
 			// List updatable
 			if (this.upgradableDevicesCount === 0) {
 				// if no device is count, write the JSON List with default value
-				this.upgradableList = [{ Device: '--none--', Adapter: '', 'Last contact': '' }];
+				this.upgradableList = [
+					{
+						Device: '--none--',
+						Adapter: '',
+						'Last contact': '',
+					},
+				];
 			}
 			//write JSON list
-			await this.setStateAsync(`devices.${dpSubFolder}upgradableList`, {
+			await this.setStateChangedAsync(`devices.${dpSubFolder}upgradableList`, {
 				val: JSON.stringify(this.upgradableList),
 				ack: true,
 			});
@@ -1658,7 +1811,7 @@ class DeviceWatcher extends utils.Adapter {
 				this.batteryPowered = [{ Device: '--none--', Adapter: '', Battery: '' }];
 			}
 			//write JSON list
-			await this.setStateAsync(`devices.${dpSubFolder}batteryList`, {
+			await this.setStateChangedAsync(`devices.${dpSubFolder}batteryList`, {
 				val: JSON.stringify(this.batteryPowered),
 				ack: true,
 			});
@@ -1669,71 +1822,71 @@ class DeviceWatcher extends utils.Adapter {
 				this.batteryLowPowered = [{ Device: '--none--', Adapter: '', Battery: '' }];
 			}
 			//write JSON list
-			await this.setStateAsync(`devices.${dpSubFolder}lowBatteryList`, {
+			await this.setStateChangedAsync(`devices.${dpSubFolder}lowBatteryList`, {
 				val: JSON.stringify(this.batteryLowPowered),
 				ack: true,
 			});
 
 			// set booleans datapoints
 			if (this.offlineDevicesCount === 0) {
-				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceOffline`, {
+				await this.setStateChangedAsync(`devices.${dpSubFolder}oneDeviceOffline`, {
 					val: false,
 					ack: true,
 				});
 			} else {
-				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceOffline`, {
+				await this.setStateChangedAsync(`devices.${dpSubFolder}oneDeviceOffline`, {
 					val: true,
 					ack: true,
 				});
 			}
 
 			if (this.lowBatteryPoweredCount === 0) {
-				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceLowBat`, {
+				await this.setStateChangedAsync(`devices.${dpSubFolder}oneDeviceLowBat`, {
 					val: false,
 					ack: true,
 				});
 			} else {
-				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceLowBat`, {
+				await this.setStateChangedAsync(`devices.${dpSubFolder}oneDeviceLowBat`, {
 					val: true,
 					ack: true,
 				});
 			}
 
 			if (this.upgradableDevicesCount === 0) {
-				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceUpdatable`, {
+				await this.setStateChangedAsync(`devices.${dpSubFolder}oneDeviceUpdatable`, {
 					val: false,
 					ack: true,
 				});
 			} else {
-				await this.setStateAsync(`devices.${dpSubFolder}oneDeviceUpdatable`, {
+				await this.setStateChangedAsync(`devices.${dpSubFolder}oneDeviceUpdatable`, {
 					val: true,
 					ack: true,
 				});
 			}
 
 			//write HTML list
-			if (this.createHtmlList) {
-				await this.setStateAsync(`devices.${dpSubFolder}linkQualityListHTML`, {
-					val: await this.creatLinkQualityListHTML(this.linkQualityDevices, this.linkQualityCount),
+			if (this.configCreateHtmlList) {
+				await this.setStateChangedAsync(`devices.${dpSubFolder}linkQualityListHTML`, {
+					val: await this.createListHTML('linkQualityList', this.linkQualityDevices, this.linkQualityCount, null),
 					ack: true,
 				});
-				await this.setStateAsync(`devices.${dpSubFolder}offlineListHTML`, {
-					val: await this.createOfflineListHTML(this.offlineDevices, this.offlineDevicesCount),
+				await this.setStateChangedAsync(`devices.${dpSubFolder}offlineListHTML`, {
+					val: await this.createListHTML('offlineList', this.offlineDevices, this.offlineDevicesCount, null),
 					ack: true,
 				});
-				await this.setStateAsync(`devices.${dpSubFolder}batteryListHTML`, {
-					val: await this.createBatteryListHTML(this.batteryPowered, this.batteryPoweredCount, false),
+				await this.setStateChangedAsync(`devices.${dpSubFolder}batteryListHTML`, {
+					val: await this.createListHTML('batteryList', this.batteryPowered, this.batteryPoweredCount, false),
 					ack: true,
 				});
-				await this.setStateAsync(`devices.${dpSubFolder}lowBatteryListHTML`, {
-					val: await this.createBatteryListHTML(this.batteryLowPowered, this.lowBatteryPoweredCount, true),
+				await this.setStateChangedAsync(`devices.${dpSubFolder}lowBatteryListHTML`, {
+					val: await this.createListHTML('batteryList', this.batteryLowPowered, this.lowBatteryPoweredCount, true),
 					ack: true,
 				});
 			}
 
 			// create timestamp of last run
 			const lastCheck = this.formatDate(new Date(), 'DD.MM.YYYY') + ' - ' + this.formatDate(new Date(), 'hh:mm:ss');
-			await this.setStateAsync('lastCheck', lastCheck, true);
+			await this.setStateChangedAsync('lastCheck', lastCheck, true);
 		} catch (error) {
 			this.errorReporting('[writeDatapoints]', error);
 		}
@@ -1741,13 +1894,25 @@ class DeviceWatcher extends utils.Adapter {
 	} //<--End  of writing Datapoints
 
 	/**
-	 * get Instances
+	 * get all Instances at start
+	 */
+	async getAllInstanceData() {
+		try {
+			const allInstances = `system.adapter.*`;
+			await this.getInstanceData(allInstances);
+		} catch (error) {
+			this.errorReporting('[getInstance]', error);
+		}
+	}
+
+	/**
+	 * get instance data
+	 *@param {string} instanceObject
 	 */
-	async getInstanceData() {
+	async getInstanceData(instanceObject) {
 		try {
-			await this.createDPsForInstances();
+			const instanceAliveDP = await this.getForeignStatesAsync(`${instanceObject}.alive`);
 
-			const instanceAliveDP = await this.getForeignStatesAsync(`system.adapter.*.alive`);
 			for (const [id] of Object.entries(instanceAliveDP)) {
 				if (!(typeof id === 'string' && id.startsWith(`system.adapter.`))) continue;
 
@@ -1771,6 +1936,7 @@ class DeviceWatcher extends utils.Adapter {
 				const instanceObjectPath = `system.adapter.${instanceName}`;
 				let adapterName;
 				let adapterVersion;
+				let adapterAvailableUpdate = '';
 				let instanceMode;
 				let scheduleTime = 'N/A';
 				const instanceObjectData = await this.getForeignObjectAsync(instanceObjectPath);
@@ -1785,20 +1951,30 @@ class DeviceWatcher extends utils.Adapter {
 					}
 				}
 
+				await this.getAdapterUpdateData(`admin.*.info.updatesJson`);
+
+				if (this.adapterUpdatesJsonRaw.has(adapterName)) {
+					for (const adapter of this.adapterUpdatesJsonRaw.values()) {
+						adapterAvailableUpdate = adapter.newVersion;
+					}
+				} else {
+					adapterAvailableUpdate = ' - ';
+				}
+
 				//const adapterVersionVal = await this.getInitValue(adapterVersionDP);
-				const instanceStatusRaw = await this.setInstanceStatus(instanceMode, scheduleTime, id, instanceAliveDP[id].val, instanceConnectedHostVal, instanceConnectedDeviceVal);
+				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);
+				this.subscribeForeignStates(id);
+				this.subscribeForeignStates(instanceConnectedHostDP);
+				this.subscribeForeignStates(instanceConnectedDeviceDP);
+				this.subscribeForeignObjects(`system.adapter.*`);
 
 				// create raw list
-				this.listInstanceRaw.push({
+				this.listInstanceRaw.set(instanceObjectPath, {
 					Adapter: adapterName,
 					InstanceName: instanceName,
 					instanceObjectPath: instanceObjectPath,
@@ -1806,6 +1982,7 @@ class DeviceWatcher extends utils.Adapter {
 					instanceMode: instanceMode,
 					schedule: scheduleTime,
 					adapterVersion: adapterVersion,
+					updateAvailable: adapterAvailableUpdate,
 					isAlive: isAlive,
 					isHealthy: isHealthy,
 					connectedHostPath: instanceConnectedHostDP,
@@ -1818,7 +1995,7 @@ class DeviceWatcher extends utils.Adapter {
 			await this.createInstanceList();
 			await this.writeInstanceDPs();
 		} catch (error) {
-			this.errorReporting('[getInstance]', error);
+			this.errorReporting('[getInstanceData]', error);
 		}
 	}
 
@@ -1835,28 +2012,29 @@ class DeviceWatcher extends utils.Adapter {
 
 	/**
 	 * set status for instance
-	 * @param {object} instanceMode
-	 * @param {object} scheduleTime
+	 * @param {string} instanceMode
+	 * @param {string} scheduleTime
 	 * @param {object} instanceAlivePath
-	 * @param {object} isAliveVal
-	 * @param {object} connectedHostVal
-	 * @param {object} connectedDeviceVal
+	 * @param {string} hostConnectedPath
+	 * @param {string} isDeviceConnctedPath
 	 */
-	async setInstanceStatus(instanceMode, scheduleTime, instanceAlivePath, isAliveVal, connectedHostVal, connectedDeviceVal) {
-		let instanceStatusString = 'not enabled';
+	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 isAlive = false;
 		let isHealthy = false;
-		let dpValue;
+
 		switch (instanceMode) {
 			case 'schedule':
-				dpValue = await this.getForeignStateAsync(instanceAlivePath);
-				if (dpValue) {
-					lastUpdate = Math.round((Date.now() - dpValue.lc) / 1000); // Last state change in seconds
-					previousCronRun = await this.getPreviousCronRun(scheduleTime); // When was the last cron run
+				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;
@@ -1864,42 +2042,43 @@ class DeviceWatcher extends utils.Adapter {
 							// if 5 minutes difference exceeded, instance is not alive
 							isAlive = true;
 							isHealthy = true;
-							instanceStatusString = 'Instance okay';
+							instanceStatusString = 'Instanz okay';
 						}
 					}
 				}
 				break;
 			case 'daemon':
-				if (!isAliveVal) return ['Instance deactivated', false, null]; // if instance is turned off
-
+				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 (connectedHostVal && connectedDeviceVal) {
-					isAlive = true;
+				if (isHostConnected && isDeviceConnected) {
 					isHealthy = true;
-					instanceStatusString = 'Instance okay';
+					instanceStatusString = 'Instanz okay';
 				} else {
 					// Attempt 2/3 - after 10 seconds
 					await this.wait(10000);
-					if (connectedHostVal && connectedDeviceVal) {
-						isAlive = true;
+					isDeviceConnected = await this.getInitValue(isDeviceConnctedPath);
+					isHostConnected = await this.getInitValue(hostConnectedPath);
+
+					if (isHostConnected && isDeviceConnected) {
 						isHealthy = true;
-						instanceStatusString = 'Instance okay';
+						instanceStatusString = 'Instanz okay';
 					} else {
 						// Attempt 3/3 - after 20 seconds in total
 						await this.wait(10000);
-						if (connectedHostVal && connectedDeviceVal) {
-							isAlive = true;
+						isDeviceConnected = await this.getInitValue(isDeviceConnctedPath);
+						isHostConnected = await this.getInitValue(hostConnectedPath);
+
+						if (isHostConnected && isDeviceConnected) {
 							isHealthy = true;
-							instanceStatusString = 'Instance okay';
+							instanceStatusString = 'Instanz okay';
 						} else {
-							if (!connectedDeviceVal) {
-								instanceStatusString = 'not connected to Device';
-								isAlive = true;
+							if (!isDeviceConnected) {
+								instanceStatusString = 'Nicht verbunden mit Gerät oder Dienst';
 								isHealthy = false;
-							} else if (!connectedHostVal) {
-								instanceStatusString = 'not connected to host';
-								isAlive = true;
+							} else if (!isHostConnected) {
+								instanceStatusString = 'Nicht verbunden mit Host';
 								isHealthy = false;
 							}
 						}
@@ -1911,27 +2090,44 @@ class DeviceWatcher extends utils.Adapter {
 		return [instanceStatusString, isAlive, isHealthy];
 	}
 
-	async createAdapterUpdateData() {
-		const adapterUpdateListDP = `admin.*.info.updatesJson`;
+	/**
+	 * 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.clear();
 		const adapterUpdatesListVal = await this.getForeignStatesAsync(adapterUpdateListDP);
 
-		// subscribe to datapoint
-		this.subscribeForeignStates(adapterUpdateListDP);
 		let adapterJsonList;
+		let adapterUpdatesJsonPath;
 
 		for (const [id] of Object.entries(adapterUpdatesListVal)) {
-			adapterJsonList = await this.parseData(adapterUpdatesListVal[id].val);
+			adapterJsonList = this.parseData(adapterUpdatesListVal[id].val);
+			adapterUpdatesJsonPath = id;
 		}
 
 		for (const [id] of Object.entries(adapterJsonList)) {
-			this.adapterUpdatesJsonRaw.push({
-				Path: adapterUpdateListDP,
-				Adapter: this.capitalize(id),
+			this.adapterUpdatesJsonRaw.set(this.capitalize(id), {
+				Path: adapterUpdatesJsonPath,
 				newVersion: adapterJsonList[id].availableVersion,
 				oldVersion: adapterJsonList[id].installedVersion,
 			});
 		}
-		await this.createAdapterUpdateList();
+		return this.adapterUpdatesJsonRaw;
 	}
 
 	/**
@@ -1941,11 +2137,11 @@ class DeviceWatcher extends utils.Adapter {
 		this.listAdapterUpdates = [];
 		this.countAdapterUpdates = 0;
 
-		for (const adapter of this.adapterUpdatesJsonRaw) {
+		for (const [adapter, updateData] of this.adapterUpdatesJsonRaw) {
 			this.listAdapterUpdates.push({
-				Adapter: adapter.Adapter,
-				'Available Version': adapter.newVersion,
-				'Installed Version': adapter.oldVersion,
+				Adapter: adapter,
+				'Available Version': updateData.newVersion,
+				'Installed Version': updateData.oldVersion,
 			});
 		}
 		this.countAdapterUpdates = this.listAdapterUpdates.length;
@@ -1957,13 +2153,13 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	async writeAdapterUpdatesDPs() {
 		// Write Datapoints for counts
-		await this.setStateAsync(`adapterAndInstances.countAdapterUpdates`, { val: this.countAdapterUpdates, ack: true });
+		await this.setStateChangedAsync(`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 });
+		await this.setStateChangedAsync(`adapterAndInstances.listAdapterUpdates`, { val: JSON.stringify(this.listAdapterUpdates), ack: true });
 	}
 
 	/**
@@ -1975,7 +2171,7 @@ class DeviceWatcher extends utils.Adapter {
 		this.listErrorInstanceRaw = [];
 		this.listErrorInstance = [];
 
-		for (const instance of this.listInstanceRaw) {
+		for (const instance of this.listInstanceRaw.values()) {
 			// fill raw list
 			if (instance.isAlive && !instance.isHealthy) {
 				this.listErrorInstanceRaw.push({
@@ -1993,6 +2189,7 @@ class DeviceWatcher extends utils.Adapter {
 				Mode: instance.instanceMode,
 				Schedule: instance.schedule,
 				Version: instance.adapterVersion,
+				Updateable: instance.updateAvailable,
 				Status: instance.status,
 			});
 			if (!instance.isAlive) {
@@ -2034,25 +2231,25 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	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 });
+		await this.setStateChangedAsync(`adapterAndInstances.countAllInstances`, { val: this.countAllInstances, ack: true });
+		await this.setStateChangedAsync(`adapterAndInstances.countDeactivatedInstances`, { val: this.countDeactivatedInstances, ack: true });
 
 		// List all instances
-		await this.setStateAsync(`adapterAndInstances.listAllInstances`, { val: JSON.stringify(this.listAllInstances), ack: true });
+		await this.setStateChangedAsync(`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 });
+		await this.setStateChangedAsync(`adapterAndInstances.listDeactivatedInstances`, { val: JSON.stringify(this.listDeactivatedInstances), ack: true });
+		await this.setStateChangedAsync(`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 });
+		await this.setStateChangedAsync(`adapterAndInstances.listInstancesError`, { val: JSON.stringify(this.listErrorInstance), ack: true });
+		await this.setStateChangedAsync(`adapterAndInstances.countInstancesError`, { val: this.countErrorInstance, ack: true });
 	}
 
 	/**
@@ -2268,6 +2465,21 @@ class DeviceWatcher extends utils.Adapter {
 		});
 	}
 
+	/**
+	 * 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       =
 	=============================================*/
@@ -2337,6 +2549,25 @@ class DeviceWatcher extends utils.Adapter {
 			this.errorReporting('[sendNotification Whatsapp]', error);
 		}
 
+		// Signal
+		try {
+			if (this.config.instanceSignal) {
+				//first check if instance is living
+				const signalAliveState = await this.getInitValue('system.adapter.' + this.config.instanceSignal + '.alive');
+
+				if (!signalAliveState) {
+					this.log.warn('Signal instance is not running. Message could not be sent. Please check your instance configuration.');
+				} else {
+					await this.sendToAsync(this.config.instanceSignal, 'send', {
+						text: text,
+						phone: this.config.phoneSignal,
+					});
+				}
+			}
+		} catch (error) {
+			this.errorReporting('[sendNotification Signal]', error);
+		}
+
 		// Email
 		try {
 			if (this.config.instanceEmail) {
@@ -2418,539 +2649,378 @@ class DeviceWatcher extends utils.Adapter {
 		}
 	} // <-- End of sendNotification function
 
-	/*----------  Battery notifications ----------*/
+	/*---------- 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`;
-
-			this.log.info(msg + deviceList);
-			await this.setStateAsync('lastNotification', msg + deviceList, true);
-			await this.sendNotification(msg + deviceList);
-		} catch (error) {
-			this.errorReporting('[sendLowBatNoticiation]', error);
+				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':
+				if (this.countAdapterUpdates === 0) return;
+				objectData = this.listAdapterUpdates;
+				list = '';
+				for (const id of objectData) {
+					list = `${list}\n${id.Adapter}: v${id['Available Version']}`;
+				}
+				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}`);
 	}
 
-	/*----------  Offline/Online notifications ----------*/
-	/**
-	 * send message if an device is offline
-	 * @param {string} deviceName
-	 * @param {string} adapter
-	 * @param {string} status
-	 * @param {string} lastContact
-	 */
-	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
-
 	/**
-	 * send shedule message with offline devices
+	 * Notifications per user defined schedule
+	 * @param {string} type
 	 */
-	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
-		}
-
-		if (!isUnloaded) {
-			const cron = '10 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
-			schedule.scheduleJob(cron, () => {
-				try {
-					let deviceList = '';
+	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(', ')} ...`);
 
-					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})`;
-							}
+				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 (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 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
 				}
-			});
-		}
-	} //<--End of daily offline notification
-
-	/*---------- Device Updates notifications ----------*/
-	/**
-	 * 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}`);
+				this.log.debug(`Number of selected days for daily offline devices message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
 
-		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 sendDeviceUpdateNotificationsShedule() {
-		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
-		}
-
-		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.upgradableDevicesRaw) {
-						if (!this.blacklistNotify.includes(id.Path)) {
-							if (!this.config.showAdapterNameinMsg) {
-								deviceList = `${deviceList}\n${id.Device}`;
-							} else {
-								deviceList = `${deviceList}\n${id.Adapter}: ${id.Device}`;
-							}
+					for (const id of this.offlineDevicesRaw) {
+						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 Upgrade: ${deviceList}`);
-						this.setStateAsync('lastNotification', `Geräte Upgrade: ${deviceList}`, true);
-
-						this.sendNotification(`Geräte Upgrade:\n${deviceList}`);
-					}
-				} catch (error) {
-					this.errorReporting('[sendUpgradeNotificationsShedule]', error);
-				}
-			});
-		}
-	} //<--End of daily device updates notification
-
-	/*----------  Adapter Updates notifications ----------*/
-	/**
-	 * check if adapter updates are available and send notification
-	 * @param {string} id
-	 * @param {ioBroker.State | null | undefined} state
-	 */
-	async sendAdapterUpdatesNotification(id, state) {
-		this.log.debug(`Start the function: ${this.sendAdapterUpdatesNotification.name}`);
 
-		try {
-			if (state && state !== undefined) {
-				const list = await this.parseData(state.val);
-				let msg = '';
-				let adapterList = '';
-
-				for (const [id] of Object.entries(list)) {
-					adapterList = `${adapterList}\n${this.capitalize(id)} - Version: ${list[id].availableVersion}`;
-				}
-				if (adapterList.length !== 0) {
-					msg = `Neue Adapter Updates vorhanden: \n`;
-
-					this.log.info(msg + adapterList);
-					await this.setStateAsync('lastNotification', msg + adapterList, true);
-					await this.sendNotification(msg + adapterList);
+					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
 				}
-			}
-		} catch (error) {
-			this.errorReporting('[sendAdapterUpdatesNotification]', error);
-		}
-		this.log.debug(`Finished the function: ${this.sendAdapterUpdatesNotification.name}`);
-	}
-
-	/**
-	 * send shedule message with  list of updatable adapters
-	 */
-	async sendAdapterUpdatesNotificatioShedule() {
-		const time = this.config.checkSendAdapterUpdateTime.split(':');
-
-		const checkDays = []; // list of selected days
-
-		// 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);
-
-		if (checkDays.length >= 1) {
-			// check if an day is selected
-			this.log.debug(`Number of selected days for daily adapter update message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
-		} else {
-			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 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);
-
-						this.sendNotification(`Geräte Upgrade:\n${deviceList}`);
-					}
-				} catch (error) {
-					this.errorReporting('[sendUpgradeNotificationsShedule]', error);
+					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
 				}
-			});
-		}
-	} //<--End of daily offline notification
-
-	/*---------- Instance error notifications ----------*/
-	/**
-	 * check if device updates are available and send notification
-	 * @param {string} instanceName
-	 * @param {string} error
-	 **/
-	async sendInstanceErrorNotification(instanceName, error) {
-		this.log.debug(`Start the function: ${this.sendInstanceErrorNotification.name}`);
-
-		try {
-			let msg = '';
-			let instanceList = '';
-
-			instanceList = `${instanceList}\n${instanceName}: ${error}`;
+				this.log.debug(`Number of selected days for daily adapter update message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
 
-			msg = `Fehler einer Instanz entdeckt: \n`;
+				cron = '4 ' + time[1] + ' ' + time[0] + ' * * ' + checkDays;
+				schedule.scheduleJob(cron, () => {
+					list = '';
 
-			this.log.info(msg + instanceList);
-			await this.setStateAsync('lastNotification', msg + instanceList, true);
-			await this.sendNotification(msg + instanceList);
-		} catch (error) {
-			this.errorReporting('[sendInstanceErrorNotification]', error);
-		}
-		this.log.debug(`Finished the function: ${this.sendInstanceErrorNotification.name}`);
-	}
-
-	/**
-	 * send shedule message with offline devices
-	 */
-	async sendInstanceErrorNotificationShedule() {
-		const time = this.config.checkSendInstanceFailedTime.split(':');
-
-		const checkDays = []; // list of selected days
-
-		// 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);
-
-		if (checkDays.length >= 1) {
-			// check if an day is selected
-			this.log.debug(`Number of selected days for daily instance error message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
-		} else {
-			this.log.warn(`No days selected for daily instance error 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 instanceList = '';
-
-					for (const id of this.listErrorInstanceRaw) {
-						if (!this.blacklistInstancesNotify.includes(id.instanceAlivePath)) {
-							instanceList = `${instanceList}\n${id.Instance}: ${id.Status}`;
-						}
+					for (const id of this.listAdapterUpdates) {
+						list = `${list}\n${id.Adapter}: v${id['Available Version']}`;
 					}
-					if (instanceList.length > 0) {
-						this.log.info(`Instanz Fehler: ${instanceList}`);
-						this.setStateAsync('lastNotification', `Instanz Fehler: ${instanceList}`, true);
+					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 = '';
 
-						this.sendNotification(`Instanz Fehler:\n${instanceList}`);
+					for (const id of this.listErrorInstanceRaw) {
+						if (this.blacklistInstancesNotify.includes(id.instanceAlivePath)) continue;
+						list = `${list}\n${id.Instance}: ${id.Status}`;
 					}
-				} catch (error) {
-					this.errorReporting('[sendInstanceErrorNotificationShedule]', error);
-				}
-			});
+					if (list.length === 0) return;
+					message = `Tägliche Meldung über fehlerhafte Instanzen: ${list}`;
+					setMessage(message);
+				});
+				break;
 		}
-	} //<--End of daily device updates 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;
+
+			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>';
+				html += '</table>';
+				break;
+		}
 		return html;
 	}
 
@@ -3041,6 +3111,30 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
+		await this.setObjectNotExistsAsync(`devices.${adptName}.listAllRawJSON`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'JSON RAW List of all devices',
+					de: 'JSON RAW Liste aller Geräte',
+					ru: 'ДЖСОН РАВ Список всех устройств',
+					pt: 'JSON RAW Lista de todos os dispositivos',
+					nl: 'JSON RAW List van alle apparaten',
+					fr: 'JSON RAW Liste de tous les dispositifs',
+					it: 'JSON RAW Elenco di tutti i dispositivi',
+					es: 'JSON RAW Lista de todos los dispositivos',
+					pl: 'JSON RAW Lista wszystkich urządzeń',
+					uk: 'ДЖСОН РАВ Список всіх пристроїв',
+					'zh-cn': 'JSONRAW 所有装置清单',
+				},
+				type: 'array',
+				role: 'json',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+
 		await this.setObjectNotExistsAsync(`devices.${adptName}.listAll`, {
 			type: 'state',
 			common: {
@@ -3302,6 +3396,30 @@ 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}.listAllRawJSON`);
+		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) {
@@ -3406,6 +3524,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   	          =
 	=============================================*/
@@ -3421,20 +3558,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;
+			}
 		}
 	}
 
@@ -3459,7 +3603,7 @@ 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);
@@ -3467,12 +3611,11 @@ class DeviceWatcher extends utils.Adapter {
 	}
 
 	/**
-	 * @param {number} time
+	 * @param {number} ms
 	 */
-	async wait(time) {
-		return new Promise((resolve) => {
-			setTimeout(resolve, time);
-		});
+	async wait(ms) {
+		if (isUnloaded) return;
+		return new Promise((resolve) => setTimeout(resolve, ms));
 	}
 
 	/**
@@ -3481,7 +3624,7 @@ class DeviceWatcher extends utils.Adapter {
 	 * Inspired by https://stackoverflow.com/questions/68134104/
 	 * @param {string} lastCronRun
 	 */
-	async getPreviousCronRun(lastCronRun) {
+	getPreviousCronRun(lastCronRun) {
 		try {
 			const interval = cronParser.parseExpression(lastCronRun);
 			const previous = interval.prev();
@@ -3516,11 +3659,14 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	onUnload(callback) {
 		try {
+			this.log.debug('clearing timeouts');
+
+			isUnloaded = true;
+
 			if (this.refreshDataTimeout) {
-				this.log.debug('clearing refresh timeout');
-				this.clearTimeout(this.refreshDataTimeout);
+				clearTimeout(this.refreshDataTimeout);
+				this.refreshDataTimeout = null;
 			}
-			isUnloaded = true;
 
 			this.log.info('cleaned everything up...');