iobroker.device-watcher 0.0.6 → 0.0.8

package/main.js

@@ -16,236 +16,355 @@ class DeviceWatcher extends utils.Adapter {
 			useFormatDate: true,
 		});
 
-		this.refreshEverythingTimeout = null;
-
 		this.on('ready', this.onReady.bind(this));
 		//this.on('stateChange', this.onStateChange.bind(this));
 		// this.on('objectChange', this.onObjectChange.bind(this));
 		// this.on('message', this.onMessage.bind(this));
 		this.on('unload', this.onUnload.bind(this));
+
+		// arrays
+		this.offlineDevices 	= [],
+		this.linkQualityDevices = [];
+		this.batteryPowered 	= [];
+		this.batteryLowPowered 	= [];
+		this.listAllDevices 	= [];
+		this.blacklistArr		= [];
+		this.arrDev				= [];
+
+		// counts
+		this.offlineDevicesCount		= 0;
+		this.deviceCounter				= 0;
+		this.linkQualityCount			= 0;
+		this.batteryPoweredCount 		= 0;
+		this.lowBatteryPoweredCount		= 0;
+
+		// arrays of supported adapters
+		this.arrApart = {
+			//**** This Datapoints are only for the dev ****//
+			test: 		{'Selektor':'0_userdata.*.UNREACH', 'adapter':'test', 'rssiState':'.RSSI_DEVICE', 'battery':'.OPERATING_VOLTAGE', 'reach':'.UNREACH'},
+			test2: 		{'Selektor':'0_userdata.*.reachable', 'adapter':'test2', 'battery':'none', 'reach':'none', 'isLowBat':'none'},
+			test3: 		{'Selektor':'0_userdata.*.link_quality', 'adapter':'test3', 'battery':'.battery', 'reach':'none', 'isLowBat':'none'},
+			//**** End of Dev Datapoints ****//
+			ble: 			{'Selektor':'ble.*.rssi', 'adapter':'Ble', 'battery':'.battery', 'reach':'none', 'isLowBat':'none'},
+			zigbee: 		{'Selektor':'zigbee.*.link_quality', 'adapter':'zigbee', 'battery':'.battery', 'reach':'none', 'isLowBat':'none'},
+			sonoff: 		{'Selektor':'sonoff.*.Wifi_RSSI', 'adapter':'sonoff', 'battery':'.battery', 'reach':'none', 'isLowBat':'none'},
+			shelly: 		{'Selektor':'shelly.*.rssi', 'adapter':'shelly', 'battery':'.sensor.battery', 'reach':'none', 'isLowBat':'none'},
+			homematic: 		{'Selektor':'hm-rpc.*.UNREACH', 'adapter':'homematic', 'rssiState':'.RSSI_DEVICE', 'battery':'.OPERATING_VOLTAGE', 'reach':'.UNREACH', 'isLowBat':'.LOW_BAT', 'isLowBat2':'.LOWBAT'},
+			deconz: 		{'Selektor':'deconz.*.reachable', 'adapter':'deconz', 'battery':'.battery', 'reach':'.reachable', 'isLowBat':'none'},
+			zwave: 			{'Selektor':'zwave2.*.ready', 'adapter':'zwave', 'battery':'.Battery.level', 'reach':'.ready', 'isLowBat':'.Battery.isLow'},
+			dect: 			{'Selektor':'fritzdect.*.present', 'adapter':'fritzDect', 'battery':'.battery', 'reach':'.present', 'isLowBat':'.batterylow'},
+			hue: 			{'Selektor':'hue.*.reachable', 'adapter':'hue', 'battery':'.battery', 'reach':'.reachable', 'isLowBat':'none'},
+			hueExt: 		{'Selektor':'hue-extended.*.reachable', 'adapter':'hue extended', 'battery':'.config.battery', 'reach':'.reachable', 'isLowBat':'none'},
+			ping: 			{'Selektor':'ping.*.alive', 'adapter':'ping', 'battery':'none', 'reach':'.alive', 'isLowBat':'none'},
+			switchbotBle: 	{'Selektor':'switchbot-ble.*.rssi', 'adapter':'switchbot ble', 'battery':'.battery', 'reach':'none', 'isLowBat':'none', 'id':'.id'},
+			sonos: 			{'Selektor':'sonos.*.alive', 'adapter':'sonos', 'battery':'none', 'reach':'.alive', 'isLowBat':'none'},
+			mihome: 		{'Selektor':'mihome.*.percent', 'adapter':'miHome', 'battery':'.percent', 'reach':'none', 'isLowBat':'none'},
+			mihomeGW:		{'Selektor':'mihome.*.connected', 'adapter':'miHome', 'battery':'none', 'reach':'.connected', 'isLowBat':'none'}
+		};
 	}
 
 	async onReady() {
-		this.log.debug('Adapter Device-Watcher was started');
+		this.log.debug(`Adapter ${adapterName} was started`);
 
 		try {
 			await this.main();
+			await this.sendNotifications();
+			await this.writeDatapoints();
 			this.log.debug('all done, exiting');
 			this.terminate ? this.terminate('Everything done. Going to terminate till next schedule', 11) : process.exit(0);
 		} catch (e) {
-			this.log.error('Error while running Device-Watcher. Error Message:' + e);
+			this.log.error(`Error while running Device-Watcher. Error Message: ${e}`);
 			this.terminate ? this.terminate(15) : process.exit(15);
 		}
-
-
-
 	}
 
