iobroker.device-watcher 2.6.0 → 2.7.0

package/main.js

@@ -27,17 +27,19 @@ class DeviceWatcher extends utils.Adapter {
 		// instances and adapters
 		// raw arrays
 		this.listInstanceRaw = new Map();
-		this.adapterUpdatesJsonRaw = [];
+		this.adapterUpdatesJsonRaw = new Map();
 		this.listErrorInstanceRaw = [];
 
 		// user arrays
 		this.listAllInstances = [];
+		this.listAllActiveInstances = [];
 		this.listDeactivatedInstances = [];
 		this.listAdapterUpdates = [];
 		this.listErrorInstance = [];
 
 		//counts
 		this.countAllInstances = 0;
+		this.countAllActiveInstances = 0;
 		this.countDeactivatedInstances = 0;
 		this.countAdapterUpdates = 0;
 		this.countErrorInstance = 0;
@@ -50,11 +52,12 @@ class DeviceWatcher extends utils.Adapter {
 		this.upgradableDevicesRaw = [];
 
 		// arrays
+		this.listAllDevicesUserRaw = [];
+		this.listAllDevices = [];
 		this.offlineDevices = [];
 		this.linkQualityDevices = [];
 		this.batteryPowered = [];
 		this.batteryLowPowered = [];
-		this.listAllDevices = [];
 		this.selAdapter = [];
 		this.adapterSelected = [];
 		this.upgradableList = [];
@@ -77,6 +80,9 @@ class DeviceWatcher extends utils.Adapter {
 		this.blacklistAdapterLists = [];
 		this.blacklistNotify = [];
 
+		// Timelist instances
+		this.userTimeInstancesList = new Map();
+
 		// Interval timer
 		this.refreshDataTimeout = null;
 
@@ -93,119 +99,124 @@ 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,
-				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,
-				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,
-			};
+		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,
+			fullyMQTT: this.config.fullyMQTTDevices,
+			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,
+			fullyMQTT: this.config.fullyMQTTMaxMinutes,
+			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));
 				}
 			}
 
