iobroker.device-watcher 2.10.3 → 2.10.5

package/main.js

@@ -83,9 +83,6 @@ class DeviceWatcher extends utils.Adapter {
 		// Check if main function is running
 		this.mainRunning = false;
 
-		// System anguage
-		this.userSystemLanguage;
-
 		this.on('ready', this.onReady.bind(this));
 		this.on('stateChange', this.onStateChange.bind(this));
 		this.on('objectChange', this.onObjectChange.bind(this));
@@ -100,11 +97,14 @@ class DeviceWatcher extends utils.Adapter {
 		this.log.debug(`Adapter ${adapterName} was started`);
 
 		// set user language
-		if (this.userSystemLanguage === undefined && this.userSystemLanguage === null) {
-			this.userSystemLanguage = 'de';
-		} else {
-			this.userSystemLanguage = this.language;
+		if (this.config.userSelectedLanguage === '') {
+			if (this.language !== undefined && this.language !== null) {
+				this.config.userSelectedLanguage = this.language;
+			} else {
+				this.config.userSelectedLanguage = 'de';
+			}
 		}
+		this.log.debug(`Set language to ${this.config.userSelectedLanguage}`);
 
 		this.configCreateInstanceList = this.config.checkAdapterInstances;
 		this.configListOnlyBattery = this.config.listOnlyBattery;
@@ -394,8 +394,7 @@ class DeviceWatcher extends utils.Adapter {
 	 */
 	async onStateChange(id, state) {
 		if (state) {
-			this.log.debug(`State changed: ${id} changed ${state.val}`);
-
+			// this.log.debug(`State changed: ${id} changed ${state.val}`);
 			try {
 				/*=============================================
 				=        	Instances / Adapter     	     =
@@ -1223,10 +1222,10 @@ class DeviceWatcher extends utils.Adapter {
 
 		lastContactString = `${this.formatDate(new Date(selector), 'hh:mm')}`;
 		if (Math.round(lastContact) > 100) {
-			lastContactString = `${Math.round(lastContact / 60)} ${translations.hours[this.userSystemLanguage]}`;
+			lastContactString = `${Math.round(lastContact / 60)} ${translations.hours[this.config.userSelectedLanguage]}`;
 		}
 		if (Math.round(lastContact / 60) > 48) {
-			lastContactString = `${Math.round(lastContact / 60 / 24)} ${translations.days[this.userSystemLanguage]}`;
+			lastContactString = `${Math.round(lastContact / 60 / 24)} ${translations.days[this.config.userSelectedLanguage]}`;
 		}
 		return lastContactString;
 	}
@@ -1417,7 +1416,7 @@ class DeviceWatcher extends utils.Adapter {
 	 * when was last contact of device
 	 */
 	async checkLastContact() {
-		for (const [device, deviceData] of this.listAllDevicesRaw.entries()) {
+		for (const [deviceID, deviceData] of this.listAllDevicesRaw.entries()) {
 			if (deviceData.instancedeviceConnected !== false) {
 				const oldContactState = deviceData.Status;
 				deviceData.UnreachState = await this.getInitValue(deviceData.UnreachDP);
@@ -1436,7 +1435,10 @@ class DeviceWatcher extends utils.Adapter {
 					deviceData.linkQuality = contactData[2];
 				}
 				if (this.config.checkSendOfflineMsg && oldContactState !== deviceData.Status && !this.blacklistNotify.includes(deviceData.Path)) {
-					await this.sendStateNotifications('Devices', 'onlineStateDevice', device);
+					// check if the generally deviceData connected state is for a while true
+					if (await this.getTimestampConnectionDP(deviceData.instanceDeviceConnectionDP, 50000)) {
+						await this.sendStateNotifications('Devices', 'onlineStateDevice', deviceID);
+					}
 				}
 			}
 		}
@@ -1559,56 +1561,56 @@ class DeviceWatcher extends utils.Adapter {
 
 		// List with all devices
 		this.listAllDevices.push({
-			[translations.Device[this.userSystemLanguage]]: device.Device,
-			[translations.Adapter[this.userSystemLanguage]]: device.Adapter,
-			[translations.Battery[this.userSystemLanguage]]: device.Battery,
-			[translations.Signal_strength[this.userSystemLanguage]]: device.SignalStrength,
-			[translations.Last_Contact[this.userSystemLanguage]]: device.LastContact,
-			[translations.Status[this.userSystemLanguage]]: device.Status,
+			[translations.Device[this.config.userSelectedLanguage]]: device.Device,
+			[translations.Adapter[this.config.userSelectedLanguage]]: device.Adapter,
+			[translations.Battery[this.config.userSelectedLanguage]]: device.Battery,
+			[translations.Signal_strength[this.config.userSelectedLanguage]]: device.SignalStrength,
+			[translations.Last_Contact[this.config.userSelectedLanguage]]: device.LastContact,
+			[translations.Status[this.config.userSelectedLanguage]]: device.Status,
 		});
 
 		// LinkQuality lists
 		if (device.SignalStrength != ' - ') {
 			this.linkQualityDevices.push({
-				[translations.Device[this.userSystemLanguage]]: device.Device,
-				[translations.Adapter[this.userSystemLanguage]]: device.Adapter,
-				[translations.Signal_strength[this.userSystemLanguage]]: device.SignalStrength,
+				[translations.Device[this.config.userSelectedLanguage]]: device.Device,
+				[translations.Adapter[this.config.userSelectedLanguage]]: device.Adapter,
+				[translations.Signal_strength[this.config.userSelectedLanguage]]: device.SignalStrength,
 			});
 		}
 
 		// Battery lists
 		if (device.isBatteryDevice) {
 			this.batteryPowered.push({
-				[translations.Device[this.userSystemLanguage]]: device.Device,
-				[translations.Adapter[this.userSystemLanguage]]: device.Adapter,
-				[translations.Battery[this.userSystemLanguage]]: device.Battery,
-				[translations.Status[this.userSystemLanguage]]: device.Status,
+				[translations.Device[this.config.userSelectedLanguage]]: device.Device,
+				[translations.Adapter[this.config.userSelectedLanguage]]: device.Adapter,
+				[translations.Battery[this.config.userSelectedLanguage]]: device.Battery,
+				[translations.Status[this.config.userSelectedLanguage]]: device.Status,
 			});
 		}
 
 		// Low Bat lists
 		if (device.LowBat && device.Status !== 'Offline') {
 			this.batteryLowPowered.push({
-				[translations.Device[this.userSystemLanguage]]: device.Device,
-				[translations.Adapter[this.userSystemLanguage]]: device.Adapter,
-				[translations.Battery[this.userSystemLanguage]]: device.Battery,
+				[translations.Device[this.config.userSelectedLanguage]]: device.Device,
+				[translations.Adapter[this.config.userSelectedLanguage]]: device.Adapter,
+				[translations.Battery[this.config.userSelectedLanguage]]: device.Battery,
 			});
 		}
 
 		// Offline List
 		if (device.Status === 'Offline') {
 			this.offlineDevices.push({
-				[translations.Device[this.userSystemLanguage]]: device.Device,
-				[translations.Adapter[this.userSystemLanguage]]: device.Adapter,
-				[translations.Last_Contact[this.userSystemLanguage]]: device.LastContact,
+				[translations.Device[this.config.userSelectedLanguage]]: device.Device,
+				[translations.Adapter[this.config.userSelectedLanguage]]: device.Adapter,
+				[translations.Last_Contact[this.config.userSelectedLanguage]]: device.LastContact,
 			});
 		}
 
 		// Device update List
 		if (device.Upgradable === true || device.Upgradable === 1) {
 			this.upgradableList.push({
-				[translations.Device[this.userSystemLanguage]]: device.Device,
-				[translations.Adapter[this.userSystemLanguage]]: device.Adapter,
+				[translations.Device[this.config.userSelectedLanguage]]: device.Device,
+				[translations.Adapter[this.config.userSelectedLanguage]]: device.Adapter,
 			});
 		}
 	}
@@ -1663,12 +1665,12 @@ class DeviceWatcher extends utils.Adapter {
 				// if no device is count, write the JSON List with default value
 				this.listAllDevices = [
 					{
-						[translations.Device[this.userSystemLanguage]]: '--none--',
-						[translations.Adapter[this.userSystemLanguage]]: '',
-						[translations.Battery[this.userSystemLanguage]]: '',
-						[translations.Signal_strength[this.userSystemLanguage]]: '',
-						[translations.Last_Contact[this.userSystemLanguage]]: '',
-						[translations.Status[this.userSystemLanguage]]: '',
+						[translations.Device[this.config.userSelectedLanguage]]: '--none--',
+						[translations.Adapter[this.config.userSelectedLanguage]]: '',
+						[translations.Battery[this.config.userSelectedLanguage]]: '',
+						[translations.Signal_strength[this.config.userSelectedLanguage]]: '',
+						[translations.Last_Contact[this.config.userSelectedLanguage]]: '',
+						[translations.Status[this.config.userSelectedLanguage]]: '',
 					},
 				];
 				this.listAllDevicesUserRaw = [
@@ -1696,9 +1698,9 @@ class DeviceWatcher extends utils.Adapter {
 				// if no device is count, write the JSON List with default value
 				this.linkQualityDevices = [
 					{
-						[translations.Device[this.userSystemLanguage]]: '--none--',
-						[translations.Adapter[this.userSystemLanguage]]: '',
-						[translations.Signal_strength[this.userSystemLanguage]]: '',
+						[translations.Device[this.config.userSelectedLanguage]]: '--none--',
+						[translations.Adapter[this.config.userSelectedLanguage]]: '',
+						[translations.Signal_strength[this.config.userSelectedLanguage]]: '',
 					},
 				];
 			}
@@ -1713,9 +1715,9 @@ class DeviceWatcher extends utils.Adapter {
 				// if no device is count, write the JSON List with default value
 				this.offlineDevices = [
 					{
-						[translations.Device[this.userSystemLanguage]]: '--none--',
-						[translations.Adapter[this.userSystemLanguage]]: '',
-						[translations.Last_Contact[this.userSystemLanguage]]: '',
+						[translations.Device[this.config.userSelectedLanguage]]: '--none--',
+						[translations.Adapter[this.config.userSelectedLanguage]]: '',
+						[translations.Last_Contact[this.config.userSelectedLanguage]]: '',
 					},
 				];
 			}
@@ -1730,9 +1732,9 @@ class DeviceWatcher extends utils.Adapter {
 				// if no device is count, write the JSON List with default value
 				this.upgradableList = [
 					{
-						[translations.Device[this.userSystemLanguage]]: '--none--',
-						[translations.Adapter[this.userSystemLanguage]]: '',
-						[translations.Last_Contact[this.userSystemLanguage]]: '',
+						[translations.Device[this.config.userSelectedLanguage]]: '--none--',
+						[translations.Adapter[this.config.userSelectedLanguage]]: '',
+						[translations.Last_Contact[this.config.userSelectedLanguage]]: '',
 					},
 				];
 			}
@@ -1746,7 +1748,11 @@ class DeviceWatcher extends utils.Adapter {
 			if (this.batteryPoweredCount === 0) {
 				// if no device is count, write the JSON List with default value
 				this.batteryPowered = [
-					{ [translations.Device[this.userSystemLanguage]]: '--none--', [translations.Adapter[this.userSystemLanguage]]: '', [translations.Battery[this.userSystemLanguage]]: '' },
+					{
+						[translations.Device[this.config.userSelectedLanguage]]: '--none--',
+						[translations.Adapter[this.config.userSelectedLanguage]]: '',
+						[translations.Battery[this.config.userSelectedLanguage]]: '',
+					},
 				];
 			}
 			//write JSON list
@@ -1759,7 +1765,11 @@ class DeviceWatcher extends utils.Adapter {
 			if (this.lowBatteryPoweredCount === 0) {
 				// if no device is count, write the JSON List with default value
 				this.batteryLowPowered = [
-					{ [translations.Device[this.userSystemLanguage]]: '--none--', [translations.Adapter[this.userSystemLanguage]]: '', [translations.Battery[this.userSystemLanguage]]: '' },
+					{
+						[translations.Device[this.config.userSelectedLanguage]]: '--none--',
+						[translations.Adapter[this.config.userSelectedLanguage]]: '',
+						[translations.Battery[this.config.userSelectedLanguage]]: '',
+					},
 				];
 			}
 			//write JSON list
@@ -1964,8 +1974,7 @@ class DeviceWatcher extends utils.Adapter {
 
 				// device unreach
 				case deviceData.UnreachDP:
-					if (deviceData.instanceDeviceConnectionDP.val !== undefined) {
-						// check if the generally deviceData connected state is for a while true
+					if (deviceData.instancedeviceConnected !== undefined) {
 						if (deviceData.UnreachState !== state.val) {
 							oldStatus = deviceData.Status;
 							deviceData.UnreachState = state.val;
@@ -1984,12 +1993,8 @@ class DeviceWatcher extends utils.Adapter {
 								deviceData.SignalStrength = contactData[2];
 							}
 							if (this.config.checkSendOfflineMsg && oldStatus !== deviceData.Status && !this.blacklistNotify.includes(deviceData.Path)) {
-								if (deviceData.instanceDeviceConnectionDP.val !== undefined) {
-									// check if the generally deviceData connected state is for a while true
-									if (await this.getTimestampConnectionDP(deviceData.instanceDeviceConnectionDP, 20000)) {
-										await this.sendStateNotifications('Devices', 'onlineStateDevice', deviceID);
-									}
-								} else {
+								// check if the generally deviceData connected state is for a while true
+								if (await this.getTimestampConnectionDP(deviceData.instanceDeviceConnectionDP, 50000)) {
 									await this.sendStateNotifications('Devices', 'onlineStateDevice', deviceID);
 								}
 							}
@@ -1999,6 +2004,7 @@ class DeviceWatcher extends utils.Adapter {
 			}
 		}
 	}
+
 	/**
 	 * get all Instances at start
 	 */
@@ -2103,7 +2109,6 @@ class DeviceWatcher extends utils.Adapter {
 					isConnectedHost: instanceConnectedHostVal,
 					isConnectedDevice: instanceConnectedDeviceVal,
 					status: instanceStatus,
-					checkIsRunning: false,
 					aliveDP: `system.adapter.${instanceID}.alive`,
 					hostConnectionDP: instanceConnectedHostDP,
 					deviceConnectionDP: instanceConnectedDeviceDP,
@@ -2135,26 +2140,25 @@ class DeviceWatcher extends utils.Adapter {
 		const connectedHostState = await this.getInitValue(`system.adapter.${instanceID}.connected`);
 		const isAlive = await this.getInitValue(`system.adapter.${instanceID}.alive`);
 		let connectedDeviceState = await this.getInitValue(`${instanceID}.info.connection`);
-
 		if (connectedDeviceState === undefined) {
 			connectedDeviceState = true;
 		}
 
 		let isHealthy = false;
-		let instanceStatusString = translations.instance_deactivated[this.userSystemLanguage];
+		let instanceStatusString = translations.instance_deactivated[this.config.userSelectedLanguage];
 
 		if (isAlive) {
 			if (connectedHostState && connectedDeviceState) {
 				isHealthy = true;
-				instanceStatusString = translations.instance_okay[this.userSystemLanguage];
+				instanceStatusString = translations.instance_okay[this.config.userSelectedLanguage];
 			} else if (!connectedHostState) {
-				instanceStatusString = translations.not_connected_host[this.userSystemLanguage];
+				instanceStatusString = translations.not_connected_host[this.config.userSelectedLanguage];
 			} else if (!connectedDeviceState) {
-				instanceStatusString = translations.not_connected_device[this.userSystemLanguage];
+				instanceStatusString = translations.not_connected_device[this.config.userSelectedLanguage];
 			}
 		}
 
-		return [Boolean(isAlive), Boolean(isHealthy), String(instanceStatusString)];
+		return [Boolean(isAlive), Boolean(isHealthy), String(instanceStatusString), Boolean(connectedHostState), Boolean(connectedDeviceState)];
 	}
 
 	/**
@@ -2166,7 +2170,7 @@ class DeviceWatcher extends utils.Adapter {
 		let isAlive = await this.getInitValue(`system.adapter.${instanceID}.alive`);
 		let daemonIsAlive;
 		let isHealthy = false;
-		let instanceStatusString = isAlive ? translations.instance_activated[this.userSystemLanguage] : translations.instance_deactivated[this.userSystemLanguage];
+		let instanceStatusString = isAlive ? translations.instance_activated[this.config.userSelectedLanguage] : translations.instance_deactivated[this.config.userSelectedLanguage];
 
 		if (isAlive) {
 			daemonIsAlive = await this.checkDaemonIsHealthy(instanceID);
@@ -2182,8 +2186,10 @@ class DeviceWatcher extends utils.Adapter {
 		isAlive = Boolean(daemonIsAlive[0]);
 		isHealthy = Boolean(daemonIsAlive[1]);
 		instanceStatusString = String(daemonIsAlive[2]);
+		const connectedToHost = Boolean(daemonIsAlive[3]);
+		const connectedToDevice = Boolean(daemonIsAlive[4]);
 
-		return [isAlive, isHealthy, instanceStatusString];
+		return [isAlive, isHealthy, instanceStatusString, connectedToHost, connectedToDevice];
 	}
 
 	async checkScheduleisHealty(instanceID, scheduleTime) {
@@ -2193,7 +2199,7 @@ class DeviceWatcher extends utils.Adapter {
 		let diff;
 		let isAlive = false;
 		let isHealthy = false;
-		let instanceStatusString = translations.instance_deactivated[this.userSystemLanguage];
+		let instanceStatusString = translations.instance_deactivated[this.config.userSelectedLanguage];
 		const isAliveSchedule = await this.getForeignStateAsync(`system.adapter.${instanceID}.alive`);
 
 		if (isAliveSchedule) {
@@ -2206,7 +2212,7 @@ class DeviceWatcher extends utils.Adapter {
 					// if 5 minutes difference exceeded, instance is not alive
 					isAlive = true;
 					isHealthy = true;
-					instanceStatusString = translations.instance_okay[this.userSystemLanguage];
+					instanceStatusString = translations.instance_okay[this.config.userSelectedLanguage];
 				}
 			}
 		}
@@ -2223,52 +2229,21 @@ class DeviceWatcher extends utils.Adapter {
 	async setInstanceStatus(instanceMode, scheduleTime, instanceID) {
 		let instanceDeactivationTime = (this.config.offlineTimeInstances * 1000) / 2;
 		let instanceErrorTime = (this.config.errorTimeInstances * 1000) / 2;
-
-		const checkScheduleIsHealthy = async () => {
-			const scheduleIsAlive = await this.checkScheduleisHealty(instanceID, scheduleTime);
-			return {
-				isAlive: Boolean(scheduleIsAlive[0]),
-				isHealthy: Boolean(scheduleIsAlive[1]),
-				instanceStatusString: String(scheduleIsAlive[2]),
-			};
-		};
-
-		const checkDaemonIsHealthy = async () => {
-			const daemonIsAlive = await this.checkDaemonIsHealthy(instanceID);
-
-			if (daemonIsAlive[0] && !daemonIsAlive[1]) {
-				await this.delay(instanceErrorTime);
-				const daemonIsAliveAfterDelay = await this.checkDaemonIsHealthy(instanceID);
-
-				if (daemonIsAliveAfterDelay[0] && !daemonIsAliveAfterDelay[1]) {
-					await this.delay(instanceErrorTime);
-					const daemonIsAliveAfterSecondDelay = await this.checkDaemonIsHealthy(instanceID);
-
-					if (daemonIsAliveAfterSecondDelay[0] && !daemonIsAliveAfterSecondDelay[1]) {
-						return {
-							isAlive: Boolean(daemonIsAliveAfterSecondDelay[0]),
-							isHealthy: Boolean(daemonIsAliveAfterSecondDelay[1]),
-							instanceStatusString: String(daemonIsAliveAfterSecondDelay[2]),
-						};
-					}
-				}
-			}
-
-			const daemonIsNotAlive = await this.checkDaemonIsAlive(instanceID, instanceDeactivationTime);
-			return {
-				isAlive: Boolean(daemonIsNotAlive[0]),
-				isHealthy: Boolean(daemonIsNotAlive[1]),
-				instanceStatusString: String(daemonIsNotAlive[2]),
-			};
-		};
-
-		let isAlive = false;
-		let isHealthy = false;
-		let instanceStatusString = translations.instance_deactivated[this.userSystemLanguage];
+		let isAlive;
+		let isHealthy;
+		let instanceStatusString;
+		let daemonIsAlive;
+		let daemonIsNotAlive;
+		let scheduleIsAlive;
+		let connectedToHost;
+		let connectedToDevice;
 
 		switch (instanceMode) {
 			case 'schedule':
-				({ isAlive, isHealthy, instanceStatusString } = await checkScheduleIsHealthy());
+				scheduleIsAlive = await this.checkScheduleisHealty(instanceID, scheduleTime);
+				isAlive = Boolean(scheduleIsAlive[0]);
+				isHealthy = Boolean(scheduleIsAlive[1]);
+				instanceStatusString = String(scheduleIsAlive[2]);
 				break;
 			case 'daemon':
 				// check with time the user did define for error and deactivation
@@ -2277,12 +2252,36 @@ class DeviceWatcher extends utils.Adapter {
 					instanceDeactivationTime = (userTimeInstances.deactivationTime * 1000) / 2;
 					instanceErrorTime = (userTimeInstances.errorTime * 1000) / 2;
 				}
+				daemonIsAlive = await this.checkDaemonIsHealthy(instanceID);
+				if (daemonIsAlive[0] && !daemonIsAlive[1]) {
+					await this.delay(instanceErrorTime);
+					const daemonIsAliveAfterDelay = await this.checkDaemonIsHealthy(instanceID);
+
+					if (daemonIsAliveAfterDelay[0] && !daemonIsAliveAfterDelay[1]) {
+						await this.delay(instanceErrorTime);
+						const daemonIsAliveAfterSecondDelay = await this.checkDaemonIsHealthy(instanceID);
+
+						if (daemonIsAliveAfterSecondDelay[0] && !daemonIsAliveAfterSecondDelay[1]) {
+							isAlive = Boolean(daemonIsAliveAfterSecondDelay[0]);
+							isHealthy = Boolean(daemonIsAliveAfterSecondDelay[1]);
+							instanceStatusString = String(daemonIsAliveAfterSecondDelay[2]);
+							connectedToHost = Boolean(daemonIsAliveAfterSecondDelay[3]);
+							connectedToDevice = Boolean(daemonIsAliveAfterSecondDelay[4]);
+						}
+					}
+				} else {
+					daemonIsNotAlive = await this.checkDaemonIsAlive(instanceID, instanceDeactivationTime);
+					isAlive = Boolean(daemonIsNotAlive[0]);
+					isHealthy = Boolean(daemonIsNotAlive[1]);
+					instanceStatusString = String(daemonIsNotAlive[2]);
+					connectedToHost = Boolean(daemonIsNotAlive[3]);
+					connectedToDevice = Boolean(daemonIsNotAlive[4]);
+				}
 
-				({ isAlive, isHealthy, instanceStatusString } = await checkDaemonIsHealthy());
 				break;
 		}
 
-		return [isAlive, isHealthy, instanceStatusString];
+		return [isAlive, isHealthy, instanceStatusString, connectedToHost, connectedToDevice];
 	}
 
 	/**
@@ -2339,9 +2338,9 @@ class DeviceWatcher extends utils.Adapter {
 
 		for (const [adapter, updateData] of this.adapterUpdatesJsonRaw) {
 			this.listAdapterUpdates.push({
-				[translations.Adapter[this.userSystemLanguage]]: adapter,
-				[translations.Available_Version[this.userSystemLanguage]]: updateData.newVersion,
-				[translations.Installed_Version[this.userSystemLanguage]]: updateData.oldVersion,
+				[translations.Adapter[this.config.userSelectedLanguage]]: adapter,
+				[translations.Available_Version[this.config.userSelectedLanguage]]: updateData.newVersion,
+				[translations.Installed_Version[this.config.userSelectedLanguage]]: updateData.oldVersion,
 			});
 		}
 		this.countAdapterUpdates = this.listAdapterUpdates.length;
@@ -2358,9 +2357,9 @@ class DeviceWatcher extends utils.Adapter {
 		if (this.countAdapterUpdates === 0) {
 			this.listAdapterUpdates = [
 				{
-					[translations.Adapter[this.userSystemLanguage]]: '--none--',
-					[translations.Available_Version[this.userSystemLanguage]]: '',
-					[translations.Installed_Version[this.userSystemLanguage]]: '',
+					[translations.Adapter[this.config.userSelectedLanguage]]: '--none--',
+					[translations.Available_Version[this.config.userSelectedLanguage]]: '',
+					[translations.Installed_Version[this.config.userSelectedLanguage]]: '',
 				},
 			];
 		}
@@ -2391,40 +2390,40 @@ class DeviceWatcher extends utils.Adapter {
 			if (this.blacklistInstancesLists.includes(instance)) continue;
 			// all instances
 			this.listAllInstances.push({
-				[translations.Adapter[this.userSystemLanguage]]: instanceData.Adapter,
-				[translations.Instance[this.userSystemLanguage]]: instance,
-				[translations.Mode[this.userSystemLanguage]]: instanceData.instanceMode,
-				[translations.Schedule[this.userSystemLanguage]]: instanceData.schedule,
-				[translations.Version[this.userSystemLanguage]]: instanceData.adapterVersion,
-				[translations.Updateable[this.userSystemLanguage]]: instanceData.updateAvailable,
-				[translations.Status[this.userSystemLanguage]]: instanceData.status,
+				[translations.Adapter[this.config.userSelectedLanguage]]: instanceData.Adapter,
+				[translations.Instance[this.config.userSelectedLanguage]]: instance,
+				[translations.Mode[this.config.userSelectedLanguage]]: instanceData.instanceMode,
+				[translations.Schedule[this.config.userSelectedLanguage]]: instanceData.schedule,
+				[translations.Version[this.config.userSelectedLanguage]]: instanceData.adapterVersion,
+				[translations.Updateable[this.config.userSelectedLanguage]]: instanceData.updateAvailable,
+				[translations.Status[this.config.userSelectedLanguage]]: instanceData.status,
 			});
 
 			if (!instanceData.isAlive) {
 				// list with deactivated instances
 				this.listDeactivatedInstances.push({
-					[translations.Adapter[this.userSystemLanguage]]: instanceData.Adapter,
-					[translations.Instance[this.userSystemLanguage]]: instance,
-					[translations.Status[this.userSystemLanguage]]: instanceData.status,
+					[translations.Adapter[this.config.userSelectedLanguage]]: instanceData.Adapter,
+					[translations.Instance[this.config.userSelectedLanguage]]: instance,
+					[translations.Status[this.config.userSelectedLanguage]]: instanceData.status,
 				});
 			} else {
 				// list with active instances
 				this.listAllActiveInstances.push({
-					[translations.Adapter[this.userSystemLanguage]]: instanceData.Adapter,
-					[translations.Instance[this.userSystemLanguage]]: instance,
-					[translations.Mode[this.userSystemLanguage]]: instanceData.instanceMode,
-					[translations.Schedule[this.userSystemLanguage]]: instanceData.schedule,
-					[translations.Status[this.userSystemLanguage]]: instanceData.status,
+					[translations.Adapter[this.config.userSelectedLanguage]]: instanceData.Adapter,
+					[translations.Instance[this.config.userSelectedLanguage]]: instance,
+					[translations.Mode[this.config.userSelectedLanguage]]: instanceData.instanceMode,
+					[translations.Schedule[this.config.userSelectedLanguage]]: instanceData.schedule,
+					[translations.Status[this.config.userSelectedLanguage]]: instanceData.status,
 				});
 			}
 
 			// list with error instances
 			if (instanceData.isAlive && !instanceData.isHealthy) {
 				this.listErrorInstance.push({
-					[translations.Adapter[this.userSystemLanguage]]: instanceData.Adapter,
-					[translations.Instance[this.userSystemLanguage]]: instance,
-					[translations.Mode[this.userSystemLanguage]]: instanceData.instanceMode,
-					[translations.Status[this.userSystemLanguage]]: instanceData.status,
+					[translations.Adapter[this.config.userSelectedLanguage]]: instanceData.Adapter,
+					[translations.Instance[this.config.userSelectedLanguage]]: instance,
+					[translations.Mode[this.config.userSelectedLanguage]]: instanceData.instanceMode,
+					[translations.Status[this.config.userSelectedLanguage]]: instanceData.status,
 				});
 			}
 		}
@@ -2462,10 +2461,10 @@ class DeviceWatcher extends utils.Adapter {
 		if (this.countDeactivatedInstances === 0) {
 			this.listDeactivatedInstances = [
 				{
-					[translations.Adapter[this.userSystemLanguage]]: '--none--',
-					[translations.Instance[this.userSystemLanguage]]: '',
-					[translations.Version[this.userSystemLanguage]]: '',
-					[translations.Status[this.userSystemLanguage]]: '',
+					[translations.Adapter[this.config.userSelectedLanguage]]: '--none--',
+					[translations.Instance[this.config.userSelectedLanguage]]: '',
+					[translations.Version[this.config.userSelectedLanguage]]: '',
+					[translations.Status[this.config.userSelectedLanguage]]: '',
 				},
 			];
 		}
@@ -2476,10 +2475,10 @@ class DeviceWatcher extends utils.Adapter {
 		if (this.countErrorInstance === 0) {
 			this.listErrorInstance = [
 				{
-					[translations.Adapter[this.userSystemLanguage]]: '--none--',
-					[translations.Instance[this.userSystemLanguage]]: '',
-					[translations.Mode[this.userSystemLanguage]]: '',
-					[translations.Status[this.userSystemLanguage]]: '',
+					[translations.Adapter[this.config.userSelectedLanguage]]: '--none--',
+					[translations.Instance[this.config.userSelectedLanguage]]: '',
+					[translations.Mode[this.config.userSelectedLanguage]]: '',
+					[translations.Status[this.config.userSelectedLanguage]]: '',
 				},
 			];
 		}
@@ -2524,15 +2523,13 @@ class DeviceWatcher extends utils.Adapter {
 			let instanceStatusRaw;
 
 			const checkInstance = async (instanceID, instanceData) => {
-				if (!instanceData.checkIsRunning) {
-					instanceData.checkIsRunning = true;
-					instanceStatusRaw = await this.setInstanceStatus(instanceData.instanceMode, instanceData.schedule, instanceID);
-					instanceData.isAlive = instanceStatusRaw[0];
-					instanceData.isHealthy = instanceStatusRaw[1];
-					instanceData.status = instanceStatusRaw[2];
-					instanceData.checkIsRunning = false;
-					return;
-				}
+				instanceStatusRaw = await this.setInstanceStatus(instanceData.instanceMode, instanceData.schedule, instanceID);
+				instanceData.isAlive = instanceStatusRaw[0];
+				instanceData.isHealthy = instanceStatusRaw[1];
+				instanceData.status = instanceStatusRaw[2];
+				instanceData.isConnectedHost = instanceStatusRaw[3];
+				instanceData.isConnectedDevice = instanceStatusRaw[4];
+				return;
 			};
 
 			switch (id) {
@@ -3080,25 +3077,25 @@ class DeviceWatcher extends utils.Adapter {
 
 		switch (type) {
 			case 'lowBatDevice':
-				message = `${translations.Device_low_bat_detected[this.userSystemLanguage]}: \n${adapterName} ${objectData.Device} (${objectData.Battery})`;
+				message = `${translations.Device_low_bat_detected[this.config.userSelectedLanguage]}: \n${adapterName} ${objectData.Device} (${objectData.Battery})`;
 				await setMessage(message);
 				break;
 
 			case 'onlineStateDevice':
 				switch (objectData.Status) {
 					case 'Online':
-						message = `${translations.Device_available_again[this.userSystemLanguage]}: \n${adapterName} ${objectData.Device} (${objectData.LastContact})`;
+						message = `${translations.Device_available_again[this.config.userSelectedLanguage]}: \n${adapterName} ${objectData.Device} (${objectData.LastContact})`;
 						break;
 
 					case 'Offline':
-						message = `${translations.Device_not_reachable[this.userSystemLanguage]}: \n${adapterName} ${objectData.Device} (${objectData.LastContact})`;
+						message = `${translations.Device_not_reachable[this.config.userSelectedLanguage]}: \n${adapterName} ${objectData.Device} (${objectData.LastContact})`;
 						break;
 				}
 				await setMessage(message);
 				break;
 
 			case 'updateDevice':
-				message = `${translations.Device_new_updates[this.userSystemLanguage]}: \n${adapterName} ${objectData.Device}`;
+				message = `${translations.Device_new_updates[this.config.userSelectedLanguage]}: \n${adapterName} ${objectData.Device}`;
 				await setMessage(message);
 				break;
 
@@ -3109,16 +3106,16 @@ class DeviceWatcher extends utils.Adapter {
 				list = '';
 
 				for (const id of objectData) {
-					list = `${list}\n${id[translations.Adapter[this.userSystemLanguage]]}: v${id[translations.Available_Version[this.userSystemLanguage]]}`;
+					list = `${list}\n${id[translations.Adapter[this.config.userSelectedLanguage]]}: v${id[translations.Available_Version[this.config.userSelectedLanguage]]}`;
 				}
 
-				message = `${translations.Adapter_new_updates[this.userSystemLanguage]}: ${list}`;
+				message = `${translations.Adapter_new_updates[this.config.userSelectedLanguage]}: ${list}`;
 				await setMessage(message);
 				break;
 
 			case 'errorInstance':
 			case 'deactivatedInstance':
-				message = `${translations.Instance_Watchdog[this.userSystemLanguage]}:\n${id}: ${objectData.status}`;
+				message = `${translations.Instance_Watchdog[this.config.userSelectedLanguage]}:\n${id}: ${objectData.status}`;
 				await setMessage(message);
 				break;
 		}
@@ -3143,6 +3140,7 @@ class DeviceWatcher extends utils.Adapter {
 		};
 
 		const processDeviceList = (deviceList, property1, property2) => {
+			list = '';
 			for (const id of deviceList) {
 				if (this.blacklistNotify.includes(id.Path)) continue;
 				list += `\n${!this.config.showAdapterNameinMsg ? '' : id.Adapter + ': '}${id[property1]}${property2 ? ` (${id[property2]})` : ''}`;
@@ -3150,9 +3148,10 @@ class DeviceWatcher extends utils.Adapter {
 		};
 
 		const processInstanceList = (instanceList, property) => {
+			list = '';
 			for (const id of instanceList) {
-				if (this.blacklistInstancesNotify.includes(id[translations['Instance'][this.userSystemLanguage]])) continue;
-				list += `\n${id[translations['Instance'][this.userSystemLanguage]]}${property ? `: ${id[property]}` : ''}`;
+				if (this.blacklistInstancesNotify.includes(id[translations['Instance'][this.config.userSelectedLanguage]])) continue;
+				list += `\n${id[translations['Instance'][this.config.userSelectedLanguage]]}${property ? `: ${id[property]}` : ''}`;
 			}
 		};
 
@@ -3161,13 +3160,13 @@ class DeviceWatcher extends utils.Adapter {
 
 			switch (checkDays.length) {
 				case 1:
-					message = `${translations.Weekly_overview[this.userSystemLanguage]} ${translations[messageType][this.userSystemLanguage]}: ${list}`;
+					message = `${translations.Weekly_overview[this.config.userSelectedLanguage]} ${translations[messageType][this.config.userSelectedLanguage]}: ${list}`;
 					break;
 				case 7:
-					message = `${translations.Daily_overview[this.userSystemLanguage]} ${translations[messageType][this.userSystemLanguage]}: ${list}`;
+					message = `${translations.Daily_overview[this.config.userSelectedLanguage]} ${translations[messageType][this.config.userSelectedLanguage]}: ${list}`;
 					break;
 				default:
-					message = `${translations.Overview_of[this.userSystemLanguage]} ${translations[messageType][this.userSystemLanguage]}: ${list}`;
+					message = `${translations.Overview_of[this.config.userSelectedLanguage]} ${translations[messageType][this.config.userSelectedLanguage]}: ${list}`;
 					break;
 			}
 
@@ -3233,8 +3232,9 @@ class DeviceWatcher extends utils.Adapter {
 				this.log.debug(`Number of selected days for daily adapter update message: ${checkDays.length}. Send Message on: ${checkDays.join(', ')} ...`);
 
 				schedule.scheduleJob(`4 ${this.config.checkSendAdapterUpdateTime.split(':').reverse().join(' ')} * * ${checkDays.join(',')}`, async () => {
+					list = '';
 					for (const id of this.listAdapterUpdates) {
-						list = `${list}\n${id[translations.Adapter[this.userSystemLanguage]]}: v${id[translations.Available_Version[this.userSystemLanguage]]}`;
+						list = `${list}\n${id[translations.Adapter[this.config.userSelectedLanguage]]}: v${id[translations.Available_Version[this.config.userSelectedLanguage]]}`;
 					}
 					await processNotification(list, 'available_adapter_updates');
 				});
@@ -3293,14 +3293,14 @@ class DeviceWatcher extends utils.Adapter {
 					return a.localeCompare(b);
 				});
 				html = `<center>
-			<b>${[translations.Link_quality_devices[this.userSystemLanguage]]}:<font> ${deviceCount}</b><small></small></font>
+			<b>${[translations.Link_quality_devices[this.config.userSelectedLanguage]]}:<font> ${deviceCount}</b><small></small></font>
 			<p></p>
 			</center>   
 			<table width=100%>
 			<tr>
-			<th align=left>${[translations.Device[this.userSystemLanguage]]}</th>
-			<th align=center width=120>${[translations.Adapter[this.userSystemLanguage]]}</th>
-			<th align=right>${[translations.Signal_strength[this.userSystemLanguage]]}</th>
+			<th align=left>${[translations.Device[this.config.userSelectedLanguage]]}</th>
+			<th align=center width=120>${[translations.Adapter[this.config.userSelectedLanguage]]}</th>
+			<th align=right>${[translations.Signal_strength[this.config.userSelectedLanguage]]}</th>
 			</tr>
 			<tr>
 			<td colspan="5"><hr></td>
@@ -3308,9 +3308,9 @@ class DeviceWatcher extends utils.Adapter {
 
 				for (const device of devices) {
 					html += `<tr>
-				<td><font>${device[translations.Device[this.userSystemLanguage]]}</font></td>
-				<td align=center><font>${device[translations.Adapter[this.userSystemLanguage]]}</font></td>
-				<td align=right><font>${device[translations.Signal_strength[this.userSystemLanguage]]}</font></td>
+				<td><font>${device[translations.Device[this.config.userSelectedLanguage]]}</font></td>
+				<td align=center><font>${device[translations.Adapter[this.config.userSelectedLanguage]]}</font></td>
+				<td align=right><font>${device[translations.Signal_strength[this.config.userSelectedLanguage]]}</font></td>
 				</tr>`;
 				}
 
@@ -3324,14 +3324,14 @@ class DeviceWatcher extends utils.Adapter {
 					return a.localeCompare(b);
 				});
 				html = `<center>
-			<b>${[translations.offline_devices[this.userSystemLanguage]]}: <font color=${deviceCount === 0 ? '#3bcf0e' : 'orange'}>${deviceCount}</b><small></small></font>
+			<b>${[translations.offline_devices[this.config.userSelectedLanguage]]}: <font color=${deviceCount === 0 ? '#3bcf0e' : 'orange'}>${deviceCount}</b><small></small></font>
 			<p></p>
 			</center>   
 			<table width=100%>
 			<tr>
-			<th align=left>${[translations.Device[this.userSystemLanguage]]}</th>
-			<th align=center width=120>${[translations.Adapter[this.userSystemLanguage]]}</th>
-			<th align=center>${[translations.Last_Contact[this.userSystemLanguage]]}</th>
+			<th align=left>${[translations.Device[this.config.userSelectedLanguage]]}</th>
+			<th align=center width=120>${[translations.Adapter[this.config.userSelectedLanguage]]}</th>
+			<th align=center>${[translations.Last_Contact[this.config.userSelectedLanguage]]}</th>
 			</tr>
 			<tr>
 			<td colspan="5"><hr></td>
@@ -3339,9 +3339,9 @@ class DeviceWatcher extends utils.Adapter {
 
 				for (const device of devices) {
 					html += `<tr>
-				<td><font>${device[translations.Device[this.userSystemLanguage]]}</font></td>
-				<td align=center><font>${device[translations.Adapter[this.userSystemLanguage]]}</font></td>
-				<td align=center><font color=orange>${device[translations.Last_Contact[this.userSystemLanguage]]}</font></td>
+				<td><font>${device[translations.Device[this.config.userSelectedLanguage]]}</font></td>
+				<td align=center><font>${device[translations.Adapter[this.config.userSelectedLanguage]]}</font></td>
+				<td align=center><font color=orange>${device[translations.Last_Contact[this.config.userSelectedLanguage]]}</font></td>
 				</tr>`;
 				}
 
@@ -3355,28 +3355,28 @@ class DeviceWatcher extends utils.Adapter {
 					return a.localeCompare(b);
 				});
 				html = `<center>
-			<b>${isLowBatteryList === true ? `${[translations.low[this.userSystemLanguage]]} ` : ''}${[translations.battery_devices[this.userSystemLanguage]]}: 
+			<b>${isLowBatteryList === true ? `${[translations.low[this.config.userSelectedLanguage]]} ` : ''}${[translations.battery_devices[this.config.userSelectedLanguage]]}: 
 			<font color=${isLowBatteryList === true ? (deviceCount > 0 ? 'orange' : '#3bcf0e') : ''}>${deviceCount}</b></font>
 			<p></p>
 			</center>   
 			<table width=100%>
 			<tr>
-			<th align=left>${[translations.Device[this.userSystemLanguage]]}</th>
-			<th align=center width=120>${[translations.Adapter[this.userSystemLanguage]]}</th>
-			<th align=${isLowBatteryList ? 'center' : 'right'}>${[translations.Battery[this.userSystemLanguage]]}</th>
+			<th align=left>${[translations.Device[this.config.userSelectedLanguage]]}</th>
+			<th align=center width=120>${[translations.Adapter[this.config.userSelectedLanguage]]}</th>
+			<th align=${isLowBatteryList ? 'center' : 'right'}>${[translations.Battery[this.config.userSelectedLanguage]]}</th>
 			</tr>
 			<tr>
 			<td colspan="5"><hr></td>
 			</tr>`;
 				for (const device of devices) {
 					html += `<tr>
-				<td><font>${device[translations.Device[this.userSystemLanguage]]}</font></td>
-				<td align=center><font>${device[translations.Adapter[this.userSystemLanguage]]}</font></td>`;
+				<td><font>${device[translations.Device[this.config.userSelectedLanguage]]}</font></td>
+				<td align=center><font>${device[translations.Adapter[this.config.userSelectedLanguage]]}</font></td>`;
 
 					if (isLowBatteryList) {
-						html += `<td align=center><font color=orange>${device[translations.Battery[this.userSystemLanguage]]}</font></td>`;
+						html += `<td align=center><font color=orange>${device[translations.Battery[this.config.userSelectedLanguage]]}</font></td>`;
 					} else {
-						html += `<td align=right><font color=#3bcf0e>${device[translations.Battery[this.userSystemLanguage]]}</font></td>`;
+						html += `<td align=right><font color=#3bcf0e>${device[translations.Battery[this.config.userSelectedLanguage]]}</font></td>`;
 					}
 					html += `</tr>`;
 				}
@@ -3402,14 +3402,14 @@ class DeviceWatcher extends utils.Adapter {
 					return a.localeCompare(b);
 				});
 				html = `<center>
-				<b>${[translations.All_Instances[this.userSystemLanguage]]}:<font> ${instancesCount}</b><small></small></font>
+				<b>${[translations.All_Instances[this.config.userSelectedLanguage]]}:<font> ${instancesCount}</b><small></small></font>
 				<p></p>
 				</center>   
 				<table width=100%>
 				<tr>
-				<th align=left>${[translations.Adapter[this.userSystemLanguage]]}</th>
-				<th align=center>${[translations.Instance[this.userSystemLanguage]]}</th>
-				<th align=center width=180>${[translations.Status[this.userSystemLanguage]]}</th>
+				<th align=left>${[translations.Adapter[this.config.userSelectedLanguage]]}</th>
+				<th align=center>${[translations.Instance[this.config.userSelectedLanguage]]}</th>
+				<th align=center width=180>${[translations.Status[this.config.userSelectedLanguage]]}</th>
 				</tr>
 				<tr>
 				<td colspan="5"><hr></td>
@@ -3417,9 +3417,9 @@ class DeviceWatcher extends utils.Adapter {
 
 				for (const instanceData of instances) {
 					html += `<tr>
-					<td><font>${instanceData[translations.Adapter[this.userSystemLanguage]]}</font></td>
-					<td align=center><font>${instanceData[translations.Instance[this.userSystemLanguage]]}</font></td>
-					<td align=center><font>${instanceData[translations.Status[this.userSystemLanguage]]}</font></td>
+					<td><font>${instanceData[translations.Adapter[this.config.userSelectedLanguage]]}</font></td>
+					<td align=center><font>${instanceData[translations.Instance[this.config.userSelectedLanguage]]}</font></td>
+					<td align=center><font>${instanceData[translations.Status[this.config.userSelectedLanguage]]}</font></td>
 					</tr>`;
 				}
 
@@ -3433,14 +3433,14 @@ class DeviceWatcher extends utils.Adapter {
 					return a.localeCompare(b);
 				});
 				html = `<center>
-				<b>${[translations.Active_Instances[this.userSystemLanguage]]}: <font> ${instancesCount}</b><small></small></font>
+				<b>${[translations.Active_Instances[this.config.userSelectedLanguage]]}: <font> ${instancesCount}</b><small></small></font>
 				<p></p>
 				</center>   
 				<table width=100%>
 				<tr>
-				<th align=left>${[translations.Adapter[this.userSystemLanguage]]}</th>
-				<th align=center>${[translations.Instance[this.userSystemLanguage]]}</th>
-				<th align=center width=180>${[translations.Status[this.userSystemLanguage]]}</th>
+				<th align=left>${[translations.Adapter[this.config.userSelectedLanguage]]}</th>
+				<th align=center>${[translations.Instance[this.config.userSelectedLanguage]]}</th>
+				<th align=center width=180>${[translations.Status[this.config.userSelectedLanguage]]}</th>
 				</tr>
 				<tr>
 				<td colspan="5"><hr></td>
@@ -3448,9 +3448,9 @@ class DeviceWatcher extends utils.Adapter {
 
 				for (const instanceData of instances) {
 					html += `<tr>
-					<td><font>${instanceData[translations.Adapter[this.userSystemLanguage]]}</font></td>
-					<td align=center><font>${instanceData[translations.Instance[this.userSystemLanguage]]}</font></td>
-					<td align=center><font color=orange>${instanceData[translations.Status[this.userSystemLanguage]]}</font></td>
+					<td><font>${instanceData[translations.Adapter[this.config.userSelectedLanguage]]}</font></td>
+					<td align=center><font>${instanceData[translations.Instance[this.config.userSelectedLanguage]]}</font></td>
+					<td align=center><font color=orange>${instanceData[translations.Status[this.config.userSelectedLanguage]]}</font></td>
 					</tr>`;
 				}
 
@@ -3464,14 +3464,14 @@ class DeviceWatcher extends utils.Adapter {
 					return a.localeCompare(b);
 				});
 				html = `<center>
-				<b>${[translations.Error_Instances[this.userSystemLanguage]]}: <font color=${instancesCount === 0 ? '#3bcf0e' : 'orange'}>${instancesCount}</b><small></small></font>
+				<b>${[translations.Error_Instances[this.config.userSelectedLanguage]]}: <font color=${instancesCount === 0 ? '#3bcf0e' : 'orange'}>${instancesCount}</b><small></small></font>
 				<p></p>
 				</center>   
 				<table width=100%>
 				<tr>
-				<th align=left>${[translations.Adapter[this.userSystemLanguage]]}</th>
-				<th align=center>${[translations.Instance[this.userSystemLanguage]]}</th>
-				<th align=center width=180>${[translations.Status[this.userSystemLanguage]]}</th>
+				<th align=left>${[translations.Adapter[this.config.userSelectedLanguage]]}</th>
+				<th align=center>${[translations.Instance[this.config.userSelectedLanguage]]}</th>
+				<th align=center width=180>${[translations.Status[this.config.userSelectedLanguage]]}</th>
 				</tr>
 				<tr>
 				<td colspan="5"><hr></td>
@@ -3479,9 +3479,9 @@ class DeviceWatcher extends utils.Adapter {
 
 				for (const instanceData of instances) {
 					html += `<tr>
-					<td><font>${instanceData[translations.Adapter[this.userSystemLanguage]]}</font></td>
-					<td align=center><font>${instanceData[translations.Instance[this.userSystemLanguage]]}</font></td>
-					<td align=center><font color=orange>${instanceData[translations.Status[this.userSystemLanguage]]}</font></td>
+					<td><font>${instanceData[translations.Adapter[this.config.userSelectedLanguage]]}</font></td>
+					<td align=center><font>${instanceData[translations.Instance[this.config.userSelectedLanguage]]}</font></td>
+					<td align=center><font color=orange>${instanceData[translations.Status[this.config.userSelectedLanguage]]}</font></td>
 					</tr>`;
 				}
 
@@ -3495,14 +3495,14 @@ class DeviceWatcher extends utils.Adapter {
 					return a.localeCompare(b);
 				});
 				html = `<center>
-				<b>${[translations.Deactivated_Instances[this.userSystemLanguage]]}: <font color=${instancesCount === 0 ? '#3bcf0e' : 'orange'}>${instancesCount}</b><small></small></font>
+				<b>${[translations.Deactivated_Instances[this.config.userSelectedLanguage]]}: <font color=${instancesCount === 0 ? '#3bcf0e' : 'orange'}>${instancesCount}</b><small></small></font>
 				<p></p>
 				</center>   
 				<table width=100%>
 				<tr>
-				<th align=left>${[translations.Adapter[this.userSystemLanguage]]}</th>
-				<th align=center>${[translations.Instance[this.userSystemLanguage]]}</th>
-				<th align=center width=180>${[translations.Status[this.userSystemLanguage]]}</th>
+				<th align=left>${[translations.Adapter[this.config.userSelectedLanguage]]}</th>
+				<th align=center>${[translations.Instance[this.config.userSelectedLanguage]]}</th>
+				<th align=center width=180>${[translations.Status[this.config.userSelectedLanguage]]}</th>
 				</tr>
 				<tr>
 				<td colspan="5"><hr></td>
@@ -3511,9 +3511,9 @@ class DeviceWatcher extends utils.Adapter {
 				for (const instanceData of instances) {
 					if (!instanceData.isAlive) {
 						html += `<tr>
-					<td><font>${instanceData[translations.Adapter[this.userSystemLanguage]]}</font></td>
-					<td align=center><font>${instanceData[translations.Instance[this.userSystemLanguage]]}</font></td>
-					<td align=center><font color=orange>${instanceData[translations.Status[this.userSystemLanguage]]}</font></td>
+					<td><font>${instanceData[translations.Adapter[this.config.userSelectedLanguage]]}</font></td>
+					<td align=center><font>${instanceData[translations.Instance[this.config.userSelectedLanguage]]}</font></td>
+					<td align=center><font color=orange>${instanceData[translations.Status[this.config.userSelectedLanguage]]}</font></td>
 					</tr>`;
 					}
 				}
@@ -3523,14 +3523,14 @@ class DeviceWatcher extends utils.Adapter {
 
 			case 'updateAdapterList':
 				html = `<center>
-				<b>${[translations.Updatable_adapters[this.userSystemLanguage]]}: <font color=${instancesCount === 0 ? '#3bcf0e' : 'orange'}>${instancesCount}</b><small></small></font>
+				<b>${[translations.Updatable_adapters[this.config.userSelectedLanguage]]}: <font color=${instancesCount === 0 ? '#3bcf0e' : 'orange'}>${instancesCount}</b><small></small></font>
 				<p></p>
 				</center>   
 				<table width=100%>
 				<tr>
-				<th align=left>${[translations.Adapter[this.userSystemLanguage]]}</th>
-				<th align=center>${[translations.Installed_Version[this.userSystemLanguage]]}</th>
-				<th align=center>${[translations.Available_Version[this.userSystemLanguage]]}</th>
+				<th align=left>${[translations.Adapter[this.config.userSelectedLanguage]]}</th>
+				<th align=center>${[translations.Installed_Version[this.config.userSelectedLanguage]]}</th>
+				<th align=center>${[translations.Available_Version[this.config.userSelectedLanguage]]}</th>
 				</tr>
 				<tr>
 				<td colspan="5"><hr></td>
@@ -3539,9 +3539,9 @@ class DeviceWatcher extends utils.Adapter {
 				for (const instanceData of instances.values()) {
 					if (instanceData.updateAvailable !== ' - ') {
 						html += `<tr>
-					<td><font>${instanceData[translations.Adapter[this.userSystemLanguage]]}</font></td>
-					<td align=center><font>${instanceData[translations.Installed_Version[this.userSystemLanguage]]}</font></td>
-					<td align=center><font color=orange>${instanceData[translations.Available_Version[this.userSystemLanguage]]}</font></td>
+					<td><font>${instanceData[translations.Adapter[this.config.userSelectedLanguage]]}</font></td>
+					<td align=center><font>${instanceData[translations.Installed_Version[this.config.userSelectedLanguage]]}</font></td>
+					<td align=center><font color=orange>${instanceData[translations.Available_Version[this.config.userSelectedLanguage]]}</font></td>
 					</tr>`;
 					}
 				}