-	async main() {
-
-		//Helperfunctions
-		//capitalize the first letter
-		/*
-		async function capitalize(sentence)
-		{
-			return sentence && sentence[0].toUpperCase() + sentence.slice(1);
-		}*/
-
-		const pushover = {
-			instance: this.config.instancePushover,
-			title: this.config.titlePushover,
-			device: this.config.devicePushover
-
-		};
-		const telegram = {
-			instance: this.config.instanceTelegram,
-			user: this.config.deviceTelegram
-		};
-		const email = {
-			instance: this.config.instanceEmail,
-			subject: this.config.subjectEmail,
-			sendTo: this.config.sendToEmail
-
-		};
-		const jarvis = {
-			instance: this.config.instanceJarvis,
-			title: this.config.titleJarvis
+	//Helpfunctions
+	async capitalize(sentence)
+	{
+		return sentence && sentence[0].toUpperCase() + sentence.slice(1);
+	}
 
-		};
-		const choosedDays = {
-			monday: this.config.checkMonday,
-			tuesday: this.config.checkTuesday,
-			wednesday: this.config.checkWednesday,
-			thursday: this.config.checkThursday,
-			friday: this.config.checkFriday,
-			saturday: this.config.checkSaturday,
-			sunday: this.config.checkSunday,
-		};
+	async getInitValue(obj) {
+		const foreignState = await this.getForeignStateAsync(obj);
+		if (foreignState) return foreignState.val;
+	}
 
-		const sendPushover = async (text) => {
-			await this.sendToAsync(pushover.instance, 'send', {
-				message: text,
-				title: pushover.title,
-				device: pushover.device
-			});
-		};
+	async getOwnInitValue(obj) {
+		const stateVal = await this.getStateAsync(obj);
+		if (stateVal) return stateVal.val;
+	}
 
-		const sendTelegram = async (text) => {
-			await this.sendToAsync(telegram.instance, 'send', {
-				text: text,
-				user: telegram.user
-			});
-		};
+	async createDPsForEachAdapter(adptName) {
+		await this.setObjectNotExistsAsync(`${adptName}.offlineCount`, {
+			'type': 'state',
+			'common': {
+				'name': 'Quantity devices offline',
+				'type': 'number',
+				'role': 'value',
+				'read': true,
+				'write': false,
+				'def': 0
+			},
+			'native': {}
+		});
+		await this.setObjectNotExistsAsync(`${adptName}.offlineList`, {
+			'type': 'state',
+			'common': {
+				'name': 'List devices offline',
+				'type': 'array',
+				'role': 'json',
+				'read': true,
+				'write': false,
+				'def': [{Device: '--keine--', Adapter: '', Last_contact: ''}]
+			},
+			'native': {}
+		});
+		await this.setObjectNotExistsAsync(`${adptName}.listAll`, {
+			'type': 'state',
+			'common': {
+				'name': 'List all devices',
+				'type': 'array',
+				'role': 'json',
+				'read': true,
+				'write': false,
+				'def': [{Device: '--keine--', Adapter: '', Battery: '', Last_contact: '', Link_quality: ''}]
+			},
+			'native': {}
+		});
+		await this.setObjectNotExistsAsync(`${adptName}.linkQualityList`, {
+			'type': 'state',
+			'common': {
+				'name': 'List devices with qualitiy strength',
+				'type': 'array',
+				'role': 'json',
+				'read': true,
+				'write': false,
+				'def': [{Device: '--keine--', Adapter: '', Link_quality: ''}]
+			},
+			'native': {}
+		});
+		await this.setObjectNotExistsAsync(`${adptName}.countAll`, {
+			'type': 'state',
+			'common': {
+				'name': 'Quantity devices all',
+				'type': 'number',
+				'role': 'value',
+				'read': true,
+				'write': false,
+				'def': 0
+			},
+			'native': {}
+		});
+		await this.setObjectNotExistsAsync(`${adptName}.batteryList`, {
+			'type': 'state',
+			'common': {
+				'name': 'List devices with battery state',
+				'type': 'array',
+				'role': 'json',
+				'read': true,
+				'write': false,
+				'def': [{Device: '--keine--', Adapter: '', Battery: ''}]
+			},
+			'native': {}
+		});
+		await this.setObjectNotExistsAsync(`${adptName}.lowBatteryList`, {
+			'type': 'state',
+			'common': {
+				'name': 'List devices with low battery state',
+				'type': 'array',
+				'role': 'json',
+				'read': true,
+				'write': false,
+				'def': [{Device: '--keine--', Adapter: '', Battery: ''}]
+			},
+			'native': {}
+		});
+		await this.setObjectNotExistsAsync(`${adptName}.lowBatteryCount`, {
+			'type': 'state',
+			'common': {
+				'name': 'Quantity devices with low battery',
+				'type': 'number',
+				'role': 'value',
+				'read': true,
+				'write': false,
+				'def': 0
+			},
+			'native': {}
+		});
+		await this.setObjectNotExistsAsync(`${adptName}.batteryCount`, {
+			'type': 'state',
+			'common': {
+				'name': 'Quantity devices with battery',
+				'type': 'number',
+				'role': 'value',
+				'read': true,
+				'write': false,
+				'def': 0
+			},
+			'native': {}
+		});
+	}
 
-		const sendEmail = async (text) => {
-			await this.sendToAsync(email.instance, 'send', {
-				sendTo: email.sendTo,
-				text: text,
-				subject: email.subject
-			});
-		};
+	async mainForAdapter(adptName) {
+		for (let i = 0; i < this.arrDev.length; i++) {
+			switch (this.arrDev[i].adapter) {
+				case adptName:
+					await this.setStateAsync(`${adptName}.offlineCount`, {val: 2, ack: true});
+					break;
+			}
+		}
+	}
 
-		const sendJarvis = async (text) => {
-			await this.setForeignStateAsync('jarvis.0.addNotification', text);
+	async main() {
+		this.log.debug(`Function started: ${this.main.name}`);
+
+		const supAdapter = {
+			zigbee: 		this.config.zigbeeDevices,
+			ble: 			this.config.bleDevices,
+			sonoff: 		this.config.sonoffDevices,
+			shelly: 		this.config.shellyDevices,
+			homematic: 		this.config.homematicDevices,
+			deconz:			this.config.deconzDevices,
+			zwave: 			this.config.zwaveDevices,
+			dect: 			this.config.dectDevices,
+			hue: 			this.config.hueDevices,
+			hueExt: 		this.config.hueExtDevices,
+			nukiExt: 		this.config.nukiExtDevices,
+			ping: 			this.config.pingDevices,
+			switchbotBle: 	this.config.switchbotBleDevices,
+			sonos: 			this.config.sonosDevices,
+			mihome:			this.config.mihomeDevices,
+			mihomeGW:		this.config.mihomeDevices,
+			test: 			false, // Only for Developer
+			test2: 			false, // Only for Developer
+			test3:			false // Only for Developer
 		};
 
-		this.log.debug('Function started: ' + this.main.name);
-
-		let arrOfflineDevices        	= []; //JSON-Info of all offline-devices
-		let jsonLinkQualityDevices    	= []; //JSON-Info of all devices with linkquality
-		let arrBatteryPowered         	= []; //JSON-Info of all devices with battery
-		let arrBatteryLowPowered		= [];
-		let arrListAllDevices         	= []; //JSON-Info total list with info of all devices
-		let offlineDevicesCount			= 0;
-		let deviceCounter				= 0;
-		let batteryPoweredCount 		= 0;
-		let lowBatteryPoweredCount		= 0;
-		let lastContactString;
-		const testMe = true;
-
-		if (!this.config.zigbeeDevices && !this.config.bleDevices && !this.config.sonoffDevices && !this.config.shellyDevices && !this.config.homematicDevices && !this.config.deconzDevices && !this.config.zwaveDevices) {
+		if (!supAdapter.zigbee &&
+			!supAdapter.ble &&
+			!supAdapter.sonoff &&
+			!supAdapter.shelly &&
+			!supAdapter.homematic &&
+			!supAdapter.deconz &&
+			!supAdapter.zwave &&
+			!supAdapter.dect &&
+			!supAdapter.hue &&
+			!supAdapter.hueExt &&
+			!supAdapter.nukiExt &&
+			!supAdapter.ping &&
+			!supAdapter.switchbotBle &&
+			!supAdapter.sonos &&
+			!supAdapter.mihome
+		) {
 			this.log.warn('No devices selected. Pleased check the instance configuration');
 		}
 
-		const myArrDev                  = []; //JSON mit Gesamtliste aller Geräte
-
-		if (testMe) { //Only for Developer to test the functions!!
-			myArrDev.push({'Selektor':'0_userdata.*.UNREACH', 'adapter':'Homematic', 'battery':'.OPERATING_VOLTAGE', 'reach':'.UNREACH'});
-			myArrDev.push({'Selektor':'0_userdata.*.link_quality', 'adapter':'Zigbee', 'battery':'.battery', 'reach':'.available'});
-			myArrDev.push({'Selektor':'0_userdata.*.reachable', 'adapter':'Test', 'battery':'.battery'});
-			myArrDev.push({'Selektor':'0_userdata.*.rssi', 'adapter':'Test', 'battery':'.sensor.battery'});
-			this.log.warn('Teststates wurden ausgewählt. Lade Daten...');
-		}
-
-		if (this.config.bleDevices) {
-			myArrDev.push({'Selektor':'ble.*.rssi', 'adapter':'Ble', 'battery':'.battery', 'reach':'none', 'isLowBat':'none'});
-			this.log.info('Ble Devices wurden ausgewählt (Xiaomi Plant Sensor). Lade Daten...');
-		}
-		if (this.config.zigbeeDevices) {
-			myArrDev.push({'Selektor':'zigbee.*.link_quality', 'adapter':'Zigbee', 'battery':'.battery', 'reach':'.available', 'isLowBat':'none'});
-			this.log.info('Zigbee Devices wurden ausgewählt. Lade Daten...');
-		}
-		if (this.config.sonoffDevices) {
-			myArrDev.push({'Selektor':'sonoff.*.Wifi_RSSI', 'adapter':'Sonoff', 'battery':'.battery', 'reach':'none', 'isLowBat':'none'});
-			myArrDev.push({'Selektor':'sonoff.*.Wifi_Signal', 'adapter':'Sonoff', 'battery':'.battery', 'reach':'none', 'isLowBat':'none'});
-			myArrDev.push({'Selektor':'sonoff.*.RSSI', 'adapter':'Sonoff', 'battery':'.battery', 'reach':'none', 'isLowBat':'none'});
-			this.log.info('Sonoff Devices wurden ausgewählt. Lade Daten...');
-		}
-		if (this.config.shellyDevices) {
-			myArrDev.push({'Selektor':'shelly.*.rssi', 'adapter':'Shelly', 'battery':'.sensor.battery', 'reach':'none', 'isLowBat':'none'});
-			this.log.info('Shelly Devices wurden ausgewählt. Lade Daten...');
-		}
-		if (this.config.homematicDevices) {
-			myArrDev.push({'Selektor':'hm-rpc.*.RSSI_DEVICE', 'adapter':'Homematic', 'battery':'.OPERATING_VOLTAGE', 'reach':'.UNREACH', 'isLowBat':'none'});
-			this.log.info('Homematic Devices wurden ausgewählt. Lade Daten...');
-		}
-		if (this.config.deconzDevices) {
-			myArrDev.push({'Selektor':'deconz.*.reachable', 'adapter':'Deconz', 'battery':'.battery', 'reach':'.reachable', 'isLowBat':'none'});
-			this.log.info('Deconz Devices wurden ausgewählt. Lade Daten...');
-		}
-		if (this.config.zwaveDevices) {
-			myArrDev.push({'Selektor':'zwave.*.ready', 'adapter':'Zwave', 'battery':'.battery.level', 'reach':'.ready', 'isLowBat':'.battery.isLow'});
-			this.log.info('Zwave Devices wurden ausgewählt. Lade Daten...');
+		for(const [id] of Object.entries(this.arrApart)) {
+			const idAdapter = supAdapter[id];
+			if (idAdapter) {
+				this.log.info(`${await this.capitalize(id)} was selected. Loading data...`);
+				this.arrDev.push(this.arrApart[id]);
+				/*try {
+					await this.createDPsForEachAdapter(id);
+					this.log.debug(`Created datapoints for ${await this.capitalize(id)}`);
+					await this.mainForAdapter(id);
+				} catch (e) {
+					this.log.warn(`Error at creating datapoints for each adapter: ${e}`);
+				}*/
+			}
 		}
 
-		this.log.debug(JSON.stringify(myArrDev));
+		this.log.debug(JSON.stringify(this.arrDev));
 
 		/*=============================================
 		=            Start of main loop    		   	  =
 		=============================================*/
-		for (let i = 0; i < myArrDev.length; i++) {
-			const devices = await this.getForeignStatesAsync(myArrDev[i].Selektor);
-			const deviceAdapterName = myArrDev[i].adapter;
-
-			this.log.debug(JSON.stringify(devices));
-
-			const myBlacklist 				= this.config.tableBlacklist;
-			const myBlacklistArr			= [];
+		for (let i = 0; i < this.arrDev.length; i++) {
+			const devices 			= await this.getForeignStatesAsync(this.arrDev[i].Selektor);
+			const deviceAdapterName = this.arrDev[i].adapter;
+			const myBlacklist 		= this.config.tableBlacklist;
 
 			/*----------  Loop for blacklist ----------*/
 			for(const i in myBlacklist){
-				myBlacklistArr.push(myBlacklist[i].device);
-				this.log.debug('Found items on the blacklist: ' + myBlacklistArr);
+				this.blacklistArr.push(myBlacklist[i].device);
+				this.log.debug(`Found items on the blacklist: ${this.blacklistArr}`);
 			}
 
 			/*----------  Start of second main loop  ----------*/
 			for(const [id] of Object.entries(devices)) {
-				if (!myBlacklistArr.includes(id)) {
+				if (!this.blacklistArr.includes(id)) {
 
-					const currDeviceString    = id.slice(0, (id.lastIndexOf('.') + 1) - 1);
+					const currDeviceString    	= id.slice(0, (id.lastIndexOf('.') + 1) - 1);
+					const shortCurrDeviceString = currDeviceString.slice(0, (currDeviceString.lastIndexOf('.') + 1) - 1);
 
 					//Get device name
 					const deviceObject = await this.getForeignObjectAsync(currDeviceString);
+					const shortDeviceObject = await this.getForeignObjectAsync(shortCurrDeviceString);
 					let deviceName;
 
 					if (deviceObject && typeof deviceObject === 'object') {
 						deviceName = deviceObject.common.name;
 					}
 
+					if  (shortDeviceObject && typeof shortDeviceObject === 'object') {
+						if (this.arrDev[i].adapter === 'hue extended') {
+							deviceName = shortDeviceObject.common.name;
+						}
+					}
 
-					//Get room name (not implement yet)
-					//const getRoomName = await this.getEnumAsync('rooms');
-					//let currRoom;
-					//this.log.warn(JSON.stringify(getRoomName));
-
-					/*for(const [id] of Object.entries(getRoomName.result)) {
-						currRoom = await capitalize(id.substring(id.lastIndexOf('.') + 1)) ;
-						this.log.warn(currRoom);
-					}*/
+					//Get ID for Switchbot Devices
+					if (this.arrDev[i].adapter === 'switchbot ble') {
+						const switchbotID = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].id);
+						if (switchbotID) {
+							deviceName = switchbotID.val;
+						}
+					}
 
 					// 1. Get link quality
-					const deviceQualityState = await this.getForeignStateAsync(id);
+					let deviceQualityState;
 					let linkQuality;
 
-					if (deviceQualityState){
+					switch (this.arrDev[i].adapter) {
+						case 'homematic':
+							deviceQualityState = await this.getForeignStateAsync(currDeviceString + this.arrDev[i].rssiState);
+							break;
+						default:
+							deviceQualityState = await this.getForeignStateAsync(id);
+					}
+
+					if ((deviceQualityState) && (typeof deviceQualityState.val === 'number')){
 						if (this.config.trueState) {
 							linkQuality = deviceQualityState.val;
-						} else if ((deviceQualityState.val != null) && (typeof deviceQualityState.val === 'number')) {
+						} else {
 							if (deviceQualityState.val < 0) {
 								linkQuality = Math.min(Math.max(2 * (deviceQualityState.val + 100), 0), 100) + '%';
 							} else if ((deviceQualityState.val) >= 0) {
 								linkQuality = parseFloat((100/255 * deviceQualityState.val).toFixed(0)) + '%';
 							}
 						}
+						this.linkQualityDevices.push(
+							{
+								Device: deviceName,
+								Adapter: deviceAdapterName,
+								Link_quality: linkQuality
+							}
+						);
+					} else {
+					// no linkQuality available for powered devices
+						linkQuality = ' - ';
 					}
-					jsonLinkQualityDevices.push(
-						{
-							Device: deviceName,
-							Adapter: deviceAdapterName,
-							Link_quality: linkQuality
-						}
-					);
 
-					// 1b. Count how many devices are exists
-					deviceCounter = jsonLinkQualityDevices.length;
+					// 1b. Count how many devices with link Quality
+					this.linkQualityCount = this.linkQualityDevices.length;
 
 					// 2. When was the last contact to the device?
+					let lastContactString;
+
 					if (deviceQualityState) {
 						try {
 							const time = new Date();
 							const lastContact = Math.round((time.getTime() - deviceQualityState.ts) / 1000 / 60);
-							const currDeviceUnreachString = currDeviceString + myArrDev[i].reach;
-							const deviceUnreachState = await this.getForeignStateAsync(currDeviceUnreachString);
+							const deviceUnreachState = await this.getInitValue(currDeviceString + this.arrDev[i].reach);
 
 							// 2b. wenn seit X Minuten kein Kontakt mehr besteht, nimm Gerät in Liste auf
 							//Rechne auf Tage um, wenn mehr als 48 Stunden seit letztem Kontakt vergangen sind
@@ -257,9 +376,10 @@ class DeviceWatcher extends utils.Adapter {
 							if (Math.round(lastContact/60) > 48) {
 								lastContactString = Math.round(lastContact/60/24) + ' Tagen';
 							}
-							if (myArrDev[i].reach === 'none') {
+
+							if (this.arrDev[i].reach === 'none') {
 								if (lastContact > this.config.maxMinutes) {
-									arrOfflineDevices.push(
+									this.offlineDevices.push(
 										{
 											Device: deviceName,
 											Adapter: deviceAdapterName,
@@ -268,71 +388,104 @@ class DeviceWatcher extends utils.Adapter {
 									);
 								}
 							} else {
-								if (deviceUnreachState) {
-									if ((deviceUnreachState.val === true) && (myArrDev[i].adapter === 'Homematic')) {
-										arrOfflineDevices.push(
-											{
-												Device: deviceName,
-												Adapter: deviceAdapterName,
-												Last_contact: lastContactString
-											}
-										);
-									} else if ((deviceUnreachState.val === false) && (myArrDev[i].adapter != 'Homematic')) {
-										arrOfflineDevices.push(
-											{
-												Device: deviceName,
-												Adapter: deviceAdapterName,
-												Last_contact: lastContactString
-											}
-										);
-									}
+								if ((deviceUnreachState) && (this.arrDev[i].adapter === 'homematic')) {
+									this.offlineDevices.push(
+										{
+											Device: deviceName,
+											Adapter: deviceAdapterName,
+											Last_contact: lastContactString
+										}
+									);
+								} else if ((!deviceUnreachState) && (this.arrDev[i].adapter != 'homematic')) {
+									this.offlineDevices.push(
+										{
+											Device: deviceName,
+											Adapter: deviceAdapterName,
+											Last_contact: lastContactString
+										}
+									);
 								}
 							}
 						} catch (e) {
-							this.log.error('(03) Error while getting timestate ' + e);
+							this.log.error(`(03) Error while getting timestate ${e}`);
 						}
 					}
 
-
 					// 2c. Count how many devcies are offline
-					offlineDevicesCount = arrOfflineDevices.length;
+					this.offlineDevicesCount = this.offlineDevices.length;
 
 					// 3. Get battery states
-					const currDeviceBatteryString 	= currDeviceString + myArrDev[i].battery;
-					const deviceBatteryState	= await this.getForeignStateAsync(currDeviceBatteryString);
+					const deviceBatteryState		= await this.getInitValue(currDeviceString + this.arrDev[i].battery);
+					const shortDeviceBatteryState	= await this.getInitValue(shortCurrDeviceString + this.arrDev[i].battery);
 					let batteryHealth;
 
-					if (!deviceBatteryState) {
-						batteryHealth = ' - ';
-					} else if ((myArrDev[i].adapter === 'Homematic') && (deviceBatteryState).val === 0) {
+					if ((!deviceBatteryState) && (!shortDeviceBatteryState)) {
 						batteryHealth = ' - ';
-					} else if ((deviceBatteryState) && (myArrDev[i].adapter != 'Homematic')) {
-						batteryHealth = (deviceBatteryState).val + '%';
-						arrBatteryPowered.push(
-							{
-								Device: deviceName,
-								Adapter: deviceAdapterName,
-								Battery: batteryHealth
-							}
-						);
-					} else if ((deviceBatteryState) && (deviceBatteryState).val != 0 && myArrDev[i].adapter === 'Homematic') {
-						batteryHealth = (deviceBatteryState).val + 'V';
-						arrBatteryPowered.push(
-							{
-								Device: deviceName,
-								Adapter: deviceAdapterName,
-								Battery: batteryHealth
-							}
-						);
+					} else {
+						this.log.debug(`Adapter ${this.arrDev[i].adapter}`);
+
+						switch (this.arrDev[i].adapter) {
+							case 'homematic':
+								if (deviceBatteryState === 0) {
+									batteryHealth = ' - ';
+								} else {
+									batteryHealth = deviceBatteryState + 'V';
+								}
+
+								this.batteryPowered.push(
+									{
+										Device: deviceName,
+										Adapter: deviceAdapterName,
+										Battery: batteryHealth
+									}
+								);
+								break;
+							case 'hue extended':
+								if (shortDeviceBatteryState) {
+									batteryHealth = shortDeviceBatteryState + '%';
+									this.batteryPowered.push(
+										{
+											Device: deviceName,
+											Adapter: deviceAdapterName,
+											Battery: batteryHealth
+										}
+									);
+								}
+								break;
+							default:
+								batteryHealth = (deviceBatteryState) + '%';
+								this.batteryPowered.push(
+									{
+										Device: deviceName,
+										Adapter: deviceAdapterName,
+										Battery: batteryHealth
+									}
+								);
+						}
 					}
+
 					// 3b. Count how many devices are with battery
-					batteryPoweredCount = arrBatteryPowered.length;
+					this.batteryPoweredCount = this.batteryPowered.length;
 
 					// 3c. Count how many devices are with low battery
-					if (deviceBatteryState && deviceBatteryState.val) {
-						const batteryWarningMin = this.config.minWarnBatterie;
-						if ((deviceBatteryState.val < batteryWarningMin) && (myArrDev[i].adapter != 'Homematic')) {
-							arrBatteryLowPowered.push(
+					const batteryWarningMin 		= this.config.minWarnBatterie;
+					const deviceLowBatState			= await this.getInitValue(currDeviceString + this.arrDev[i].isLowBat);
+					const deviceLowBatStateHM		= await this.getInitValue(currDeviceString + this.arrDev[i].isLowBat2);
+
+
+					if (this.arrDev[i].isLowBat === 'none') {
+						if (deviceBatteryState && (deviceBatteryState < batteryWarningMin)) {
+							this.batteryLowPowered.push(
+								{
+									Device: deviceName,
+									Adapter: deviceAdapterName,
+									Battery: batteryHealth
+								}
+							);
+						}
+					} else {
+						if (deviceLowBatState || deviceLowBatStateHM) {
+							this.batteryLowPowered.push(
 								{
 									Device: deviceName,
 									Adapter: deviceAdapterName,
@@ -340,84 +493,178 @@ class DeviceWatcher extends utils.Adapter {
 								}
 							);
 						}
-
 					}
+
 					// 3d. Count how many devices are with low battery
-					lowBatteryPoweredCount = arrBatteryLowPowered.length;
+					this.lowBatteryPoweredCount = this.batteryLowPowered.length;
 
 					// 4. Add all devices in the list
-					arrListAllDevices.push(
-						{
-							Device: deviceName,
-							Adapter: deviceAdapterName,
-							Battery: batteryHealth,
-							Last_contact: lastContactString,
-							Link_quality: linkQuality
+					// only pusk if available
+					if (this.config.listOnlyBattery) {
+						if (deviceBatteryState !== null || shortDeviceBatteryState !== null) {
+							this.listAllDevices.push(
+								{
+									Device: deviceName,
+									Adapter: deviceAdapterName,
+									Battery: batteryHealth,
+									Last_contact: lastContactString,
+									Link_quality: linkQuality
+								}
+							);
 						}
-					);
+					} else if (!this.config.listOnlyBattery) {
+						this.listAllDevices.push(
+							{
+								Device: deviceName,
+								Adapter: deviceAdapterName,
+								Battery: batteryHealth,
+								Last_contact: lastContactString,
+								Link_quality: linkQuality
+							}
+						);
+					}
+
+
+					// 4a. Count how many devices are exists
+					this.deviceCounter = this.listAllDevices.length;
 				}
 			} //<--End of second loop
 		} //<---End of main loop
+		this.log.debug(`Function finished: ${this.main.name}`);
+	}
 
+	async sendNotifications() {
 		/*=============================================
 		=         	  	 Notifications 		          =
 		=============================================*/
+		this.log.debug(`Start the function: ${this.sendNotifications.name}`);
+
+		const pushover = {
+			instance: this.config.instancePushover,
+			title: this.config.titlePushover,
+			device: this.config.devicePushover
+
+		};
+		const telegram = {
+			instance: this.config.instanceTelegram,
+			user: this.config.deviceTelegram,
+			chatId: this.config.chatIdTelegram
+		};
+		const email = {
+			instance: this.config.instanceEmail,
+			subject: this.config.subjectEmail,
+			sendTo: this.config.sendToEmail
+
+		};
+		const jarvis = {
+			instance: this.config.instanceJarvis,
+			title: this.config.titleJarvis
+
+		};
+		const lovelace = {
+			instance: this.config.instanceLovelace,
+			title: this.config.titleLovelace
+
+		};
+
+		const choosedDays = {
+			monday: this.config.checkMonday,
+			tuesday: this.config.checkTuesday,
+			wednesday: this.config.checkWednesday,
+			thursday: this.config.checkThursday,
+			friday: this.config.checkFriday,
+			saturday: this.config.checkSaturday,
+			sunday: this.config.checkSunday,
+		};
+
+		const sendPushover = async (text) => {
+			await this.sendToAsync(pushover.instance, 'send', {
+				message: text,
+				title: pushover.title,
+				device: pushover.device
+			});
+		};
+
+		const sendTelegram = async (text) => {
+			await this.sendToAsync(telegram.instance, 'send', {
+				text: text,
+				user: telegram.user,
+				chatId: telegram.chatId
+			});
+		};
+
+		const sendEmail = async (text) => {
+			await this.sendToAsync(email.instance, 'send', {
+				sendTo: email.sendTo,
+				text: text,
+				subject: email.subject
+			});
+		};
+
+		const sendJarvis = async (text) => {
+			await this.setForeignStateAsync(`${jarvis.instance}.addNotification`, text);
+		};
+
+		const sendLovelace = async (text) => {
+			await this.setForeignStateAsync(`${lovelace.instance}.notifications.add`, text);
+		};
 
 		/*----------  oflline notification ----------*/
 		if(this.config.checkSendOfflineMsg) {
 			try {
 				let msg = '';
-				const offlineDevicesCountOld = await this.getStateAsync('offlineCount');
-
-				if ((offlineDevicesCountOld != undefined) && (offlineDevicesCountOld != null)) {
-					if ((offlineDevicesCount != offlineDevicesCountOld.val) && (offlineDevicesCount != 0)) {
-						if (offlineDevicesCount == 1) {
-							msg = 'Folgendes Gerät ist seit einiger Zeit nicht erreichbar: \n';
-						} else if (offlineDevicesCount >= 2) {
-							msg = 'Folgende ' + offlineDevicesCount + ' Geräte sind seit einiger Zeit nicht erreichbar: \n';
-						}
-						for (const id of arrOfflineDevices) {
-							msg = msg + '\n' + id['Device'] + ' ' + /*id['room'] +*/ ' (' + id['Last_contact'] + ')';
+				const offlineDevicesCountOld = await this.getOwnInitValue('offlineCount');
+
+				if ((this.offlineDevicesCount != offlineDevicesCountOld) && (this.offlineDevicesCount != 0)) {
+					if (this.offlineDevicesCount == 1) {
+						msg = 'Folgendes Gerät ist seit einiger Zeit nicht erreichbar: \n';
+					} else if (this.offlineDevicesCount >= 2) {
+						msg = 'Folgende ' + this.offlineDevicesCount + ' Geräte sind seit einiger Zeit nicht erreichbar: \n';
+					}
+					for (const id of this.offlineDevices) {
+						msg = msg + '\n' + id['Device'] + ' ' + /*id['room'] +*/ ' (' + id['Last_contact'] + ')';
+					}
+					this.log.info(msg);
+					await this.setStateAsync('lastNotification', msg, true);
+					if (pushover.instance) {
+						try {
+							await sendPushover(msg);
+						} catch (e) {
+							this.log.warn (`Getting error at sending notification ${e}`);
 						}
-						this.log.info(msg);
-						await this.setStateAsync('lastNotification', msg, true);
-						if (pushover.instance) {
-							try {
-								await sendPushover(msg);
-							} catch (e) {
-								this.log.warn ('Getting error at sending notification' + (e));
-							}
+					}
+					if (telegram.instance) {
+						try {
+							await sendTelegram(msg);
+						} catch (e) {
+							this.log.warn (`Getting error at sending notification ${e}`);
 						}
-						if (telegram.instance) {
-							try {
-								await sendTelegram(msg);
-							} catch (e) {
-								this.log.warn ('Getting error at sending notification' + (e));
-							}
+					}
+					if (email.instance) {
+						try {
+							await sendEmail(msg);
+						} catch (e) {
+							this.log.warn (`Getting error at sending notification ${e}`);
 						}
-						if (email.instance) {
-							try {
-								await sendEmail(msg);
-							} catch (e) {
-								this.log.warn ('Getting error at sending notification' + (e));
-							}
+					}
+					if (jarvis.instance) {
+						try {
+							await sendJarvis('{"title":"'+ jarvis.title +' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')","message":" ' + this.offlineDevicesCount + ' Geräte sind nicht erreichbar","display": "drawer"}');
+						} catch (e) {
+							this.log.warn (`Getting error at sending notification ${e}`);
 						}
-						if (jarvis.instance) {
-							try {
-								await sendJarvis('{"title":"'+ jarvis.title +' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')","message":" ' + offlineDevicesCount + ' Geräte sind nicht erreichbar","display": "drawer"}');
-							} catch (e) {
-								this.log.warn ('Getting error at sending notification' + (e));
-							}
+					}
+					if (lovelace.instance) {
+						try {
+							await sendLovelace('{"message":" ' + this.offlineDevicesCount + ' Geräte sind nicht erreichbar", "title":"'+ lovelace.title +' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')"}');
+						} catch (e) {
+							this.log.warn (`Getting error at sending notification ${e}`);
 						}
-
-
 					}
 				}
-
 			} catch (e) {
-				this.log.debug('Getting error at sending offline notification ' + e);
+				this.log.debug(`Getting error at sending offline notification ${e}`);
 			}
-
 		}
 
 		/*----------  Low battery Notification ----------*/
@@ -444,122 +691,139 @@ class DeviceWatcher extends utils.Adapter {
 
 		if (this.config.checkSendBatteryMsg) {
 			try {
-			//Nur einmal abfragen
-				const lastBatteryNotifyIndicator = await this.getStateAsync('info.lastBatteryNotification');
-
-				if ((lastBatteryNotifyIndicator != undefined) && (lastBatteryNotifyIndicator != null)) {
-					if (now.getHours() < 11) {await this.setStateAsync('info.lastBatteryNotification', false, true);}
-					if ((now.getHours() > 11) && (lastBatteryNotifyIndicator.val == false) && (checkToday != undefined)){
-						let batteryMinCount = 0;
-						const batteryWarningMin = this.config.minWarnBatterie;
-
-						let infotext = '';
-						for (const id of arrBatteryPowered) {
-							if (id['Battery']) {
-								const batteryValue = parseFloat(id['Battery'].replace('%', ''));
-								if ((batteryValue < batteryWarningMin) && (id['Adapter'] != 'Homematic')) {
-									infotext = infotext + '\n' + id['Device'] + ' ' + /*id['room'] +*/ ' (' + id['Battery'] + ')'.split(', ');
-									++batteryMinCount;
-								}
+				const lastBatteryNotifyIndicator = await this.getOwnInitValue('info.lastBatteryNotification');
+				const batteryWarningMin = this.config.minWarnBatterie;
+
+				if (now.getHours() < 11) {await this.setStateAsync('info.lastBatteryNotification', false, true);} //Nur einmal abfragen
+				if ((now.getHours() > 11) && (!lastBatteryNotifyIndicator) && (checkToday != undefined)){
+					let batteryMinCount = 0;
+					let infotext = '';
+
+					for (const id of this.batteryPowered) {
+						if (id['Battery']) {
+							const batteryValue = parseFloat(id['Battery'].replace('%', ''));
+							if ((batteryValue < batteryWarningMin) && (id['Adapter'] != 'homematic')) {
+								infotext = infotext + '\n' + id['Device'] + ' ' + /*id['room'] +*/ ' (' + id['Battery'] + ')'.split(', ');
+								++batteryMinCount;
 							}
 						}
-						if (batteryMinCount > 0) {
-							this.log.info('Batteriezustände: ' + infotext);
-							await this.setStateAsync('lastNotification', infotext, true);
-							if (jarvis.instance) {
-								try {
-									await sendJarvis('{"title":"'+ jarvis.title +' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')","message":" ' + batteryMinCount + ' Geräte mit schwacher Batterie","display": "drawer"}');
-								} catch (e) {
-									this.log.warn ('Getting error at sending notification' + (e));
-								}
+					}
+					if (batteryMinCount > 0) {
+						this.log.info(`Batteriezustände: ${infotext}`);
+						await this.setStateAsync('lastNotification', infotext, true);
+
+						if (pushover.instance) {
+							try {
+								await sendPushover(`Batteriezustände: ${infotext}`);
+							} catch (e) {
+								this.log.warn (`Getting error at sending notification ${e}`);
 							}
-							if (pushover.instance) {
-								try {
-									await sendPushover('Batteriezustände: ' + infotext);
-								} catch (e) {
-									this.log.warn ('Getting error at sending notification' + (e));
-								}
+						}
+						if (telegram.instance) {
+							try {
+								await sendTelegram(`Batteriezustände: ${infotext}`);
+							} catch (e) {
+								this.log.warn (`Getting error at sending notification ${e}`);
 							}
-							if (telegram.instance) {
-								try {
-									await sendTelegram('Batteriezuständ: ' + infotext);
-								} catch (e) {
-									this.log.warn ('Getting error at sending notification' + (e));
-								}
+						}
+						if (email.instance) {
+							try {
+								await sendEmail(`Batteriezustände: ${infotext}`);
+							} catch (e) {
+								this.log.warn (`Getting error at sending notification ${e}`);
+							}
+						}
+						if (jarvis.instance) {
+							try {
+								await sendJarvis('{"title":"'+ jarvis.title +' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')","message":" ' + batteryMinCount + ' Geräte mit schwacher Batterie","display": "drawer"}');
+							} catch (e) {
+								this.log.warn (`Getting error at sending notification ${e}`);
 							}
-							await this.setStateAsync('info.lastBatteryNotification', true, true);
 						}
+						if (lovelace.instance) {
+							try {
+								await sendLovelace('{"message":" ' + batteryMinCount + ' Geräte mit schwacher Batterie", "title":"'+ lovelace.title +' (' + this.formatDate(new Date(), 'DD.MM.YYYY - hh:mm:ss') + ')"}');
+							} catch (e) {
+								this.log.warn (`Getting error at sending notification ${e}`);
+							}
+						}
+
+						await this.setStateAsync('info.lastBatteryNotification', true, true);
 					}
 				}
 			} catch (e) {
-				this.log.debug('Getting error at batterynotification ' + e);
+				this.log.debug(`Getting error at sending battery notification ${e}`);
 			}
 		}
-
-
 		/*=====  End of Section notifications ======*/
+		this.log.debug(`Function finished: ${this.sendNotifications.name}`);
+	}
 
-
+	async writeDatapoints() {
 		/*=============================================
 		=            	Write Datapoints 		      =
 		=============================================*/
-		this.log.debug('write the datapoints ' + this.main.name);
+		this.log.debug(`Start the function: ${this.writeDatapoints.name}`);
 
 		try {
-			await this.setStateAsync('offlineCount', {val: offlineDevicesCount, ack: true});
-			await this.setStateAsync('countAll', {val: deviceCounter, ack: true});
-			await this.setStateAsync('batteryCount', {val: batteryPoweredCount, ack: true});
-			await this.setStateAsync('lowBatteryCount', {val: lowBatteryPoweredCount, ack: true});
+			await this.setStateAsync('offlineCount', {val: this.offlineDevicesCount, ack: true});
+			await this.setStateAsync('countAll', {val: this.deviceCounter, ack: true});
+			await this.setStateAsync('batteryCount', {val: this.batteryPoweredCount, ack: true});
+			await this.setStateAsync('lowBatteryCount', {val: this.lowBatteryPoweredCount, ack: true});
 
-			if (deviceCounter == 0) {
-				jsonLinkQualityDevices	= [{Device: '--keine--', Adapter: '', Link_quality: ''}]; //JSON-Info alle mit LinkQuality
-				arrListAllDevices       = [{Device: '--keine--', Adapter: '', Battery: '', Last_contact: '', Link_quality: ''}]; //JSON-Info Gesamtliste mit Info je Gerät
+			if (this.deviceCounter == 0) {
+				this.listAllDevices       = [{Device: '--keine--', Adapter: '', Battery: '', Last_contact: '', Link_quality: ''}]; //JSON-Info Gesamtliste mit Info je Gerät
 
-				await this.setStateAsync('linkQualityList', {val: JSON.stringify(jsonLinkQualityDevices), ack: true});
-				await this.setStateAsync('listAll', {val: JSON.stringify(arrListAllDevices), ack: true});
+				await this.setStateAsync('listAll', {val: JSON.stringify(this.listAllDevices), ack: true});
 			} else {
-				await this.setStateAsync('linkQualityList', {val: JSON.stringify(jsonLinkQualityDevices), ack: true});
-				await this.setStateAsync('listAll', {val: JSON.stringify(arrListAllDevices), ack: true});
+				await this.setStateAsync('listAll', {val: JSON.stringify(this.listAllDevices), ack: true});
 			}
 
-			if (offlineDevicesCount == 0) {
-				arrOfflineDevices	= [{Device: '--keine--', Adapter: '', Last_contact: ''}]; //JSON-Info alle offline-Geräte = 0
+			if (this.linkQualityCount == 0) {
+				this.linkQualityDevices	= [{Device: '--keine--', Adapter: '', Link_quality: ''}]; //JSON-Info alle mit LinkQuality
 
-				await this.setStateAsync('offlineList', {val: JSON.stringify(arrOfflineDevices), ack: true});
+				await this.setStateAsync('linkQualityList', {val: JSON.stringify(this.linkQualityDevices), ack: true});
 			} else {
-				await this.setStateAsync('offlineList', {val: JSON.stringify(arrOfflineDevices), ack: true});
+				await this.setStateAsync('linkQualityList', {val: JSON.stringify(this.linkQualityDevices), ack: true});
 			}
 
-			if (batteryPoweredCount == 0) {
-				arrBatteryPowered	= [{Device: '--keine--', Adapter: '', Battery: ''}]; //JSON-Info alle batteriebetriebenen Geräte
 
-				await this.setStateAsync('batteryList', {val: JSON.stringify(arrBatteryPowered), ack: true});
+			if (this.offlineDevicesCount == 0) {
+				this.offlineDevices	= [{Device: '--keine--', Adapter: '', Last_contact: ''}]; //JSON-Info alle offline-Geräte = 0
+
+				await this.setStateAsync('offlineList', {val: JSON.stringify(this.offlineDevices), ack: true});
+			} else {
+				await this.setStateAsync('offlineList', {val: JSON.stringify(this.offlineDevices), ack: true});
+			}
+
+			if (this.batteryPoweredCount == 0) {
+				this.batteryPowered	= [{Device: '--keine--', Adapter: '', Battery: ''}]; //JSON-Info alle batteriebetriebenen Geräte
+
+				await this.setStateAsync('batteryList', {val: JSON.stringify(this.batteryPowered), ack: true});
 			} else {
-				await this.setStateAsync('batteryList', {val: JSON.stringify(arrBatteryPowered), ack: true});
+				await this.setStateAsync('batteryList', {val: JSON.stringify(this.batteryPowered), ack: true});
 			}
 
-			if (lowBatteryPoweredCount == 0) {
-				arrBatteryLowPowered	= [{Device: '--keine--', Adapter: '', Battery: ''}]; //JSON-Info alle batteriebetriebenen Geräte
+			if (this.lowBatteryPoweredCount == 0) {
+				this.batteryLowPowered	= [{Device: '--keine--', Adapter: '', Battery: ''}]; //JSON-Info alle batteriebetriebenen Geräte
 
-				await this.setStateAsync('lowBatteryList', {val: JSON.stringify(arrBatteryLowPowered), ack: true});
+				await this.setStateAsync('lowBatteryList', {val: JSON.stringify(this.batteryLowPowered), ack: true});
 			} else {
-				await this.setStateAsync('lowBatteryList', {val: JSON.stringify(arrBatteryLowPowered), ack: true});
+				await this.setStateAsync('lowBatteryList', {val: JSON.stringify(this.batteryLowPowered), ack: true});
 			}
 
 			//Zeitstempel wann die Datenpunkte zuletzt gecheckt wurden
 			const lastCheck = this.formatDate(new Date(), 'DD.MM.YYYY') + ' - ' + this.formatDate(new Date(), 'hh:mm:ss');
 			await this.setStateAsync('lastCheck', lastCheck, true);
-
-			this.log.debug('write the datapoints finished ' + this.main.name);
 		}
 		catch (e) {
-			this.log.error('(05) Error while writing the states ' + e);
+			this.log.error(`(05) Error while writing the states ${e}`);
 		}
 		/*=====  End of writing Datapoints ======*/
-
-		this.log.debug('Function finished: ' + this.main.name);
+		this.log.debug(`Function finished: ${this.writeDatapoints.name}`);
 	}
 
+
 	onUnload(callback) {
 		try {
 			this.log.info('cleaned everything up...');
@@ -579,4 +843,4 @@ if (require.main !== module) {
 } else {
 	// otherwise start the instance directly
 	new DeviceWatcher();
-}
+}