@@ -223,17 +234,20 @@ class DeviceWatcher extends utils.Adapter {
 			//create Blacklist
 			await this.createBlacklist();
 
+			// create user defined list with time of error for instances
+			await this.createTimeListInstances();
+
 			//create datapoints for each adapter if selected
 			for (const [id] of Object.entries(arrApart)) {
 				try {
-					if (!this.createOwnFolder) {
+					if (!this.configCreateOwnFolder) {
 						await this.deleteDPsForEachAdapter(id);
 						await this.deleteHtmlListDatapoints(id);
 					} else {
 						if (this.configSetAdapter && this.configSetAdapter[id]) {
 							await this.createDPsForEachAdapter(id);
 							// create HTML list datapoints
-							if (!this.createHtmlList) {
+							if (!this.configCreateHtmlList) {
 								await this.deleteHtmlListDatapoints(id);
 							} else {
 								await this.createHtmlListDatapoints(id);
@@ -247,25 +261,28 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			// create HTML list datapoints
-			if (!this.createHtmlList) {
+			if (!this.configCreateHtmlList) {
 				await this.deleteHtmlListDatapoints();
+				await this.deleteHtmlListDatapointsInstances();
 			} else {
 				await this.createHtmlListDatapoints();
+				if (this.config.checkAdapterInstances) await this.createHtmlListDatapointsInstances();
 			}
+			if (!this.config.checkAdapterInstances) await this.deleteHtmlListDatapointsInstances();
 
 			// read data first at start
 			// devices
 			await this.main();
 
 			// instances and adapters
-			if (!this.config.checkAdapterInstances) {
-				await this.deleteDPsForInstances();
-			} else {
+			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
@@ -301,27 +318,41 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	async onObjectChange(id, obj) {
 		if (obj) {
-			// The object was changed
-			//this.log.warn(`object ${id} changed: ${JSON.stringify(obj)}`);
-
-			//read new instance data and add it to the lists
-			await this.getInstanceData(id);
+			try {
+				// The object was changed
+				//this.log.debug(`object ${id} changed: ${JSON.stringify(obj)}`);
 
-			//read devices data and renew the lists
-			await this.main();
+				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 {
-			// The object was deleted
-			//this.log.warn(`object ${id} deleted`);
+			try {
+				// The object was deleted
+				this.log.info(`object ${id} deleted`);
 
-			// delete instance data in map
-			this.listInstanceRaw.delete(id);
+				// delete instance data in map
+				if (this.listInstanceRaw.has(id)) {
+					this.listInstanceRaw.delete(id);
+				}
 
-			// delete device data in map
-			this.listAllDevicesRaw.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);
+				//unsubscribe of Objects and states
+				this.unsubscribeForeignObjects(id);
+				this.unsubscribeForeignStates(id);
+			} catch (error) {
+				this.log.error(`Issue at object deletion: ${error}`);
+			}
 		}
 	}
 
@@ -332,9 +363,10 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	async onStateChange(id, state) {
 		// Admin JSON for Adapter updates
-		if (id && state) {
+		if (state) {
 			// this.log.debug(`State changed: ${id} changed ${state.val}`);
 			let batteryData;
+			let signalData;
 			let oldLowBatState;
 			let contactData;
 			let oldStatus;
@@ -342,192 +374,212 @@ class DeviceWatcher extends utils.Adapter {
 			let instanceStatusRaw;
 			let oldInstanceHostState;
 			let oldInstanceDeviceState;
+			let oldAdapterUpdatesCounts;
 
-			for (const adapter of this.adapterUpdatesJsonRaw) {
-				switch (id) {
-					case adapter.Path:
-						await this.getAdapterUpdateData(id);
-						await this.createAdapterUpdateList();
-						if (this.config.checkSendAdapterUpdateMsg) {
-							await this.sendStateNotifications('updateAdapter', null);
+			try {
+				if (id.endsWith('updatesJson')) {
+					oldAdapterUpdatesCounts = this.countAdapterUpdates;
+					await this.getAdapterUpdateData(id);
+					await this.createAdapterUpdateList();
+					if (this.config.checkSendAdapterUpdateMsg && this.countAdapterUpdates > oldAdapterUpdatesCounts) {
+						await this.sendStateNotifications('updateAdapter', null);
+					}
+					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 = ' - ';
 						}
+					}
 				}
-			}
 
-			for (const [instance, instanceData] of this.listInstanceRaw) {
-				switch (id) {
-					case instanceData.instanceAlivePath:
-						if (state.val !== instanceData.isAlive) {
-							instanceStatusRaw = await this.setInstanceStatus(
-								instanceData.instanceMode,
-								instanceData.schedule,
-								instanceData.instanceAlivePath,
-								instanceData.connectedHostPath,
-								instanceData.connectedDevicePath,
-							);
-							instanceData.isAlive = instanceStatusRaw[1];
-							instanceData.status = instanceStatusRaw[0];
-							instanceData.isHealthy = instanceStatusRaw[2];
-						}
-						break;
-					case instanceData.connectedHostPath:
-						oldInstanceHostState = instanceData.isConnectedHost;
-						instanceData.isConnectedHost = state.val;
-						if (oldInstanceHostState !== instanceData.isConnectedHost) {
-							instanceStatusRaw = await this.setInstanceStatus(
-								instanceData.instanceMode,
-								instanceData.schedule,
-								instanceData.instanceAlivePath,
-								instanceData.connectedHostPath,
-								instanceData.connectedDevicePath,
-							);
-							instanceData.isAlive = instanceStatusRaw[1];
-							instanceData.status = instanceStatusRaw[0];
-							instanceData.isHealthy = instanceStatusRaw[2];
-
-							if (!instanceData.isAlive) continue;
-							if (this.config.checkSendInstanceFailedMsg && !this.blacklistInstancesNotify.includes(instanceData.instanceAlivePath)) {
-								if (!instanceData.isHealthy) {
-									await this.sendStateNotifications('errorInstance', instance);
+				for (const [instance, instanceData] of this.listInstanceRaw) {
+					switch (id) {
+						case instanceData.instanceAlivePath:
+							if (state.val !== instanceData.isAlive) {
+								instanceStatusRaw = await this.setInstanceStatus(
+									instanceData.instanceMode,
+									instanceData.schedule,
+									instanceData.instanceAlivePath,
+									instanceData.connectedHostPath,
+									instanceData.connectedDevicePath,
+								);
+								instanceData.isAlive = instanceStatusRaw[1];
+								instanceData.status = instanceStatusRaw[0];
+								instanceData.isHealthy = instanceStatusRaw[2];
+							}
+							break;
+						case instanceData.connectedHostPath:
+							oldInstanceHostState = instanceData.isConnectedHost;
+							instanceData.isConnectedHost = state.val;
+							if (oldInstanceHostState !== instanceData.isConnectedHost) {
+								instanceStatusRaw = await this.setInstanceStatus(
+									instanceData.instanceMode,
+									instanceData.schedule,
+									instanceData.instanceAlivePath,
+									instanceData.connectedHostPath,
+									instanceData.connectedDevicePath,
+								);
+								instanceData.isAlive = instanceStatusRaw[1];
+								instanceData.status = instanceStatusRaw[0];
+								instanceData.isHealthy = instanceStatusRaw[2];
+
+								if (!instanceData.isAlive) continue;
+								if (this.config.checkSendInstanceFailedMsg && !this.blacklistInstancesNotify.includes(instanceData.instanceAlivePath)) {
+									if (!instanceData.isHealthy) {
+										await this.sendStateNotifications('errorInstance', instance);
+									}
 								}
 							}
-						}
-						break;
-					case instanceData.connectedDevicePath:
-						oldInstanceDeviceState = instanceData.isConnectedDevice;
-						instanceData.isConnectedDevice = state.val;
-						if (oldInstanceDeviceState !== instanceData.isConnectedDevice) {
-							instanceStatusRaw = await this.setInstanceStatus(
-								instanceData.instanceMode,
-								instanceData.schedule,
-								instanceData.instanceAlivePath,
-								instanceData.connectedHostPath,
-								instanceData.connectedDevicePath,
-							);
-							instanceData.isAlive = instanceStatusRaw[1];
-							instanceData.status = instanceStatusRaw[0];
-							instanceData.isHealthy = instanceStatusRaw[2];
-
-							if (!instanceData.isAlive) continue;
-							if (this.config.checkSendInstanceFailedMsg && !this.blacklistInstancesNotify.includes(instanceData.instanceAlivePath)) {
-								if (!instanceData.isHealthy) {
-									await this.sendStateNotifications('errorInstance', instance);
+							break;
+						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;
+							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;
+				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 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);
+						case deviceData.UpdateDP:
+							if (state.val !== deviceData.Upgradable) {
+								deviceData.Upgradable = state.val;
+								if (state.val === true || state.val === 1) {
+									if (this.config.checkSendDeviceUpgrade && !this.blacklistNotify.includes(deviceData.Path)) {
+										await this.sendStateNotifications('updateDevice', device);
+									}
 								}
 							}
-						}
-						break;
+							break;
 
-					case deviceData.SignalStrengthDP:
-						deviceData.SignalStrength = await this.calculateSignalStrength(state, deviceData.adapterID);
-						break;
+						case deviceData.SignalStrengthDP:
+							signalData = await this.calculateSignalStrength(state, deviceData.adapterID);
+							deviceData.SignalStrength = signalData[0];
 
-					case deviceData.batteryDP:
-						if (deviceData.isBatteryDevice) {
-							oldLowBatState = deviceData.LowBat;
-							batteryData = await this.getBatteryData(state.val, oldLowBatState, deviceData.adapterID);
+							break;
 
-							deviceData.Battery = batteryData[0];
-							deviceData.BatteryRaw = batteryData[2];
-							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);
+						case deviceData.batteryDP:
+							if (deviceData.isBatteryDevice) {
+								oldLowBatState = deviceData.LowBat;
+								batteryData = await this.getBatteryData(state.val, oldLowBatState, deviceData.faultReport, deviceData.adapterID);
 
-							if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
-								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
-									await this.sendStateNotifications('lowBatDevice', device);
+								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 (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
+									if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
+										await this.sendStateNotifications('lowBatDevice', device);
+									}
 								}
 							}
-						}
-						break;
+							break;
 
-					case deviceData.LowBatDP:
-						if (deviceData.isBatteryDevice) {
-							oldLowBatState = deviceData.LowBat;
-							batteryData = await this.getBatteryData(deviceData.BatteryRaw, state.val, deviceData.adapterID);
-							deviceData.Battery = batteryData[0];
-							deviceData.BatteryRaw = batteryData[2];
-							deviceData.LowBat = await this.setLowbatIndicator(deviceData.BatteryRaw, state.val, deviceData.faultReport, deviceData.adapterID);
-
-							if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
-								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
-									await this.sendStateNotifications('lowBatDevice', device);
+						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 deviceData.faultReportDP:
-						if (deviceData.isBatteryDevice) {
-							oldLowBatState = deviceData.LowBat;
-							batteryData = await this.getBatteryData(deviceData.BatteryRaw, oldLowBatState, deviceData.adapterID);
+						case deviceData.faultReportDP:
+							if (deviceData.isBatteryDevice) {
+								oldLowBatState = deviceData.LowBat;
+								batteryData = await this.getBatteryData(deviceData.BatteryRaw, oldLowBatState, state.val, deviceData.adapterID);
 
-							deviceData.Battery = batteryData[0];
-							deviceData.BatteryRaw = batteryData[2];
-							deviceData.LowBat = await this.setLowbatIndicator(deviceData.BatteryRaw, undefined, state.val, deviceData.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 (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
-								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
-									await this.sendStateNotifications('lowBatDevice', device);
+								if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
+									if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
+										await this.sendStateNotifications('lowBatDevice', device);
+									}
 								}
 							}
-						}
-						break;
+							break;
 
-					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];
-						}
-						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)) {
+						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];
+							}
+							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);
 								}
-							} 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`);
 		}
 	}
 
@@ -537,6 +589,7 @@ class DeviceWatcher extends utils.Adapter {
 	onMessage(obj) {
 		const devices = [];
 		const instances = [];
+		const instancesTime = [];
 		let countDevices = 0;
 		let countInstances = 0;
 
@@ -562,10 +615,8 @@ 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);
 				}
 				break;
 
@@ -590,10 +641,33 @@ 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]', error);
+					}
+				}
+				break;
+			case 'instancesListTime':
+				if (obj.message) {
+					try {
+						for (const instanceData of this.listInstanceRaw.values()) {
+							const label = `${instanceData.Adapter}: ${instanceData.InstanceName}`;
+							const valueObjectInstances = {
+								adapter: instanceData.Adapter,
+								instanceName: instanceData.InstanceName,
+								path: instanceData.instanceAlivePath,
+							};
+							instancesTime[countInstances] = { label: label, value: JSON.stringify(valueObjectInstances) };
+							countInstances++;
+						}
+						const sortInstances = instancesTime.slice(0);
+						sortInstances.sort(function (a, b) {
+							const x = a.label;
+							const y = b.label;
+							return x < y ? -1 : x > y ? 1 : 0;
+						});
+						this.sendTo(obj.from, obj.command, sortInstances, obj.callback);
+					} catch (error) {
+						this.errorReporting('[onMessage - instanceList]', error);
 					}
-				} else {
-					this.sendTo(obj.from, obj.command, obj.callback);
 				}
 				break;
 		}
@@ -618,7 +692,7 @@ class DeviceWatcher extends utils.Adapter {
 		}
 
 		// fill datapoints for each adapter if selected
-		if (this.createOwnFolder) {
+		if (this.configCreateOwnFolder) {
 			try {
 				for (const [id] of Object.entries(arrApart)) {
 					if (this.configSetAdapter && this.configSetAdapter[id]) {
@@ -644,13 +718,16 @@ 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 && this.configSetAdapter[id]) {
 					await this.createLists(id);
@@ -660,26 +737,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);
+			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 = this.setTimeout(() => {
+			this.log.debug('Updating Data');
+			this.refreshData();
+		}, nextTimeout);
 	} // <-- refreshData end
 
 	/**
@@ -690,277 +763,327 @@ class DeviceWatcher extends utils.Adapter {
 
 		// DEVICES
 		const myBlacklist = this.config.tableBlacklist;
-
-		for (const i in myBlacklist) {
-			try {
-				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);
-				}
-				if (myBlacklist[i].checkIgnorAdapterLists) {
-					this.blacklistAdapterLists.push(blacklistParse.path);
-				}
-				// push devices in list to ignor device in notifications
-				if (myBlacklist[i].checkIgnorNotify) {
-					this.blacklistNotify.push(blacklistParse.path);
+		if (myBlacklist.length >= 1) {
+			for (const i in myBlacklist) {
+				try {
+					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);
+					}
+					if (myBlacklist[i].checkIgnorAdapterLists) {
+						this.blacklistAdapterLists.push(blacklistParse.path);
+					}
+					// push devices in list to ignor device in notifications
+					if (myBlacklist[i].checkIgnorNotify) {
+						this.blacklistNotify.push(blacklistParse.path);
+					}
+				} catch (error) {
+					this.errorReporting('[createBlacklist]', error);
 				}
-			} catch (error) {
-				this.errorReporting('[createBlacklist]', error);
+				if (this.blacklistLists.length >= 1) this.log.info(`Found devices/services on blacklist for lists: ${this.blacklistLists}`);
+				if (this.blacklistAdapterLists.length >= 1) this.log.info(`Found devices/services on blacklist for lists: ${this.blacklistAdapterLists}`);
+				if (this.blacklistNotify.length >= 1) this.log.info(`Found devices/services on blacklist for notifications: ${this.blacklistNotify}`);
 			}
 		}
 
-		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 notifications: ${this.blacklistNotify}`);
-
 		// INSTANCES
 		const myBlacklistInstances = this.config.tableBlacklistInstances;
-
-		for (const i in myBlacklistInstances) {
-			try {
-				const blacklistParse = this.parseData(myBlacklistInstances[i].instances);
-				// push devices in list to ignor device in lists
-				if (myBlacklistInstances[i].checkIgnorLists) {
-					this.blacklistInstancesLists.push(blacklistParse.path);
-				}
-				// push devices in list to ignor device in notifications
-				if (myBlacklistInstances[i].checkIgnorNotify) {
-					this.blacklistInstancesNotify.push(blacklistParse.path);
+		if (myBlacklistInstances.length >= 1) {
+			for (const i in myBlacklistInstances) {
+				try {
+					const blacklistParse = this.parseData(myBlacklistInstances[i].instances);
+					// push devices in list to ignor device in lists
+					if (myBlacklistInstances[i].checkIgnorLists) {
+						this.blacklistInstancesLists.push(blacklistParse.path);
+					}
+					// push devices in list to ignor device in notifications
+					if (myBlacklistInstances[i].checkIgnorNotify) {
+						this.blacklistInstancesNotify.push(blacklistParse.path);
+					}
+				} catch (error) {
+					this.errorReporting('[createBlacklist]', error);
 				}
-			} catch (error) {
-				this.errorReporting('[createBlacklist]', error);
 			}
+			if (this.blacklistInstancesLists.length >= 1) this.log.info(`Found instances items on blacklist for lists: ${this.blacklistInstancesLists}`);
+			if (this.blacklistInstancesNotify.length >= 1) this.log.info(`Found instances items on blacklist for notifications: ${this.blacklistInstancesNotify}`);
 		}
-
-		if (this.blacklistInstancesLists.length >= 1) this.log.info(`Found items on blacklist for lists: ${this.blacklistInstancesLists}`);
-		if (this.blacklistInstancesNotify.length >= 1) this.log.info(`Found items on blacklist for notifications: ${this.blacklistInstancesNotify}`);
-
 		this.log.debug(`Function finished: ${this.createBlacklist.name}`);
 	}
 
+	/**
+	 * create list with time for instances
+	 */
+	async createTimeListInstances() {
+		// INSTANCES
+		const userTimeListInstances = this.config.tableTimeInstance;
+		if (userTimeListInstances.length >= 1) {
+			for (const i in userTimeListInstances) {
+				try {
+					const userTimeListparse = this.parseData(userTimeListInstances[i].instancesTime);
+					// push devices in list to ignor device in lists
+					if (userTimeListInstances[i].errorTime) {
+						this.userTimeInstancesList.set(userTimeListparse.path, {
+							instanceName: userTimeListparse.instanceName,
+							errorTime: userTimeListInstances[i].errorTime,
+						});
+					}
+				} catch (error) {
+					this.errorReporting('[createTimeListInstances]', error);
+				}
+			}
+			if (this.userTimeInstancesList.size >= 1) this.log.info(`Found instances items on lists for timesettings: ${this.blacklistInstancesLists}`);
+		}
+	}
+
 	/**
 	 * @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);
-			this.subscribeForeignObjectsAsync(`${this.selAdapter[i].Selektor}`);
+				const instance = id.slice(0, id.indexOf('.') + 2);
+				if (id.endsWith('.')) continue; // ! Test - sometimes id's are wrong or has no name so break up here.
 
-			/*=============================================
+				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.subscribeForeignObjectsAsync(currDeviceString);
+				// 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);
-
-			const onlineState = await this.getOnlineState(timeSelector, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP);
-			let deviceState;
-			let lastContactString;
+				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);
+				}
 
-			if (onlineState) {
-				lastContactString = onlineState[0];
-				deviceState = onlineState[1];
-				linkQuality = onlineState[2];
-			}
+				// 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];
+				}
 
-			/*=============================================
+				/*=============================================
 			=            Get update data	              =
 			=============================================*/
-			const deviceUpdateDP = currDeviceString + this.selAdapter[i].upgrade;
-			let isUpgradable;
+				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) {
-					isUpgradable = true;
-				} else if (!deviceUpdateSelector) {
-					isUpgradable = false;
+					if (deviceUpdateSelector !== undefined) {
+						if (deviceUpdateSelector) {
+							isUpgradable = true;
+						} else if (!deviceUpdateSelector) {
+							isUpgradable = false;
+						}
+					} else {
+						isUpgradable = ' - ';
+					}
+
+					// subscribe to states
+					this.subscribeForeignStates(deviceUpdateDP);
 				}
-				// subscribe to states
-				this.subscribeForeignStates(deviceUpdateDP);
-			}
 
-			/*=============================================
+				/*=============================================
 				=          		  Fill Raw Lists          	  =
 				=============================================*/
-			const setupList = () => {
-				this.listAllDevicesRaw.set(currDeviceString, {
-					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,
-				});
-			};
+				const setupList = () => {
+					this.listAllDevicesRaw.set(currDeviceString, {
+						Path: id,
+						instanceDeviceConnectionDP: instanceDeviceConnectionDP,
+						instancedeviceConnected: instancedeviceConnected,
+						instance: instance,
+						Device: deviceName,
+						adapterID: adapterID,
+						Adapter: adapter,
+						timeSelector: timeSelector,
+						isBatteryDevice: isBatteryDevice,
+						Battery: batteryHealth,
+						BatteryRaw: batteryHealthRaw,
+						BatteryUnitRaw: batteryUnitRaw,
+						batteryDP: deviceBatteryStateDP,
+						LowBat: lowBatIndicator,
+						LowBatDP: isLowBatDP,
+						faultReport: faultReportingState,
+						faultReportDP: faultReportingDP,
+						SignalStrengthDP: deviceQualityDP,
+						SignalStrength: linkQuality,
+						SignalStrengthRaw: linkQualityRaw,
+						UnreachState: deviceUnreachState,
+						UnreachDP: unreachDP,
+						DeviceStateSelectorDP: deviceStateSelectorDP,
+						rssiPeerSelectorDP: rssiPeerSelectorDP,
+						LastContact: lastContactString,
+						Status: deviceState,
+						UpdateDP: deviceUpdateDP,
+						Upgradable: isUpgradable,
+					});
+				};
 
-			if (!this.listOnlyBattery) {
-				// Add all devices
-				setupList();
-			} else {
-				// Add only devices with battery in the rawlist
-				if (!isBatteryDevice) continue;
-				setupList();
-			}
-		} // <-- end of loop
+				if (!this.configListOnlyBattery) {
+					// Add all devices
+					setupList();
+				} else {
+					// Add only devices with battery in the rawlist
+					if (!isBatteryDevice) continue;
+					setupList();
+				}
+			} // <-- end of loop
+		} catch (error) {
+			this.errorReporting('[createData - create data of devices]', error);
+		}
 	} // <-- end of createData
 
 	/*=============================================
@@ -972,11 +1095,13 @@ class DeviceWatcher extends utils.Adapter {
 	 * @param {object} i - each Device
 	 */
 	async getDeviceName(id, i) {
-		const currDeviceString = id.slice(0, id.lastIndexOf('.') + 1 - 1);
-		const shortCurrDeviceString = currDeviceString.slice(0, currDeviceString.lastIndexOf('.') + 1 - 1);
-		const shortshortCurrDeviceString = shortCurrDeviceString.slice(0, shortCurrDeviceString.lastIndexOf('.') + 1 - 1);
-
 		try {
+			//id = id.replace(/[\]\\[.*,;'"`<>\\\s?]/g, '-');
+
+			const currDeviceString = id.slice(0, id.lastIndexOf('.') + 1 - 1);
+			const shortCurrDeviceString = currDeviceString.slice(0, currDeviceString.lastIndexOf('.') + 1 - 1);
+			const shortshortCurrDeviceString = shortCurrDeviceString.slice(0, shortCurrDeviceString.lastIndexOf('.') + 1 - 1);
+
 			// Get device name
 			const deviceObject = await this.getForeignObjectAsync(currDeviceString);
 			const shortDeviceObject = await this.getForeignObjectAsync(shortCurrDeviceString);
@@ -1062,6 +1187,7 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	async calculateSignalStrength(deviceQualityState, adapterID) {
 		let linkQuality;
+		let linkQualityRaw;
 		let mqttNukiValue;
 
 		if (deviceQualityState != null) {
@@ -1075,6 +1201,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;
@@ -1086,9 +1213,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;
 						}
@@ -1111,7 +1241,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;
@@ -1119,24 +1249,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 {
@@ -1152,6 +1291,7 @@ class DeviceWatcher extends utils.Adapter {
 					} else {
 						batteryHealth = deviceBatteryState + 'V';
 						batteryHealthRaw = deviceBatteryState;
+						batteryHealthUnitRaw = 'V';
 						isBatteryDevice = true;
 					}
 				}
@@ -1171,12 +1311,13 @@ class DeviceWatcher extends utils.Adapter {
 				} else {
 					batteryHealth = deviceBatteryState + '%';
 					batteryHealthRaw = deviceBatteryState;
+					batteryHealthUnitRaw = '%';
 					isBatteryDevice = true;
 				}
 				break;
 		}
 
-		return [batteryHealth, isBatteryDevice, batteryHealthRaw];
+		return [batteryHealth, isBatteryDevice, batteryHealthRaw, batteryHealthUnitRaw];
 	}
 
 	/**
@@ -1263,162 +1404,162 @@ class DeviceWatcher extends utils.Adapter {
 
 		try {
 			const deviceTimeSelector = await this.getForeignStateAsync(timeSelector);
-			if (deviceTimeSelector) {
-				const deviceUnreachSelector = await this.getForeignStateAsync(unreachDP);
-				const deviceStateSelector = await this.getForeignStateAsync(deviceStateSelectorDP); // for hmrpc devices
-				const rssiPeerSelector = await this.getForeignStateAsync(rssiPeerSelectorDP);
-				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) {
-					case 'none':
-						lastContactString = await this.getLastContact(deviceTimeSelector.ts);
-						break;
+			const deviceUnreachSelector = await this.getForeignStateAsync(unreachDP);
+			const deviceStateSelector = await this.getForeignStateAsync(deviceStateSelectorDP); // for hmrpc devices
+			const rssiPeerSelector = await this.getForeignStateAsync(rssiPeerSelectorDP);
+			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) {
+				case 'none':
+					if (deviceTimeSelector) lastContactString = await this.getLastContact(deviceTimeSelector.ts);
+					break;
 
-					default:
-						//State changed
-						if (adapterID === 'hmrpc') {
-							if (linkQuality !== ' - ') {
-								if (deviceUnreachState === 1) {
-									lastContactString = await this.getLastContact(deviceTimeSelector.lc);
-								} else {
-									lastContactString = await this.getLastContact(deviceTimeSelector.ts);
-								}
-							} else {
-								if (deviceStateSelector) {
-									// because old hm devices don't send rssi states
-									lastContactString = await this.getLastContact(deviceStateSelector.ts);
-								} else if (rssiPeerSelector) {
-									// because old hm sensors don't send rssi/state values
-									lastContactString = await this.getLastContact(rssiPeerSelector.ts);
-								}
-							}
-						} else {
-							if (deviceUnreachState === 0) {
+				default:
+					//State changed
+					if (adapterID === 'hmrpc') {
+						if (linkQuality !== ' - ' && deviceTimeSelector) {
+							if (deviceUnreachState === 1) {
 								lastContactString = await this.getLastContact(deviceTimeSelector.lc);
 							} else {
 								lastContactString = await this.getLastContact(deviceTimeSelector.ts);
 							}
-							break;
+						} else {
+							if (deviceStateSelector) {
+								// because old hm devices don't send rssi states
+								lastContactString = await this.getLastContact(deviceStateSelector.ts);
+							} else if (rssiPeerSelector) {
+								// because old hm sensors don't send rssi/state values
+								lastContactString = await this.getLastContact(rssiPeerSelector.ts);
+							}
 						}
-				}
+					} else {
+						if (deviceUnreachState === 0 && deviceTimeSelector) {
+							lastContactString = await this.getLastContact(deviceTimeSelector.lc);
+						} else {
+							if (deviceTimeSelector) lastContactString = await this.getLastContact(deviceTimeSelector.ts);
+						}
+						break;
+					}
+			}
 
-				/*=============================================
+			/*=============================================
 				=            Set Online Status             =
 				=============================================*/
-				if (this.configMaxMinutes !== undefined) {
-					switch (adapterID) {
-						case 'hmrpc':
-							if (this.configMaxMinutes[adapterID] <= 0) {
-								if (deviceUnreachState === 1) {
-									deviceState = 'Offline'; //set online state to offline
-									linkQuality = '0%'; // set linkQuality to nothing
-								}
-							} else if (lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID] && deviceUnreachState === 1) {
+			let lastContact;
+			if (deviceTimeSelector) lastContact = this.getTimestamp(deviceTimeSelector.ts);
+
+			if (this.configMaxMinutes !== undefined) {
+				switch (adapterID) {
+					case 'hmrpc':
+						if (this.configMaxMinutes[adapterID] <= 0) {
+							if (deviceUnreachState === 1) {
 								deviceState = 'Offline'; //set online state to offline
 								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') {
+						} else if (lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID] && deviceUnreachState === 1) {
+							deviceState = 'Offline'; //set online state to offline
+							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) {
+							if (deviceUnreachState) {
 								deviceState = 'Offline'; //set online state to offline
 								linkQuality = '0%'; // set linkQuality to nothing
 							}
-							break;
-						case 'hmiP':
-						case 'maxcube':
-							if (this.configMaxMinutes[adapterID] <= 0) {
-								if (deviceUnreachState) {
-									deviceState = 'Offline'; //set online state to offline
-									linkQuality = '0%'; // set linkQuality to nothing
-								}
-							} else if (lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID] && deviceUnreachState) {
+						} else if (lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID] && deviceUnreachState) {
+							deviceState = 'Offline'; //set online state to offline
+							linkQuality = '0%'; // set linkQuality to nothing
+						}
+						break;
+					case 'apcups':
+					case 'hue':
+					case 'hueExt':
+					case 'ping':
+					case 'deconz':
+					case 'shelly':
+					case 'sonoff':
+					case 'unifi':
+					case 'zigbee':
+					case 'zigbee2MQTT':
+						if (this.configMaxMinutes[adapterID] <= 0) {
+							if (!deviceUnreachState) {
 								deviceState = 'Offline'; //set online state to offline
 								linkQuality = '0%'; // set linkQuality to nothing
 							}
-							break;
-						case 'apcups':
-						case 'hue':
-						case 'hueExt':
-						case 'ping':
-						case 'deconz':
-						case 'shelly':
-						case 'sonoff':
-						case 'unifi':
-						case 'zigbee':
-						case 'zigbee2MQTT':
-							if (this.configMaxMinutes[adapterID] <= 0) {
-								if (!deviceUnreachState) {
-									deviceState = 'Offline'; //set online state to offline
-									linkQuality = '0%'; // set linkQuality to nothing
-								}
-							} else if (!deviceUnreachState && lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID]) {
+						} else if (!deviceUnreachState && lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID]) {
+							deviceState = 'Offline'; //set online state to offline
+							linkQuality = '0%'; // set linkQuality to nothing
+						}
+						break;
+					case 'mqttClientZigbee2Mqtt':
+						if (this.configMaxMinutes[adapterID] <= 0) {
+							if (deviceUnreachState !== 'online') {
 								deviceState = 'Offline'; //set online state to offline
 								linkQuality = '0%'; // set linkQuality to nothing
 							}
-							break;
-						case 'mqttClientZigbee2Mqtt':
+						} else if (deviceUnreachState !== 'online' && lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID]) {
+							deviceState = 'Offline'; //set online state to offline
+							linkQuality = '0%'; // set linkQuality to nothing
+						}
+						break;
+					case 'mihome':
+						if (deviceUnreachState !== undefined) {
 							if (this.configMaxMinutes[adapterID] <= 0) {
-								if (deviceUnreachState !== 'online') {
+								if (!deviceUnreachState) {
 									deviceState = 'Offline'; //set online state to offline
 									linkQuality = '0%'; // set linkQuality to nothing
 								}
-							} else if (deviceUnreachState !== 'online' && lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID]) {
+							} else if (lastContact && lastContact > this.configMaxMinutes[adapterID]) {
 								deviceState = 'Offline'; //set online state to offline
 								linkQuality = '0%'; // set linkQuality to nothing
 							}
-							break;
-						case 'mihome':
-							if (deviceUnreachState !== undefined) {
+						} else {
+							if (this.config.mihomeMaxMinutes <= 0) {
 								if (this.configMaxMinutes[adapterID] <= 0) {
-									if (!deviceUnreachState) {
-										deviceState = 'Offline'; //set online state to offline
-										linkQuality = '0%'; // set linkQuality to nothing
-									}
-								} else if (lastContact > this.configMaxMinutes[adapterID]) {
 									deviceState = 'Offline'; //set online state to offline
 									linkQuality = '0%'; // set linkQuality to nothing
 								}
-							} else {
-								if (this.config.mihomeMaxMinutes <= 0) {
-									if (this.configMaxMinutes[adapterID] <= 0) {
-										deviceState = 'Offline'; //set online state to offline
-										linkQuality = '0%'; // set linkQuality to nothing
-									}
-								} else if (lastContact > this.configMaxMinutes[adapterID]) {
-									deviceState = 'Offline'; //set online state to offline
-									linkQuality = '0%'; // set linkQuality to nothing
-								}
-							}
-							break;
-						case 'smartgarden':
-							if (this.configMaxMinutes[adapterID] <= 0) {
-								if (deviceUnreachState === 'OFFLINE') {
-									deviceState = 'Offline'; //set online state to offline
-									linkQuality = '0%'; // set linkQuality to nothing
-								}
-							} else if (deviceUnreachState === 'OFFLINE' && lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID]) {
+							} else if (lastContact && lastContact > this.configMaxMinutes[adapterID]) {
 								deviceState = 'Offline'; //set online state to offline
 								linkQuality = '0%'; // set linkQuality to nothing
 							}
-							break;
-						default:
-							if (this.configMaxMinutes[adapterID] <= 0) {
-								if (!deviceUnreachState) {
-									deviceState = 'Offline'; //set online state to offline
-									linkQuality = '0%'; // set linkQuality to nothing
-								}
-							} else if (lastContact > this.configMaxMinutes[adapterID]) {
+						}
+						break;
+					case 'smartgarden':
+						if (this.configMaxMinutes[adapterID] <= 0) {
+							if (deviceUnreachState === 'OFFLINE') {
 								deviceState = 'Offline'; //set online state to offline
 								linkQuality = '0%'; // set linkQuality to nothing
 							}
-							break;
-					}
+						} else if (deviceUnreachState === 'OFFLINE' && lastDeviceUnreachStateChange > this.configMaxMinutes[adapterID]) {
+							deviceState = 'Offline'; //set online state to offline
+							linkQuality = '0%'; // set linkQuality to nothing
+						}
+						break;
+					default:
+						if (this.configMaxMinutes[adapterID] <= 0) {
+							if (!deviceUnreachState) {
+								deviceState = 'Offline'; //set online state to offline
+								linkQuality = '0%'; // set linkQuality to nothing
+							}
+						} else if (lastContact && lastContact > this.configMaxMinutes[adapterID]) {
+							deviceState = 'Offline'; //set online state to offline
+							linkQuality = '0%'; // set linkQuality to nothing
+						}
+						break;
 				}
 			}
 			return [lastContactString, deviceState, linkQuality];
@@ -1463,6 +1604,7 @@ class DeviceWatcher extends utils.Adapter {
 		this.linkQualityDevices = [];
 		this.batteryPowered = [];
 		this.batteryLowPowered = [];
+		this.listAllDevicesUserRaw = [];
 		this.listAllDevices = [];
 		this.offlineDevices = [];
 		this.batteryLowPoweredRaw = [];
@@ -1496,7 +1638,7 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			// upgradable raw list
-			if (deviceData.Upgradable) {
+			if (deviceData.Upgradable === true) {
 				this.upgradableDevicesRaw.push({
 					Path: deviceData.Path,
 					Device: deviceData.Device,
@@ -1523,6 +1665,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,
@@ -1571,7 +1731,7 @@ class DeviceWatcher extends utils.Adapter {
 		}
 
 		// Device update List
-		if (device.Upgradable) {
+		if (device.Upgradable === true || device.Upgradable === 1) {
 			this.upgradableList.push({
 				Device: device.Device,
 				Adapter: device.Adapter,
@@ -1620,26 +1780,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,
 			});
@@ -1647,10 +1839,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,
 			});
@@ -1658,10 +1856,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,
 			});
@@ -1672,7 +1876,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,
 			});
@@ -1683,71 +1887,93 @@ 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`, {
+			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`, {
+				await this.setStateChangedAsync(`devices.${dpSubFolder}offlineListHTML`, {
 					val: await this.createListHTML('offlineList', this.offlineDevices, this.offlineDevicesCount, null),
 					ack: true,
 				});
-				await this.setStateAsync(`devices.${dpSubFolder}batteryListHTML`, {
+				await this.setStateChangedAsync(`devices.${dpSubFolder}batteryListHTML`, {
 					val: await this.createListHTML('batteryList', this.batteryPowered, this.batteryPoweredCount, false),
 					ack: true,
 				});
-				await this.setStateAsync(`devices.${dpSubFolder}lowBatteryListHTML`, {
+				await this.setStateChangedAsync(`devices.${dpSubFolder}lowBatteryListHTML`, {
 					val: await this.createListHTML('batteryList', this.batteryLowPowered, this.lowBatteryPoweredCount, true),
 					ack: true,
 				});
+				if (this.config.checkAdapterInstances) {
+					await this.setStateChangedAsync(`adapterAndInstances.HTML_Lists.listAllInstancesHTML`, {
+						val: await this.createListHTMLInstances('allInstancesList', this.listAllInstances, this.countAllInstances),
+						ack: true,
+					});
+					await this.setStateChangedAsync(`adapterAndInstances.HTML_Lists.listAllActiveInstancesHTML`, {
+						val: await this.createListHTMLInstances('allActiveInstancesList', this.listAllActiveInstances, this.countAllActiveInstances),
+						ack: true,
+					});
+					await this.setStateChangedAsync(`adapterAndInstances.HTML_Lists.listInstancesErrorHTML`, {
+						val: await this.createListHTMLInstances('errorInstanceList', this.listErrorInstance, this.countErrorInstance),
+						ack: true,
+					});
+					await this.setStateChangedAsync(`adapterAndInstances.HTML_Lists.listDeactivatedInstancesHTML`, {
+						val: await this.createListHTMLInstances('deactivatedInstanceList', this.listDeactivatedInstances, this.countDeactivatedInstances),
+						ack: true,
+					});
+					await this.setStateChangedAsync(`adapterAndInstances.HTML_Lists.listAdapterUpdatesHTML`, {
+						val: await this.createListHTMLInstances('updateAdapterList', this.listAdapterUpdates, this.countAdapterUpdates),
+						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);
 		}
@@ -1771,77 +1997,93 @@ class DeviceWatcher extends utils.Adapter {
 	 *@param {string} instanceObject
 	 */
 	async getInstanceData(instanceObject) {
-		const instanceAliveDP = await this.getForeignStatesAsync(`${instanceObject}.alive`);
+		try {
+			const instanceAliveDP = await this.getForeignStatesAsync(`${instanceObject}.alive`);
 
-		for (const [id] of Object.entries(instanceAliveDP)) {
-			if (!(typeof id === 'string' && id.startsWith(`system.adapter.`))) continue;
+			for (const [id] of Object.entries(instanceAliveDP)) {
+				if (!(typeof id === 'string' && id.startsWith(`system.adapter.`))) continue;
 
-			// get instance name
-			const instanceName = await this.getInstanceName(id);
+				// get instance name
+				const instanceName = await this.getInstanceName(id);
 
-			// get instance connected to host data
-			const instanceConnectedHostDP = `system.adapter.${instanceName}.connected`;
-			const instanceConnectedHostVal = await this.getInitValue(instanceConnectedHostDP);
+				// get instance connected to host data
+				const instanceConnectedHostDP = `system.adapter.${instanceName}.connected`;
+				const instanceConnectedHostVal = await this.getInitValue(instanceConnectedHostDP);
 
-			// get instance connected to device data
-			const instanceConnectedDeviceDP = `${instanceName}.info.connection`;
-			let instanceConnectedDeviceVal;
-			if (instanceConnectedDeviceDP !== undefined && typeof instanceConnectedDeviceDP === 'boolean') {
-				instanceConnectedDeviceVal = await this.getInitValue(instanceConnectedDeviceDP);
-			} else {
-				instanceConnectedDeviceVal = 'N/A';
-			}
+				// get instance connected to device data
+				const instanceConnectedDeviceDP = `${instanceName}.info.connection`;
+				let instanceConnectedDeviceVal;
+				if (instanceConnectedDeviceDP !== undefined && typeof instanceConnectedDeviceDP === 'boolean') {
+					instanceConnectedDeviceVal = await this.getInitValue(instanceConnectedDeviceDP);
+				} else {
+					instanceConnectedDeviceVal = 'N/A';
+				}
 
-			// get adapter version
-			const instanceObjectPath = `system.adapter.${instanceName}`;
-			let adapterName;
-			let adapterVersion;
-			let instanceMode;
-			let scheduleTime = 'N/A';
-			const instanceObjectData = await this.getForeignObjectAsync(instanceObjectPath);
-			if (instanceObjectData) {
-				// @ts-ignore
-				adapterName = this.capitalize(instanceObjectData.common.name);
-				adapterVersion = instanceObjectData.common.version;
-				instanceMode = instanceObjectData.common.mode;
-
-				if (instanceMode === 'schedule') {
-					scheduleTime = instanceObjectData.common.schedule;
+				// get adapter version
+				const instanceObjectPath = `system.adapter.${instanceName}`;
+				let adapterName;
+				let adapterVersion;
+				let adapterAvailableUpdate = '';
+				let instanceMode;
+				let scheduleTime = 'N/A';
+				const instanceObjectData = await this.getForeignObjectAsync(instanceObjectPath);
+				if (instanceObjectData) {
+					// @ts-ignore
+					adapterName = this.capitalize(instanceObjectData.common.name);
+					adapterVersion = instanceObjectData.common.version;
+					instanceMode = instanceObjectData.common.mode;
+
+					if (instanceMode === 'schedule') {
+						scheduleTime = instanceObjectData.common.schedule;
+					}
 				}
-			}
 
-			//const adapterVersionVal = await this.getInitValue(adapterVersionDP);
-			const instanceStatusRaw = await this.setInstanceStatus(instanceMode, scheduleTime, id, instanceConnectedHostDP, instanceConnectedDeviceDP);
-			const isAlive = instanceStatusRaw[1];
-			const instanceStatus = instanceStatusRaw[0];
-			const isHealthy = instanceStatusRaw[2];
-
-			//subscribe to statechanges
-			this.subscribeForeignStatesAsync(id);
-			this.subscribeForeignStatesAsync(instanceConnectedHostDP);
-			this.subscribeForeignStatesAsync(instanceConnectedDeviceDP);
-			this.subscribeForeignObjectsAsync(instanceObjectPath);
-
-			// create raw list
-			this.listInstanceRaw.set(instanceObjectPath, {
-				Adapter: adapterName,
-				InstanceName: instanceName,
-				instanceObjectPath: instanceObjectPath,
-				instanceAlivePath: id,
-				instanceMode: instanceMode,
-				schedule: scheduleTime,
-				adapterVersion: adapterVersion,
-				isAlive: isAlive,
-				isHealthy: isHealthy,
-				connectedHostPath: instanceConnectedHostDP,
-				isConnectedHost: instanceConnectedHostVal,
-				connectedDevicePath: instanceConnectedDeviceDP,
-				isConnectedDevice: instanceConnectedDeviceVal,
-				status: instanceStatus,
-			});
+				await this.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, instanceConnectedHostDP, instanceConnectedDeviceDP);
+				const isAlive = instanceStatusRaw[1];
+				const instanceStatus = instanceStatusRaw[0];
+				const isHealthy = instanceStatusRaw[2];
+
+				//subscribe to statechanges
+				this.subscribeForeignStates(id);
+				this.subscribeForeignStates(instanceConnectedHostDP);
+				this.subscribeForeignStates(instanceConnectedDeviceDP);
+				this.subscribeForeignObjects(`system.adapter.*`);
+
+				// create raw list
+				this.listInstanceRaw.set(instanceObjectPath, {
+					Adapter: adapterName,
+					InstanceName: instanceName,
+					instanceObjectPath: instanceObjectPath,
+					instanceAlivePath: id,
+					instanceMode: instanceMode,
+					schedule: scheduleTime,
+					adapterVersion: adapterVersion,
+					updateAvailable: adapterAvailableUpdate,
+					isAlive: isAlive,
+					isHealthy: isHealthy,
+					connectedHostPath: instanceConnectedHostDP,
+					isConnectedHost: instanceConnectedHostVal,
+					connectedDevicePath: instanceConnectedDeviceDP,
+					isConnectedDevice: instanceConnectedDeviceVal,
+					status: instanceStatus,
+				});
+			}
+			await this.createInstanceList();
+			await this.writeInstanceDPs();
+		} catch (error) {
+			this.errorReporting('[getInstanceData]', error);
 		}
-		await this.createInstanceList();
-		await this.writeInstanceDPs();
 	}
 
 	/**
@@ -1874,6 +2116,7 @@ class DeviceWatcher extends utils.Adapter {
 		let diff;
 		let previousCronRun = null;
 		let isHealthy = false;
+		let instanceErrorTime = 20000 / 2;
 
 		switch (instanceMode) {
 			case 'schedule':
@@ -1895,14 +2138,20 @@ class DeviceWatcher extends utils.Adapter {
 			case 'daemon':
 				if (!isAlive) return ['Instanz deaktiviert', false, null]; // if instance is turned off
 				if (isDeviceConnected === undefined) isDeviceConnected = true;
-				// In case of (re)start, connection may take some time. We take 3 attempts.
-				// Attempt 1/3 - immediately
+
+				if (this.userTimeInstancesList.has(instanceAlivePath)) {
+					instanceErrorTime = this.userTimeInstancesList.get(instanceAlivePath).errorTime;
+					instanceErrorTime = (instanceErrorTime * 1000) / 2; // calculate sec to ms and divide into two
+				}
+
 				if (isHostConnected && isDeviceConnected) {
+					// In case of (re)start, connection may take some time. We take 3 attempts.
+					// Attempt 1/3 - immediately
 					isHealthy = true;
 					instanceStatusString = 'Instanz okay';
 				} else {
-					// Attempt 2/3 - after 10 seconds
-					await this.wait(10000);
+					// 2/3 - after 15 seconds
+					await this.wait(instanceErrorTime);
 					isDeviceConnected = await this.getInitValue(isDeviceConnctedPath);
 					isHostConnected = await this.getInitValue(hostConnectedPath);
 
@@ -1910,8 +2159,8 @@ class DeviceWatcher extends utils.Adapter {
 						isHealthy = true;
 						instanceStatusString = 'Instanz okay';
 					} else {
-						// Attempt 3/3 - after 20 seconds in total
-						await this.wait(10000);
+						// 3/3 - after 30 seconds in total or user time setting
+						await this.wait(instanceErrorTime);
 						isDeviceConnected = await this.getInitValue(isDeviceConnctedPath);
 						isHostConnected = await this.getInitValue(hostConnectedPath);
 
@@ -1954,7 +2203,7 @@ class DeviceWatcher extends utils.Adapter {
 	 * @param {string} adapterUpdateListDP
 	 */
 	async getAdapterUpdateData(adapterUpdateListDP) {
-		this.adapterUpdatesJsonRaw = [];
+		this.adapterUpdatesJsonRaw.clear();
 		const adapterUpdatesListVal = await this.getForeignStatesAsync(adapterUpdateListDP);
 
 		let adapterJsonList;
@@ -1966,9 +2215,8 @@ class DeviceWatcher extends utils.Adapter {
 		}
 
 		for (const [id] of Object.entries(adapterJsonList)) {
-			this.adapterUpdatesJsonRaw.push({
+			this.adapterUpdatesJsonRaw.set(this.capitalize(id), {
 				Path: adapterUpdatesJsonPath,
-				Adapter: this.capitalize(id),
 				newVersion: adapterJsonList[id].availableVersion,
 				oldVersion: adapterJsonList[id].installedVersion,
 			});
@@ -1983,11 +2231,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;
@@ -1999,13 +2247,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 });
 	}
 
 	/**
@@ -2013,6 +2261,7 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	async createInstanceList() {
 		this.listAllInstances = [];
+		this.listAllActiveInstances = [];
 		this.listDeactivatedInstances = [];
 		this.listErrorInstanceRaw = [];
 		this.listErrorInstance = [];
@@ -2029,23 +2278,36 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			if (this.blacklistInstancesLists.includes(instance.instanceAlivePath)) continue;
+			// all instances
 			this.listAllInstances.push({
 				Adapter: instance.Adapter,
 				Instance: instance.InstanceName,
 				Mode: instance.instanceMode,
 				Schedule: instance.schedule,
 				Version: instance.adapterVersion,
+				Updateable: instance.updateAvailable,
 				Status: instance.status,
 			});
+
 			if (!instance.isAlive) {
+				// list with deactivated instances
 				this.listDeactivatedInstances.push({
 					Adapter: instance.Adapter,
 					Instance: instance.InstanceName,
 					Status: instance.status,
 				});
+			} else {
+				// list with active instances
+				this.listAllActiveInstances.push({
+					Adapter: instance.Adapter,
+					Instance: instance.InstanceName,
+					Mode: instance.instanceMode,
+					Schedule: instance.schedule,
+					Status: instance.status,
+				});
 			}
 
-			// fill List for User
+			// list with error instances
 			if (instance.isAlive && !instance.isHealthy) {
 				this.listErrorInstance.push({
 					Adapter: instance.Adapter,
@@ -2063,10 +2325,12 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	async countInstances() {
 		this.countAllInstances = 0;
+		this.countAllActiveInstances = 0;
 		this.countDeactivatedInstances = 0;
 		this.countErrorInstance = 0;
 
 		this.countAllInstances = this.listAllInstances.length;
+		this.countAllActiveInstances = this.listAllActiveInstances.length;
 		this.countDeactivatedInstances = this.listDeactivatedInstances.length;
 		this.countErrorInstance = this.listErrorInstance.length;
 	}
@@ -2075,26 +2339,27 @@ class DeviceWatcher extends utils.Adapter {
 	 * write datapoints for instances list and counts
 	 */
 	async writeInstanceDPs() {
-		// Write Datapoints for counts
-		await this.setStateAsync(`adapterAndInstances.countAllInstances`, { val: this.countAllInstances, ack: true });
-		await this.setStateAsync(`adapterAndInstances.countDeactivatedInstances`, { val: this.countDeactivatedInstances, ack: true });
-
 		// List all instances
-		await this.setStateAsync(`adapterAndInstances.listAllInstances`, { val: JSON.stringify(this.listAllInstances), ack: true });
+		await this.setStateChangedAsync(`adapterAndInstances.listAllInstances`, { val: JSON.stringify(this.listAllInstances), ack: true });
+		await this.setStateChangedAsync(`adapterAndInstances.countAllInstances`, { val: this.countAllInstances, ack: true });
+
+		// List all active instances
+		await this.setStateChangedAsync(`adapterAndInstances.listAllActiveInstances`, { val: JSON.stringify(this.listAllActiveInstances), ack: true });
+		await this.setStateChangedAsync(`adapterAndInstances.countAllActiveInstances`, { val: this.countAllActiveInstances, ack: true });
 
 		// list deactivated instances
 		if (this.countDeactivatedInstances === 0) {
-			this.listDeactivatedInstances = [{ Instance: '--none--', Version: '', Status: '' }];
+			this.listDeactivatedInstances = [{ Adapter: '--none--', Instance: '', 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: '' }];
+			this.listErrorInstance = [{ Adapter: '--none--', Instance: '', 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 });
 	}
 
 	/**
@@ -2168,6 +2433,53 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			native: {},
 		});
+		// Instances
+		await this.setObjectNotExistsAsync(`adapterAndInstances.listAllActiveInstances`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'JSON List of all active instances',
+					de: 'JSON Liste aller aktiven Instanzen',
+					ru: 'ДЖСОН Список всех активных инстанций',
+					pt: 'J. Lista de todas as instâncias ativas',
+					nl: 'JSON List van alle actieve instanties',
+					fr: 'JSON Liste de tous les cas actifs',
+					it: 'JSON Elenco di tutte le istanze attive',
+					es: 'JSON Lista de todos los casos activos',
+					pl: 'JSON Lista wszystkich aktywnych instancji',
+					uk: 'Сонце Список всіх активних екземплярів',
+					'zh-cn': '附 件 所有积极事件清单',
+				},
+				type: 'array',
+				role: 'json',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+		await this.setObjectNotExistsAsync(`adapterAndInstances.countAllActiveInstances`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'Number of all active instances',
+					de: 'Anzahl aller aktiven Instanzen',
+					ru: 'Количество всех активных инстанций',
+					pt: 'Número de todas as instâncias ativas',
+					nl: 'Nummer van alle actieve instanties',
+					fr: 'Nombre de toutes les instances actives',
+					it: 'Numero di tutte le istanze attive',
+					es: 'Número de casos activos',
+					pl: 'Liczba wszystkich czynnych przypadków',
+					uk: 'Кількість всіх активних екземплярів',
+					'zh-cn': '所有积极事件的数目',
+				},
+				type: 'number',
+				role: 'value',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
 		await this.setObjectNotExistsAsync(`adapterAndInstances.listDeactivatedInstances`, {
 			type: 'state',
 			common: {
@@ -2317,6 +2629,8 @@ class DeviceWatcher extends utils.Adapter {
 		await this.delObjectAsync(`adapterAndInstances`);
 		await this.delObjectAsync(`adapterAndInstances.listAllInstances`);
 		await this.delObjectAsync(`adapterAndInstances.countAllInstances`);
+		await this.delObjectAsync(`adapterAndInstances.listAllActiveInstances`);
+		await this.delObjectAsync(`adapterAndInstances.countAllActiveInstances`);
 		await this.delObjectAsync(`adapterAndInstances.listDeactivatedInstances`);
 		await this.delObjectAsync(`adapterAndInstances.countDeactivatedInstances`);
 		await this.delObjectAsync(`adapterAndInstances.listInstancesError`);
@@ -2394,6 +2708,44 @@ class DeviceWatcher extends utils.Adapter {
 			this.errorReporting('[sendNotification Whatsapp]', error);
 		}
 
+		// Matrix
+		try {
+			if (this.config.instanceMatrix) {
+				//first check if instance is living
+				const matrixAliveState = await this.getInitValue('system.adapter.' + this.config.instanceMatrix + '.alive');
+
+				if (!matrixAliveState) {
+					this.log.warn('Matrix instance is not running. Message could not be sent. Please check your instance configuration.');
+				} else {
+					await this.sendToAsync(this.config.instanceMatrix, 'send', {
+						html: `<h1>${this.config.titleMatrix}</h1>`,
+						text: text,
+					});
+				}
+			}
+		} catch (error) {
+			this.errorReporting('[sendNotification Matrix]', 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) {
@@ -2532,13 +2884,12 @@ class DeviceWatcher extends utils.Adapter {
 				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']}`;
 				}
-				if (list.length === 0) return;
 				message = `Neue Adapter Updates vorhanden: ${list}`;
 				setMessage(message);
 				break;
@@ -2851,6 +3202,172 @@ class DeviceWatcher extends utils.Adapter {
 		return html;
 	}
 
+	/**
+	 * @param {string} type - type of list
+	 * @param {object} instances - Instance
+	 * @param {number} instancesCount - Counted devices
+	 */
+	async createListHTMLInstances(type, instances, instancesCount) {
+		let html;
+		switch (type) {
+			case 'allInstancesList':
+				instances = instances.sort((a, b) => {
+					a = a.Instance || '';
+					b = b.Instance || '';
+					return a.localeCompare(b);
+				});
+				html = `<center>
+				<b>All Instances:<font> ${instancesCount}</b><small></small></font>
+				<p></p>
+				</center>   
+				<table width=100%>
+				<tr>
+				<th align=left>Adapter</th>
+				<th align=center>Instance</th>
+				<th align=center width=180>Status</th>
+				</tr>
+				<tr>
+				<td colspan="5"><hr></td>
+				</tr>`;
+
+				for (const instance of instances) {
+					html += `<tr>
+					<td><font>${instance.Adapter}</font></td>
+					<td align=center><font>${instance.Instance}</font></td>
+					<td align=center><font>${instance.Status}</font></td>
+					</tr>`;
+				}
+
+				html += '</table>';
+				break;
+
+			case 'allActiveInstancesList':
+				instances = instances.sort((a, b) => {
+					a = a.Instance || '';
+					b = b.Instances || '';
+					return a.localeCompare(b);
+				});
+				html = `<center>
+				<b>Active Devices: <font> ${instancesCount}</b><small></small></font>
+				<p></p>
+				</center>   
+				<table width=100%>
+				<tr>
+				<th align=left>Adapter</th>
+				<th align=center>Instance</th>
+				<th align=center width=180>Status</th>
+				</tr>
+				<tr>
+				<td colspan="5"><hr></td>
+				</tr>`;
+
+				for (const instance of instances) {
+					html += `<tr>
+					<td><font>${instance.Adapter}</font></td>
+					<td align=center><font>${instance.Instance}</font></td>
+					<td align=center><font color=orange>${instance.Status}</font></td>
+					</tr>`;
+				}
+
+				html += '</table>';
+				break;
+
+			case 'errorInstanceList':
+				instances = instances.sort((a, b) => {
+					a = a.Instance || '';
+					b = b.Instances || '';
+					return a.localeCompare(b);
+				});
+				html = `<center>
+				<b>Error Instances: <font color=${instancesCount === 0 ? '#3bcf0e' : 'orange'}>${instancesCount}</b><small></small></font>
+				<p></p>
+				</center>   
+				<table width=100%>
+				<tr>
+				<th align=left>Adapter</th>
+				<th align=center width=120>Instance</th>
+				<th align=center>Status</th>
+				</tr>
+				<tr>
+				<td colspan="5"><hr></td>
+				</tr>`;
+
+				for (const instance of instances) {
+					html += `<tr>
+					<td><font>${instance.Adapter}</font></td>
+					<td align=center><font>${instance.Instance}</font></td>
+					<td align=center><font color=orange>${instance.Status}</font></td>
+					</tr>`;
+				}
+
+				html += '</table>';
+				break;
+
+			case 'deactivatedInstanceList':
+				instances = instances.sort((a, b) => {
+					a = a.Instance || '';
+					b = b.Instances || '';
+					return a.localeCompare(b);
+				});
+				html = `<center>
+				<b>Deactivated Instances: <font color=${instancesCount === 0 ? '#3bcf0e' : 'orange'}>${instancesCount}</b><small></small></font>
+				<p></p>
+				</center>   
+				<table width=100%>
+				<tr>
+				<th align=left>Adapter</th>
+				<th align=center width=120>Instance</th>
+				<th align=center>Status</th>
+				</tr>
+				<tr>
+				<td colspan="5"><hr></td>
+				</tr>`;
+
+				for (const instance of instances) {
+					html += `<tr>
+					<td><font>${instance.Adapter}</font></td>
+					<td align=center><font>${instance.Instance}</font></td>
+					<td align=center><font color=orange>${instance.Status}</font></td>
+					</tr>`;
+				}
+
+				html += '</table>';
+				break;
+
+			case 'updateAdapterList':
+				instances = instances.sort((a, b) => {
+					a = a.Instance || '';
+					b = b.Instances || '';
+					return a.localeCompare(b);
+				});
+				html = `<center>
+				<b>Updatable Adapter: <font color=${instancesCount === 0 ? '#3bcf0e' : 'orange'}>${instancesCount}</b><small></small></font>
+				<p></p>
+				</center>   
+				<table width=100%>
+				<tr>
+				<th align=left>Adapter</th>
+				<th align=center>Installed Version</th>
+				<th align=center>Available Version</th>
+				</tr>
+				<tr>
+				<td colspan="5"><hr></td>
+				</tr>`;
+
+				for (const instance of instances) {
+					html += `<tr>
+					<td><font>${instance.Adapter}</font></td>
+					<td align=center><font>${instance['Installed Version']}</font></td>
+					<td align=center><font color=orange>${instance['Available Version']}</font></td>
+					</tr>`;
+				}
+
+				html += '</table>';
+				break;
+		}
+		return html;
+	}
+
 	/*=============================================
 	=     create datapoints for each adapter      =
 	=============================================*/
@@ -2938,6 +3455,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: {
@@ -3207,6 +3748,7 @@ class DeviceWatcher extends utils.Adapter {
 		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`);
@@ -3345,6 +3887,161 @@ class DeviceWatcher extends utils.Adapter {
 		await this.delObjectAsync(`devices.${dpSubFolder}lowBatteryListHTML`);
 	}
 
+	/**
+	 * create HTML list datapoints for instances
+	 **/
+	async createHtmlListDatapointsInstances() {
+		await this.setObjectNotExistsAsync(`adapterAndInstances.HTML_Lists`, {
+			type: 'channel',
+			common: {
+				name: {
+					en: 'HTML lists for adapter and instances',
+					de: 'HTML-Listen für Adapter und Instanzen',
+					ru: 'HTML-списки для адаптеров и инстанций',
+					pt: 'Listas HTML para adaptador e instâncias',
+					nl: 'HTML lijsten voor adapter en instituut',
+					fr: "Listes HTML pour l'adaptateur et les instances",
+					it: 'Elenchi HTML per adattatore e istanze',
+					es: 'Listas HTML para adaptador y casos',
+					pl: 'Listy HTML dla adaptera i instancji',
+					uk: 'Списки HTML для адаптерів та екземплярів',
+					'zh-cn': 'HTML名单',
+				},
+			},
+			native: {},
+		});
+		await this.setObjectNotExistsAsync(`adapterAndInstances.HTML_Lists.listAllInstancesHTML`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'HTML List of all instances',
+					de: 'HTML Liste aller Instanzen',
+					ru: 'HTML Список всех инстанций',
+					pt: 'HTML Lista de todas as instâncias',
+					nl: 'HTM List van alle instanties',
+					fr: 'HTML Liste de tous les cas',
+					it: 'HTML Elenco di tutte le istanze',
+					es: 'HTML Lista de todos los casos',
+					pl: 'HTML Lista wszystkich instancji',
+					uk: 'Українська Список всіх екземплярів',
+					'zh-cn': 'HTML 所有事例一览表',
+				},
+				type: 'string',
+				role: 'html',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+
+		await this.setObjectNotExistsAsync(`adapterAndInstances.HTML_Lists.listAllActiveInstancesHTML`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'HTML List of all active instances',
+					de: 'HTML Liste aller aktiven Instanzen',
+					ru: 'HTML Список всех активных инстанций',
+					pt: 'HTML Lista de todas as instâncias ativas',
+					nl: 'HTM List van alle actieve instanties',
+					fr: 'HTML Liste de tous les cas actifs',
+					it: 'HTML Elenco di tutte le istanze attive',
+					es: 'HTML Lista de todos los casos activos',
+					pl: 'HTML Lista wszystkich aktywnych instancji',
+					uk: 'Українська Список всіх активних екземплярів',
+					'zh-cn': 'HTML 所有积极事件清单',
+				},
+				type: 'string',
+				role: 'value',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+
+		await this.setObjectNotExistsAsync(`adapterAndInstances.HTML_Lists.listDeactivatedInstancesHTML`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'HTML List of all deactivated instances',
+					de: 'HTML Liste aller deaktivierten Instanzen',
+					ru: 'HTML Список всех деактивированных инстанций',
+					pt: 'HTML Lista de todas as instâncias desativadas',
+					nl: 'HTM List van alle gedeactiveerde instanties',
+					fr: 'HTML Liste de tous les cas désactivés',
+					it: 'HTML Elenco di tutte le istanze disattivate',
+					es: 'HTML Lista de todos los casos desactivados',
+					pl: 'HTML Lista wszystkich przypadków deaktywowanych',
+					uk: 'Українська Список всіх деактивованих екземплярів',
+					'zh-cn': 'HTML 所有违犯事件清单',
+				},
+				type: 'string',
+				role: 'html',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+
+		await this.setObjectNotExistsAsync(`adapterAndInstances.HTML_Lists.listInstancesErrorHTML`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'HTML List of instances with error',
+					de: 'HTML Liste der Fälle mit Fehler',
+					ru: 'HTML Список инстанций с ошибкой',
+					pt: 'HTML Lista de casos com erro',
+					nl: 'HTM List van instoringen met fouten',
+					fr: 'HTML Liste des instances avec erreur',
+					it: 'HTML Elenco delle istanze con errore',
+					es: 'HTML Lista de casos con error',
+					pl: 'HTML Lista przykładów z błądem',
+					uk: 'Українська Список екземплярів з помилкою',
+					'zh-cn': 'HTML 出现错误的情况清单',
+				},
+				type: 'string',
+				role: 'html',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+		await this.setObjectNotExistsAsync(`adapterAndInstances.HTML_Lists.listAdapterUpdatesHTML`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'HTML list of adapters with available updates',
+					de: 'HTML-Liste der Adapter mit verfügbaren Updates',
+					ru: 'HTML список адаптеров с доступными обновлениями',
+					pt: 'Lista HTML de adaptadores com atualizações disponíveis',
+					nl: 'HTML lijst met beschikbare updates',
+					fr: 'Liste HTML des adaptateurs avec mises à jour disponibles',
+					it: 'Elenco HTML degli adattatori con aggiornamenti disponibili',
+					es: 'Lista HTML de adaptadores con actualizaciones disponibles',
+					pl: 'Lista adapterów HTML z dostępnymi aktualizacjami',
+					uk: 'HTML список адаптерів з доступними оновленнями',
+					'zh-cn': 'HTML 可供更新的适应者名单',
+				},
+				type: 'string',
+				role: 'html',
+				read: true,
+				write: false,
+			},
+			native: {},
+		});
+	}
+
+	/**
+	 * delete html datapoints for instances
+	 **/
+	async deleteHtmlListDatapointsInstances() {
+		await this.delObjectAsync(`adapterAndInstances.HTML_Lists.listAllInstancesHTML`);
+		await this.delObjectAsync(`adapterAndInstances.HTML_Lists.listAllActiveInstancesHTML`);
+		await this.delObjectAsync(`adapterAndInstances.HTML_Lists.listDeactivatedInstancesHTML`);
+		await this.delObjectAsync(`adapterAndInstances.HTML_Lists.listInstancesErrorHTML`);
+		await this.delObjectAsync(`adapterAndInstances.HTML_Lists.listAdapterUpdatesHTML`);
+		await this.delObjectAsync(`adapterAndInstances.HTML_Lists`);
+	}
+
 	/*=============================================
 	=            	help functions   	          =
 	=============================================*/
@@ -3413,12 +4110,11 @@ class DeviceWatcher extends utils.Adapter {
 	}
 
 	/**
-	 * @param {number} time
+	 * @param {number} ms
 	 */
-	wait(time) {
-		return new Promise(function (resolve) {
-			setTimeout(resolve, time);
-		});
+	async wait(ms) {
+		if (isUnloaded) return;
+		return new Promise((resolve) => setTimeout(resolve, ms));
 	}
 
 	/**
@@ -3462,11 +4158,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);
+				this.refreshDataTimeout = null;
 			}
-			isUnloaded = true;
 
 			this.log.info('cleaned everything up...');