iobroker.device-watcher 2.2.2 → 2.3.1

package/main.js

@@ -30,6 +30,7 @@ class DeviceWatcher extends utils.Adapter {
 		this.batteryLowPowered = [];
 		this.listAllDevices = [];
 		this.blacklistLists = [];
+		this.blacklistAdapterLists = [];
 		this.blacklistNotify = [];
 		this.arrDev = [];
 		this.adapterSelected = [];
@@ -78,6 +79,7 @@ class DeviceWatcher extends utils.Adapter {
 				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,
@@ -126,6 +128,7 @@ class DeviceWatcher extends utils.Adapter {
 				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,
@@ -247,6 +250,7 @@ class DeviceWatcher extends utils.Adapter {
 			let oldLowBatState;
 			let contactData;
 			let oldStatus;
+			let isLowBatValue;
 
 			for (const device of this.listAllDevicesRaw) {
 				// On statechange update available datapoint
@@ -271,7 +275,12 @@ class DeviceWatcher extends utils.Adapter {
 
 							device.Battery = batteryData[0];
 							device.BatteryRaw = batteryData[2];
-							device.LowBat = await this.setLowbatIndicator(state.val, undefined, device.LowBatDP);
+							if (device.LowBatDP !== 'none') {
+								isLowBatValue = await this.getInitValue(device.LowBatDP);
+							} else {
+								isLowBatValue = undefined;
+							}
+							device.LowBat = await this.setLowbatIndicator(state.val, isLowBatValue, device.faultReport, device.adapterID);
 
 							if (device.LowBat && oldLowBatState !== device.LowBat) {
 								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(device.Path)) {
@@ -287,7 +296,7 @@ class DeviceWatcher extends utils.Adapter {
 							batteryData = await this.getBatteryData(device.BatteryRaw, state.val, device.adapterID);
 							device.Battery = batteryData[0];
 							device.BatteryRaw = batteryData[2];
-							device.LowBat = await this.setLowbatIndicator(device.BatteryRaw, state.val, device.LowBatDP);
+							device.LowBat = await this.setLowbatIndicator(device.BatteryRaw, state.val, device.faultReport, device.adapterID);
 
 							if (device.LowBat && oldLowBatState !== device.LowBat) {
 								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(device.Path)) {
@@ -295,16 +304,30 @@ class DeviceWatcher extends utils.Adapter {
 								}
 							}
 						}
+						break;
 
+					case device.faultReportDP:
+						if (device.isBatteryDevice) {
+							oldLowBatState = device.LowBat;
+							batteryData = await this.getBatteryData(device.BatteryRaw, oldLowBatState, device.adapterID);
+
+							device.Battery = batteryData[0];
+							device.BatteryRaw = batteryData[2];
+							device.LowBat = await this.setLowbatIndicator(device.BatteryRaw, undefined, state.val, device.adapterID);
+
+							if (device.LowBat && oldLowBatState !== device.LowBat) {
+								if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(device.Path)) {
+									await this.sendLowBatNoticiation(device.Device, device.Adapter, device.Battery);
+								}
+							}
+						}
 						break;
+
 					case device.UnreachDP:
-					case device.DeviceStateSelectorDP:
-					case device.rssiPeerSelectorDP:
-					case device.Path:
 						oldStatus = device.Status;
 						device.UnreachState = await this.getInitValue(device.UnreachDP);
 						contactData = await this.getOnlineState(
-							device.Path,
+							device.timeSelector,
 							device.adapterID,
 							device.UnreachDP,
 							device.SignalStrength,
@@ -318,7 +341,7 @@ class DeviceWatcher extends utils.Adapter {
 							device.SignalStrength = contactData[2];
 						}
 
-						if (device.Status && oldStatus !== device.Status && this.config.checkSendOfflineMsg && !this.blacklistNotify.includes(device.Path)) {
+						if (this.config.checkSendOfflineMsg && oldStatus !== device.Status && !this.blacklistNotify.includes(device.Path)) {
 							await this.sendOfflineNotifications(device.Device, device.Adapter, device.Status, device.LastContact);
 						}
 						break;
@@ -341,7 +364,7 @@ class DeviceWatcher extends utils.Adapter {
 					try {
 						result = this.listAllDevicesRaw;
 						for (const element in result) {
-							const label = 'Device: ' + result[element].Device + '  - Adapter: ' + result[element].Adapter;
+							const label = `${result[element].Adapter}: ${result[element].Device}`;
 							const myValueObject = {
 								deviceName: result[element].Device,
 								adapter: result[element].Adapter,
@@ -350,7 +373,13 @@ class DeviceWatcher extends utils.Adapter {
 							devices[myCount] = { label: label, value: JSON.stringify(myValueObject) };
 							myCount++;
 						}
-						this.sendTo(obj.from, obj.command, devices, obj.callback);
+						const sortDevices = devices.slice(0);
+						sortDevices.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, sortDevices, obj.callback);
 					} catch (error) {
 						this.sendTo(obj.from, obj.command, obj.callback);
 					}
@@ -490,6 +519,9 @@ class DeviceWatcher extends utils.Adapter {
 					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);
@@ -500,6 +532,7 @@ class DeviceWatcher extends utils.Adapter {
 			}
 
 			if (this.blacklistLists.length >= 1) this.log.info(`Found items on blacklist for lists: ${this.blacklistLists}`);
+			if (this.blacklistAdapterLists.length >= 1) this.log.info(`Found items on blacklist for lists: ${this.blacklistAdapterLists}`);
 			if (this.blacklistNotify.length >= 1) this.log.info(`Found items on blacklist for notificatioons: ${this.blacklistNotify}`);
 		} else {
 			return; // cancel run if unloaded was called.
@@ -526,15 +559,23 @@ class DeviceWatcher extends utils.Adapter {
 			let folderName;
 			let deviceID;
 
-			// Get ID with currDeviceString from datapoint
 			switch (this.arrDev[i].adapterID) {
-				// Get ID for Switchbot and ESPHome Devices
+				// Get ID with currDeviceString from datapoint
 				case 'switchbotBle':
 				case 'esphome':
 				case 'apcups':
 					deviceName = await this.getInitValue(currDeviceString + this.arrDev[i].id);
 					break;
 
+				case 'eusec':
+					deviceName = await this.getInitValue(currDeviceString + this.arrDev[i].id);
+					if (deviceName === null || deviceName === undefined) {
+						if (deviceObject && typeof deviceObject === 'object') {
+							deviceName = deviceObject.common.name;
+						}
+					}
+					break;
+
 				case 'fullybrowser':
 					deviceName = (await this.getInitValue(currDeviceString + this.arrDev[i].id)) + ' ' + (await this.getInitValue(currDeviceString + this.arrDev[i].id2));
 					break;
@@ -677,77 +718,93 @@ class DeviceWatcher extends utils.Adapter {
 		let batteryHealth;
 		let isBatteryDevice;
 
-		if (deviceBatteryState === undefined) {
-			if (deviceLowBatState !== undefined) {
-				switch (deviceLowBatState) {
-					case 'none':
-						break;
-					default:
-						if (deviceLowBatState !== true || deviceLowBatState === 'NORMAL' || deviceLowBatState === 1) {
+		switch (adapterID) {
+			case 'hmrpc':
+				if (deviceBatteryState === undefined) {
+					if (deviceLowBatState !== undefined) {
+						if (deviceLowBatState !== 1) {
 							batteryHealth = 'ok';
-							isBatteryDevice = true;
 						} else {
 							batteryHealth = 'low';
-							isBatteryDevice = true;
 						}
-						break;
-				}
-			} else {
-				batteryHealth = ' - ';
-			}
-		} else {
-			switch (adapterID) {
-				case 'hmrpc':
-					if (deviceBatteryState === 0 || (deviceBatteryState && deviceBatteryState >= 6)) {
+						isBatteryDevice = true;
+					} else {
+						batteryHealth = ' - ';
+					}
+				} else {
+					if (deviceBatteryState === 0 || deviceBatteryState >= 6) {
 						batteryHealth = ' - ';
 					} else {
 						batteryHealth = deviceBatteryState + 'V';
 						batteryHealthRaw = deviceBatteryState;
 						isBatteryDevice = true;
 					}
-					break;
-				default:
+				}
+				break;
+			default:
+				if (deviceBatteryState === undefined) {
+					if (deviceLowBatState !== undefined) {
+						if (deviceLowBatState !== true || deviceLowBatState === 'NORMAL' || deviceLowBatState === 1) {
+							batteryHealth = 'ok';
+						} else {
+							batteryHealth = 'low';
+						}
+						isBatteryDevice = true;
+					} else {
+						batteryHealth = ' - ';
+					}
+				} else {
 					batteryHealth = deviceBatteryState + '%';
 					batteryHealthRaw = deviceBatteryState;
 					isBatteryDevice = true;
-					break;
-			}
+				}
+				break;
 		}
+
 		return [batteryHealth, isBatteryDevice, batteryHealthRaw];
 	}
 
 	/**
-	 *set low bat indicator
+	 * set low bat indicator
 	 * @param {object} deviceBatteryState
 	 * @param {object} deviceLowBatState
-	 * @param {object} isLowBatDP
+	 * @param {object} faultReportState
+	 * @param {object} adapterID
 	 */
 
-	async setLowbatIndicator(deviceBatteryState, deviceLowBatState, isLowBatDP) {
+	async setLowbatIndicator(deviceBatteryState, deviceLowBatState, faultReportState, adapterID) {
 		let lowBatIndicator = false;
 		/*=============================================
 		=            Set Lowbat indicator             =
 		=============================================*/
-		if (deviceLowBatState !== null && isLowBatDP !== 'none') {
-			switch (typeof deviceLowBatState) {
-				case 'number':
-					if (deviceLowBatState === 0) {
+		if (deviceLowBatState !== undefined || faultReportState !== undefined) {
+			switch (adapterID) {
+				case 'hmrpc':
+					if (deviceLowBatState === 1 || faultReportState === 6) {
 						lowBatIndicator = true;
 					}
 					break;
+				default:
+					switch (typeof deviceLowBatState) {
+						case 'number':
+							if (deviceLowBatState === 0) {
+								lowBatIndicator = true;
+							}
+							break;
 
-				case 'string':
-					if (deviceLowBatState !== 'NORMAL') {
-						// Tado devices
-						lowBatIndicator = true;
-					}
-					break;
+						case 'string':
+							if (deviceLowBatState !== 'NORMAL') {
+								// Tado devices
+								lowBatIndicator = true;
+							}
+							break;
 
-				case 'boolean':
-					if (deviceLowBatState) {
-						lowBatIndicator = true;
+						case 'boolean':
+							if (deviceLowBatState) {
+								lowBatIndicator = true;
+							}
+							break;
 					}
-					break;
 			}
 		} else {
 			if (deviceBatteryState < this.config.minWarnBatterie) {
@@ -777,7 +834,7 @@ class DeviceWatcher extends utils.Adapter {
 
 	/**
 	 * get online state and time
-	 * @param {object} id - ID
+	 * @param {object} timeSelector - device Timeselector
 	 * @param {string} adapterID - ID of Adapter
 	 * @param {string} unreachDP - Datapoint of Unreach
 	 * @param {object} linkQuality - Linkquality Value
@@ -785,33 +842,33 @@ class DeviceWatcher extends utils.Adapter {
 	 * @param {string} deviceStateSelectorDP - Selector of device state (like .state)
 	 * @param {string} rssiPeerSelectorDP - HM RSSI Peer Datapoint
 	 */
-	async getOnlineState(id, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP) {
+	async getOnlineState(timeSelector, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP) {
 		let lastContactString;
 		let deviceState = 'Online';
 
 		try {
-			const deviceMainSelector = await this.getForeignStateAsync(id);
-			if (deviceMainSelector) {
+			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 = await this.getTimestamp(deviceMainSelector.ts);
-				const lastDeviceUnreachStateChange = deviceUnreachSelector != undefined ? await this.getTimestamp(deviceUnreachSelector.lc) : await this.getTimestamp(deviceMainSelector.ts);
+				const lastContact = await this.getTimestamp(deviceTimeSelector.ts);
+				const lastDeviceUnreachStateChange = deviceUnreachSelector != undefined ? await this.getTimestamp(deviceUnreachSelector.lc) : await 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(deviceMainSelector.ts);
+						lastContactString = await this.getLastContact(deviceTimeSelector.ts);
 						break;
 
 					default:
 						//State changed
 						if (adapterID === 'hmrpc') {
 							if (linkQuality !== ' - ') {
-								if (deviceUnreachState) {
-									lastContactString = await this.getLastContact(deviceMainSelector.lc);
+								if (deviceUnreachState === 1) {
+									lastContactString = await this.getLastContact(deviceTimeSelector.lc);
 								} else {
-									lastContactString = await this.getLastContact(deviceMainSelector.ts);
+									lastContactString = await this.getLastContact(deviceTimeSelector.ts);
 								}
 							} else {
 								if (deviceStateSelector) {
@@ -823,10 +880,10 @@ class DeviceWatcher extends utils.Adapter {
 								}
 							}
 						} else {
-							if (!deviceUnreachState) {
-								lastContactString = await this.getLastContact(deviceMainSelector.lc);
+							if (deviceUnreachState === 0) {
+								lastContactString = await this.getLastContact(deviceTimeSelector.lc);
 							} else {
-								lastContactString = await this.getLastContact(deviceMainSelector.ts);
+								lastContactString = await this.getLastContact(deviceTimeSelector.ts);
 							}
 							break;
 						}
@@ -838,6 +895,16 @@ class DeviceWatcher extends utils.Adapter {
 				if (this.maxMinutes !== undefined) {
 					switch (adapterID) {
 						case 'hmrpc':
+							if (this.maxMinutes[adapterID] <= 0) {
+								if (deviceUnreachState === 1) {
+									deviceState = 'Offline'; //set online state to offline
+									linkQuality = '0%'; // set linkQuality to nothing
+								}
+							} else if (lastDeviceUnreachStateChange > this.maxMinutes[adapterID] && deviceUnreachState === 1) {
+								deviceState = 'Offline'; //set online state to offline
+								linkQuality = '0%'; // set linkQuality to nothing
+							}
+							break;
 						case 'hmiP':
 						case 'maxcube':
 							if (this.maxMinutes[adapterID] <= 0) {
@@ -932,7 +999,7 @@ class DeviceWatcher extends utils.Adapter {
 			const oldContactState = device.Status;
 			device.UnreachState = await this.getInitValue(device.UnreachDP);
 			const contactData = await this.getOnlineState(
-				device.Path,
+				device.timeSelector,
 				device.adapterID,
 				device.UnreachDP,
 				device.SignalStrength,
@@ -1011,49 +1078,65 @@ class DeviceWatcher extends utils.Adapter {
 				=============================================*/
 				let deviceBatteryStateDP;
 				let deviceBatteryState;
-				// Get battery states
-				switch (adapterID) {
-					case 'hueExt':
-					case 'mihomeVacuum':
-					case 'mqttNuki':
-						deviceBatteryStateDP = shortCurrDeviceString + this.arrDev[i].battery;
-						deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
-						if (deviceBatteryState === undefined) {
-							deviceBatteryStateDP = shortCurrDeviceString + this.arrDev[i].battery2;
+				let batteryHealth;
+				let batteryHealthRaw;
+				let lowBatIndicator;
+				let isBatteryDevice;
+				let isLowBatDP;
+				let faultReportingDP;
+				let faultReportingState;
+
+				const deviceChargerStateDP = currDeviceString + this.arrDev[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.arrDev[i].battery;
 							deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
-						}
-						break;
-					default:
-						deviceBatteryStateDP = currDeviceString + this.arrDev[i].battery;
-						deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
-						if (deviceBatteryState === undefined) {
-							deviceBatteryStateDP = currDeviceString + this.arrDev[i].battery2;
+							if (deviceBatteryState === undefined) {
+								deviceBatteryStateDP = shortCurrDeviceString + this.arrDev[i].battery2;
+								deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
+							}
+							break;
+						default:
+							deviceBatteryStateDP = currDeviceString + this.arrDev[i].battery;
 							deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
-						}
-						break;
-				}
+							if (deviceBatteryState === undefined) {
+								deviceBatteryStateDP = currDeviceString + this.arrDev[i].battery2;
+								deviceBatteryState = await this.getInitValue(deviceBatteryStateDP);
+							}
+							break;
+					}
 
-				// Get low bat states
-				let isLowBatDP = currDeviceString + this.arrDev[i].isLowBat;
-				let deviceLowBatState = await this.getInitValue(isLowBatDP);
-				if (deviceLowBatState === undefined) {
-					isLowBatDP = currDeviceString + this.arrDev[i].isLowBat2;
-					deviceLowBatState = await this.getInitValue(isLowBatDP);
-				}
-				if (deviceLowBatState === undefined) isLowBatDP = 'none';
+					// Get low bat states
+					isLowBatDP = currDeviceString + this.arrDev[i].isLowBat;
+					let deviceLowBatState = await this.getInitValue(isLowBatDP);
+					if (deviceLowBatState === undefined) {
+						isLowBatDP = currDeviceString + this.arrDev[i].isLowBat2;
+						deviceLowBatState = await this.getInitValue(isLowBatDP);
+					}
+					if (deviceLowBatState === undefined) isLowBatDP = 'none';
 
-				//subscribe to states
-				this.subscribeForeignStatesAsync(deviceBatteryStateDP);
-				this.subscribeForeignStatesAsync(isLowBatDP);
+					faultReportingDP = shortCurrDeviceString + this.arrDev[i].faultReporting;
+					faultReportingState = await this.getInitValue(faultReportingDP);
 
-				const batteryData = await this.getBatteryData(deviceBatteryState, deviceLowBatState, adapterID);
-				const batteryHealth = batteryData[0];
-				const batteryHealthRaw = batteryData[2];
-				const isBatteryDevice = batteryData[1];
-				let lowBatIndicator;
+					//subscribe to states
+					this.subscribeForeignStatesAsync(deviceBatteryStateDP);
+					this.subscribeForeignStatesAsync(isLowBatDP);
+					this.subscribeForeignStatesAsync(faultReportingDP);
+
+					const batteryData = await this.getBatteryData(deviceBatteryState, deviceLowBatState, adapterID);
+					batteryHealth = batteryData[0];
+					batteryHealthRaw = batteryData[2];
+					isBatteryDevice = batteryData[1];
 
-				if (isBatteryDevice) {
-					lowBatIndicator = await this.setLowbatIndicator(deviceBatteryState, deviceLowBatState, isLowBatDP);
+					if (isBatteryDevice) {
+						lowBatIndicator = await this.setLowbatIndicator(deviceBatteryState, deviceLowBatState, faultReportingState, adapterID);
+					}
 				}
 
 				/*=============================================
@@ -1062,6 +1145,7 @@ class DeviceWatcher extends utils.Adapter {
 				let unreachDP = currDeviceString + this.arrDev[i].reach;
 				const deviceStateSelectorDP = shortCurrDeviceString + this.arrDev[i].stateValue;
 				const rssiPeerSelectorDP = currDeviceString + this.arrDev[i].rssiPeerState;
+				const timeSelector = currDeviceString + this.arrDev[i].timeSelector;
 
 				let deviceUnreachState = await this.getInitValue(unreachDP);
 				if (deviceUnreachState === undefined) {
@@ -1070,12 +1154,12 @@ class DeviceWatcher extends utils.Adapter {
 				}
 
 				// subscribe to states
-				this.subscribeForeignStatesAsync(id);
+				this.subscribeForeignStatesAsync(timeSelector);
 				this.subscribeForeignStatesAsync(unreachDP);
 				this.subscribeForeignStatesAsync(deviceStateSelectorDP);
 				this.subscribeForeignStatesAsync(rssiPeerSelectorDP);
 
-				const onlineState = await this.getOnlineState(id, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP);
+				const onlineState = await this.getOnlineState(timeSelector, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP);
 				let deviceState;
 				let lastContactString;
 
@@ -1114,12 +1198,15 @@ class DeviceWatcher extends utils.Adapter {
 						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,
@@ -1138,12 +1225,15 @@ class DeviceWatcher extends utils.Adapter {
 						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,
@@ -1181,78 +1271,35 @@ class DeviceWatcher extends utils.Adapter {
 		}
 
 		for (const device of this.listAllDevicesRaw) {
-			if (device.adapterID.includes(adptName)) {
-				/*----------  fill raw lists  ----------*/
-				// low bat list
-				if (device.LowBat && device.Status !== 'Offline') {
-					this.batteryLowPoweredRaw.push({
-						Path: device.Path,
-						Device: device.Device,
-						Adapter: device.Adapter,
-						Battery: device.Battery,
-					});
-				}
-				// offline raw list
-				if (device.Status === 'Offline') {
-					this.offlineDevicesRaw.push({
-						Path: device.Path,
-						Device: device.Device,
-						Adapter: device.Adapter,
-						'Last contact': device.LastContact,
-					});
-				}
-
-				/*----------  fill user lists  ----------*/
-				if (!this.blacklistLists.includes(device.Path)) {
-					this.listAllDevices.push({
-						Device: device.Device,
-						Adapter: device.Adapter,
-						Battery: device.Battery,
-						'Signal strength': device.SignalStrength,
-						'Last contact': device.LastContact,
-						Status: device.Status,
-					});
-					// LinkQuality lists
-					if (device.SignalStrength != ' - ') {
-						this.linkQualityDevices.push({
-							Device: device.Device,
-							Adapter: device.Adapter,
-							'Signal strength': device.SignalStrength,
-						});
-					}
-					// Battery lists
-					if (device['isBatteryDevice']) {
-						this.batteryPowered.push({
-							Device: device.Device,
-							Adapter: device.Adapter,
-							Battery: device.Battery,
-							Status: device.Status,
-						});
-					}
-					// Low Bat lists
-					if (device.LowBat && device.Status !== 'Offline') {
-						this.batteryLowPowered.push({
-							Device: device.Device,
-							Adapter: device.Adapter,
-							Battery: device.Battery,
-						});
-					}
+			/*----------  fill raw lists  ----------*/
+			// low bat list
+			if (device.LowBat && device.Status !== 'Offline') {
+				this.batteryLowPoweredRaw.push({
+					Path: device.Path,
+					Device: device.Device,
+					Adapter: device.Adapter,
+					Battery: device.Battery,
+				});
+			}
+			// offline raw list
+			if (device.Status === 'Offline') {
+				this.offlineDevicesRaw.push({
+					Path: device.Path,
+					Device: device.Device,
+					Adapter: device.Adapter,
+					LastContact: device.LastContact,
+				});
+			}
 
-					// Offline List
-					if (device.Status === 'Offline') {
-						this.offlineDevices.push({
-							Device: device.Device,
-							Adapter: device.Adapter,
-							'Last contact': device.LastContact,
-						});
-					}
+			if (adptName === '' && !this.blacklistLists.includes(device.Path)) {
+				await this.theLists(device);
+			}
 
-					// Device update List
-					if (device.Upgradable) {
-						this.upgradableList.push({
-							Device: device.Device,
-							Adapter: device.Adapter,
-						});
+			if (this.config.createOwnFolder && adptName !== '') {
+				if (device.adapterID.includes(adptName)) {
+					/*----------  fill user lists for each adapter  ----------*/
+					if (!this.blacklistAdapterLists.includes(device.Path)) {
+						await this.theLists(device);
 					}
 				}
 			}
@@ -1260,6 +1307,67 @@ class DeviceWatcher extends utils.Adapter {
 		await this.countDevices();
 	}
 
+	/**
+	 * fill the lists for user
+	 * @param {object} device
+	 */
+	async theLists(device) {
+		// List with all devices
+		this.listAllDevices.push({
+			Device: device.Device,
+			Adapter: device.Adapter,
+			Battery: device.Battery,
+			'Signal strength': device.SignalStrength,
+			'Last contact': device.LastContact,
+			Status: device.Status,
+		});
+
+		// LinkQuality lists
+		if (device.SignalStrength != ' - ') {
+			this.linkQualityDevices.push({
+				Device: device.Device,
+				Adapter: device.Adapter,
+				'Signal strength': device.SignalStrength,
+			});
+		}
+
+		// Battery lists
+		if (device.isBatteryDevice) {
+			this.batteryPowered.push({
+				Device: device.Device,
+				Adapter: device.Adapter,
+				Battery: device.Battery,
+				Status: device.Status,
+			});
+		}
+
+		// Low Bat lists
+		if (device.LowBat && device.Status !== 'Offline') {
+			this.batteryLowPowered.push({
+				Device: device.Device,
+				Adapter: device.Adapter,
+				Battery: device.Battery,
+			});
+		}
+
+		// Offline List
+		if (device.Status === 'Offline') {
+			this.offlineDevices.push({
+				Device: device.Device,
+				Adapter: device.Adapter,
+				'Last contact': device.LastContact,
+			});
+		}
+
+		// Device update List
+		if (device.Upgradable) {
+			this.upgradableList.push({
+				Device: device.Device,
+				Adapter: device.Adapter,
+			});
+		}
+	}
+
 	/**
 	 * Count devices for each type
 	 */
@@ -1744,18 +1852,21 @@ class DeviceWatcher extends utils.Adapter {
 				dpSubFolder = '';
 			}
 
+			// Write Datapoints for counts
 			await this.setStateAsync(`${dpSubFolder}offlineCount`, { val: this.offlineDevicesCount, ack: true });
 			await this.setStateAsync(`${dpSubFolder}countAll`, { val: this.deviceCounter, ack: true });
 			await this.setStateAsync(`${dpSubFolder}batteryCount`, { val: this.batteryPoweredCount, ack: true });
 			await this.setStateAsync(`${dpSubFolder}lowBatteryCount`, { val: this.lowBatteryPoweredCount, ack: true });
 			await this.setStateAsync(`${dpSubFolder}upgradableCount`, { val: this.upgradableDevicesCount, ack: true });
 
+			// List all devices
 			if (this.deviceCounter === 0) {
 				// if no device is count, write the JSON List with default value
 				this.listAllDevices = [{ Device: '--none--', Adapter: '', Battery: '', 'Last contact': '', 'Signal strength': '' }];
 			}
 			await this.setStateAsync(`${dpSubFolder}listAll`, { val: JSON.stringify(this.listAllDevices), ack: true });
 
+			// 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': '' }];
@@ -1766,6 +1877,7 @@ class DeviceWatcher extends utils.Adapter {
 				ack: true,
 			});
 
+			// 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': '' }];
@@ -1776,6 +1888,7 @@ class DeviceWatcher extends utils.Adapter {
 				ack: true,
 			});
 
+			// 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': '' }];
@@ -1786,6 +1899,7 @@ class DeviceWatcher extends utils.Adapter {
 				ack: true,
 			});
 
+			// List battery powered
 			if (this.batteryPoweredCount === 0) {
 				// if no device is count, write the JSON List with default value
 				this.batteryPowered = [{ Device: '--none--', Adapter: '', Battery: '' }];
@@ -1796,6 +1910,7 @@ class DeviceWatcher extends utils.Adapter {
 				ack: true,
 			});
 
+			// list battery low powered
 			if (this.lowBatteryPoweredCount === 0) {
 				// if no device is count, write the JSON List with default value
 				this.batteryLowPowered = [{ Device: '--none--', Adapter: '', Battery: '' }];
@@ -1806,6 +1921,43 @@ class DeviceWatcher extends utils.Adapter {
 				ack: true,
 			});
 
+			// set booleans datapoints
+			if (this.offlineDevicesCount === 0) {
+				await this.setStateAsync(`${dpSubFolder}oneDeviceOffline`, {
+					val: false,
+					ack: true,
+				});
+			} else {
+				await this.setStateAsync(`${dpSubFolder}oneDeviceOffline`, {
+					val: true,
+					ack: true,
+				});
+			}
+
+			if (this.lowBatteryPoweredCount === 0) {
+				await this.setStateAsync(`${dpSubFolder}oneDeviceLowBat`, {
+					val: false,
+					ack: true,
+				});
+			} else {
+				await this.setStateAsync(`${dpSubFolder}oneDeviceLowBat`, {
+					val: true,
+					ack: true,
+				});
+			}
+
+			if (this.upgradableDevicesCount === 0) {
+				await this.setStateAsync(`${dpSubFolder}oneDeviceUpdatable`, {
+					val: false,
+					ack: true,
+				});
+			} else {
+				await this.setStateAsync(`${dpSubFolder}oneDeviceUpdatable`, {
+					val: true,
+					ack: true,
+				});
+			}
+
 			//write HTML list
 			if (this.createHtmlList) {
 				await this.setStateAsync(`${dpSubFolder}linkQualityListHTML`, {
@@ -1863,7 +2015,7 @@ class DeviceWatcher extends utils.Adapter {
 			html += `<tr>
 			<td><font>${device.Device}</font></td>
 			<td align=center><font>${device.Adapter}</font></td>
-			<td align=right><font>${device.SignalStrength}</font></td>
+			<td align=right><font>${device['Signal strength']}</font></td>
 			</tr>`;
 		}
 
@@ -1899,7 +2051,7 @@ class DeviceWatcher extends utils.Adapter {
 			html += `<tr>
 			<td><font>${device.Device}</font></td>
 			<td align=center><font>${device.Adapter}</font></td>
-			<td align=center><font color=orange>${device.LastContact}</font></td>
+			<td align=center><font color=orange>${device['Last contact']}</font></td>
 			</tr>`;
 		}
 
@@ -2007,6 +2159,31 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
+		await this.setObjectNotExistsAsync(`${adptName}.oneDeviceOffline`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'Is one device with offline',
+					de: 'Ist ein Gerät mit Offline',
+					ru: 'Это одно устройство с offline',
+					pt: 'É um dispositivo com offline',
+					nl: 'Is een apparaat met offline',
+					fr: 'Est un appareil avec hors ligne',
+					it: 'È un dispositivo con offline',
+					es: 'Es un dispositivo sin conexión',
+					pl: 'Jest to jeden urządzenie z offlinem',
+					uk: 'Є один пристрій з автономним',
+					'zh-cn': '一处有线装置',
+				},
+				type: 'boolean',
+				role: 'state',
+				read: true,
+				write: false,
+				def: false,
+			},
+			native: {},
+		});
+
 		await this.setObjectNotExistsAsync(`${adptName}.listAll`, {
 			type: 'state',
 			common: {
@@ -2145,6 +2322,31 @@ class DeviceWatcher extends utils.Adapter {
 			native: {},
 		});
 
+		await this.setObjectNotExistsAsync(`${adptName}.oneDeviceLowBat`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'Is one device with low battery',
+					de: 'Ist ein Gerät mit niedrigem Akku',
+					ru: 'Один прибор с низкой батареей',
+					pt: 'É um dispositivo com bateria baixa',
+					nl: 'Is een apparaat met lage batterijen',
+					fr: 'Est un appareil avec batterie basse',
+					it: 'È un dispositivo con batteria bassa',
+					es: 'Es un dispositivo con batería baja',
+					pl: 'Jest to jeden urządzenie z niską baterią',
+					uk: 'Є одним пристроєм з низьких акумуляторів',
+					'zh-cn': '低电池的装置',
+				},
+				type: 'boolean',
+				role: 'state',
+				read: true,
+				write: false,
+				def: false,
+			},
+			native: {},
+		});
+
 		await this.setObjectNotExistsAsync(`${adptName}.batteryCount`, {
 			type: 'state',
 			common: {
@@ -2215,6 +2417,31 @@ class DeviceWatcher extends utils.Adapter {
 			},
 			native: {},
 		});
+
+		await this.setObjectNotExistsAsync(`${adptName}.oneDeviceUpdatable`, {
+			type: 'state',
+			common: {
+				name: {
+					en: 'Is one device updatable',
+					de: 'Ist ein Gerät aufnehmbar',
+					ru: 'Одно устройство обновляется',
+					pt: 'É um dispositivo updatable',
+					nl: 'Is een apparaat updat',
+					fr: "Est-ce qu'un appareil est indéfectible",
+					it: 'È un dispositivo updatable',
+					es: 'Es un dispositivo actualizado',
+					pl: 'Jest to jedno urządzenie updatable',
+					uk: 'Є одним пристроєм',
+					'zh-cn': '一台装置',
+				},
+				type: 'boolean',
+				role: 'state',
+				read: true,
+				write: false,
+				def: false,
+			},
+			native: {},
+		});
 	}
 
 	/**