MSA-2158: Hue Motion Sensor device control

devicetypes/digitalgecko/hue-motion-sensor.src/hue-motion-sensor.groovy

@@ -0,0 +1,466 @@
+/**
+ *  Copyright 2015 SmartThings
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ */
+
+metadata {
+    definition (name: "Hue Motion Sensor", namespace: "digitalgecko", author: "digitalgecko") {
+
+        
+		capability "Motion Sensor"
+		capability "Configuration"
+		capability "Battery"
+		capability "Refresh"
+        capability "Temperature Measurement"
+        capability "Sensor"
+        capability "Illuminance Measurement" //0x0400
+
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0406,0400,0402", outClusters: "0019", manufacturer: "Philips", model: "SML001", deviceJoinName: "Hue Motion Sensor"
+    }
+
+	preferences {
+    		section {
+			input title: "Temperature Offset", description: "This feature allows you to correct any temperature variations by selecting an offset. Ex: If your sensor consistently reports a temp that's 5 degrees too warm, you'd enter '-5'. If 3 degrees too cold, enter '+3'.", displayDuringSetup: false, type: "paragraph", element: "paragraph"
+			input "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+		}
+            section {
+			input title: "Luminance Offset", description: "This feature allows you to correct the luminance reading by selecting an offset. Enter a value such as 20 or -20 to adjust the luminance reading.", displayDuringSetup: false, type: "paragraph", element: "paragraph"
+			input "luxOffset", "number", title: "Lux", description: "Adjust luminance by this amount", range: "*..*", displayDuringSetup: false
+		}
+    }
+
+    tiles(scale: 2) {
+		multiAttributeTile(name:"motion", type: "generic", width: 6, height: 4){
+			tileAttribute ("device.motion", key: "PRIMARY_CONTROL") {
+				attributeState "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
+				attributeState "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
+			}
+		}
+       
+        
+		valueTile("temperature", "device.temperature", width: 2, height: 2) {
+			state("temperature", label:'${currentValue}°',
+				backgroundColors:[
+					[value: 31, color: "#153591"],
+					[value: 44, color: "#1e9cbb"],
+					[value: 59, color: "#90d2a7"],
+					[value: 74, color: "#44b621"],
+					[value: 84, color: "#f1d801"],
+					[value: 95, color: "#d04e00"],
+					[value: 96, color: "#bc2323"]
+				]
+			)
+		}
+        
+        valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false, width: 2, height: 2) {
+			state "battery", label:'${currentValue}% battery', unit:""
+		}
+		valueTile("illuminance", "device.illuminance", width: 2, height: 2) {
+			state("illuminance", label:'${currentValue}', unit:"lux",
+				backgroundColors:[
+					[value: 9, color: "#767676"],
+					[value: 315, color: "#ffa81e"],
+					[value: 1000, color: "#fbd41b"]
+				]
+			)
+		}
+        standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+        standardTile("configure", "device.configure", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "default", label:"configure", action:"configure"
+        }
+        main "motion"
+        details(["motion","temperature","battery", "refresh","illuminance",'configure'])
+    }
+}
+
+
+
+// Parse incoming device messages to generate events
+def parse(String description) {
+    def msg = zigbee.parse(description)
+    
+    //log.warn "--"
+    //log.trace description
+    //log.debug msg
+    //def x = zigbee.parseDescriptionAsMap( description )
+    //log.error x
+    
+	Map map = [:]
+    if (description?.startsWith('catchall:')) {
+		map = parseCatchAllMessage(description)
+	}
+	else if (description?.startsWith('temperature: ')) {
+		map = parseCustomMessage(description)
+	}
+    else if (description?.startsWith('illuminance: ')) {
+		map = parseCustomMessage(description)
+	}
+//	else if (description?.startsWith('zone status')) {
+//		//map = parseIasMessage(description)
+//        log.trace "zone status"
+//	}
+
+	def result = map ? createEvent(map) : null
+
+	if (description?.startsWith('enroll request')) {
+		List cmds = enrollResponse()
+		result = cmds?.collect { new physicalgraph.device.HubAction(it) }
+	}
+	else if (description?.startsWith('read attr -')) {
+		result = parseReportAttributeMessage(description).each { createEvent(it) }
+	}
+	return result
+}
+
+/*
+  Refresh Function
+*/
+def refresh() {
+    log.debug "Refreshing Values"
+
+    def refreshCmds = []
+    refreshCmds +=zigbee.readAttribute(0x0001, 0x0020) // Read battery?
+    refreshCmds += zigbee.readAttribute(0x0402, 0x0000) // Read temp?
+    refreshCmds += zigbee.readAttribute(0x0400, 0x0000) // Read luminance?
+    refreshCmds += zigbee.readAttribute(0x0406, 0x0000) // Read motion?
+
+    return refreshCmds + enrollResponse()
+
+    }
+/*
+  Configure Function
+*/
+def configure() {
+
+// TODO : device watch?
+
+	String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+	log.debug "Confuguring Reporting and Bindings."
+    
+    
+	def configCmds = []
+    configCmds += zigbee.batteryConfig()
+	configCmds += zigbee.temperatureConfig(60, 600) // Set temp reporting times // Confirmed
+    
+    configCmds += zigbee.configureReporting(0x406,0x0000, 0x18, 30, 600, null) // motion // confirmed
+    
+    
+    // Data type is not 0x20 = 0x8D invalid data type Unsigned 8-bit integer
+    
+	configCmds += zigbee.configureReporting(0x400,0x0000, 0x21, 60, 600, 0x20) // Set luminance reporting times?? maybe    
+    return refresh() + configCmds 
+}
+
+/*
+	getMotionResult
+ */
+
+private Map getMotionResult(value) {
+    //log.trace "Motion : " + value
+	
+    def descriptionText = value == "01" ? '{{ device.displayName }} detected motion':
+			'{{ device.displayName }} stopped detecting motion'
+    
+    return [
+		name: 'motion',
+		value: value == "01" ? "active" : "inactive",
+		descriptionText: descriptionText,
+		translatable: true,
+	]
+}
+
+
+/*
+  getTemperatureResult
+*/
+private Map getTemperatureResult(value) {
+
+	//log.trace "Temperature : " + value
+	if (tempOffset) {
+		def offset = tempOffset as int
+		def v = value as int
+		value = v + offset
+	}
+	def descriptionText = temperatureScale == 'C' ? '{{ device.displayName }} was {{ value }}°C':
+			'{{ device.displayName }} was {{ value }}°F'
+
+	return [
+		name: 'temperature',
+		value: value,
+		descriptionText: descriptionText,
+		translatable: true,
+		unit: temperatureScale
+	]
+}
+
+def getTemperature(value) {
+	def celsius = Integer.parseInt(value, 16).shortValue() / 100
+	if(getTemperatureScale() == "C"){
+		return Math.round(celsius)
+		} else {
+			return Math.round(celsiusToFahrenheit(celsius))
+		}
+	}
+
+private Map getLuminanceResult(rawValue) {
+	log.debug "Luminance rawValue = ${rawValue}"
+
+	if (luxOffset) {
+		def offset = luxOffset as int
+		def v = rawValue as int
+		rawValue = v + offset
+	}
+    
+	def result = [
+		name: 'illuminance',
+		value: '--',
+		translatable: true,
+ 		unit: 'lux'
+	]
+    
+    result.value = rawValue as Integer
+    return result
+}
+
+/*
+	getBatteryResult
+*/
+//TODO: needs calibration
+private Map getBatteryResult(rawValue) {
+	//log.debug "Battery rawValue = ${rawValue}"
+
+	def result = [
+		name: 'battery',
+		value: '--',
+		translatable: true
+	]
+
+	def volts = rawValue / 10
+
+	if (rawValue == 0 || rawValue == 255) {}
+	else {
+		if (volts > 3.5) {
+			result.descriptionText = "{{ device.displayName }} battery has too much power: (> 3.5) volts."
+		}
+		else {
+			if (device.getDataValue("manufacturer") == "SmartThings") {
+				volts = rawValue // For the batteryMap to work the key needs to be an int
+				def batteryMap = [28:100, 27:100, 26:100, 25:90, 24:90, 23:70,
+								  22:70, 21:50, 20:50, 19:30, 18:30, 17:15, 16:1, 15:0]
+				def minVolts = 15
+				def maxVolts = 28
+
+				if (volts < minVolts)
+					volts = minVolts
+				else if (volts > maxVolts)
+					volts = maxVolts
+				def pct = batteryMap[volts]
+				if (pct != null) {
+					result.value = pct
+					result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+				}
+			}
+			else {
+				def minVolts = 2.1
+				def maxVolts = 3.0
+				def pct = (volts - minVolts) / (maxVolts - minVolts)
+				def roundedPct = Math.round(pct * 100)
+				if (roundedPct <= 0)
+					roundedPct = 1
+				result.value = Math.min(100, roundedPct)
+				result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+			}
+		}
+	}
+
+	return result
+}
+/*
+	parseCustomMessage
+*/
+private Map parseCustomMessage(String description) {
+	Map resultMap = [:]
+	if (description?.startsWith('temperature: ')) {
+		def value = zigbee.parseHATemperatureValue(description, "temperature: ", getTemperatureScale())
+		resultMap = getTemperatureResult(value)
+	}
+    
+    if (description?.startsWith('illuminance: ')) {
+    log.warn "value: " + description.split(": ")[1]
+            log.warn "proc: " + value
+
+		def value = zigbee.lux( description.split(": ")[1] as Integer ) //zigbee.parseHAIlluminanceValue(description, "illuminance: ", getTemperatureScale())
+		resultMap = getLuminanceResult(value)
+	}
+	return resultMap
+}
+
+/*
+	parseReportAttributeMessage
+*/
+private List parseReportAttributeMessage(String description) {
+	Map descMap = (description - "read attr - ").split(",").inject([:]) { map, param ->
+		def nameAndValue = param.split(":")
+		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
+	}
+
+	List result = []
+    
+    // Temperature
+	if (descMap.cluster == "0402" && descMap.attrId == "0000") {
+		def value = getTemperature(descMap.value)
+		result << getTemperatureResult(value)
+	}
+    
+    // Motion
+   	else if (descMap.cluster == "0406" && descMap.attrId == "0000") {
+    	result << getMotionResult(descMap.value)
+	}
+    
+    // Battery
+	else if (descMap.cluster == "0001" && descMap.attrId == "0020") {
+		result << getBatteryResult(Integer.parseInt(descMap.value, 16))
+	}
+    
+    // Luminance
+    else if (descMap.cluster == "0402" ) { //&& descMap.attrId == "0020") {
+		log.error "Luminance Response " + description
+        //result << getBatteryResult(Integer.parseInt(descMap.value, 16))
+	}
+
+	return result
+}
+
+
+/*
+	parseCatchAllMessage
+*/
+private Map parseCatchAllMessage(String description) {
+	Map resultMap = [:]
+	def cluster = zigbee.parse(description)
+//	log.debug cluster
+	if (shouldProcessMessage(cluster)) {
+		switch(cluster.clusterId) {
+			case 0x0001:
+				// 0x07 - configure reporting
+				if (cluster.command != 0x07) {
+					resultMap = getBatteryResult(cluster.data.last())
+				}
+			break
+
+			case 0x0400:
+            	if (cluster.command == 0x07) { // Ignore Configure Reporting Response
+                	if(cluster.data[0] == 0x00) {
+						log.trace "Luminance Reporting Configured"
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+					}
+					else {
+						log.warn "Luminance REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+					}
+				}
+				else {
+            		log.debug "catchall : luminance" + cluster
+                	resultMap = getLuminanceResult(cluster.data.last());
+                }
+
+			break
+            
+			
+            
+			case 0x0402:
+				if (cluster.command == 0x07) {
+					if(cluster.data[0] == 0x00) {
+						log.trace "Temperature Reporting Configured"
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+					}
+					else {
+						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+					}
+				}
+				else {
+					// temp is last 2 data values. reverse to swap endian
+					String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+					def value = getTemperature(temp)
+					resultMap = getTemperatureResult(value)
+				}
+			break
+		}
+	}
+
+	return resultMap
+}
+
+private boolean shouldProcessMessage(cluster) {
+	// 0x0B is default response indicating message got through
+	boolean ignoredMessage = cluster.profileId != 0x0104 ||
+	cluster.command == 0x0B ||
+	(cluster.data.size() > 0 && cluster.data.first() == 0x3e)
+	return !ignoredMessage
+}
+
+
+// This seems to be IAS Specific and not needed we are not really a motion sensor
+def enrollResponse() {
+//	log.debug "Sending enroll response"
+//	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
+//	[
+//		//Resending the CIE in case the enroll request is sent before CIE is written
+//		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+//		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+//		//Enroll Response
+//		"raw 0x500 {01 23 00 00 00}", "delay 200",
+//		"send 0x${device.deviceNetworkId} 1 1", "delay 200"
+//	]
+}
+
+def configureHealthCheck() {
+    Integer hcIntervalMinutes = 12
+    refresh()
+    sendEvent(name: "checkInterval", value: hcIntervalMinutes * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+}
+
+def updated() {
+    log.debug "in updated()"
+    configureHealthCheck()
+}
+
+def ping() {
+    return zigbee.onOffRefresh()
+}
+
+
+
+
+
+private getEndpointId() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+private String swapEndianHex(String hex) {
+    reverseArray(hex.decodeHex()).encodeHex()
+}
+
+private byte[] reverseArray(byte[] array) {
+    int i = 0;
+    int j = array.length - 1;
+    byte tmp;
+    while (j > i) {
+        tmp = array[j];
+        array[j] = array[i];
+        array[i] = tmp;
+        j--;
+        i++;
+    }
+    return array
+}

devicetypes/smartthings/aeon-hemv2.src/aeon-hemv2.groovy

@@ -1,427 +0,0 @@
-/**
- *  Aeon HEMv2
- *
- *  Copyright 2014 Barry A. Burke
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- *
- *  Aeon Home Energy Meter v2 (US)
- *
- *  Author: Barry A. Burke
- *  Contributors: Brock Haymond: UI updates
- *
- *  Genesys: Based off of Aeon Smart Meter Code sample provided by SmartThings (2013-05-30). Built on US model
- *           may also work on international versions (currently reports total values only)
- *
- *  History:
- *      
- *  2014-06-13: Massive OverHaul
- *              - Fixed Configuration (original had byte order of bitstrings backwards
- *              - Increased reporting frequency to 10s - note that values won't report unless they change
- *                (they will also report if they exceed limits defined in the settings - currently just using
- *                the defaults).
- *              - Added support for Volts & Amps monitoring (was only Power and Energy)
- *              - Added flexible tile display. Currently only used to show High and Low values since last
- *                reset (with time stamps). 
- *              - All tiles are attributes, so that their values are preserved when you're not 'watching' the
- *                meter display
- *              - Values are formatted to Strings in zwaveEvent parser so that we don't lose decimal values 
- *                in the tile label display conversion
- *              - Updated fingerprint to match Aeon Home Energy Monitor v2 deviceId & clusters
- *              - Added colors for Watts and Amps display
- *              - Changed time format to 24 hour
- *  2014-06-17: Tile Tweaks
- *              - Reworked "decorations:" - current values are no longer "flat"
- *              - Added colors to current Watts (0-18000) & Amps (0-150)
- *              - Changed all colors to use same blue-green-orange-red as standard ST temperature guages
- *  2014-06-18: Cost calculations
- *              - Added $/kWh preference
- *  2014-09-07: Bug fix & Cleanup
- *              - Fixed "Unexpected Error" on Refresh tile - (added Refresh Capability)
- *              - Cleaned up low values - reset to ridiculously high value instead of null
- *              - Added poll() command/capability (just does a refresh)
- *              
- *  2014-09-19   GUI Tweaks, HEM v1 alterations (from Brock Haymond)
- *              - Reworked all tiles for look, color, text formatting, & readability
- */
-metadata {
-    // Automatically generated. Make future change here.
-    definition (
-        name: "Aeon HEMv2", 
-        namespace: "smartthings",
-        category: "Green Living",
-        author: "Barry A. Burke"
-    ) 
-    {
-        capability "Energy Meter"
-        capability "Power Meter"
-        capability "Configuration"
-        capability "Sensor"
-        capability "Refresh"
-        capability "Polling"
-        capability "Battery"
-        
-        attribute "energy", "string"
-        attribute "power", "string"
-        attribute "volts", "string"
-        attribute "amps", "string"
-        
-        attribute "energyDisp", "string"
-        attribute "energyOne", "string"
-        attribute "energyTwo", "string"
-        
-        attribute "powerDisp", "string"
-        attribute "powerOne", "string"
-        attribute "powerTwo", "string"
-        
-        attribute "voltsDisp", "string"
-        attribute "voltsOne", "string"
-        attribute "voltsTwo", "string"
-        
-        attribute "ampsDisp", "string"
-        attribute "ampsOne", "string"
-        attribute "ampsTwo", "string"        
-        
-        command "reset"
-        command "configure"
-        
-// v1       fingerprint deviceId: "0x2101", inClusters: " 0x70,0x31,0x72,0x86,0x32,0x80,0x85,0x60"
-
-        fingerprint deviceId: "0x3101", inClusters: "0x70,0x32,0x60,0x85,0x56,0x72,0x86"
-    }
-
-    // simulator metadata
-    simulator {
-        for (int i = 0; i <= 10000; i += 1000) {
-            status "power  ${i} W": new physicalgraph.zwave.Zwave().meterV1.meterReport(
-                scaledMeterValue: i, precision: 3, meterType: 33, scale: 2, size: 4).incomingMessage()
-        }
-        for (int i = 0; i <= 100; i += 10) {
-            status "energy  ${i} kWh": new physicalgraph.zwave.Zwave().meterV1.meterReport(
-                scaledMeterValue: i, precision: 3, meterType: 33, scale: 0, size: 4).incomingMessage()
-        }
-        // TODO: Add data feeds for Volts and Amps
-    }
-
-    // tile definitions
-    tiles {
-    
-    // Watts row
-
-        valueTile("powerDisp", "device.powerDisp") {
-            state (
-                "default", 
-                label:'${currentValue}', 
-                foregroundColors:[
-                    [value: 1, color: "#000000"],
-                    [value: 10000, color: "#ffffff"]
-                ], 
-                foregroundColor: "#000000",
-                backgroundColors:[
-                    [value: "0 Watts",      color: "#153591"],
-                    [value: "500 Watts",   color: "#1e9cbb"],
-                    [value: "1000 Watts",   color: "#90d2a7"],
-                    [value: "1500 Watts",   color: "#44b621"],
-                    [value: "2000 Watts",  color: "#f1d801"],
-                    [value: "2500 Watts",  color: "#d04e00"], 
-                    [value: "3000 Watts",  color: "#bc2323"] 
-                    /*
-                    [value: "0 Watts",      color: "#153591"],
-                    [value: "3000 Watts",   color: "#1e9cbb"],
-                    [value: "6000 Watts",   color: "#90d2a7"],
-                    [value: "9000 Watts",   color: "#44b621"],
-                    [value: "12000 Watts",  color: "#f1d801"],
-                    [value: "15000 Watts",  color: "#d04e00"], 
-                    [value: "18000 Watts",  color: "#bc2323"]  
-                    */
-                ]
-            )
-        }
-        valueTile("powerOne", "device.powerOne", decoration: "flat") {
-            state("default", label:'${currentValue}')
-        }
-        valueTile("powerTwo", "device.powerTwo", decoration: "flat") {
-            state("default", label:'${currentValue}')
-        }
-
-    // Power row
-    
-        valueTile("energyDisp", "device.energyDisp") {
-            state("default", label: '${currentValue}', backgroundColor:"#ffffff")
-        }
-        valueTile("energyOne", "device.energyOne") {
-            state("default", label: '${currentValue}', backgroundColor:"#ffffff")
-        }        
-        valueTile("energyTwo", "device.energyTwo") {
-            state("default", label: '${currentValue}', backgroundColor:"#ffffff")
-        }
-        
-    
-    // Volts row
-    
-        valueTile("voltsDisp", "device.voltsDisp") {
-            state "default", label: '${currentValue}', backgroundColors:[
-                [value: "115.6 Volts",  color: "#bc2323"],
-                [value: "117.8 Volts",  color: "#D04E00"],
-                [value: "120.0 Volts",  color: "#44B621"],
-                [value: "122.2 Volts",  color: "#D04E00"],
-                [value: "124.4 Volts",  color: "#bc2323"]
-            ]
-        }
-        valueTile("voltsOne", "device.voltsOne", decoration: "flat") {
-            state "default", label:'${currentValue}'
-        }
-        valueTile("voltsTwo", "device.voltsTwo", decoration: "flat") {
-            state "default", label:'${currentValue}'
-        }
-    
-    // Amps row
-    
-        valueTile("ampsDisp", "device.ampsDisp") {
-            state "default", label: '${currentValue}' , foregroundColor: "#000000", color: "#000000", backgroundColors:[
-                [value: "0 Amps",   color: "#153591"],
-                [value: "25 Amps",  color: "#1e9cbb"],
-                [value: "50 Amps",  color: "#90d2a7"],
-                [value: "75 Amps",  color: "#44b621"],
-                [value: "100 Amps", color: "#f1d801"],
-                [value: "125 Amps", color: "#d04e00"], 
-                [value: "150 Amps", color: "#bc2323"]
-            ] 
-        }
-        valueTile("ampsOne", "device.ampsOne", decoration: "flat") {
-            state "default", label:'${currentValue}'
-        }
-        valueTile("ampsTwo", "device.ampsTwo", decoration: "flat") {
-            state "default", label:'${currentValue}'
-        }
-    
-    // Controls row
-    
-        standardTile("reset", "device.energy", inactiveLabel: false) {
-            state "default", label:'reset', action:"reset", icon: "st.Health & Wellness.health7"
-        }
-        standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat" ) {
-            state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-        standardTile("configure", "device.power", inactiveLabel: false, decoration: "flat") {
-            state "configure", label:'', action:"configure", icon:"st.secondary.configure"
-        }
-        valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat") {
-            state "battery", label:'${currentValue}% battery', unit:""
-        }
-
-
-// TODO: Add configurable delay button - Cycle through 10s, 30s, 1m, 5m, 60m, off?
-
-        main (["powerDisp","energyDisp","ampsDisp","voltsDisp"])
-        details([
-            "energyOne","energyDisp","energyTwo",
-            "powerOne","powerDisp","powerTwo",
-            //"ampsOne","ampsDisp","ampsTwo",         // Comment out these two lines for HEMv!
-            //"voltsOne","voltsDisp","voltsTwo",      // Comment out these two lines for HEMv1
-            "reset","refresh", "battery", "configure"
-        ])
-    }
-    preferences {
-        input "kWhCost", "string", title: "\$/kWh (0.16)", defaultValue: "0.16" as String
-    }
-}
-
-
-def parse(String description) {
-//  log.debug "Parse received ${description}"
-    def result = null
-    def cmd = zwave.parse(description, [0x31: 1, 0x32: 1, 0x60: 3])
-    if (cmd) {
-        result = createEvent(zwaveEvent(cmd))
-    }
-    if (result) log.debug "Parse returned ${result}"
-    return result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.meterv1.MeterReport cmd) {
-//  log.debug "zwaveEvent received ${cmd}"
-    
-    def dispValue
-    def newValue
-    def timeString = new Date().format("h:mm a", location.timeZone)
-    
-    if (cmd.meterType == 33) {
-        if (cmd.scale == 0) {
-            newValue = cmd.scaledMeterValue
-            if (newValue != state.energyValue) {
-                dispValue = String.format("%5.2f",newValue)+"\nkWh"
-                sendEvent(name: "energyDisp", value: dispValue as String, unit: "")
-                state.energyValue = newValue
-                BigDecimal costDecimal = newValue * ( kWhCost as BigDecimal)
-                def costDisplay = String.format("%3.2f",costDecimal)
-                sendEvent(name: "energyTwo", value: "Cost\n\$${costDisplay}", unit: "")
-                [name: "energy", value: newValue, unit: "kWh"]
-            }
-        } else if (cmd.scale == 1) {
-            newValue = cmd.scaledMeterValue
-            if (newValue != state.energyValue) {
-                dispValue = String.format("%5.2f",newValue)+"\nkVAh"
-                sendEvent(name: "energyDisp", value: dispValue as String, unit: "")
-                state.energyValue = newValue
-                [name: "energy", value: newValue, unit: "kVAh"]
-            }
-        }
-        else if (cmd.scale==2) {                
-            newValue = Math.round( cmd.scaledMeterValue )       // really not worth the hassle to show decimals for Watts
-            if (newValue != state.powerValue) {
-                dispValue = newValue+"\nWatts"
-                sendEvent(name: "powerDisp", value: dispValue as String, unit: "")
-                
-                if (newValue < state.powerLow) {
-                    dispValue = "Low\n"+newValue+" W\n"+timeString
-                    sendEvent(name: "powerOne", value: dispValue as String, unit: "")
-                    state.powerLow = newValue
-                }
-                if (newValue > state.powerHigh) {
-                    dispValue = "High\n"+newValue+" W\n"+timeString
-                    sendEvent(name: "powerTwo", value: dispValue as String, unit: "")
-                    state.powerHigh = newValue
-                }
-                state.powerValue = newValue
-                [name: "power", value: newValue, unit: "W"]
-            }
-        }
-    }
-    else if (cmd.meterType == 161) {
-        if (cmd.scale == 0) {
-            newValue = cmd.scaledMeterValue
-            if (newValue != state.voltsValue) {
-                dispValue = String.format("%5.2f", newValue)+"\nVolts"
-                sendEvent(name: "voltsDisp", value: dispValue as String, unit: "")
-
-                if (newValue < state.voltsLow) {
-                    dispValue = "Low\n"+String.format("%5.2f", newValue)+" V\n"+timeString
-                    sendEvent(name: "voltsOne", value: dispValue as String, unit: "")                   
-                    state.voltsLow = newValue
-                }
-                if (newValue > state.voltsHigh) {
-                    dispValue = "High\n"+String.format("%5.2f", newValue)+" V\n"+timeString
-                    sendEvent(name: "voltsTwo", value: dispValue as String, unit: "")                    
-                    state.voltsHigh = newValue
-                }                
-                state.voltsValue = newValue
-                [name: "volts", value: newValue, unit: "V"]
-            }
-        }
-        else if (cmd.scale==1) {
-            newValue = cmd.scaledMeterValue
-            if (newValue != state.ampsValue) {
-                dispValue = String.format("%5.2f", newValue)+"\nAmps"
-                sendEvent(name: "ampsDisp", value: dispValue as String, unit: "")
-                
-                if (newValue < state.ampsLow) {
-                    dispValue = "Low\n"+String.format("%5.2f", newValue)+" A\n"+timeString
-                    sendEvent(name: "ampsOne", value: dispValue as String, unit: "")
-                    state.ampsLow = newValue
-                }
-                if (newValue > state.ampsHigh) {
-                    dispValue = "High\n"+String.format("%5.2f", newValue)+" A\n"+timeString
-                    sendEvent(name: "ampsTwo", value: dispValue as String, unit: "")
-                    state.ampsHigh = newValue
-                }                
-                state.ampsValue = newValue
-                [name: "amps", value: newValue, unit: "A"]
-            }
-        }
-    }           
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
-    def map = [:]
-    map.name = "battery"
-    map.unit = "%"
-    if (cmd.batteryLevel == 0xFF) {
-        map.value = 1
-        map.descriptionText = "${device.displayName} has a low battery"
-        map.isStateChange = true
-    } else {
-        map.value = cmd.batteryLevel
-    }
-    log.debug map
-    return map
-}
-
-def zwaveEvent(physicalgraph.zwave.Command cmd) {
-    // Handles all Z-Wave commands we aren't interested in
-    log.debug "Unhandled event ${cmd}"
-    [:]
-}
-
-def refresh() {
-    delayBetween([
-        zwave.meterV2.meterGet(scale: 0).format(),
-        zwave.meterV2.meterGet(scale: 2).format()
-    ])
-}
-
-def poll() {
-    refresh()
-}
-    
-def reset() {
-    log.debug "${device.name} reset"
-
-    state.powerHigh = 0
-    state.powerLow = 99999
-    state.ampsHigh = 0
-    state.ampsLow = 999
-    state.voltsHigh = 0
-    state.voltsLow = 999
-    
-    def dateString = new Date().format("m/d/YY", location.timeZone)
-    def timeString = new Date().format("h:mm a", location.timeZone)
-    sendEvent(name: "energyOne", value: "Since\n"+dateString+"\n"+timeString, unit: "")
-    sendEvent(name: "powerOne", value: "", unit: "")    
-    sendEvent(name: "voltsOne", value: "", unit: "")
-    sendEvent(name: "ampsOne", value: "", unit: "")
-    sendEvent(name: "ampsDisp", value: "", unit: "")
-    sendEvent(name: "voltsDisp", value: "", unit: "")
-    sendEvent(name: "powerDisp", value: "", unit: "")    
-    sendEvent(name: "energyDisp", value: "", unit: "")
-    sendEvent(name: "energyTwo", value: "Cost\n--", unit: "")
-    sendEvent(name: "powerTwo", value: "", unit: "")    
-    sendEvent(name: "voltsTwo", value: "", unit: "")
-    sendEvent(name: "ampsTwo", value: "", unit: "")
-    
-// No V1 available
-    def cmd = delayBetween( [
-        zwave.meterV2.meterReset().format(),
-        zwave.meterV2.meterGet(scale: 0).format()
-    ])
-    
-    cmd
-}
-
-def configure() {
-    // TODO: Turn on reporting for each leg of power - display as alternate view (Currently those values are
-    //       returned as zwaveEvents...they probably aren't implemented in the core Meter device yet.
-
-    def cmd = delayBetween([
-        zwave.configurationV1.configurationSet(parameterNumber: 3, size: 1, scaledConfigurationValue: 1).format(),      // Enable selective reporting
-        zwave.configurationV1.configurationSet(parameterNumber: 4, size: 2, scaledConfigurationValue: 50).format(),     // Don't send unless watts have increased by 50
-        zwave.configurationV1.configurationSet(parameterNumber: 8, size: 2, scaledConfigurationValue: 10).format(),     // Or by 10% (these 3 are the default values
-        zwave.configurationV1.configurationSet(parameterNumber: 101, size: 4, scaledConfigurationValue: 10).format(),   // Average Watts & Amps
-        zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: 30).format(),   // Every 30 Seconds
-        zwave.configurationV1.configurationSet(parameterNumber: 102, size: 4, scaledConfigurationValue: 4).format(),    // Average Voltage
-        zwave.configurationV1.configurationSet(parameterNumber: 112, size: 4, scaledConfigurationValue: 150).format(),  // every 2.5 minute
-        zwave.configurationV1.configurationSet(parameterNumber: 103, size: 4, scaledConfigurationValue: 1).format(),    // Total kWh (cumulative)
-        zwave.configurationV1.configurationSet(parameterNumber: 113, size: 4, scaledConfigurationValue: 300).format()   // every 5 minutes
-    ])
-    log.debug cmd
-
-    cmd
-}