MSA-615: Add control for the indicator light on the enerwave zw15sm switch. This is a modification to the stock metering switch device type.

Adds capabilities "Temperature Measurement" and "Relative Humidity Me…

devicetypes/keen-home/keen-home-smart-vent.src/keen-home-smart-vent.groovy

@@ -0,0 +1,506 @@
+/**
+ *  Keen Home Smart Vent
+ *
+ *  Author: Keen Home
+ *  Date: 2015-06-23
+ */
+
+metadata {
+    definition (name: "Keen Home Smart Vent", namespace: "Keen Home", author: "Gregg Altschul") {
+        capability "Switch Level"
+        capability "Switch"
+        capability "Configuration"
+        capability "Refresh"
+        capability "Sensor"
+        capability "Temperature Measurement"
+        capability "Battery"
+
+        command "getLevel"
+        command "getOnOff"
+        command "getPressure"
+        command "getBattery"
+        command "getTemperature"
+        command "setZigBeeIdTile"
+
+        fingerprint endpoint: "1",
+        profileId: "0104",
+        inClusters: "0000,0001,0003,0004,0005,0006,0008,0020,0402,0403,0B05,FC01,FC02",
+        outClusters: "0019"
+    }
+
+    // simulator metadata
+    simulator {
+        // status messages
+        status "on": "on/off: 1"
+        status "off": "on/off: 0"
+
+        // reply messages
+        reply "zcl on-off on": "on/off: 1"
+        reply "zcl on-off off": "on/off: 0"
+    }
+
+    // UI tile definitions
+    tiles {
+        standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+            state "on", action:"switch.off", icon:"st.vents.vent-open-text", backgroundColor:"#53a7c0"
+            state "off", action:"switch.on", icon:"st.vents.vent-closed", backgroundColor:"#ffffff"
+            state "obstructed", action: "switch.off", icon:"st.vents.vent-closed", backgroundColor:"#ff0000"
+        }
+        controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false) {
+            state "level", action:"switch level.setLevel"
+        }
+        standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat") {
+            state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+        valueTile("temperature", "device.temperature", inactiveLabel: false) {
+            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", inactiveLabel: false, decoration: "flat") {
+            state "battery", label: 'Battery \n${currentValue}%', backgroundColor:"#ffffff"
+        }
+        valueTile("zigbeeId", "device.zigbeeId", inactiveLabel: true, decoration: "flat") {
+            state "serial", label:'${currentValue}', backgroundColor:"#ffffff"
+        }
+        main "switch"
+        details(["switch","refresh","temperature","levelSliderControl","battery"])
+    }
+}
+
+/**** PARSE METHODS ****/
+def parse(String description) {
+    log.debug "description: $description"
+
+    Map map = [:]
+    if (description?.startsWith('catchall:')) {
+        map = parseCatchAllMessage(description)
+    }
+    else if (description?.startsWith('read attr -')) {
+        map = parseReportAttributeMessage(description)
+    }
+    else if (description?.startsWith('temperature: ') || description?.startsWith('humidity: ')) {
+        map = parseCustomMessage(description)
+    }
+    else if (description?.startsWith('on/off: ')) {
+        map = parseOnOffMessage(description)
+    }
+
+    log.debug "Parse returned $map"
+    return map ? createEvent(map) : null
+}
+
+private Map parseCatchAllMessage(String description) {
+    log.debug "parseCatchAllMessage"
+
+    def cluster = zigbee.parse(description)
+    log.debug "cluster: ${cluster}"
+    if (shouldProcessMessage(cluster)) {
+        log.debug "processing message"
+        switch(cluster.clusterId) {
+            case 0x0001:
+                return makeBatteryResult(cluster.data.last())
+                break
+
+            case 0x0402:
+                // temp is last 2 data values. reverse to swap endian
+                String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+                def value = convertTemperatureHex(temp)
+                return makeTemperatureResult(value)
+                break
+
+            case 0x0006:
+                return makeOnOffResult(cluster.data[-1])
+                break
+        }
+    }
+
+    return [:]
+}
+
+private boolean shouldProcessMessage(cluster) {
+    // 0x0B is default response indicating message got through
+    // 0x07 is bind message
+    if (cluster.profileId != 0x0104 ||
+        cluster.command == 0x0B ||
+        cluster.command == 0x07 ||
+        (cluster.data.size() > 0 && cluster.data.first() == 0x3e)) {
+        return false
+    }
+
+    return true
+}
+
+private Map parseReportAttributeMessage(String description) {
+    log.debug "parseReportAttributeMessage"
+
+    Map descMap = (description - "read attr - ").split(",").inject([:]) { map, param ->
+        def nameAndValue = param.split(":")
+        map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
+    }
+    log.debug "Desc Map: $descMap"
+
+    if (descMap.cluster == "0006" && descMap.attrId == "0000") {
+        return makeOnOffResult(Int.parseInt(descMap.value));
+    }
+    else if (descMap.cluster == "0008" && descMap.attrId == "0000") {
+        return makeLevelResult(descMap.value)
+    }
+    else if (descMap.cluster == "0402" && descMap.attrId == "0000") {
+        def value = convertTemperatureHex(descMap.value)
+        return makeTemperatureResult(value)
+    }
+    else if (descMap.cluster == "0001" && descMap.attrId == "0021") {
+        return makeBatteryResult(Integer.parseInt(descMap.value, 16))
+    }
+    else if (descMap.cluster == "0403" && descMap.attrId == "0020") {
+        return makePressureResult(Integer.parseInt(descMap.value, 16))
+    }
+    else if (descMap.cluster == "0000" && descMap.attrId == "0006") {
+        return makeSerialResult(new String(descMap.value.decodeHex()))
+    }
+
+    // shouldn't get here
+    return [:]
+}
+
+private Map parseCustomMessage(String description) {
+    Map resultMap = [:]
+    if (description?.startsWith('temperature: ')) {
+        // log.debug "${description}"
+        // def value = zigbee.parseHATemperatureValue(description, "temperature: ", getTemperatureScale())
+        // log.debug "split: " + description.split(": ")
+        def value = Double.parseDouble(description.split(": ")[1])
+        // log.debug "${value}"
+        resultMap = makeTemperatureResult(convertTemperature(value))
+    }
+    return resultMap
+}
+
+private Map parseOnOffMessage(String description) {
+    Map resultMap = [:]
+    if (description?.startsWith('on/off: ')) {
+        def value = Integer.parseInt(description - "on/off: ")
+        resultMap = makeOnOffResult(value)
+    }
+    return resultMap
+}
+
+private Map makeOnOffResult(rawValue) {
+    log.debug "makeOnOffResult: ${rawValue}"
+    def linkText = getLinkText(device)
+    def value = rawValue == 1 ? "on" : "off"
+    return [
+        name: "switch",
+        value: value,
+        descriptionText: "${linkText} is ${value}"
+    ]
+}
+
+private Map makeLevelResult(rawValue) {
+    def linkText = getLinkText(device)
+    // log.debug "rawValue: ${rawValue}"
+    def value = Integer.parseInt(rawValue, 16)
+    def rangeMax = 254
+
+    if (value == 255) {
+        log.debug "obstructed"
+        // Just return here. Once the vent is power cycled
+        // it will go back to the previous level before obstruction.
+        // Therefore, no need to update level on the display.
+        return [
+            name: "switch",
+            value: "obstructed",
+            descriptionText: "${linkText} is obstructed. Please power cycle."
+        ]
+    } else if ( device.currentValue("switch") == "obstructed" &&
+                value == 254)  {
+        // When the device is reset after an obstruction, the switch
+        // state will be obstructed and the value coming from the device
+        // will be 254. Since we're not using heating/cooling mode from
+        // the device type handler, we need to bump it down to the lower
+        // (cooling) range
+        sendEvent(makeOnOffResult(1)) // clear the obstructed switch state
+        value = rangeMax
+    }
+    // else if (device.currentValue("switch") == "off") {
+    //     sendEvent(makeOnOffResult(1)) // turn back on if in off state
+    // }
+
+
+    // log.debug "pre-value: ${value}"
+    value = Math.floor(value / rangeMax * 100)
+    // log.debug "post-value: ${value}"
+
+    return [
+        name: "level",
+        value: value,
+        descriptionText: "${linkText} level is ${value}%"
+    ]
+}
+
+private Map makePressureResult(rawValue) {
+    log.debug 'makePressureResut'
+    def linkText = getLinkText(device)
+
+    def pascals = rawValue / 10
+    def result = [
+        name: 'pressure',
+        descriptionText: "${linkText} pressure is ${pascals}Pa",
+        value: pascals
+    ]
+
+    return result
+}
+
+private Map makeBatteryResult(rawValue) {
+    // log.debug 'makeBatteryResult'
+    def linkText = getLinkText(device)
+
+    // log.debug
+    [
+        name: 'battery',
+        value: rawValue,
+        descriptionText: "${linkText} battery is at ${rawValue}%"
+    ]
+}
+
+private Map makeTemperatureResult(value) {
+    // log.debug 'makeTemperatureResult'
+    def linkText = getLinkText(device)
+
+    // log.debug "tempOffset: ${tempOffset}"
+    if (tempOffset) {
+        def offset = tempOffset as int
+        // log.debug "offset: ${offset}"
+        def v = value as int
+        // log.debug "v: ${v}"
+        value = v + offset
+        // log.debug "value: ${value}"
+    }
+
+    return [
+        name: 'temperature',
+        value: "" + value,
+        descriptionText: "${linkText} is ${value}°${temperatureScale}",
+    ]
+}
+
+/**** HELPER METHODS ****/
+private def convertTemperatureHex(value) {
+    // log.debug "convertTemperatureHex(${value})"
+    def celsius = Integer.parseInt(value, 16).shortValue() / 100
+    // log.debug "celsius: ${celsius}"
+
+    return convertTemperature(celsius)
+}
+
+private def convertTemperature(celsius) {
+    // log.debug "convertTemperature()"
+
+    if(getTemperatureScale() == "C"){
+        return celsius
+    } else {
+        def fahrenheit = Math.round(celsiusToFahrenheit(celsius) * 100) /100
+        // log.debug "converted to F: ${fahrenheit}"
+        return fahrenheit
+    }
+}
+
+private def makeSerialResult(serial) {
+    log.debug "makeSerialResult: " + serial
+
+    def linkText = getLinkText(device)
+    sendEvent([
+        name: "serial",
+        value: serial,
+        descriptionText: "${linkText} has serial ${serial}" ])
+    return [
+        name: "serial",
+        value: serial,
+        descriptionText: "${linkText} has serial ${serial}" ]
+}
+/**** COMMAND METHODS ****/
+// def mfgCode() {
+// 	 ["zcl mfg-code 0x115B", "delay 200"]
+// }
+
+def on() {
+    log.debug "on()"
+    sendEvent(makeOnOffResult(1))
+    "st cmd 0x${device.deviceNetworkId} 1 6 1 {}"
+}
+
+def off() {
+    log.debug "off()"
+    sendEvent(makeOnOffResult(0))
+    "st cmd 0x${device.deviceNetworkId} 1 6 0 {}"
+}
+
+// does this work?
+def toggle() {
+    log.debug "toggle()"
+
+    "st cmd 0x${device.deviceNetworkId} 1 6 2 {}"
+}
+
+def setLevel(value) {
+    log.debug "setting level: ${value}"
+
+    def linkText = getLinkText(device)
+
+    sendEvent(name: "level", value: value)
+    if (value > 0) {
+        sendEvent(name: "switch", value: "on", descriptionText: "${linkText} is on by setting a level")
+    }
+    else {
+        sendEvent(name: "switch", value: "off", descriptionText: "${linkText} is off by setting level to 0")
+    }
+    def rangeMax = 254
+    def computedLevel = Math.round(value * rangeMax / 100)
+    log.debug "computedLevel: ${computedLevel}"
+
+    def level = new BigInteger(computedLevel.toString()).toString(16)
+    log.debug "level: ${level}"
+
+    if (level.size() < 2){
+        level = '0' + level
+    }
+
+    "st cmd 0x${device.deviceNetworkId} 1 8 4 {${level} 0000}"
+}
+
+
+def getOnOff() {
+    log.debug "getOnOff()"
+
+    ["st rattr 0x${device.deviceNetworkId} 1 0x0006 0"]
+}
+
+def getPressure() {
+    log.debug "getPressure()"
+    [
+        "zcl mfg-code 0x115B", "delay 200",
+        "zcl global read 0x0403 0x20", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 200"
+    ]
+}
+
+def getLevel() {
+    log.debug "getLevel()"
+    // rattr = read attribute
+    // 0x${} = device net id
+    // 1 = endpoint
+    // 8 = cluster id (level control, in this case)
+    // 0 = attribute within cluster
+    // sendEvent(name: "level", value: value)
+    ["st rattr 0x${device.deviceNetworkId} 1 0x0008 0x0000"]
+}
+
+def getTemperature() {
+    log.debug "getTemperature()"
+
+    ["st rattr 0x${device.deviceNetworkId} 1 0x0402 0"]
+}
+
+def getBattery() {
+    log.debug "getBattery()"
+
+    ["st rattr 0x${device.deviceNetworkId} 1 0x0001 0x0021"]
+}
+
+def setZigBeeIdTile() {
+    log.debug "setZigBeeIdTile() - ${device.zigbeeId}"
+
+    def linkText = getLinkText(device)
+
+    sendEvent([
+        name: "zigbeeId",
+        value: device.zigbeeId,
+        descriptionText: "${linkText} has zigbeeId ${device.zigbeeId}" ])
+	return [
+        name: "zigbeeId",
+        value: device.zigbeeId,
+        descriptionText: "${linkText} has zigbeeId ${device.zigbeeId}" ]
+}
+
+def refresh() {
+	getOnOff() +
+    getLevel() +
+    getTemperature() +
+    getPressure() +
+    getBattery()
+}
+
+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
+}
+
+private String swapEndianHex(String hex) {
+    reverseArray(hex.decodeHex()).encodeHex()
+}
+
+def configure() {
+    log.debug "CONFIGURE"
+    log.debug "zigbeeId: ${device.hub.zigbeeId}"
+
+    setZigBeeIdTile()
+
+    def configCmds = [
+        // binding commands
+        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0006 {${device.zigbeeId}} {}", "delay 500",
+        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0008 {${device.zigbeeId}} {}", "delay 500",
+        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0402 {${device.zigbeeId}} {}", "delay 500",
+        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0403 {${device.zigbeeId}} {}", "delay 500",
+        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0001 {${device.zigbeeId}} {}", "delay 500",
+        
+        // configure report commands
+        // [cluster] [attr] [type] [min-interval] [max-interval] [min-change]
+
+        // mike 2015/06/22: preconfigured; see tech spec
+        // vent on/off state - type: boolean, change: 1
+        // "zcl global send-me-a-report 6 0 0x10 5 60 {01}", "delay 200",
+        // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+
+        // mike 2015/06/22: preconfigured; see tech spec
+        // vent level - type: int8u, change: 1
+        // "zcl global send-me-a-report 8 0 0x20 5 60 {01}", "delay 200",
+        // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+
+        // mike 2015/06/22: temp and pressure reports are preconfigured, but
+        //   we'd like to override their settings for our own purposes
+        // temperature - type: int16s, change: 0xA = 10 = 0.1C
+        "zcl global send-me-a-report 0x0402 0 0x29 10 60 {0A00}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+
+        // mike 2015/06/22: use new custom pressure attribute
+        // pressure - type: int32u, change: 1 = 0.1Pa
+        "zcl mfg-code 0x115B", "delay 200",
+        "zcl global send-me-a-report 0x0403 0x20 0x22 10 60 {010000}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1500"
+
+        // mike 2015/06/22: preconfigured; see tech spec
+        // battery - type: int8u, change: 1
+        // "zcl global send-me-a-report 1 0x21 0x20 60 3600 {01}", "delay 200",
+        // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+    ]
+
+    return configCmds + refresh()
+}

devicetypes/smartthings/enerwave-zw15sm-metering-switch.src/enerwave-zw15sm-metering-switch.groovy

@@ -0,0 +1,249 @@
+/**
+ *  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.
+ * modified by lgkahn v1 for control of the on/off light
+ * the lite when on/off is not the normal parameter settings of the config class and there also
+ * is no never lite option.. So custom code for this device only.
+ *
+ */
+metadata {
+	definition (name: "Enerwave ZW15SM Metering Switch", namespace: "smartthings", author: "LGKahn") {
+		capability "Energy Meter"
+		capability "Actuator"
+		capability "Switch"
+		capability "Power Meter"
+		capability "Polling"
+		capability "Refresh"
+		capability "Configuration"
+		capability "Sensor"
+        capability "Indicator"
+        
+      
+        
+		fingerprint inClusters: "0x25,0x32"
+	}
+
+	// simulator metadata
+	simulator {
+		status "on":  "command: 2003, payload: FF"
+		status "off": "command: 2003, payload: 00"
+
+		for (int i = 0; i <= 10000; i += 1000) {
+			status "power  ${i} W": new physicalgraph.zwave.Zwave().meterV1.meterReport(
+				scaledMeterValue: i, precision: 3, meterType: 4, 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: 0, scale: 0, size: 4).incomingMessage()
+		}
+
+		// reply messages
+		reply "2001FF,delay 100,2502": "command: 2503, payload: FF"
+		reply "200100,delay 100,2502": "command: 2503, payload: 00"
+
+	}
+
+	// tile definitions
+	tiles {
+		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+			state "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
+		}
+		valueTile("power", "device.power") {
+			state "default", label:'${currentValue} W'
+		}
+		valueTile("energy", "device.energy") {
+			state "default", label:'${currentValue} kWh'
+		}
+		standardTile("reset", "device.energy", inactiveLabel: false, decoration: "flat") {
+			state "default", label:'reset kWh', action:"reset"
+		}
+		standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat") {
+			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+
+		standardTile("indicatorStatus", "device.indicatorStatus", width: 1, height: 1, inactiveLabel: false, decoration: "flat") {
+			state "when off", action:"indicator.indicatorWhenOn", icon:"st.indicators.lit-when-off"
+			state "when on", action:"indicator.indicatorWhenOff", icon:"st.indicators.lit-when-on"
+		
+		}
+		main(["switch","power","energy"])
+		details(["switch","power","energy","indicatorStatus","refresh","reset"])
+	}
+}
+
+def updated() {
+	try {
+		if (!state.MSR) {
+			response(zwave.manufacturerSpecificV2.manufacturerSpecificGet().format())
+		}
+	} catch (e) { log.debug e }
+}
+
+def parse(String description) {
+	def result = null
+    //log.debug "in parse desc = $description"
+    
+	if(description == "updated") return 
+	def cmd = zwave.parse(description, [0x20: 1, 0x32: 1, 0x72: 2])
+	if (cmd) {
+		result = zwaveEvent(cmd)
+	}
+	return result
+}
+
+
+
+def zwaveEvent(physicalgraph.zwave.commands.meterv1.MeterReport cmd) {
+	if (cmd.scale == 0) {
+		createEvent(name: "energy", value: cmd.scaledMeterValue, unit: "kWh")
+	} else if (cmd.scale == 1) {
+		createEvent(name: "energy", value: cmd.scaledMeterValue, unit: "kVAh")
+	} else if (cmd.scale == 2) {
+		createEvent(name: "power", value: Math.round(cmd.scaledMeterValue), unit: "W")
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd)
+{
+	def evt = createEvent(name: "switch", value: cmd.value ? "on" : "off", type: "physical")
+	if (evt.isStateChange) {
+		[evt, response(["delay 3000", zwave.meterV2.meterGet(scale: 2).format()])]
+	} else {
+		evt
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd)
+{
+	createEvent(name: "switch", value: cmd.value ? "on" : "off", type: "digital")
+}
+
+
+def zwaveEvent(physicalgraph.zwave.commands.configurationv1.ConfigurationReport cmd) {
+
+   // log.debug "in config report  got indicatorstatus = $state.currentIndicatorStatus"	
+	[name: "indicatorStatus", value: state.currentIndicatorStatus, display: true]
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
+	def result = []
+
+	
+	def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
+	log.debug "msr: $msr"
+	updateDataValue("MSR", msr)
+
+	// retypeBasedOnMSR()
+
+	result << createEvent(descriptionText: "$device.displayName MSR: $msr", isStateChange: false)
+
+	if (msr.startsWith("0086") && !state.aeonconfig) {  // Aeon Labs meter
+		state.aeonconfig = 1
+		result << response(delayBetween([
+			zwave.configurationV1.configurationSet(parameterNumber: 101, size: 4, scaledConfigurationValue: 4).format(),   // report power in watts
+			zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: 300).format(), // every 5 min
+			zwave.configurationV1.configurationSet(parameterNumber: 102, size: 4, scaledConfigurationValue: 8).format(),   // report energy in kWh
+			zwave.configurationV1.configurationSet(parameterNumber: 112, size: 4, scaledConfigurationValue: 300).format(), // every 5 min
+			zwave.configurationV1.configurationSet(parameterNumber: 103, size: 4, scaledConfigurationValue: 0).format(),    // no third report
+			//zwave.configurationV1.configurationSet(parameterNumber: 113, size: 4, scaledConfigurationValue: 300).format(), // every 5 min
+			zwave.meterV2.meterGet(scale: 0).format(),
+			zwave.meterV2.meterGet(scale: 2).format(),
+		]))
+	} else {
+		result << response(delayBetween([
+			zwave.meterV2.meterGet(scale: 0).format(),
+			zwave.meterV2.meterGet(scale: 2).format(),
+		]))
+	}
+
+	result
+}
+
+def zwaveEvent(physicalgraph.zwave.Command cmd) {
+	log.debug "$device.displayName: Unhandled: $cmd"
+	[:]
+}
+
+def on() {
+
+log.debug "in on"
+	[
+    
+		zwave.basicV1.basicSet(value: 0xFF).format(),
+		zwave.switchBinaryV1.switchBinaryGet().format(),
+		"delay 3000",
+		zwave.meterV2.meterGet(scale: 2).format()
+	]
+}
+
+def off() {
+log.debug "in off"
+	[
+    	zwave.basicV1.basicSet(value: 0x00).format(),
+		zwave.switchBinaryV1.switchBinaryGet().format(),
+		"delay 3000",
+		zwave.meterV2.meterGet(scale: 2).format()
+	]
+}
+
+def poll() {
+	delayBetween([
+		zwave.switchBinaryV1.switchBinaryGet().format(),
+		zwave.meterV2.meterGet(scale: 0).format(),
+		zwave.meterV2.meterGet(scale: 2).format()
+	])
+}
+
+def refresh() {
+	def value = "when off"
+   
+    log.debug "in refresh for whenon got indicatorstatus = $state.currentIndicatorStatus"
+    sendEvent(name: "indicatorStatus", value: state.currentIndicatorStatus, display: true)
+	
+	delayBetween([
+		zwave.switchBinaryV1.switchBinaryGet().format(),
+		zwave.meterV2.meterGet(scale: 0).format(),
+		zwave.meterV2.meterGet(scale: 2).format()
+	])
+}
+
+def configure() {
+	zwave.manufacturerSpecificV2.manufacturerSpecificGet().format()
+}
+
+def reset() {
+			 state.currentIndicatorStatus = "when on"
+	return [
+		zwave.meterV2.meterReset().format(),
+		zwave.meterV2.meterGet(scale: 0).format()
+	]
+}
+
+
+
+
+def indicatorWhenOn() {
+log.debug "in when on"
+ state.currentIndicatorStatus = "when on"
+	sendEvent(name: "indicatorStatus", value: "when on", display: true)
+zwave.configurationV1.configurationSet(parameterNumber: 0x01, size: 1, scaledConfigurationValue: 1).format()
+	}
+
+def indicatorWhenOff() {
+log.debug "in when off"
+ state.currentIndicatorStatus = "when off"
+	sendEvent(name: "indicatorStatus", value: "when off", display: true)	  
+zwave.configurationV1.configurationSet(parameterNumber: 0x01, size: 1, scaledConfigurationValue: 0).format()
+	}
+
+
+

devicetypes/zenwithin/zen-thermostat.src/zen-thermostat.groovy

@@ -8,6 +8,7 @@ metadata {
   definition (name: "Zen Thermostat", namespace: "zenwithin", author: "ZenWithin") {
     capability "Actuator"
     capability "Thermostat"
+    capability "Temperature Measurement"
     capability "Configuration"
     capability "Refresh"
     capability "Sensor"

smartapps/initialstate-events/initial-state-event-streamer.src/initial-state-event-streamer.groovy

@@ -341,6 +341,13 @@ def eventHandler(name, value) {
 
 	def eventBuffer = atomicState.eventBuffer
 	def epoch = now() / 1000
+	
+	// if for some reason this code block is being run
+	// but the SmartApp wasn't propery setup during install
+	// we need to set initialize the eventBuffer.
+	if (!atomicState.eventBuffer) {
+		atomicState.eventBuffer = []
+	}
 	eventBuffer << [key: "$name", value: "$value", epoch: "$epoch"]
 	
 	log.debug eventBuffer