Merge pull request #2208 from SmartThingsCommunity/staging

Rolling up staging to production

devicetypes/erocm123/sonoff-wifi-switch.src/sonoff-wifi-switch.groovy

@@ -1,450 +0,0 @@
-/**
- *  Copyright 2016 Eric Maycock
- *
- *  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.
- *
- *  Sonoff Wifi Switch
- *
- *  Author: Eric Maycock (erocm123)
- *  Date: 2016-06-02
- */
- 
-import groovy.json.JsonSlurper
-import groovy.util.XmlSlurper
-
-metadata {
-	definition (name: "Sonoff Wifi Switch", namespace: "erocm123", author: "Eric Maycock") {
-        capability "Actuator"
-		capability "Switch"
-		capability "Refresh"
-		capability "Sensor"
-        capability "Configuration"
-        capability "Health Check"
-        
-        command "reboot"
-        
-        attribute   "needUpdate", "string"
-	}
-
-	simulator {
-	}
-    
-    preferences {
-        input description: "Once you change values on this page, the corner of the \"configuration\" icon will change orange until all configuration parameters are updated.", title: "Settings", displayDuringSetup: false, type: "paragraph", element: "paragraph"
-		generate_preferences(configuration_model())
-	}
-
-	tiles (scale: 2){      
-		multiAttributeTile(name:"switch", type: "generic", width: 6, height: 4, canChangeIcon: true){
-			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", backgroundColor:"#00a0dc", icon: "st.switches.switch.on", nextState:"turningOff"
-				attributeState "off", label:'${name}', action:"switch.on", backgroundColor:"#ffffff", icon: "st.switches.switch.off", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", backgroundColor:"#00a0dc", icon: "st.switches.switch.off", nextState:"turningOff"
-				attributeState "turningOff", label:'${name}', action:"switch.on", backgroundColor:"#ffffff", icon: "st.switches.switch.on", nextState:"turningOn"
-			}
-        }
-
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-        standardTile("configure", "device.needUpdate", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "NO" , label:'', action:"configuration.configure", icon:"st.secondary.configure"
-            state "YES", label:'', action:"configuration.configure", icon:"https://github.com/erocm123/SmartThingsPublic/raw/master/devicetypes/erocm123/qubino-flush-1d-relay.src/configure@2x.png"
-        }
-        standardTile("reboot", "device.reboot", decoration: "flat", height: 2, width: 2, inactiveLabel: false) {
-            state "default", label:"Reboot", action:"reboot", icon:"", backgroundColor:"#ffffff"
-        }
-        valueTile("ip", "ip", width: 2, height: 1) {
-    		state "ip", label:'IP Address\r\n${currentValue}'
-		}
-        valueTile("uptime", "uptime", width: 2, height: 1) {
-    		state "uptime", label:'Uptime ${currentValue}'
-		}
-        
-    }
-
-	main(["switch"])
-	details(["switch",
-             "refresh","configure","reboot",
-             "ip", "uptime"])
-}
-
-def installed() {
-	log.debug "installed()"
-	configure()
-}
-
-def configure() {
-    logging("configure()", 1)
-    def cmds = []
-    cmds = update_needed_settings()
-    if (cmds != []) cmds
-}
-
-def updated()
-{
-    logging("updated()", 1)
-    def cmds = [] 
-    cmds = update_needed_settings()
-    sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "lan", hubHardwareId: device.hub.hardwareID])
-    sendEvent(name:"needUpdate", value: device.currentValue("needUpdate"), displayed:false, isStateChange: true)
-    if (cmds != []) response(cmds)
-}
-
-private def logging(message, level) {
-    if (logLevel != "0"){
-    switch (logLevel) {
-       case "1":
-          if (level > 1)
-             log.debug "$message"
-       break
-       case "99":
-          log.debug "$message"
-       break
-    }
-    }
-}
-
-def parse(description) {
-	//log.debug "Parsing: ${description}"
-    def events = []
-    def descMap = parseDescriptionAsMap(description)
-    def body
-    //log.debug "descMap: ${descMap}"
-
-    if (!state.mac || state.mac != descMap["mac"]) {
-		log.debug "Mac address of device found ${descMap["mac"]}"
-        updateDataValue("mac", descMap["mac"])
-	}
-    
-    if (state.mac != null && state.dni != state.mac) state.dni = setDeviceNetworkId(state.mac)
-    if (descMap["body"]) body = new String(descMap["body"].decodeBase64())
-
-    if (body && body != "") {
-    
-    if(body.startsWith("{") || body.startsWith("[")) {
-    def slurper = new JsonSlurper()
-    def result = slurper.parseText(body)
-    
-    log.debug "result: ${result}"
-    
-    if (result.containsKey("type")) {
-        if (result.type == "configuration")
-            events << update_current_properties(result)
-    }
-    if (result.containsKey("power")) {
-        events << createEvent(name: "switch", value: result.power)
-    }
-    if (result.containsKey("uptime")) {
-        events << createEvent(name: "uptime", value: result.uptime, displayed: false)
-    }
-    } else {
-        //log.debug "Response is not JSON: $body"
-    }
-    }
-
-    if (!device.currentValue("ip") || (device.currentValue("ip") != getDataValue("ip"))) events << createEvent(name: 'ip', value: getDataValue("ip"))
-
-    return events
-}
-
-def parseDescriptionAsMap(description) {
-	description.split(",").inject([:]) { map, param ->
-		def nameAndValue = param.split(":")
-        
-        if (nameAndValue.length == 2) map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
-        else map += [(nameAndValue[0].trim()):""]
-	}
-}
-
-def on() {
-	log.debug "on()"
-    def cmds = []
-    cmds << getAction("/on")
-    return cmds
-}
-
-def off() {
-    log.debug "off()"
-	def cmds = []
-    cmds << getAction("/off")
-    return cmds
-}
-
-def refresh() {
-	log.debug "refresh()"
-    def cmds = []
-    cmds << getAction("/status")
-    return cmds
-}
-
-def ping() {
-    log.debug "ping()"
-    refresh()
-}
-
-private getAction(uri){ 
-  updateDNI()
-  def userpass
-  //log.debug uri
-  if(password != null && password != "") 
-    userpass = encodeCredentials("admin", password)
-    
-  def headers = getHeader(userpass)
-
-  def hubAction = new physicalgraph.device.HubAction(
-    method: "GET",
-    path: uri,
-    headers: headers
-  )
-  return hubAction    
-}
-
-private postAction(uri, data){ 
-  updateDNI()
-  
-  def userpass
-  
-  if(password != null && password != "") 
-    userpass = encodeCredentials("admin", password)
-  
-  def headers = getHeader(userpass)
-  
-  def hubAction = new physicalgraph.device.HubAction(
-    method: "POST",
-    path: uri,
-    headers: headers,
-    body: data
-  )
-  return hubAction    
-}
-
-private setDeviceNetworkId(ip, port = null){
-    def myDNI
-    if (port == null) {
-        myDNI = ip
-    } else {
-  	    def iphex = convertIPtoHex(ip)
-  	    def porthex = convertPortToHex(port)
-        myDNI = "$iphex:$porthex"
-    }
-    log.debug "Device Network Id set to ${myDNI}"
-    return myDNI
-}
-
-private updateDNI() { 
-    if (state.dni != null && state.dni != "" && device.deviceNetworkId != state.dni) {
-       device.deviceNetworkId = state.dni
-    }
-}
-
-private getHostAddress() {
-    if (override == "true" && ip != null && ip != ""){
-        return "${ip}:80"
-    }
-    else if(getDeviceDataByName("ip") && getDeviceDataByName("port")){
-        return "${getDeviceDataByName("ip")}:${getDeviceDataByName("port")}"
-    }else{
-	    return "${ip}:80"
-    }
-}
-
-private String convertIPtoHex(ipAddress) { 
-    String hex = ipAddress.tokenize( '.' ).collect {  String.format( '%02x', it.toInteger() ) }.join()
-    return hex
-}
-
-private String convertPortToHex(port) {
-	String hexport = port.toString().format( '%04x', port.toInteger() )
-    return hexport
-}
-
-private encodeCredentials(username, password){
-	def userpassascii = "${username}:${password}"
-    def userpass = "Basic " + userpassascii.encodeAsBase64().toString()
-    return userpass
-}
-
-private getHeader(userpass = null){
-    def headers = [:]
-    headers.put("Host", getHostAddress())
-    headers.put("Content-Type", "application/x-www-form-urlencoded")
-    if (userpass != null)
-       headers.put("Authorization", userpass)
-    return headers
-}
-
-def reboot() {
-	log.debug "reboot()"
-    def uri = "/reboot"
-    getAction(uri)
-}
-
-def sync(ip, port) {
-    def existingIp = getDataValue("ip")
-    def existingPort = getDataValue("port")
-    if (ip && ip != existingIp) {
-        updateDataValue("ip", ip)
-        sendEvent(name: 'ip', value: ip)
-    }
-    if (port && port != existingPort) {
-        updateDataValue("port", port)
-    }
-}
-
-def generate_preferences(configuration_model)
-{
-    def configuration = parseXml(configuration_model)
-   
-    configuration.Value.each
-    {
-        if(it.@hidden != "true" && it.@disabled != "true"){
-        switch(it.@type)
-        {   
-            case ["number"]:
-                input "${it.@index}", "number",
-                    title:"${it.@label}\n" + "${it.Help}",
-                    range: "${it.@min}..${it.@max}",
-                    defaultValue: "${it.@value}",
-                    displayDuringSetup: "${it.@displayDuringSetup}"
-            break
-            case "list":
-                def items = []
-                it.Item.each { items << ["${it.@value}":"${it.@label}"] }
-                input "${it.@index}", "enum",
-                    title:"${it.@label}\n" + "${it.Help}",
-                    defaultValue: "${it.@value}",
-                    displayDuringSetup: "${it.@displayDuringSetup}",
-                    options: items
-            break
-            case ["password"]:
-                input "${it.@index}", "password",
-                    title:"${it.@label}\n" + "${it.Help}",
-                    displayDuringSetup: "${it.@displayDuringSetup}"
-            break
-            case "decimal":
-               input "${it.@index}", "decimal",
-                    title:"${it.@label}\n" + "${it.Help}",
-                    range: "${it.@min}..${it.@max}",
-                    defaultValue: "${it.@value}",
-                    displayDuringSetup: "${it.@displayDuringSetup}"
-            break
-            case "boolean":
-               input "${it.@index}", "boolean",
-                    title:"${it.@label}\n" + "${it.Help}",
-                    defaultValue: "${it.@value}",
-                    displayDuringSetup: "${it.@displayDuringSetup}"
-            break
-        }
-        }
-    }
-}
-
- /*  Code has elements from other community source @CyrilPeponnet (Z-Wave Parameter Sync). */
-
-def update_current_properties(cmd)
-{
-    def currentProperties = state.currentProperties ?: [:]
-    currentProperties."${cmd.name}" = cmd.value
-
-    if (settings."${cmd.name}" != null)
-    {
-        if (settings."${cmd.name}".toString() == cmd.value)
-        {
-            sendEvent(name:"needUpdate", value:"NO", displayed:false, isStateChange: true)
-        }
-        else
-        {
-            sendEvent(name:"needUpdate", value:"YES", displayed:false, isStateChange: true)
-        }
-    }
-    state.currentProperties = currentProperties
-}
-
-
-def update_needed_settings()
-{
-    def cmds = []
-    def currentProperties = state.currentProperties ?: [:]
-     
-    def configuration = parseXml(configuration_model())
-    def isUpdateNeeded = "NO"
-    
-    cmds << getAction("/configSet?name=haip&value=${device.hub.getDataValue("localIP")}")
-    cmds << getAction("/configSet?name=haport&value=${device.hub.getDataValue("localSrvPortTCP")}")
-    
-    configuration.Value.each
-    {     
-        if ("${it.@setting_type}" == "lan" && it.@disabled != "true"){
-            if (currentProperties."${it.@index}" == null)
-            {
-               if (it.@setonly == "true"){
-                  logging("Setting ${it.@index} will be updated to ${it.@value}", 2)
-                  cmds << getAction("/configSet?name=${it.@index}&value=${it.@value}")
-               } else {
-                  isUpdateNeeded = "YES"
-                  logging("Current value of setting ${it.@index} is unknown", 2)
-                  cmds << getAction("/configGet?name=${it.@index}")
-               }
-            }
-            else if ((settings."${it.@index}" != null || it.@hidden == "true") && currentProperties."${it.@index}" != (settings."${it.@index}"? settings."${it.@index}".toString() : "${it.@value}"))
-            { 
-                isUpdateNeeded = "YES"
-                logging("Setting ${it.@index} will be updated to ${settings."${it.@index}"}", 2)
-                cmds << getAction("/configSet?name=${it.@index}&value=${settings."${it.@index}"}")
-            } 
-        }
-    }
-    
-    sendEvent(name:"needUpdate", value: isUpdateNeeded, displayed:false, isStateChange: true)
-    return cmds
-}
-
-def configuration_model()
-{
-'''
-<configuration>
-<Value type="password" byteSize="1" index="password" label="Password" min="" max="" value="" setting_type="preference" fw="">
-<Help>
-</Help>
-</Value>
-<Value type="list" byteSize="1" index="pos" label="Boot Up State" min="0" max="2" value="0" setting_type="lan" fw="">
-<Help>
-Default: Off
-</Help>
-    <Item label="Off" value="0" />
-    <Item label="On" value="1" />
-    <Item label="Previous" value="2" />
-</Value>
-<Value type="number" byteSize="1" index="autooff" label="Auto Off" min="0" max="65536" value="0" setting_type="lan" fw="">
-<Help>
-Automatically turn the switch off after this many seconds.
-Range: 0 to 65536
-Default: 0 (Disabled)
-</Help>
-</Value>
-<Value type="list" byteSize="1" index="switchtype" label="External Switch Type" min="0" max="1" value="0" setting_type="lan" fw="">
-<Help>
-If a switch is attached to GPIO 14.
-Default: Momentary
-</Help>
-    <Item label="Momentary" value="0" />
-    <Item label="Toggle" value="1" />
-</Value>
-<Value type="list" index="logLevel" label="Debug Logging Level?" value="0" setting_type="preference" fw="">
-<Help>
-</Help>
-    <Item label="None" value="0" />
-    <Item label="Reports" value="1" />
-    <Item label="All" value="99" />
-</Value>
-</configuration>
-'''
-}

devicetypes/plaidsystems/spruce-sensor.src/spruce-sensor.groovy

@@ -1,5 +1,5 @@
 /**
- *  Spruce Sensor -Pre-release V2 10/8/2015
+ *  Spruce Sensor -updated with SLP model number 5/2017
  *
  *  Copyright 2014 Plaid Systems
  *
@@ -14,25 +14,33 @@
  *
  -------10/20/2015 Updates--------
  -Fix/add battery reporting interval to update
- -remove polling and/or refresh(?)
+ -remove polling and/or refresh
+ 
+ -------5/2017 Updates--------
+ -Add fingerprints for SLP
+ -add device health, check every 60mins + 2mins
  */
+ 
 metadata {
-	definition (name: "Spruce Sensor", namespace: "plaidsystems", author: "NCauffman") {
+	definition (name: "Spruce Sensor", namespace: "plaidsystems", author: "Plaid Systems") {
 		
 		capability "Configuration"
 		capability "Battery"
         capability "Relative Humidity Measurement"
         capability "Temperature Measurement"
         capability "Sensor"
+        capability "Health Check"
         //capability "Polling"
 		
         attribute "maxHum", "string"
         attribute "minHum", "string"        
         
+        
         command "resetHumidity"
         command "refresh"
         
-        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0402,0405", outClusters: "0003, 0019", manufacturer: "PLAID SYSTEMS", model: "PS-SPRZMS-01"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0402,0405", outClusters: "0003, 0019", manufacturer: "PLAID SYSTEMS", model: "PS-SPRZMS-01", deviceJoinName: "Spruce Sensor"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0402,0405", outClusters: "0003, 0019", manufacturer: "PLAID SYSTEMS", model: "PS-SPRZMS-SLP1", deviceJoinName: "Spruce Sensor"
 	}
 
 	preferences {
@@ -65,7 +73,7 @@ metadata {
 					[value: 64, color: "#44B621"],
 					[value: 80, color: "#3D79D9"],
 					[value: 96, color: "#0A50C2"]
-				]
+				], icon:"st.Weather.weather12"
 		}
         
         valueTile("maxHum", "device.maxHum", canChangeIcon: false, canChangeBackground: false) {
@@ -293,6 +301,11 @@ def setConfig(){
     sendEvent(name: 'configuration',value: configInterval, descriptionText: "Configuration initialized")
 }
 
+def installed(){
+	//check every 1 hour + 2mins
+    sendEvent(name: "checkInterval", value: 1 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+}
+
 //when device preferences are changed
 def updated(){	
     log.debug "device updated"
@@ -303,6 +316,8 @@ def updated(){
             sendEvent(name: 'configuration',value: 0, descriptionText: "Settings changed and will update at next report. Measure interval set to ${interval} mins")
     	}
     }
+    //check every 1 hour + 2mins
+    sendEvent(name: "checkInterval", value: 1 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 }
 
 //poll
@@ -395,4 +410,4 @@ private byte[] reverseArray(byte[] array) {
         i++;
     }
     return array
-}
+}

devicetypes/smartthings/aeon-key-fob.src/aeon-key-fob.groovy

@@ -133,8 +133,8 @@ def updated() {
 }
 
 def initialize() {
-	// Arrival sensors only goes OFFLINE when Hub is off
+	// Device only goes OFFLINE when Hub is off
-	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "zigbee", scheme:"untracked"]), displayed: false)
+	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "zwave", scheme:"untracked"]), displayed: false)
 
 	def zwMap = getZwaveInfo()
 	def buttons = 4 // Default for Key Fob

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

@@ -111,7 +111,6 @@ def configure() {
 	return cmds
 }
 
-
 def installed() {
 	initialize()
 }
@@ -121,7 +120,7 @@ def updated() {
 }
 
 def initialize() {
-	// Arrival sensors only goes OFFLINE when Hub is off
+	// Device only goes OFFLINE when Hub is off
-	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "zigbee", scheme:"untracked"]), displayed: false)
+	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "zwave", scheme:"untracked"]), displayed: false)
 	sendEvent(name: "numberOfButtons", value: 4)
 }

devicetypes/smartthings/aeon-multisensor-6.src/README.md

@@ -27,13 +27,9 @@ Works with:
 ## Device Health
 
 Aeon Labs MultiSensor 6 is polled by the hub.
-As of hubCore version 0.14.38 the hub sends up reports every 15 minutes regardless of whether the state changed.
+Aeon MultiSensor reports in once every hour.
-Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*15 + 2)mins = 32 mins.
-Not to mention after going OFFLINE when the device is plugged back in, it might take a considerable amount of time for
-the device to appear as ONLINE again. This is because if this listening device does not respond to two poll requests in a row,
-it is not polled for 5 minutes by the hub. This can delay up the process of being marked ONLINE by quite some time.
 
-* __32min__ checkInterval
+* __122min__ checkInterval
 
 ## Troubleshooting
 

devicetypes/smartthings/aeon-multisensor-6.src/aeon-multisensor-6.groovy

@@ -130,13 +130,13 @@ metadata {
 }
 
 def installed(){
-// Device-Watch simply pings if no device events received for 32min(checkInterval)
+// Device-Watch simply pings if no device events received for 122min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 }
 
 def updated() {
-// Device-Watch simply pings if no device events received for 32min(checkInterval)
+// Device-Watch simply pings if no device events received for 122min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 	log.debug "Updated with settings: ${settings}"
 	log.debug "${device.displayName} is now ${device.latestValue("powerSupply")}"
 

devicetypes/smartthings/aeon-multisensor-gen5.src/README.md

@@ -27,13 +27,9 @@ Works with:
 ## Device Health
 
 Aeon Labs MultiSensor (Gen 5) is polled by the hub.
-As of hubCore version 0.14.38 the hub sends up reports every 15 minutes regardless of whether the state changed.
+Aeon MultiSensor Gen5 reports in once every hour.
-Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*15 + 2)mins = 32 mins.
-Not to mention after going OFFLINE when the device is plugged back in, it might take a considerable amount of time for
-the device to appear as ONLINE again. This is because if this listening device does not respond to two poll requests in a row,
-it is not polled for 5 minutes by the hub. This can delay up the process of being marked ONLINE by quite some time.
 
-* __32min__ checkInterval
+* __122min__ checkInterval
 
 ## Troubleshooting
 

devicetypes/smartthings/aeon-multisensor-gen5.src/aeon-multisensor-gen5.groovy

@@ -100,12 +100,12 @@ metadata {
 
 def installed(){
 // Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 }
 
 def updated(){
 // Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 }
 
 def parse(String description)

devicetypes/smartthings/aeon-multisensor.src/README.md

@@ -28,13 +28,9 @@ Works with:
 ## Device Health
 
 Aeon Labs MultiSensor is polled by the hub.
-As of hubCore version 0.14.38 the hub sends up reports every 15 minutes regardless of whether the state changed.
+Aeon MultiSensor reports in once every hour.
-Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*15 + 2)mins = 32 mins.
-Not to mention after going OFFLINE when the device is plugged back in, it might take a considerable amount of time for
-the device to appear as ONLINE again. This is because if this listening device does not respond to two poll requests in a row,
-it is not polled for 5 minutes by the hub. This can delay up the process of being marked ONLINE by quite some time.
 
-* __32min__ checkInterval
+* __122min__ checkInterval
 
 ## Battery Specification
 

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

@@ -96,12 +96,12 @@ metadata {
 
 def installed(){
 // Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 }
 
 def updated(){
 // Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 }
 
 // Parse incoming device messages to generate events

devicetypes/smartthings/ct100-thermostat.src/ct100-thermostat.groovy

@@ -6,7 +6,6 @@ metadata {
 		capability "Relative Humidity Measurement"
 		capability "Thermostat"
 		capability "Battery"
-		capability "Configuration"
 		capability "Refresh"
 		capability "Sensor"
 		capability "Health Check"
@@ -15,161 +14,173 @@ metadata {
 
 		command "switchMode"
 		command "switchFanMode"
-		command "quickSetCool"
+		command "lowerHeatingSetpoint"
-		command "quickSetHeat"
+		command "raiseHeatingSetpoint"
+		command "lowerCoolSetpoint"
+		command "raiseCoolSetpoint"
 
 		fingerprint deviceId: "0x08", inClusters: "0x43,0x40,0x44,0x31,0x80,0x85,0x60"
 		fingerprint mfr:"0098", prod:"6401", model:"0107", deviceJoinName: "2Gig CT100 Programmable Thermostat"
 	}
 
-	// simulator metadata
-	simulator {
-		status "off"            : "command: 4003, payload: 00"
-		status "heat"           : "command: 4003, payload: 01"
-		status "cool"           : "command: 4003, payload: 02"
-		status "auto"           : "command: 4003, payload: 03"
-		status "emergencyHeat"  : "command: 4003, payload: 04"
-
-		status "fanAuto"        : "command: 4403, payload: 00"
-		status "fanOn"          : "command: 4403, payload: 01"
-		status "fanCirculate"   : "command: 4403, payload: 06"
-
-		status "heat 60"        : "command: 4303, payload: 01 09 3C"
-		status "heat 72"        : "command: 4303, payload: 01 09 48"
-
-		status "cool 76"        : "command: 4303, payload: 02 09 4C"
-		status "cool 80"        : "command: 4303, payload: 02 09 50"
-
-		status "temp 58"        : "command: 3105, payload: 01 2A 02 44"
-		status "temp 62"        : "command: 3105, payload: 01 2A 02 6C"
-		status "temp 78"        : "command: 3105, payload: 01 2A 03 0C"
-		status "temp 86"        : "command: 3105, payload: 01 2A 03 34"
-
-		status "idle"           : "command: 4203, payload: 00"
-		status "heating"        : "command: 4203, payload: 01"
-		status "cooling"        : "command: 4203, payload: 02"
-
-		// reply messages
-		reply "2502": "command: 2503, payload: FF"
-	}
-
 	tiles {
-		valueTile("temperature", "device.temperature", width: 2, height: 2) {
+		multiAttributeTile(name:"temperature", type:"generic", width:3, height:2, canChangeIcon: true) {
-			state("temperature", label:'${currentValue}°',
+			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
-				backgroundColors:[
+				attributeState("temperature", label:'${currentValue}°', icon: "st.alarm.temperature.normal",
-					[value: 32, color: "#153591"],
+					backgroundColors:[
-					[value: 44, color: "#1e9cbb"],
+							// Celsius
-					[value: 59, color: "#90d2a7"],
+							[value: 0, color: "#153591"],
-					[value: 74, color: "#44b621"],
+							[value: 7, color: "#1e9cbb"],
-					[value: 84, color: "#f1d801"],
+							[value: 15, color: "#90d2a7"],
-					[value: 92, color: "#d04e00"],
+							[value: 23, color: "#44b621"],
-					[value: 98, color: "#bc2323"]
+							[value: 28, color: "#f1d801"],
-				]
+							[value: 35, color: "#d04e00"],
-			)
+							[value: 37, color: "#bc2323"],
+							// Fahrenheit
+							[value: 40, 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"]
+					]
+				)
+			}
+			tileAttribute("device.batteryIcon", key: "SECONDARY_CONTROL") {
+				attributeState "ok_battery", label:'${currentValue}%', icon:"st.arlo.sensor_battery_4"
+				attributeState "low_battery", label:'Low Battery', icon:"st.arlo.sensor_battery_0"
+			}
 		}
-		standardTile("mode", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
+		standardTile("mode", "device.thermostatMode", width:2, height:2, inactiveLabel: false, decoration: "flat") {
-			state "off", label:'${name}', action:"switchMode", nextState:"to_heat"
+			state "off", action:"switchMode", nextState:"to_heat", icon: "st.thermostat.heating-cooling-off"
-			state "heat", label:'${name}', action:"switchMode", nextState:"to_cool"
+			state "heat", action:"switchMode", nextState:"to_cool", icon: "st.thermostat.heat"
-			state "cool", label:'${name}', action:"switchMode", nextState:"..."
+			state "cool", action:"switchMode", nextState:"...", icon: "st.thermostat.cool"
-			state "auto", label:'${name}', action:"switchMode", nextState:"..."
+			state "auto", action:"switchMode", nextState:"...", icon: "st.thermostat.auto"
-			state "emergency heat", label:'${name}', action:"switchMode", nextState:"..."
+			state "emergency heat", action:"switchMode", nextState:"...", icon: "st.thermostat.emergency-heat"
-			state "to_heat", label: "heat", action:"switchMode", nextState:"to_cool"
+			state "to_heat", action:"switchMode", nextState:"to_cool", icon: "st.secondary.secondary"
-			state "to_cool", label: "cool", action:"switchMode", nextState:"..."
+			state "to_cool", action:"switchMode", nextState:"...", icon: "st.secondary.secondary"
-			state "...", label: "...", action:"off", nextState:"off"
+			state "...", label: "...", action:"off", nextState:"off", icon: "st.secondary.secondary"
 		}
-		standardTile("fanMode", "device.thermostatFanMode", inactiveLabel: false, decoration: "flat") {
+		standardTile("fanMode", "device.thermostatFanMode", width:2, height:2, inactiveLabel: false, decoration: "flat") {
-			state "fanAuto", label:'${name}', action:"switchFanMode"
+			state "auto", action:"switchFanMode", icon: "st.thermostat.fan-auto"
-			state "fanOn", label:'${name}', action:"switchFanMode"
+			state "on", action:"switchFanMode", icon: "st.thermostat.fan-on"
-			state "fanCirculate", label:'${name}', action:"switchFanMode"
+			state "circulate", action:"switchFanMode", icon: "st.thermostat.fan-circulate"
 		}
-		controlTile("heatSliderControl", "device.heatingSetpoint", "slider", height: 1, width: 2, inactiveLabel: false) {
+		valueTile("humidity", "device.humidity", width:2, height:2, inactiveLabel: false, decoration: "flat") {
-			state "setHeatingSetpoint", action:"quickSetHeat", backgroundColor:"#e86d13"
+			state "humidity", label:'${currentValue}%', icon:"st.Weather.weather12"
 		}
-		valueTile("heatingSetpoint", "device.heatingSetpoint", inactiveLabel: false, decoration: "flat") {
+		standardTile("lowerHeatingSetpoint", "device.heatingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
-			state "heat", label:'${currentValue}° heat', backgroundColor:"#ffffff"
+			state "heatingSetpoint", action:"lowerHeatingSetpoint", icon:"st.thermostat.thermostat-left"
 		}
-		controlTile("coolSliderControl", "device.coolingSetpoint", "slider", height: 1, width: 2, inactiveLabel: false) {
+		valueTile("heatingSetpoint", "device.heatingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
-			state "setCoolingSetpoint", action:"quickSetCool", backgroundColor: "#00a0dc"
+			state "heatingSetpoint", label:'${currentValue}° heat', backgroundColor:"#ffffff"
 		}
-		valueTile("coolingSetpoint", "device.coolingSetpoint", inactiveLabel: false, decoration: "flat") {
+		standardTile("raiseHeatingSetpoint", "device.heatingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
-			state "cool", label:'${currentValue}° cool', backgroundColor:"#ffffff"
+			state "heatingSetpoint", action:"raiseHeatingSetpoint", icon:"st.thermostat.thermostat-right"
 		}
-		valueTile("humidity", "device.humidity", inactiveLabel: false, decoration: "flat") {
+		standardTile("lowerCoolSetpoint", "device.coolingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
-			state "humidity", label:'${currentValue}% humidity', unit:""
+			state "coolingSetpoint", action:"lowerCoolSetpoint", icon:"st.thermostat.thermostat-left"
 		}
-		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat") {
+		valueTile("coolingSetpoint", "device.coolingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
-			state "battery", label:'${currentValue}% battery', unit:""
+			state "coolingSetpoint", label:'${currentValue}° cool', backgroundColor:"#ffffff"
 		}
-		standardTile("refresh", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
+		standardTile("raiseCoolSetpoint", "device.heatingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
+			state "heatingSetpoint", action:"raiseCoolSetpoint", icon:"st.thermostat.thermostat-right"
+		}
+
+		standardTile("refresh", "device.thermostatMode", width:2, height:2, inactiveLabel: false, decoration: "flat") {
 			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 		main "temperature"
-		details(["temperature", "mode", "fanMode", "heatSliderControl", "heatingSetpoint", "coolSliderControl", "coolingSetpoint", "refresh", "humidity", "battery"])
+		details(["temperature", "mode", "fanMode", "humidity", "lowerHeatingSetpoint", "heatingSetpoint", "raiseHeatingSetpoint", "lowerCoolSetpoint", "coolingSetpoint", "raiseCoolSetpoint", "refresh"])
 	}
 }
 
 def updated() {
-	// Device-Watch simply pings if no device events received for 32min(checkInterval)
+	// If not set update ManufacturerSpecific data
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	if (!getDataValue("manufacturer")) {
+		sendHubCommand(new physicalgraph.device.HubAction(zwave.manufacturerSpecificV2.manufacturerSpecificGet().format()))
+	}
+	initialize()
 }
 
 def installed() {
+	// Configure device
+	def cmds = []
+	cmds << new physicalgraph.device.HubAction(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:[zwaveHubNodeId]).format())
+	cmds << new physicalgraph.device.HubAction(zwave.manufacturerSpecificV2.manufacturerSpecificGet().format())
+	sendHubCommand(cmds)
+	initialize()
+}
+
+def initialize() {
 	// Device-Watch simply pings if no device events received for 32min(checkInterval)
 	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	// Poll device for additional data that will be updated by refresh tile
+	refresh()
 }
 
 def parse(String description)
 {
-	def result = []
+	def result = null
 	if (description == "updated") {
 	} else {
 		def zwcmd = zwave.parse(description, [0x42:2, 0x43:2, 0x31: 2, 0x60: 3])
 		if (zwcmd) {
-			result += zwaveEvent(zwcmd)
+			result = zwaveEvent(zwcmd)
+			// Check battery level at least once every 2 days
+			if (!state.lastbatt || now() - state.lastbatt > 48*60*60*1000) {
+				sendHubCommand(new physicalgraph.device.HubAction(zwave.batteryV1.batteryGet().format()))
+			}
 		} else {
 			log.debug "$device.displayName couldn't parse $description"
 		}
 	}
 	if (!result) {
-		return null
+		return []
 	}
-	if (result.size() == 1 && (!state.lastbatt || now() - state.lastbatt > 48*60*60*1000)) {
+	return [result]
-		result << response(zwave.batteryV1.batteryGet().format())
-	}
-	log.debug "$device.displayName parsed '$description' to $result"
-	result
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.multichannelv3.MultiChannelCmdEncap cmd) {
+def zwaveEvent(physicalgraph.zwave.commands.multichannelv3.MultiInstanceCmdEncap cmd) {
-	def result = null
+	def encapsulatedCommand = cmd.encapsulatedCommand([0x31: 3])
-	def encapsulatedCommand = cmd.encapsulatedCommand([0x42:2, 0x43:2, 0x31: 2])
+	log.debug ("multiinstancev1.MultiInstanceCmdEncap: command from instance ${cmd.instance}: ${encapsulatedCommand}")
-	log.debug ("Command from endpoint ${cmd.sourceEndPoint}: ${encapsulatedCommand}")
 	if (encapsulatedCommand) {
-		result = zwaveEvent(encapsulatedCommand)
+		zwaveEvent(encapsulatedCommand)
-		if (cmd.sourceEndPoint == 1) {    // indicates a response to refresh() vs an unrequested update
-			def event = ([] + result)[0]  // in case zwaveEvent returns a list
-			def resp = nextRefreshQuery(event?.name)
-			if (resp) {
-				log.debug("sending next refresh query: $resp")
-				result = [] + result + response(["delay 200", resp])
-			}
-		}
 	}
-	result
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatsetpointv2.ThermostatSetpointReport cmd)
 {
-	def cmdScale = cmd.scale == 1 ? "F" : "C"
+	def sendCmd = []
-	def temp = convertTemperatureIfNeeded(cmd.scaledValue, cmdScale, cmd.precision)
 	def unit = getTemperatureScale()
-	def map1 = [ value: temp, unit: unit, displayed: false ]
+	def cmdScale = cmd.scale == 1 ? "F" : "C"
+	def setpoint = getTempInLocalScale(cmd.scaledValue, cmdScale)
 	switch (cmd.setpointType) {
 		case 1:
-			map1.name = "heatingSetpoint"
+			//map1.name = "heatingSetpoint"
+			sendEvent(name: "heatingSetpoint", value: setpoint, unit: unit, displayed: false)
+			updateThermostatSetpoint("heatingSetpoint", setpoint)
+			// Enforce coolingSetpoint limits, as device doesn't
+			if (setpoint > getTempInLocalScale("coolingSetpoint")) {
+				sendCmd << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointSet(
+						setpointType: 2, scale: cmd.scale, precision: cmd.precision, scaledValue: cmd.scaledValue).format())
+				sendCmd << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format())
+				sendHubCommand(sendCmd)
+			}
 			break;
 		case 2:
-			map1.name = "coolingSetpoint"
+			//map1.name = "coolingSetpoint"
+			sendEvent(name: "coolingSetpoint", value: setpoint, unit: unit, displayed: false)
+			updateThermostatSetpoint("coolingSetpoint", setpoint)
+			// Enforce heatingSetpoint limits, as device doesn't
+			if (setpoint < getTempInLocalScale("heatingSetpoint")) {
+				sendCmd << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointSet(
+						setpointType: 1, scale: cmd.scale, precision: cmd.precision, scaledValue: cmd.scaledValue).format())
+				sendCmd << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format())
+				sendHubCommand(sendCmd)
+			}
 			break;
 		default:
 			log.debug "unknown setpointType $cmd.setpointType"
@@ -180,33 +191,55 @@ def zwaveEvent(physicalgraph.zwave.commands.thermostatsetpointv2.ThermostatSetpo
 	state.size = cmd.size
 	state.scale = cmd.scale
 	state.precision = cmd.precision
-
-	def mode = device.latestValue("thermostatMode")
-	if (mode && map1.name.startsWith(mode) || (mode == "emergency heat" && map1.name == "heatingSetpoint")) {
-		def map2 = [ name: "thermostatSetpoint", value: temp, unit: unit ]
-		[ createEvent(map1), createEvent(map2) ]
-	} else {
-		createEvent(map1)
-	}
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv2.SensorMultilevelReport cmd)
+// thermostatSetpoint is not displayed by any tile as it can't be predictable calculated due to
-{
+// the device's quirkiness but it is defined by the capability so it must be set, set it to the most likely value
+def updateThermostatSetpoint(setpoint, value) {
+	def scale = getTemperatureScale()
+	def heatingSetpoint = (setpoint == "heatingSetpoint") ? value : getTempInLocalScale("heatingSetpoint")
+	def coolingSetpoint = (setpoint == "coolingSetpoint") ? value : getTempInLocalScale("coolingSetpoint")
+	def mode = device.currentValue("thermostatMode")
+	def thermostatSetpoint = heatingSetpoint    // corresponds to (mode == "heat" || mode == "emergency heat")
+	if (mode == "cool") {
+		thermostatSetpoint = coolingSetpoint
+	}
+	// Just set to average of heating + cooling for mode off and auto
+	if (mode == "off" || mode == "auto") {
+		thermostatSetpoint = getTempInLocalScale((heatingSetpoint + coolingSetpoint)/2, scale)
+	}
+	sendEvent(name: "thermostatSetpoint", value: thermostatSetpoint, unit: scale)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv2.SensorMultilevelReport cmd) {
 	def map = [:]
 	if (cmd.sensorType == 1) {
 		map.name = "temperature"
 		map.unit = getTemperatureScale()
-		map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmd.scale == 1 ? "F" : "C", cmd.precision)
+		map.value = getTempInLocalScale(cmd.scaledSensorValue, (cmd.scale == 1 ? "F" : "C"))
 	} else if (cmd.sensorType == 5) {
 		map.name = "humidity"
 		map.unit = "%"
 		map.value = cmd.scaledSensorValue
 	}
-	createEvent(map)
+	sendEvent(map)
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.thermostatoperatingstatev2.ThermostatOperatingStateReport cmd)
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv3.SensorMultilevelReport cmd) {
-{
+	def map = [:]
+	if (cmd.sensorType == 1) {
+		map.name = "temperature"
+		map.unit = getTemperatureScale()
+		map.value = getTempInLocalScale(cmd.scaledSensorValue, (cmd.scale == 1 ? "F" : "C"))
+	} else if (cmd.sensorType == 5) {
+		map.value = cmd.scaledSensorValue
+		map.unit = "%"
+		map.name = "humidity"
+	}
+	sendEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.thermostatoperatingstatev2.ThermostatOperatingStateReport cmd) {
 	def map = [name: "thermostatOperatingState" ]
 	switch (cmd.operatingState) {
 		case physicalgraph.zwave.commands.thermostatoperatingstatev2.ThermostatOperatingStateReport.OPERATING_STATE_IDLE:
@@ -231,12 +264,7 @@ def zwaveEvent(physicalgraph.zwave.commands.thermostatoperatingstatev2.Thermosta
 			map.value = "vent economizer"
 			break
 	}
-	def result = createEvent(map)
+	sendEvent(map)
-	if (result.isStateChange && device.latestValue("thermostatMode") == "auto" && (result.value == "heating" || result.value == "cooling")) {
-		def thermostatSetpoint = device.latestValue("${result.value}Setpoint")
-		result = [result, createEvent(name: "thermostatSetpoint", value: thermostatSetpoint, unit: getTemperatureScale())]
-	}
-	result
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatfanstatev1.ThermostatFanStateReport cmd) {
@@ -252,203 +280,256 @@ def zwaveEvent(physicalgraph.zwave.commands.thermostatfanstatev1.ThermostatFanSt
 			map.value = "running high"
 			break
 	}
-	createEvent(map)
+	sendEvent(map)
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport cmd) {
-	def map = [name: "thermostatMode"]
+	def map = [name: "thermostatMode", data:[supportedThermostatModes: state.supportedModes]]
-	def thermostatSetpoint = null
 	switch (cmd.mode) {
 		case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_OFF:
 			map.value = "off"
 			break
 		case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_HEAT:
 			map.value = "heat"
-			thermostatSetpoint = device.latestValue("heatingSetpoint")
 			break
 		case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_AUXILIARY_HEAT:
 			map.value = "emergency heat"
-			thermostatSetpoint = device.latestValue("heatingSetpoint")
 			break
 		case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_COOL:
 			map.value = "cool"
-			thermostatSetpoint = device.latestValue("coolingSetpoint")
 			break
 		case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_AUTO:
 			map.value = "auto"
-			def temp = device.latestValue("temperature")
-			def heatingSetpoint = device.latestValue("heatingSetpoint")
-			def coolingSetpoint = device.latestValue("coolingSetpoint")
-			if (temp && heatingSetpoint && coolingSetpoint) {
-				if (temp < (heatingSetpoint + coolingSetpoint) / 2.0) {
-					thermostatSetpoint = heatingSetpoint
-				} else {
-					thermostatSetpoint = coolingSetpoint
-				}
-			}
 			break
 	}
 	state.lastTriedMode = map.value
-	if (thermostatSetpoint) {
+	sendEvent(map)
-		[ createEvent(map), createEvent(name: "thermostatSetpoint", value: thermostatSetpoint, unit: getTemperatureScale()) ]
+	updateThermostatSetpoint(null, null)
-	} else {
-		createEvent(map)
-	}
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport cmd) {
-	def map = [name: "thermostatFanMode", displayed: false]
+	def map = [name: "thermostatFanMode", data:[supportedThermostatFanModes: state.supportedFanModes]]
 	switch (cmd.fanMode) {
-		case physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport.FAN_MODE_AUTO_LOW:
+	case physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport.FAN_MODE_AUTO_LOW:
-			map.value = "fanAuto"
+			map.value = "auto"
 			break
 		case physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport.FAN_MODE_LOW:
-			map.value = "fanOn"
+			map.value = "on"
 			break
 		case physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport.FAN_MODE_CIRCULATION:
-			map.value = "fanCirculate"
+			map.value = "circulate"
 			break
 	}
 	state.lastTriedFanMode = map.value
-	createEvent(map)
+	sendEvent(map)
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeSupportedReport cmd) {
-	def supportedModes = ""
+	def supportedModes = []
-	if(cmd.off) { supportedModes += "off " }
+	if(cmd.heat) { supportedModes << "heat" }
-	if(cmd.heat) { supportedModes += "heat " }
+	if(cmd.cool) { supportedModes << "cool" }
-	if(cmd.auxiliaryemergencyHeat) { supportedModes += "emergency heat " }
+	// Make sure off is before auto, this ensures the right setpoint is used based on current temperature when auto is set
-	if(cmd.cool) { supportedModes += "cool " }
+	if(cmd.off) { supportedModes << "off" }
-	if(cmd.auto) { supportedModes += "auto " }
+	if(cmd.auto) { supportedModes << "auto" }
+	if(cmd.auxiliaryemergencyHeat) { supportedModes << "emergency heat" }
 
 	state.supportedModes = supportedModes
-	[ createEvent(name:"supportedModes", value: supportedModes, displayed: false),
+	sendEvent(name: "supportedThermostatModes", value: supportedModes, isStateChange: true, displayed: false)
-	  response(zwave.thermostatFanModeV3.thermostatFanModeSupportedGet()) ]
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeSupportedReport cmd) {
-	def supportedFanModes = ""
+	def supportedFanModes = []
-	if(cmd.auto) { supportedFanModes += "fanAuto " }
+	if(cmd.auto) { supportedFanModes << "auto" }
-	if(cmd.low) { supportedFanModes += "fanOn " }
+	if(cmd.low) { supportedFanModes << "on" }
-	if(cmd.circulation) { supportedFanModes += "fanCirculate " }
+	if(cmd.circulation) { supportedFanModes << "circulate" }
 
 	state.supportedFanModes = supportedFanModes
-	[ createEvent(name:"supportedFanModes", value: supportedModes, displayed: false),
+	sendEvent(name: "supportedThermostatFanModes", value: supportedFanModes, isStateChange: true, displayed: false)
-	  response(refresh()) ]
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
-	log.debug "Zwave event received: $cmd"
+	log.debug "Zwave BasicReport: $cmd"
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
-	def map = [ name: "battery", unit: "%" ]
+	def batteryState = cmd.batteryLevel
-	if (cmd.batteryLevel == 0xFF) {
+	def map = [name: "battery", unit: "%", value: cmd.batteryLevel]
+	if ((cmd.batteryLevel == 0xFF) || (cmd.batteryLevel == 0x00)) {  // Special value for low battery alert
 		map.value = 1
 		map.descriptionText = "${device.displayName} battery is low"
 		map.isStateChange = true
-	} else {
+		batteryState = "low_battery"
-		map.value = cmd.batteryLevel
 	}
 	state.lastbatt = now()
-	createEvent(map)
+	sendEvent(name: "batteryIcon", value: batteryState, displayed: false)
+	sendEvent(map)
 }
 
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	log.warn "Unexpected zwave command $cmd"
 }
 
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
+log.debug "ManufacturerSpecificReport ${cmd}: value:${cmd}"
+	if (cmd.manufacturerName) {
+		updateDataValue("manufacturer", cmd.manufacturerName)
+	}
+	if (cmd.productTypeId) {
+		updateDataValue("productTypeId", cmd.productTypeId.toString())
+	}
+	if (cmd.productId) {
+		updateDataValue("productId", cmd.productId.toString())
+	}
+}
+
 def refresh() {
-	// Use encapsulation to differentiate refresh cmds from what the thermostat sends proactively on change
+	// Only allow refresh every 2 minutes to prevent flooding the Zwave network
-	def cmd = zwave.sensorMultilevelV2.sensorMultilevelGet()
+	def timeNow = now()
-	zwave.multiChannelV3.multiChannelCmdEncap(destinationEndPoint:1).encapsulate(cmd).format()
+	if (!state.refreshTriggeredAt || (2 * 60 * 1000 < (timeNow - state.refreshTriggeredAt))) {
-}
+		state.refreshTriggeredAt = timeNow
-
+		// refresh will request battery, prevent multiple request by setting lastbatt now
-def nextRefreshQuery(name) {
+		state.lastbatt = timeNow
-	def cmd = null
+		// use runIn with overwrite to prevent multiple DTH instances run before state.refreshTriggeredAt has been saved
-	switch (name) {
+		runIn(2, "poll", [overwrite: true])
-		case "temperature":
-			cmd = zwave.thermostatModeV2.thermostatModeGet()
-			break
-		case "thermostatMode":
-			cmd = zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1)
-			break
-		case "heatingSetpoint":
-			cmd = zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2)
-			break
-		case "coolingSetpoint":
-			cmd = zwave.thermostatFanModeV3.thermostatFanModeGet()
-			break
-		case "thermostatFanMode":
-			cmd = zwave.thermostatOperatingStateV2.thermostatOperatingStateGet()
-			break
-		case "thermostatOperatingState":
-			// get humidity, multilevel sensor get to endpoint 2
-			cmd = zwave.sensorMultilevelV2.sensorMultilevelGet()
-			return zwave.multiChannelV3.multiChannelCmdEncap(destinationEndPoint:2).encapsulate(cmd).format()
-		default: return null
 	}
-	zwave.multiChannelV3.multiChannelCmdEncap(destinationEndPoint:1).encapsulate(cmd).format()
 }
 
-def quickSetHeat(degrees) {
+def poll() {
-	setHeatingSetpoint(degrees, 1000)
+	def cmds = []
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeSupportedGet().format())
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeSupportedGet().format())
+	cmds << new physicalgraph.device.HubAction(zwave.multiChannelV3.multiInstanceCmdEncap(instance: 1).encapsulate(zwave.sensorMultilevelV3.sensorMultilevelGet()).format()) // temperature
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeGet().format())
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeGet().format())
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format())
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format()) // HeatingSetpoint
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format()) // CoolingSetpoint
+	cmds << new physicalgraph.device.HubAction(zwave.batteryV1.batteryGet().format())
+	cmds << new physicalgraph.device.HubAction(zwave.multiChannelV3.multiInstanceCmdEncap(instance: 2).encapsulate(zwave.sensorMultilevelV3.sensorMultilevelGet()).format()) // humidity
+	def time = getTimeAndDay()
+log.debug "time: $time"
+	if (time) {
+		cmds << new physicalgraph.device.HubAction(zwave.clockV1.clockSet(time).format())
+	}
+	// Add 3 seconds delay between each command to avoid flooding the Z-Wave network choking the hub 
+	sendHubCommand(cmds, 3000)
 }
 
-def setHeatingSetpoint(degrees, delay = 30000) {
+def raiseHeatingSetpoint() {
-	setHeatingSetpoint(degrees.toDouble(), delay)
+	alterSetpoint(null, true, "heatingSetpoint")
 }
 
-def setHeatingSetpoint(Double degrees, Integer delay = 30000) {
+def lowerHeatingSetpoint() {
-	log.trace "setHeatingSetpoint($degrees, $delay)"
+	alterSetpoint(null, false, "heatingSetpoint")
-	def deviceScale = state.scale ?: 1
+}
-	def deviceScaleString = deviceScale == 2 ? "C" : "F"
+
+def raiseCoolSetpoint() {
+	alterSetpoint(null, true, "coolingSetpoint")
+}
+
+def lowerCoolSetpoint() {
+	alterSetpoint(null, false, "coolingSetpoint")
+}
+
+// Adjusts nextHeatingSetpoint either .5° C/1° F) if raise true/false
+def alterSetpoint(degrees, raise, setpoint) {
 	def locationScale = getTemperatureScale()
-	def p = (state.precision == null) ? 1 : state.precision
+	def heatingSetpoint = getTempInLocalScale("heatingSetpoint")
-
+	def coolingSetpoint = getTempInLocalScale("coolingSetpoint")
-	def convertedDegrees
+	def targetvalue = (setpoint == "heatingSetpoint") ? heatingSetpoint : coolingSetpoint
-	if (locationScale == "C" && deviceScaleString == "F") {
+	def delta = (locationScale == "F") ? 1 : 0.5
-		convertedDegrees = celsiusToFahrenheit(degrees)
+	if (raise != null) {
-	} else if (locationScale == "F" && deviceScaleString == "C") {
+		targetvalue += raise ? delta : - delta
-		convertedDegrees = fahrenheitToCelsius(degrees)
+	} else if (degrees) {
+		targetvalue = degrees
 	} else {
-		convertedDegrees = degrees
+		log.warn "alterSetpoint called with neither up/down/degree information"
+		return
+	}
+	def data = enforceSetpointLimits(setpoint, [targetvalue: targetvalue, heatingSetpoint: heatingSetpoint, coolingSetpoint: coolingSetpoint])
+	// update UI without waiting for the device to respond, this to give user a smoother UI experience
+	// also, as runIn's have to overwrite and user can change heating/cooling setpoint separately separate runIn's have to be used
+	if (data.targetHeatingSetpoint) {
+		sendEvent("name": "heatingSetpoint", "value": data.targetHeatingSetpoint, unit: locationScale, eventType: "ENTITY_UPDATE")//, displayed: false)
+		runIn(4, "updateHeatingSetpoint", [data: data, overwrite: true])
+	}
+	if (data.targetCoolingSetpoint) {
+		sendEvent("name": "coolingSetpoint", "value": data.targetCoolingSetpoint, unit: locationScale, eventType: "ENTITY_UPDATE")//, displayed: false)
+		runIn(4, "updateCoolingSetpoint", [data: data, overwrite: true])
+	}
+}
+
+def updateHeatingSetpoint(data) {
+	updateSetpoints(data)
+}
+
+def updateCoolingSetpoint(data) {
+	updateSetpoints(data)
+}
+
+def enforceSetpointLimits(setpoint, data) {
+	// Enforce max/min for setpoints
+	def maxSetpoint = getTempInLocalScale(95, "F")
+	def minSetpoint = getTempInLocalScale(35, "F")
+	def targetvalue = data.targetvalue
+	def heatingSetpoint = null
+	def coolingSetpoint = null
+
+	if (targetvalue > maxSetpoint) {
+		targetvalue = maxSetpoint
+	} else if (targetvalue < minSetpoint) {
+		targetvalue = minSetpoint
+	}
+	// Enforce limits, for now make sure heating <= cooling, and cooling >= heating
+	if (setpoint == "heatingSetpoint") {
+		heatingSetpoint = targetvalue
+		coolingSetpoint = (heatingSetpoint > data.coolingSetpoint) ? heatingSetpoint : null
+	}
+	if (setpoint == "coolingSetpoint") {
+		coolingSetpoint = targetvalue
+		heatingSetpoint = (coolingSetpoint < data.heatingSetpoint) ? coolingSetpoint : null
+	}
+	return [targetHeatingSetpoint: heatingSetpoint, targetCoolingSetpoint: coolingSetpoint]
+}
+
+def setHeatingSetpoint(degrees) {
+	if (degrees) {
+		def data = enforceSetpointLimits("heatingSetpoint",
+				[targetvalue: degrees.toDouble(), heatingSetpoint: getTempInLocalScale("heatingSetpoint"), coolingSetpoint: getTempInLocalScale("coolingSetpoint")])
+		updateSetpoints(data)
+	}
+}
+
+def setCoolingSetpoint(degrees) {
+	if (degrees) {
+		def data = enforceSetpointLimits("coolingSetpoint",
+				[targetvalue: degrees.toDouble(), heatingSetpoint: getTempInLocalScale("heatingSetpoint"), coolingSetpoint: getTempInLocalScale("coolingSetpoint")])
+		updateSetpoints(data)
+	}
+}
+
+def updateSetpoints(data) {
+	def cmds = []
+	if (data.targetHeatingSetpoint) {
+		cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointSet(
+					setpointType: 1, scale: state.scale, precision: state.precision, scaledValue: convertToDeviceScale(data.targetHeatingSetpoint)).format())
+	}
+	if (data.targetCoolingSetpoint) {
+		cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointSet(
+					setpointType: 2, scale: state.scale, precision: state.precision, scaledValue: convertToDeviceScale(data.targetCoolingSetpoint)).format())
 	}
 
-	delayBetween([
+	// Always request both setpoints in case thermostat changed both
-		zwave.thermostatSetpointV1.thermostatSetpointSet(setpointType: 1, scale: deviceScale, precision: p, scaledValue: convertedDegrees).format(),
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format())
-		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format()
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format())
-	], delay)
+	sendHubCommand(cmds)
 }
 
-def quickSetCool(degrees) {
+def convertToDeviceScale(setpoint) {
-	setCoolingSetpoint(degrees, 1000)
-}
-
-def setCoolingSetpoint(degrees, delay = 30000) {
-	setCoolingSetpoint(degrees.toDouble(), delay)
-}
-
-def setCoolingSetpoint(Double degrees, Integer delay = 30000) {
-	log.trace "setCoolingSetpoint($degrees, $delay)"
-	def deviceScale = state.scale ?: 1
-	def deviceScaleString = deviceScale == 2 ? "C" : "F"
 	def locationScale = getTemperatureScale()
-	def p = (state.precision == null) ? 1 : state.precision
+	def deviceScale = (state.scale == 1) ? "F" : "C"
-
+	return (deviceScale == locationScale) ? setpoint :
-	def convertedDegrees
+		(deviceScale == "F" ? celsiusToFahrenheit(setpoint.toBigDecimal()) : roundC(fahrenheitToCelsius(setpoint.toBigDecimal())))
-	if (locationScale == "C" && deviceScaleString == "F") {
-		convertedDegrees = celsiusToFahrenheit(degrees)
-	} else if (locationScale == "F" && deviceScaleString == "C") {
-		convertedDegrees = fahrenheitToCelsius(degrees)
-	} else {
-		convertedDegrees = degrees
-	}
-
-	delayBetween([
-		zwave.thermostatSetpointV1.thermostatSetpointSet(setpointType: 2, scale: deviceScale, precision: p,	 scaledValue: convertedDegrees).format(),
-		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format()
-	], delay)
 }
 
 /**
@@ -456,78 +537,56 @@ def setCoolingSetpoint(Double degrees, Integer delay = 30000) {
  * */
 def ping() {
 	log.debug "ping() called"
-	refresh()
+	// Just get Operating State as it is not reported when it chnages and there's no need to flood more commands
-}
+	sendHubCommand(new physicalgraph.device.HubAction(zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format()))
-
-def configure() {
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSupportedGet().format(),
-	], 2300)
-}
-
-def modes() {
-	["off", "heat", "cool", "auto", "emergency heat"]
 }
 
 def switchMode() {
-	def currentMode = device.currentState("thermostatMode")?.value
+	def currentMode = device.currentValue("thermostatMode")
 	def lastTriedMode = state.lastTriedMode ?: currentMode ?: "off"
-	def supportedModes = getDataByName("supportedModes")
+	def supportedModes = state.supportedModes
-	def modeOrder = modes()
+	if (supportedModes) {
-	def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
+		def next = { supportedModes[supportedModes.indexOf(it) + 1] ?: supportedModes[0] }
-	def nextMode = next(lastTriedMode)
+		def nextMode = next(lastTriedMode)
-	if (supportedModes?.contains(currentMode)) {
+		setThermostatMode(nextMode)
-		while (!supportedModes.contains(nextMode) && nextMode != "off") {
+		state.lastTriedMode = nextMode
-			nextMode = next(nextMode)
+	} else {
-		}
+		log.warn "supportedModes not defined"
 	}
-	state.lastTriedMode = nextMode
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: modeMap[nextMode]).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], 1000)
 }
 
 def switchToMode(nextMode) {
-	def supportedModes = getDataByName("supportedModes")
+	def supportedModes = state.supportedModes
-	if(supportedModes && !supportedModes.contains(nextMode)) log.warn "thermostat mode '$nextMode' is not supported"
+	if (supportedModes && supportedModes.contains(nextMode)) {
-	if (nextMode in modes()) {
+		setThermostatMode(nextMode)
 		state.lastTriedMode = nextMode
-		"$nextMode"()
 	} else {
-		log.debug("no mode method '$nextMode'")
+		log.debug("ThermostatMode $nextMode is not supported by ${device.displayName}")
 	}
 }
 
 def switchFanMode() {
 	def currentMode = device.currentState("thermostatFanMode")?.value
 	def lastTriedMode = state.lastTriedFanMode ?: currentMode ?: "off"
-	def supportedModes = getDataByName("supportedFanModes") ?: "fanAuto fanOn"
+	def supportedFanModes = state.supportedFanModes
-	def modeOrder = ["fanAuto", "fanCirculate", "fanOn"]
+	if (supportedFanModes) {
-	def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
+		def next = { supportedFanModes[supportedFanModes.indexOf(it) + 1] ?: supportedFanModes[0] }
-	def nextMode = next(lastTriedMode)
+		def nextMode = next(lastTriedMode)
-	while (!supportedModes?.contains(nextMode) && nextMode != "fanAuto") {
+		setThermostatFanMode(nextMode)
-		nextMode = next(nextMode)
+		state.lastTriedFanMode = nextMode
+	} else {
+		log.warn "supportedFanModes not defined"
 	}
-	switchToFanMode(nextMode)
 }
 
 def switchToFanMode(nextMode) {
-	def supportedFanModes = getDataByName("supportedFanModes")
+	def supportedFanModes = state.supportedFanModes
-	if(supportedFanModes && !supportedFanModes.contains(nextMode)) log.warn "thermostat mode '$nextMode' is not supported"
+	if (supportedFanModes && supportedFanModes.contains(nextMode)) {
-
+		setThermostatFanMode(nextMode)
-	def returnCommand
+		state.lastTriedFanMode = nextMode
-	if (nextMode == "fanAuto") {
-		returnCommand = fanAuto()
-	} else if (nextMode == "fanOn") {
-		returnCommand = fanOn()
-	} else if (nextMode == "fanCirculate") {
-		returnCommand = fanCirculate()
 	} else {
-		log.debug("no fan mode '$nextMode'")
+		log.debug("FanMode $nextMode is not supported by ${device.displayName}")
 	}
-	if(returnCommand) state.lastTriedFanMode = nextMode
-	returnCommand
 }
 
 def getDataByName(String name) {
@@ -543,10 +602,10 @@ def getModeMap() { [
 ]}
 
 def setThermostatMode(String value) {
-	delayBetween([
+	def cmds = []
-		zwave.thermostatModeV2.thermostatModeSet(mode: modeMap[value]).format(),
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeSet(mode: modeMap[value]).format())
-		zwave.thermostatModeV2.thermostatModeGet().format()
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeGet().format())
-	], standardDelay)
+	sendHubCommand(cmds)
 }
 
 def getFanModeMap() { [
@@ -556,69 +615,70 @@ def getFanModeMap() { [
 ]}
 
 def setThermostatFanMode(String value) {
-	delayBetween([
+	def cmds = []
-		zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: fanModeMap[value]).format(),
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: fanModeMap[value]).format())
-		zwave.thermostatFanModeV3.thermostatFanModeGet().format()
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeGet().format())
-	], standardDelay)
+	sendHubCommand(cmds)
 }
 
 def off() {
-	delayBetween([
+	switchToMode("off")
-		zwave.thermostatModeV2.thermostatModeSet(mode: 0).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
 }
 
 def heat() {
-	delayBetween([
+	switchToMode("heat")
-		zwave.thermostatModeV2.thermostatModeSet(mode: 1).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
 }
 
 def emergencyHeat() {
-	delayBetween([
+	switchToMode("emergency heat")
-		zwave.thermostatModeV2.thermostatModeSet(mode: 4).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
 }
 
 def cool() {
-	delayBetween([
+	switchToMode("cool")
-		zwave.thermostatModeV2.thermostatModeSet(mode: 2).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
 }
 
 def auto() {
-	delayBetween([
+	switchToMode("auto")
-		zwave.thermostatModeV2.thermostatModeSet(mode: 3).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
 }
 
 def fanOn() {
-	delayBetween([
+	switchToFanMode("on")
-		zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: 1).format(),
-		zwave.thermostatFanModeV3.thermostatFanModeGet().format()
-	], standardDelay)
 }
 
 def fanAuto() {
-	delayBetween([
+	switchToFanMode("auto")
-		zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: 0).format(),
-		zwave.thermostatFanModeV3.thermostatFanModeGet().format()
-	], standardDelay)
 }
 
 def fanCirculate() {
-	delayBetween([
+	switchToFanMode("circulate")
-		zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: 6).format(),
-		zwave.thermostatFanModeV3.thermostatFanModeGet().format()
-	], standardDelay)
 }
 
-private getStandardDelay() {
+private getTimeAndDay() {
-	1000
+	def timeNow = now()
+	// Need to check that location have timeZone as SC may have created the location without setting it
+	// Don't update clock more than once a day
+	if (location.timeZone && (!state.timeClockSet || (24 * 60 * 60 * 1000 < (timeNow - state.timeClockSet)))) {
+		def currentDate = Calendar.getInstance(location.timeZone)
+		state.timeClockSet = timeNow
+		return [hour: currentDate.get(Calendar.HOUR_OF_DAY), minute: currentDate.get(Calendar.MINUTE), weekday: currentDate.get(Calendar.DAY_OF_WEEK)]
+	}
 }
 
+// Get stored temperature from currentState in current local scale
+def getTempInLocalScale(state) {
+	def temp = device.currentState(state)
+	if (temp && temp.value && temp.unit) {
+		return getTempInLocalScale(temp.value.toBigDecimal(), temp.unit)
+	}
+	return 0
+}
+
+// get/convert temperature to current local scale
+def getTempInLocalScale(temp, scale) {
+	def scaledTemp = convertTemperatureIfNeeded(temp.toBigDecimal(), scale).toDouble()
+	return (getTemperatureScale() == "F" ? scaledTemp.round(0).toInteger() : roundC(scaledTemp))
+}
+
+def roundC (tempC) {
+	return (Math.round(tempC.toDouble() * 2))/2
+}

devicetypes/smartthings/ecobee-thermostat.src/ecobee-thermostat.groovy

@@ -158,7 +158,7 @@ def generateEvent(Map results) {
 	if(results) {
 
 			def linkText = getLinkText(device)
-		def supportedThermostatModes = []
+		def supportedThermostatModes = ["off"]
 		def thermostatMode = null
 
 		results.each { name, value ->

devicetypes/smartthings/smartsense-moisture-sensor.src/smartsense-moisture-sensor.groovy

@@ -105,6 +105,8 @@ def parse(String description) {
 				} else {
 					log.warn "TEMP REPORTING CONFIG FAILED- error code: ${descMap.data[0]}"
 				}
+			} else if (descMap?.clusterInt == zigbee.IAS_ZONE_CLUSTER && descMap.attrInt == zigbee.ATTRIBUTE_IAS_ZONE_STATUS && descMap?.value) {
+				map = translateZoneStatus(new ZoneStatus(zigbee.convertToInt(descMap?.value)))
 			}
 		}
 	} else if (map.name == "temperature") {
@@ -129,6 +131,10 @@ def parse(String description) {
 private Map parseIasMessage(String description) {
 	ZoneStatus zs = zigbee.parseZoneStatus(description)
 
+	translateZoneStatus(zs)
+}
+
+private Map translateZoneStatus(ZoneStatus zs) {
 	return zs.isAlarm1Set() ? getMoistureResult('wet') : getMoistureResult('dry')
 }
 
@@ -197,7 +203,8 @@ def ping() {
 def refresh() {
 	log.debug "Refreshing Temperature and Battery"
 	def refreshCmds = zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
-			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020)
+			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) +
+			zigbee.readAttribute(zigbee.IAS_ZONE_CLUSTER, zigbee.ATTRIBUTE_IAS_ZONE_STATUS)
 
 	return refreshCmds + zigbee.enrollResponse()
 }

devicetypes/smartthings/smartsense-motion-sensor.src/smartsense-motion-sensor.groovy

@@ -111,6 +111,8 @@ def parse(String description) {
 				def value = descMap.value.endsWith("01") ? "active" : "inactive"
 				log.debug "Doing a read attr motion event"
 				map = getMotionResult(value)
+			} else if (descMap?.clusterInt == zigbee.IAS_ZONE_CLUSTER && descMap.attrInt == zigbee.ATTRIBUTE_IAS_ZONE_STATUS && descMap?.value) {
+				map = translateZoneStatus(new ZoneStatus(zigbee.convertToInt(descMap?.value)))
 			}
 		}
 	} else if (map.name == "temperature") {
@@ -135,6 +137,10 @@ def parse(String description) {
 private Map parseIasMessage(String description) {
 	ZoneStatus zs = zigbee.parseZoneStatus(description)
 
+	translateZoneStatus(zs)
+}
+
+private Map translateZoneStatus(ZoneStatus zs) {
 	// Some sensor models that use this DTH use alarm1 and some use alarm2 to signify motion
 	return (zs.isAlarm1Set() || zs.isAlarm2Set()) ? getMotionResult('active') : getMotionResult('inactive')
 }
@@ -165,13 +171,29 @@ private Map getBatteryResult(rawValue) {
 			def pct = batteryMap[volts]
 			result.value = pct
 		} else {
-			def minVolts = 2.1
+			def minVolts = 2.4
-			def maxVolts = 3.0
+			def maxVolts = 2.7
-			def pct = (volts - minVolts) / (maxVolts - minVolts)
+			// Get the current battery percentage as a multiplier 0 - 1
-			def roundedPct = Math.round(pct * 100)
+			def curValVolts = Integer.parseInt(device.currentState("battery")?.value ?: "100") / 100.0
-			if (roundedPct <= 0)
+			// Find the corresponding voltage from our range
-				roundedPct = 1
+			curValVolts = curValVolts * (maxVolts - minVolts) + minVolts
-			result.value = Math.min(100, roundedPct)
+			// Round to the nearest 10th of a volt
+			curValVolts = Math.round(10 * curValVolts) / 10.0
+			// Only update the battery reading if we don't have a last reading,
+			// OR we have received the same reading twice in a row
+			// OR we don't currently have a battery reading
+			// OR the value we just received is at least 2 steps off from the last reported value
+			if(state?.lastVolts == null || state?.lastVolts == volts || device.currentState("battery")?.value == null || Math.abs(curValVolts - volts) > 0.1) {
+				def pct = (volts - minVolts) / (maxVolts - minVolts)
+				def roundedPct = Math.round(pct * 100)
+				if (roundedPct <= 0)
+					roundedPct = 1
+				result.value = Math.min(100, roundedPct)
+			} else {
+				// Don't update as we want to smooth the battery values
+				result = null
+			}
+			state.lastVolts = volts
 		}
 	}
 
@@ -200,7 +222,8 @@ def refresh() {
 	log.debug "refresh called"
 
 	def refreshCmds = zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) +
-			zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000)
+			zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
+			zigbee.readAttribute(zigbee.IAS_ZONE_CLUSTER, zigbee.ATTRIBUTE_IAS_ZONE_STATUS)
 
 	return refreshCmds + zigbee.enrollResponse()
 }

devicetypes/smartthings/smartsense-multi-sensor.src/smartsense-multi-sensor.groovy

@@ -134,8 +134,9 @@ def parse(String description) {
 				} else {
 					log.warn "TEMP REPORTING CONFIG FAILED- error code: ${descMap.data[0]}"
 				}
+			} else if (descMap?.clusterInt == zigbee.IAS_ZONE_CLUSTER && descMap.attrInt == zigbee.ATTRIBUTE_IAS_ZONE_STATUS && descMap?.value) {
+				maps += translateZoneStatus(new ZoneStatus(zigbee.convertToInt(descMap?.value)))
 			} else {
-
 				maps += handleAcceleration(descMap)
 			}
 		}
@@ -229,6 +230,11 @@ private List<Map> parseAxis(List<Map> attrData) {
 
 private List<Map> parseIasMessage(String description) {
 	ZoneStatus zs = zigbee.parseZoneStatus(description)
+
+	translateZoneStatus(zs)
+}
+
+private List<Map> translateZoneStatus(ZoneStatus zs) {
 	List<Map> results = []
 
 	if (garageSensor != "Yes") {
@@ -268,12 +274,28 @@ private Map getBatteryResult(rawValue) {
 			result.value = pct
 		} else {
 			def minVolts = 2.1
-			def maxVolts = 3.0
+			def maxVolts = 2.7
-			def pct = (volts - minVolts) / (maxVolts - minVolts)
+			// Get the current battery percentage as a multiplier 0 - 1
-			def roundedPct = Math.round(pct * 100)
+			def curValVolts = Integer.parseInt(device.currentState("battery")?.value ?: "100") / 100.0
-			if (roundedPct <= 0)
+			// Find the corresponding voltage from our range
-				roundedPct = 1
+			curValVolts = curValVolts * (maxVolts - minVolts) + minVolts
-			result.value = Math.min(100, roundedPct)
+			// Round to the nearest 10th of a volt
+			curValVolts = Math.round(10 * curValVolts) / 10.0
+			// Only update the battery reading if we don't have a last reading,
+			// OR we have received the same reading twice in a row
+			// OR we don't currently have a battery reading
+			// OR the value we just received is at least 2 steps off from the last reported value
+			if(state?.lastVolts == null || state?.lastVolts == volts || device.currentState("battery")?.value == null || Math.abs(curValVolts - volts) > 0.1) {
+				def pct = (volts - minVolts) / (maxVolts - minVolts)
+				def roundedPct = Math.round(pct * 100)
+				if (roundedPct <= 0)
+					roundedPct = 1
+				result.value = Math.min(100, roundedPct)
+			} else {
+				// Don't update as we want to smooth the battery values
+				result = null
+			}
+			state.lastVolts = volts
 		}
 	}
 
@@ -313,7 +335,7 @@ def refresh() {
 	def refreshCmds = zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
 			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) +
 			zigbee.readAttribute(0xFC02, 0x0010, [mfgCode: manufacturerCode]) +
-			zigbee.enrollResponse()
+			zigbee.readAttribute(zigbee.IAS_ZONE_CLUSTER, zigbee.ATTRIBUTE_IAS_ZONE_STATUS) + zigbee.enrollResponse()
 
 	return refreshCmds
 }

devicetypes/smartthings/zigbee-button.src/README.md

@@ -28,9 +28,8 @@ Works with:
 
 ## Device Health
 
-SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
+ZigBee Button is marked offline only in the case when Hub is offline.
 
-* __722min__ checkInterval
 
 ## Troubleshooting
 

devicetypes/smartthings/zigbee-button.src/zigbee-button.groovy

@@ -13,6 +13,8 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
+
+import groovy.json.JsonOutput
 import physicalgraph.zigbee.zcl.DataType
 
 metadata {
@@ -183,13 +185,6 @@ private Map parseNonIasButtonMessage(Map descMap){
     }
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-    refresh()
-}
-
 def refresh() {
     log.debug "Refreshing Battery"
 
@@ -198,8 +193,6 @@ def refresh() {
 }
 
 def configure() {
-    // Device-Watch allows 2 check-in misses from device (plus 2 mins lag time)
-    sendEvent(name: "checkInterval", value: 2 * 6 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
     log.debug "Configuring Reporting, IAS CIE, and Bindings."
     def cmds = []
     if (device.getDataValue("model") == "3450-L") {
@@ -259,6 +252,8 @@ def updated() {
 }
 
 def initialize() {
+    // Arrival sensors only goes OFFLINE when Hub is off
+    sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "zigbee", scheme:"untracked"]), displayed: false)
     if ((device.getDataValue("manufacturer") == "OSRAM") && (device.getDataValue("model") == "LIGHTIFY Dimming Switch")) {
         sendEvent(name: "numberOfButtons", value: 2)
     }

devicetypes/smartthings/zwave-basic-smoke-alarm.src/.st-ignore

@@ -0,0 +1,2 @@
+.st-ignore
+README.md

devicetypes/smartthings/zwave-basic-smoke-alarm.src/README.md

@@ -0,0 +1,39 @@
+# Z-wave Basic Smoke Alarm
+
+Cloud Execution
+
+Works with: 
+
+* [First Alert Smoke Detector (ZSMOKE)](https://www.smartthings.com/products/first-alert-smoke-detector)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Battery](#battery-specification)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Smoke Detector** - measure smoke and optionally carbon monoxide levels
+* **Sensor** - detects sensor events
+* **Battery** - defines device uses a battery
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+First Alert Smoke Detector (ZSMOKE) is a Z-wave sleepy device and checks in every 1 hour.
+Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*60 + 2)mins = 122 mins.
+
+* __122min__ checkInterval
+
+## Battery Specification
+
+Two AA 1.5V batteries are required.
+
+## Troubleshooting
+
+If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the device is out of range.
+Pairing needs to be tried again by placing the device closer to the hub.
+Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following link:
+* [First Alert Smoke Detector (ZSMOKE) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/207150556-First-Alert-Smoke-Detector-ZSMOKE-)

devicetypes/smartthings/zwave-basic-smoke-alarm.src/zwave-basic-smoke-alarm.groovy

@@ -0,0 +1,181 @@
+/**
+ *  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: "Z-Wave Basic Smoke Alarm", namespace: "smartthings", author: "SmartThings") {
+		capability "Smoke Detector"
+		capability "Sensor"
+		capability "Battery"
+		capability "Health Check"
+
+		fingerprint deviceId: "0xA100", inClusters: "0x20,0x80,0x70,0x85,0x71,0x72,0x86"
+		fingerprint mfr:"0138", prod:"0001", model:"0001", deviceJoinName: "First Alert Smoke Detector"
+	}
+
+	simulator {
+		status "smoke": "command: 7105, payload: 01 FF"
+		status "clear": "command: 7105, payload: 01 00"
+		status "test": "command: 7105, payload: 0C FF"
+		status "battery 100%": "command: 8003, payload: 64"
+		status "battery 5%": "command: 8003, payload: 05"
+	}
+
+	tiles (scale: 2){
+		multiAttributeTile(name:"smoke", type: "lighting", width: 6, height: 4){
+			tileAttribute ("device.smoke", key: "PRIMARY_CONTROL") {
+				attributeState("clear", label:"clear", icon:"st.alarm.smoke.clear", backgroundColor:"#ffffff")
+				attributeState("detected", label:"SMOKE", icon:"st.alarm.smoke.smoke", backgroundColor:"#e86d13")
+				attributeState("tested", label:"TEST", icon:"st.alarm.smoke.test", backgroundColor:"#e86d13")
+			}
+		}
+		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "battery", label:'${currentValue}% battery', unit:""
+		}
+
+		main "smoke"
+		details(["smoke", "battery"])
+	}
+}
+
+def installed() {
+// Device checks in every hour, this interval allows us to miss one check-in notification before marking offline
+	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+
+	def cmds = []
+	createSmokeEvents("smokeClear", cmds)
+	cmds.each { cmd -> sendEvent(cmd) }
+}
+
+def updated() {
+// Device checks in every hour, this interval allows us to miss one check-in notification before marking offline
+	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+}
+
+def parse(String description) {
+	def results = []
+	if (description.startsWith("Err")) {
+	    results << createEvent(descriptionText:description, displayed:true)
+	} else {
+		def cmd = zwave.parse(description, [ 0x80: 1, 0x84: 1, 0x71: 2, 0x72: 1 ])
+		if (cmd) {
+			zwaveEvent(cmd, results)
+		}
+	}
+	log.debug "'$description' parsed to ${results.inspect()}"
+	return results
+}
+
+def createSmokeEvents(name, results) {
+	def text = null
+	switch (name) {
+		case "smoke":
+			text = "$device.displayName smoke was detected!"
+			// these are displayed:false because the composite event is the one we want to see in the app
+			results << createEvent(name: "smoke",          value: "detected", descriptionText: text)
+			break
+		case "tested":
+			text = "$device.displayName was tested"
+			results << createEvent(name: "smoke",          value: "tested", descriptionText: text)
+			break
+		case "smokeClear":
+			text = "$device.displayName smoke is clear"
+			results << createEvent(name: "smoke",          value: "clear", descriptionText: text)
+			name = "clear"
+			break
+		case "testClear":
+			text = "$device.displayName test cleared"
+			results << createEvent(name: "smoke",          value: "clear", descriptionText: text)
+			name = "clear"
+			break
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd, results) {
+	if (cmd.zwaveAlarmType == physicalgraph.zwave.commands.alarmv2.AlarmReport.ZWAVE_ALARM_TYPE_SMOKE) {
+		if (cmd.zwaveAlarmEvent == 3) {
+			createSmokeEvents("tested", results)
+		} else {
+			createSmokeEvents((cmd.zwaveAlarmEvent == 1 || cmd.zwaveAlarmEvent == 2) ? "smoke" : "smokeClear", results)
+		}
+	} else switch(cmd.alarmType) {
+		case 1:
+			createSmokeEvents(cmd.alarmLevel ? "smoke" : "smokeClear", results)
+			break
+		case 12:  // test button pressed
+			createSmokeEvents(cmd.alarmLevel ? "tested" : "testClear", results)
+			break
+		case 13:  // sent every hour -- not sure what this means, just a wake up notification?
+			if (cmd.alarmLevel == 255) {
+				results << createEvent(descriptionText: "$device.displayName checked in", isStateChange: false)
+			} else {
+				results << createEvent(descriptionText: "$device.displayName code 13 is $cmd.alarmLevel", isStateChange:true, displayed:false)
+			}
+			
+			// Clear smoke in case they pulled batteries and we missed the clear msg
+			if(device.currentValue("smoke") != "clear") {
+				createSmokeEvents("smokeClear", results)
+			}
+			
+			// Check battery if we don't have a recent battery event
+			if (!state.lastbatt || (now() - state.lastbatt) >= 48*60*60*1000) {
+				results << response(zwave.batteryV1.batteryGet())
+			}
+			break
+		default:
+			results << createEvent(displayed: true, descriptionText: "Alarm $cmd.alarmType ${cmd.alarmLevel == 255 ? 'activated' : cmd.alarmLevel ?: 'deactivated'}".toString())
+			break
+	}
+}
+
+// SensorBinary and SensorAlarm aren't tested, but included to preemptively support future smoke alarms
+//
+def zwaveEvent(physicalgraph.zwave.commands.sensorbinaryv2.SensorBinaryReport cmd, results) {
+	if (cmd.sensorType == physicalgraph.zwave.commandclasses.SensorBinaryV2.SENSOR_TYPE_SMOKE) {
+		createSmokeEvents(cmd.sensorValue ? "smoke" : "smokeClear", results)
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.sensoralarmv1.SensorAlarmReport cmd, results) {
+	if (cmd.sensorType == 1) {
+		createSmokeEvents(cmd.sensorState ? "smoke" : "smokeClear", results)
+	}
+	
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd, results) {
+	results << createEvent(descriptionText: "$device.displayName woke up", isStateChange: false)
+	if (!state.lastbatt || (now() - state.lastbatt) >= 56*60*60*1000) {
+		results << response(zwave.batteryV1.batteryGet(), "delay 2000", zwave.wakeUpV1.wakeUpNoMoreInformation())
+	} else {
+		results << response(zwave.wakeUpV1.wakeUpNoMoreInformation())
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd, results) {
+	def map = [ name: "battery", unit: "%", isStateChange: true ]
+	state.lastbatt = now()
+	if (cmd.batteryLevel == 0xFF) {
+		map.value = 1
+		map.descriptionText = "$device.displayName battery is low!"
+	} else {
+		map.value = cmd.batteryLevel
+	}
+	results << createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.Command cmd, results) {
+	def event = [ displayed: false ]
+	event.linkText = device.label ?: device.name
+	event.descriptionText = "$event.linkText: $cmd"
+	results << createEvent(event)
+}

devicetypes/smartthings/zwave-lock.src/zwave-lock.groovy

@@ -88,19 +88,21 @@ import physicalgraph.zwave.commands.usercodev1.*
 def installed() {
 	// Device-Watch pings if no device events received for 1 hour (checkInterval)
 	sendEvent(name: "checkInterval", value: 1 * 60 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+
+	try {
+		if (!state.init) {
+			state.init = true
+			// Wait long enough for behind-the-scenes z-wave magic to finish, but be quick enough before hub goes back into inclusion and blocks us
+			response(["delay 2000"] + secureSequence([zwave.doorLockV1.doorLockOperationGet(), zwave.batteryV1.batteryGet()], 2200))
+		}
+	} catch (e) {
+		log.warn "installed() threw $e"
+	}
 }
 
 def updated() {
 	// Device-Watch pings if no device events received for 1 hour (checkInterval)
 	sendEvent(name: "checkInterval", value: 1 * 60 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-	try {
-		if (!state.init) {
-			state.init = true
-			response(secureSequence([zwave.doorLockV1.doorLockOperationGet(), zwave.batteryV1.batteryGet()]))
-		}
-	} catch (e) {
-		log.warn "updated() threw $e"
-	}
 }
 
 def parse(String description) {

devicetypes/smartthings/zwave-siren.src/zwave-siren.groovy

@@ -72,7 +72,7 @@ def createEvents(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
 
 def poll() {
 	if (secondsPast(state.lastbatt, 36*60*60)) {
-		return zwave.batteryV1.batteryGet().format
+		return zwave.batteryV1.batteryGet().format()
 	} else {
 		return null
 	}

devicetypes/smartthings/zwave-smoke-alarm.src/zwave-smoke-alarm.groovy

@@ -21,8 +21,6 @@ metadata {
 
 		attribute "alarmState", "string"
 
-		fingerprint deviceId: "0xA100", inClusters: "0x20,0x80,0x70,0x85,0x71,0x72,0x86"
-		fingerprint mfr:"0138", prod:"0001", model:"0001", deviceJoinName: "First Alert Smoke Detector"
 		fingerprint mfr:"0138", prod:"0001", model:"0002", deviceJoinName: "First Alert Smoke Detector and Carbon Monoxide Alarm (ZCOMBO)"
 	}
 
@@ -57,6 +55,10 @@ metadata {
 def installed() {
 // Device checks in every hour, this interval allows us to miss one check-in notification before marking offline
 	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+
+	def cmds = []
+	createSmokeOrCOEvents("allClear", cmds) // allClear to set inital states for smoke and CO
+	cmds.each { cmd -> sendEvent(cmd) }
 }
 
 def updated() {
@@ -105,6 +107,12 @@ def createSmokeOrCOEvents(name, results) {
 			results << createEvent(name: "carbonMonoxide", value: "clear", descriptionText: text, displayed: false)
 			name = "clear"
 			break
+		case "allClear":
+			text = "$device.displayName all clear"
+			results << createEvent(name: "smoke",          value: "clear", descriptionText: text, displayed: false)
+			results << createEvent(name: "carbonMonoxide", value: "clear", displayed: false)
+			name = "clear"
+			break
 		case "testClear":
 			text = "$device.displayName test cleared"
 			results << createEvent(name: "smoke",          value: "clear", descriptionText: text, displayed: false)

devicetypes/smartthings/zwave-thermostat.src/zwave-thermostat.groovy

@@ -15,10 +15,9 @@ metadata {
 	definition (name: "Z-Wave Thermostat", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
 		capability "Temperature Measurement"
-		capability "Relative Humidity Measurement"
 		capability "Thermostat"
 		capability "Configuration"
-		capability "Polling"
+		capability "Refresh"
 		capability "Sensor"
 		capability "Health Check"
 		
@@ -117,7 +116,7 @@ metadata {
 			state "cool", label:'${currentValue}° cool', backgroundColor:"#ffffff"
 		}
 		standardTile("refresh", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
-			state "default", action:"polling.poll", icon:"st.secondary.refresh"
+			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 		main "temperature"
 		details(["temperature", "mode", "fanMode", "heatSliderControl", "heatingSetpoint", "coolSliderControl", "coolingSetpoint", "refresh"])
@@ -125,13 +124,20 @@ metadata {
 }
 
 def installed(){
-	// Device-Watch simply pings if no device events received for 32min(checkInterval)
+	sendHubCommand(new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeSupportedGet().format()))
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	initialize()
 }
 
 def updated(){
+	initialize()
+}
+
+def initialize() {
 	// Device-Watch simply pings if no device events received for 32min(checkInterval)
 	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	unschedule()
+	runEvery5Minutes("refresh")
+	refresh()
 }
 
 def parse(String description)
@@ -149,6 +155,7 @@ def parse(String description)
 		]
 		if (map.name == "thermostatMode") {
 			state.lastTriedMode = map.value
+			map.data = [supportedThermostatModes:state.supportedThermostatModes]
 			if (map.value == "cool") {
 				map2.value = device.latestValue("coolingSetpoint")
 				log.info "THERMOSTAT, latest cooling setpoint = ${map2.value}"
@@ -172,6 +179,7 @@ def parse(String description)
 		}
 	} else if (map.name == "thermostatFanMode" && map.isStateChange) {
 		state.lastTriedFanMode = map.value
+		map.data = [supportedThermostatFanModes: state.supportedThermostatFanModes]
 	}
 	log.debug "Parse returned $result"
 	result
@@ -305,26 +313,26 @@ def zwaveEvent(physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanMod
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeSupportedReport cmd) {
-	def supportedModes = ""
+	def supportedModes = []
-	if(cmd.off) { supportedModes += "off " }
+	if(cmd.off) { supportedModes << "off" }
-	if(cmd.heat) { supportedModes += "heat " }
+	if(cmd.heat) { supportedModes << "heat" }
-	if(cmd.auxiliaryemergencyHeat) { supportedModes += "emergency heat " }
+	if(cmd.cool) { supportedModes << "cool" }
-	if(cmd.cool) { supportedModes += "cool " }
+	if(cmd.auto) { supportedModes << "auto" }
-	if(cmd.auto) { supportedModes += "auto " }
+	if(cmd.auxiliaryemergencyHeat) { supportedModes << "emergency heat" }
 
-	state.supportedModes = supportedModes
+	state.supportedThermostatModes = supportedModes
-	// No events to be generated, return empty map
+	sendEvent(name: "supportedThermostatModes", value: supportedModes, displayed: false)
 	return [:]
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeSupportedReport cmd) {
-	def supportedFanModes = ""
+	def supportedFanModes = []
-	if(cmd.auto) { supportedFanModes += "auto " } // "fanAuto "
+	if(cmd.auto) { supportedFanModes << "auto" } // "fanAuto "
-	if(cmd.low) { supportedFanModes += "on " } // "fanOn"
+	if(cmd.circulation) { supportedFanModes << "circulate" } // "fanCirculate"
-	if(cmd.circulation) { supportedFanModes += "circulate " } // "fanCirculate"
+	if(cmd.low) { supportedFanModes << "on" } // "fanOn"
 
-	state.supportedFanModes = supportedFanModes
+	state.supportedThermostatFanModes = supportedFanModes
-	// No events to be generated, return empty map
+	sendEvent(name: "supportedThermostatFanModes", value: supportedFanModes, displayed: false)
 	return [:]
 }
 
@@ -337,15 +345,17 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 }
 
 // Command Implementations
-def poll() {
+def refresh() {
-	delayBetween([
+	def cmds = []
-		zwave.sensorMultilevelV3.sensorMultilevelGet().format(), // current temperature
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeSupportedGet().format())
-		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format(),
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeSupportedGet().format())
-		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format(),
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeGet().format())
-		zwave.thermostatModeV2.thermostatModeGet().format(),
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeGet().format())
-		zwave.thermostatFanModeV3.thermostatFanModeGet().format(),
+	cmds << new physicalgraph.device.HubAction(zwave.sensorMultilevelV2.sensorMultilevelGet().format()) // current temperature
-		zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format()
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format())
-	], 2300)
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format())
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format())
+	sendHubCommand(cmds)
 }
 
 def quickSetHeat(degrees) {
@@ -416,28 +426,14 @@ def ping() {
 	poll()
 }
 
-def configure() {
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSupportedGet().format(),
-		zwave.thermostatFanModeV3.thermostatFanModeSupportedGet().format(),
-		zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:[zwaveHubNodeId]).format(),
-		zwave.sensorMultilevelV3.sensorMultilevelGet().format(), // current temperature
-		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format(),
-		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format(),
-		zwave.thermostatFanModeV3.thermostatFanModeGet().format(),
-		zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format()
-	], 2300)
-}
-
 def modes() {
-	["off", "heat", "cool", "auto", "emergency heat"]
+	return state.supportedThermostatModes
 }
 
 def switchMode() {
 	def currentMode = device.currentState("thermostatMode")?.value
-	def lastTriedMode = state.lastTriedMode ?: currentMode ?: "off"
+	def lastTriedMode = state.lastTriedMode ?: currentMode ?: ["off"]
-	def supportedModes = getDataByName("supportedModes")
+	def supportedModes = getDataByName("supportedThermostatModes")
 	def modeOrder = modes()
 	def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
 	def nextMode = next(lastTriedMode)
@@ -454,7 +450,7 @@ def switchMode() {
 }
 
 def switchToMode(nextMode) {
-	def supportedModes = getDataByName("supportedModes")
+	def supportedModes = getDataByName("supportedThermostatModes")
 	if(supportedModes && !supportedModes.contains(nextMode)) log.warn "thermostat mode '$nextMode' is not supported"
 	if (nextMode in modes()) {
 		state.lastTriedMode = nextMode
@@ -466,9 +462,9 @@ def switchToMode(nextMode) {
 
 def switchFanMode() {
 	def currentMode = device.currentState("thermostatFanMode")?.value
-	def lastTriedMode = state.lastTriedFanMode ?: currentMode ?: "off"
+	def lastTriedMode = state.lastTriedFanMode ?: currentMode ?: ["off"]
-	def supportedModes = getDataByName("supportedFanModes") ?: "auto on" // "fanAuto fanOn"
+	def supportedModes = getDataByName("supportedThermostatFanModes") ?: ["auto", "on"]
-	def modeOrder = ["auto", "circulate", "on"]                 // "fanAuto", "fanCirculate", "fanOn"
+	def modeOrder = state.supportedThermostatFanModes
 	def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
 	def nextMode = next(lastTriedMode)
 	while (!supportedModes?.contains(nextMode) && nextMode != "auto") { // "fanAuto"
@@ -478,7 +474,7 @@ def switchFanMode() {
 }
 
 def switchToFanMode(nextMode) {
-	def supportedFanModes = getDataByName("supportedFanModes")
+	def supportedFanModes = getDataByName("supportedThermostatFanModes")
 	if(supportedFanModes && !supportedFanModes.contains(nextMode)) log.warn "thermostat mode '$nextMode' is not supported"
 
 	def returnCommand

devicetypes/smartthings/zwave-water-valve.src/zwave-water-valve.groovy

@@ -58,6 +58,7 @@ metadata {
 def installed() {
 	// Device-Watch simply pings if no device events received for 32min(checkInterval)
 	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	response(refresh())
 }
 
 def updated() {

smartapps/erocm123/sonoff-connect.src/sonoff-connect.groovy

@@ -1,409 +0,0 @@
-/**
- *  Copyright 2016 Eric Maycock
- *
- *  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.
- *
- *  Sonoff (Connect)
- *
- *  Author: Eric Maycock (erocm123)
- *  Date: 2016-06-02
- */
-
-definition(
-    name: "Sonoff (Connect)",
-    namespace: "erocm123",
-    author: "Eric Maycock (erocm123)",
-    description: "Service Manager for Sonoff switches",
-    category: "Convenience",
-    iconUrl:   "https://raw.githubusercontent.com/erocm123/SmartThingsPublic/master/smartapps/erocm123/sonoff-connect.src/sonoff-connect-icon.png",
-    iconX2Url: "https://raw.githubusercontent.com/erocm123/SmartThingsPublic/master/smartapps/erocm123/sonoff-connect.src/sonoff-connect-icon-2x.png",
-    iconX3Url: "https://raw.githubusercontent.com/erocm123/SmartThingsPublic/master/smartapps/erocm123/sonoff-connect.src/sonoff-connect-icon-3x.png"
-)
-
-preferences {
-	page(name: "mainPage")
-    page(name: "configurePDevice")
-    page(name: "deletePDevice")
-    page(name: "changeName")
-    page(name: "discoveryPage", title: "Device Discovery", content: "discoveryPage", refreshTimeout:5)
-    page(name: "addDevices", title: "Add Sonoff Switches", content: "addDevices")
-    page(name: "manuallyAdd")
-    page(name: "manuallyAddConfirm")
-    page(name: "deviceDiscovery")
-}
-
-def mainPage() {
-	dynamicPage(name: "mainPage", title: "Manage your Sonoff switches", nextPage: null, uninstall: true, install: true) {
-        section("Configure"){
-           href "deviceDiscovery", title:"Discover Devices", description:""
-           href "manuallyAdd", title:"Manually Add Device", description:""
-        }
-        section("Installed Devices"){
-            getChildDevices().sort({ a, b -> a["deviceNetworkId"] <=> b["deviceNetworkId"] }).each {
-                href "configurePDevice", title:"$it.label", description:"", params: [did: it.deviceNetworkId]
-            }
-        }
-    }
-}
-
-def configurePDevice(params){
-   if (params?.did || params?.params?.did) {
-      if (params.did) {
-         state.currentDeviceId = params.did
-         state.currentDisplayName = getChildDevice(params.did)?.displayName
-      } else {
-         state.currentDeviceId = params.params.did
-         state.currentDisplayName = getChildDevice(params.params.did)?.displayName
-      }
-   }  
-   if (getChildDevice(state.currentDeviceId) != null) getChildDevice(state.currentDeviceId).configure()
-   dynamicPage(name: "configurePDevice", title: "Configure Sonoff Switches created with this app", nextPage: null) {
-		section {
-            app.updateSetting("${state.currentDeviceId}_label", getChildDevice(state.currentDeviceId).label)
-            input "${state.currentDeviceId}_label", "text", title:"Device Name", description: "", required: false
-            href "changeName", title:"Change Device Name", description: "Edit the name above and click here to change it"
-        }
-        section {
-              href "deletePDevice", title:"Delete $state.currentDisplayName", description: ""
-        }
-   }
-}
-
-def manuallyAdd(){
-   dynamicPage(name: "manuallyAdd", title: "Manually add a Sonoff device", nextPage: "manuallyAddConfirm") {
-		section {
-			paragraph "This process will manually create a Sonoff device based on the entered IP address. The SmartApp needs to then communicate with the device to obtain additional information from it. Make sure the device is on and connected to your wifi network."
-            input "deviceType", "enum", title:"Device Type", description: "", required: false, options: ["Sonoff Wifi Switch","Sonoff TH Wifi Switch","Sonoff POW Wifi Switch","Sonoff Dual Wifi Switch","Sonoff 4CH Wifi Switch"]
-            input "ipAddress", "text", title:"IP Address", description: "", required: false 
-		}
-    }
-}
-
-def manuallyAddConfirm(){
-   if ( ipAddress =~ /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/) {
-       log.debug "Creating Sonoff Wifi Switch with dni: ${convertIPtoHex(ipAddress)}:${convertPortToHex("80")}"
-       addChildDevice("erocm123", deviceType ? deviceType : "Sonoff Wifi Switch", "${convertIPtoHex(ipAddress)}:${convertPortToHex("80")}", location.hubs[0].id, [
-           "label": (deviceType ? deviceType : "Sonoff Wifi Switch") + " (${ipAddress})",
-           "data": [
-           "ip": ipAddress,
-           "port": "80" 
-           ]
-       ])
-   
-       app.updateSetting("ipAddress", "")
-            
-       dynamicPage(name: "manuallyAddConfirm", title: "Manually add a Sonoff device", nextPage: "mainPage") {
-		   section {
-			   paragraph "The device has been added. Press next to return to the main page."
-	    	}
-       }
-    } else {
-        dynamicPage(name: "manuallyAddConfirm", title: "Manually add a Sonoff device", nextPage: "mainPage") {
-		    section {
-			    paragraph "The entered ip address is not valid. Please try again."
-		    }
-        }
-    }
-}
-
-def deletePDevice(){
-    try {
-        unsubscribe()
-        deleteChildDevice(state.currentDeviceId)
-        dynamicPage(name: "deletePDevice", title: "Deletion Summary", nextPage: "mainPage") {
-            section {
-                paragraph "The device has been deleted. Press next to continue"
-            } 
-        }
-    
-	} catch (e) {
-        dynamicPage(name: "deletePDevice", title: "Deletion Summary", nextPage: "mainPage") {
-            section {
-                paragraph "Error: ${(e as String).split(":")[1]}."
-            } 
-        }
-    
-    }
-}
-
-def changeName(){
-    def thisDevice = getChildDevice(state.currentDeviceId)
-    thisDevice.label = settings["${state.currentDeviceId}_label"]
-
-    dynamicPage(name: "changeName", title: "Change Name Summary", nextPage: "mainPage") {
-	    section {
-            paragraph "The device has been renamed. Press \"Next\" to continue"
-        }
-    }
-}
-
-def discoveryPage(){
-   return deviceDiscovery()
-}
-
-def deviceDiscovery(params=[:])
-{
-	def devices = devicesDiscovered()
-    
-	int deviceRefreshCount = !state.deviceRefreshCount ? 0 : state.deviceRefreshCount as int
-	state.deviceRefreshCount = deviceRefreshCount + 1
-	def refreshInterval = 3
-    
-	def options = devices ?: []
-	def numFound = options.size() ?: 0
-
-	if ((numFound == 0 && state.deviceRefreshCount > 25) || params.reset == "true") {
-    	log.trace "Cleaning old device memory"
-    	state.devices = [:]
-        state.deviceRefreshCount = 0
-        app.updateSetting("selectedDevice", "")
-    }
-
-	ssdpSubscribe()
-
-	//sonoff discovery request every 15 //25 seconds
-	if((deviceRefreshCount % 5) == 0) {
-		discoverDevices()
-	}
-
-	//setup.xml request every 3 seconds except on discoveries
-	if(((deviceRefreshCount % 3) == 0) && ((deviceRefreshCount % 5) != 0)) {
-		verifyDevices()
-	}
-
-	return dynamicPage(name:"deviceDiscovery", title:"Discovery Started!", nextPage:"addDevices", refreshInterval:refreshInterval, uninstall: true) {
-		section("Please wait while we discover your Sonoff devices. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
-			input "selectedDevices", "enum", required:false, title:"Select Sonoff Switch (${numFound} found)", multiple:true, options:options
-		}
-        section("Options") {
-			href "deviceDiscovery", title:"Reset list of discovered devices", description:"", params: ["reset": "true"]
-		}
-	}
-}
-
-Map devicesDiscovered() {
-	def vdevices = getVerifiedDevices()
-	def map = [:]
-	vdevices.each {
-		def value = "${it.value.name}"
-		def key = "${it.value.mac}"
-		map["${key}"] = value
-	}
-	map
-}
-
-def getVerifiedDevices() {
-	getDevices().findAll{ it?.value?.verified == true }
-}
-
-private discoverDevices() {
-	sendHubCommand(new physicalgraph.device.HubAction("lan discovery urn:schemas-upnp-org:device:Basic:1", physicalgraph.device.Protocol.LAN))
-}
-
-def configured() {
-	
-}
-
-def buttonConfigured(idx) {
-	return settings["lights_$idx"]
-}
-
-def isConfigured(){
-   if(getChildDevices().size() > 0) return true else return false
-}
-
-def isVirtualConfigured(did){ 
-    def foundDevice = false
-    getChildDevices().each {
-       if(it.deviceNetworkId != null){
-       if(it.deviceNetworkId.startsWith("${did}/")) foundDevice = true
-       }
-    }
-    return foundDevice
-}
-
-private virtualCreated(number) {
-    if (getChildDevice(getDeviceID(number))) {
-        return true
-    } else {
-        return false
-    }
-}
-
-private getDeviceID(number) {
-    return "${state.currentDeviceId}/${app.id}/${number}"
-}
-
-def installed() {
-	initialize()
-}
-
-def updated() {
-	unsubscribe()
-    unschedule()
-	initialize()
-}
-
-def initialize() {
-    ssdpSubscribe()
-    runEvery5Minutes("ssdpDiscover")
-}
-
-void ssdpSubscribe() {
-    subscribe(location, "ssdpTerm.urn:schemas-upnp-org:device:Basic:1", ssdpHandler)
-}
-
-void ssdpDiscover() {
-    sendHubCommand(new physicalgraph.device.HubAction("lan discovery urn:schemas-upnp-org:device:Basic:1", physicalgraph.device.Protocol.LAN))
-}
-
-def ssdpHandler(evt) {
-    def description = evt.description
-    def hub = evt?.hubId
-    def parsedEvent = parseLanMessage(description)
-    parsedEvent << ["hub":hub]
-
-    def devices = getDevices()
-    
-    String ssdpUSN = parsedEvent.ssdpUSN.toString()
-    
-    if (devices."${ssdpUSN}") {
-        def d = devices."${ssdpUSN}"
-        def child = getChildDevice(parsedEvent.mac)
-        def childIP
-        def childPort
-        if (child) {
-            childIP = child.getDeviceDataByName("ip")
-            childPort = child.getDeviceDataByName("port").toString()
-            log.debug "Device data: ($childIP:$childPort) - reporting data: (${convertHexToIP(parsedEvent.networkAddress)}:${convertHexToInt(parsedEvent.deviceAddress)})."
-            if(childIP != convertHexToIP(parsedEvent.networkAddress) || childPort != convertHexToInt(parsedEvent.deviceAddress).toString()){
-               log.debug "Device data (${child.getDeviceDataByName("ip")}) does not match what it is reporting(${convertHexToIP(parsedEvent.networkAddress)}). Attempting to update."
-               child.sync(convertHexToIP(parsedEvent.networkAddress), convertHexToInt(parsedEvent.deviceAddress).toString())
-            }
-        }
-
-        if (d.networkAddress != parsedEvent.networkAddress || d.deviceAddress != parsedEvent.deviceAddress) {
-            d.networkAddress = parsedEvent.networkAddress
-            d.deviceAddress = parsedEvent.deviceAddress
-        }
-    } else {
-        devices << ["${ssdpUSN}": parsedEvent]
-    }
-}
-
-void verifyDevices() {
-    def devices = getDevices().findAll { it?.value?.verified != true }
-    devices.each {
-        def ip = convertHexToIP(it.value.networkAddress)
-        def port = convertHexToInt(it.value.deviceAddress)
-        String host = "${ip}:${port}"
-        sendHubCommand(new physicalgraph.device.HubAction("""GET ${it.value.ssdpPath} HTTP/1.1\r\nHOST: $host\r\n\r\n""", physicalgraph.device.Protocol.LAN, host, [callback: deviceDescriptionHandler]))
-    }
-}
-
-def getDevices() {
-    state.devices = state.devices ?: [:]
-}
-
-void deviceDescriptionHandler(physicalgraph.device.HubResponse hubResponse) {
-	log.trace "description.xml response (application/xml)"
-	def body = hubResponse.xml
-    log.debug body?.device?.friendlyName?.text()
-	if (body?.device?.modelName?.text().startsWith("Sonoff")) {
-		def devices = getDevices()
-		def device = devices.find {it?.key?.contains(body?.device?.UDN?.text())}
-		if (device) {
-			device.value << [name:body?.device?.friendlyName?.text() + " (" + convertHexToIP(hubResponse.ip) + ")", serialNumber:body?.device?.serialNumber?.text(), verified: true]
-		} else {
-			log.error "/description.xml returned a device that didn't exist"
-		}
-	}
-}
-
-def addDevices() {
-    def devices = getDevices()
-    def sectionText = ""
-
-    selectedDevices.each { dni ->bridgeLinking
-        def selectedDevice = devices.find { it.value.mac == dni }
-        def d
-        if (selectedDevice) {
-            d = getChildDevices()?.find {
-                it.deviceNetworkId == selectedDevice.value.mac
-            }
-        }
-
-        if (!d) {
-            log.debug selectedDevice
-            log.debug "Creating Sonoff Switch with dni: ${selectedDevice.value.mac}"
-
-            def deviceHandlerName
-            if (selectedDevice?.value?.name?.startsWith("Sonoff TH"))
-                deviceHandlerName = "Sonoff TH Wifi Switch"
-            else if (selectedDevice?.value?.name?.startsWith("Sonoff POW"))
-                deviceHandlerName = "Sonoff POW Wifi Switch"
-            else if (selectedDevice?.value?.name?.startsWith("Sonoff Dual"))
-                deviceHandlerName = "Sonoff Dual Wifi Switch"
-            else if (selectedDevice?.value?.name?.startsWith("Sonoff 4CH"))
-                deviceHandlerName = "Sonoff 4CH Wifi Switch"
-            else 
-                deviceHandlerName = "Sonoff Wifi Switch"
-            def newDevice = addChildDevice("erocm123", deviceHandlerName, selectedDevice.value.mac, selectedDevice?.value.hub, [
-                "label": selectedDevice?.value?.name ?: "Sonoff Wifi Switch",
-                "data": [
-                    "mac": selectedDevice.value.mac,
-                    "ip": convertHexToIP(selectedDevice.value.networkAddress),
-                    "port": "" + Integer.parseInt(selectedDevice.value.deviceAddress,16)
-                ]
-            ])
-            sectionText = sectionText + "Succesfully added Sonoff device with ip address ${convertHexToIP(selectedDevice.value.networkAddress)} \r\n"
-        }
-        
-	} 
-    log.debug sectionText
-        return dynamicPage(name:"addDevices", title:"Devices Added", nextPage:"mainPage",  uninstall: true) {
-        if(sectionText != ""){
-		section("Add Sonoff Results:") {
-			paragraph sectionText
-		}
-        }else{
-        section("No devices added") {
-			paragraph "All selected devices have previously been added"
-		}
-        }
-}
-    }
-
-def uninstalled() {
-    unsubscribe()
-    getChildDevices().each {
-        deleteChildDevice(it.deviceNetworkId)
-    }
-}
-
-
-
-private String convertHexToIP(hex) {
-	[convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
-}
-
-private Integer convertHexToInt(hex) {
-	Integer.parseInt(hex,16)
-}
-
-private String convertIPtoHex(ipAddress) { 
-    String hex = ipAddress.tokenize( '.' ).collect {  String.format( '%02x', it.toInteger() ) }.join()
-    return hex
-}
-
-private String convertPortToHex(port) {
-	String hexport = port.toString().format( '%04x', port.toInteger() )
-    return hexport
-}

smartapps/opent2t/opent2t-smartapp-test.src/opent2t-smartapp-test.groovy

@@ -2,26 +2,11 @@ import javax.crypto.Mac;
 import javax.crypto.spec.SecretKeySpec;
 import java.security.InvalidKeyException;
 
-/**
- *  OpenT2T SmartApp Test
- *
- *  Copyright 2016 OpenT2T
- *
- *  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.
- *
- */
 definition(
 		name: "OpenT2T SmartApp Test",
 		namespace: "opent2t",
-		author: "OpenT2T",
+		author: "Microsoft",
-		description: "Test app to test end to end SmartThings scenarios via OpenT2T",
+		description: "SmartApp for end to end SmartThings scenarios via OpenT2T",
 		category: "SmartThings Labs",
 		iconUrl: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience.png",
 		iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png",
@@ -55,16 +40,16 @@ definition(
 
 //Device Inputs
 preferences {
-	section("Allow OpenT2T to control these things...") {
+	section("Allow Microsoft to control these things...") {
-		input "contactSensors", "capability.contactSensor", title: "Which Contact Sensors", multiple: true, required: false, hideWhenEmpty: true
+//		input "contactSensors", "capability.contactSensor", title: "Which Contact Sensors", multiple: true, required: false, hideWhenEmpty: true
-		input "garageDoors", "capability.garageDoorControl", title: "Which Garage Doors?", multiple: true, required: false, hideWhenEmpty: true
+//		input "garageDoors", "capability.garageDoorControl", title: "Which Garage Doors?", multiple: true, required: false, hideWhenEmpty: true
-		input "locks", "capability.lock", title: "Which Locks?", multiple: true, required: false, hideWhenEmpty: true
+//		input "locks", "capability.lock", title: "Which Locks?", multiple: true, required: false, hideWhenEmpty: true
-		input "cameras", "capability.videoCapture", title: "Which Cameras?", multiple: true, required: false, hideWhenEmpty: true
+//		input "cameras", "capability.videoCapture", title: "Which Cameras?",  multiple: true, required: false, hideWhenEmpty: true
-		input "motionSensors", "capability.motionSensor", title: "Which Motion Sensors?", multiple: true, required: false, hideWhenEmpty: true
+//		input "motionSensors", "capability.motionSensor", title: "Which Motion Sensors?", multiple: true, required: false, hideWhenEmpty: true
-		input "presenceSensors", "capability.presenceSensor", title: "Which Presence Sensors", multiple: true, required: false, hideWhenEmpty: true
+//		input "presenceSensors", "capability.presenceSensor", title: "Which Presence Sensors", multiple: true, required: false, hideWhenEmpty: true
 		input "switches", "capability.switch", title: "Which Switches and Lights?", multiple: true, required: false, hideWhenEmpty: true
 		input "thermostats", "capability.thermostat", title: "Which Thermostat?", multiple: true, required: false, hideWhenEmpty: true
-		input "waterSensors", "capability.waterSensor", title: "Which Water Leak Sensors?", multiple: true, required: false, hideWhenEmpty: true
+//		input "waterSensors", "capability.waterSensor", title: "Which Water Leak Sensors?", multiple: true, required: false, hideWhenEmpty: true
 	}
 }
 
@@ -82,36 +67,32 @@ def getInputs() {
 	return inputList
 }
 
+
 //API external Endpoints
 mappings {
 	path("/devices") {
-		action:
+		action: [
-		[
 				GET: "getDevices"
 		]
 	}
 	path("/devices/:id") {
-		action:
+		action: [
-		[
 				GET: "getDevice"
 		]
 	}
 	path("/update/:id") {
-		action:
+		action: [
-		[
 				PUT: "updateDevice"
 		]
 	}
 	path("/deviceSubscription") {
-		action:
+		action: [
-		[
 				POST  : "registerDeviceChange",
 				DELETE: "unregisterDeviceChange"
 		]
 	}
 	path("/locationSubscription") {
-		action:
+		action: [
-		[
 				POST  : "registerDeviceGraph",
 				DELETE: "unregisterDeviceGraph"
 		]
@@ -196,7 +177,7 @@ def registerDeviceChange() {
 				log.info "Added subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
 			} else if (!state.deviceSubscriptionMap[deviceId].contains(subscriptionEndpt)) {
 				// state.deviceSubscriptionMap[deviceId] << subscriptionEndpt
-				// For now, we will only have one subscription endpoint per device
+                // For now, we will only have one subscription endpoint per device
 				state.deviceSubscriptionMap.remove(deviceId)
 				state.deviceSubscriptionMap.put(deviceId, [subscriptionEndpt])
 				log.info "Added subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
@@ -311,16 +292,16 @@ def deviceEventHandler(evt) {
 	def evtDeviceType = getDeviceType(evtDevice)
 	def deviceData = [];
 
-	if (evt.data != null) {
-		def evtData = parseJson(evt.data)
-		log.info "Received event for ${evtDevice.displayName}, data: ${evtData},  description: ${evt.descriptionText}"
-	}
-
 	if (evtDeviceType == "thermostat") {
 		deviceData = [name: evtDevice.displayName, id: evtDevice.id, status: evtDevice.status, deviceType: evtDeviceType, manufacturer: evtDevice.manufacturerName, model: evtDevice.modelName, attributes: deviceAttributeList(evtDevice, evtDeviceType), locationMode: getLocationModeInfo(), locationId: location.id]
 	} else {
 		deviceData = [name: evtDevice.displayName, id: evtDevice.id, status: evtDevice.status, deviceType: evtDeviceType, manufacturer: evtDevice.manufacturerName, model: evtDevice.modelName, attributes: deviceAttributeList(evtDevice, evtDeviceType), locationId: location.id]
 	}
+    
+    if(evt.data != null){
+		def evtData = parseJson(evt.data)
+		log.info "Received event for ${evtDevice.displayName}, data: ${evtData},  description: ${evt.descriptionText}"
+	}
 
 	def params = [body: deviceData]
 
@@ -330,10 +311,10 @@ def deviceEventHandler(evt) {
 		params.uri = "${it}"
 		if (state.verificationKeyMap[it] != null) {
 			def key = state.verificationKeyMap[it]
-			params.header = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
+            params.headers = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
 		}
 		log.trace "POST URI: ${params.uri}"
-		log.trace "Header: ${params.header}"
+        log.trace "Headers: ${params.headers}"
 		log.trace "Payload: ${params.body}"
 		try {
 			httpPostJson(params) { resp ->
@@ -363,10 +344,10 @@ def locationEventHandler(evt) {
 				params.uri = "${it}"
 				if (state.verificationKeyMap[it] != null) {
 					def key = state.verificationKeyMap[it]
-					params.header = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
+                    params.headers = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
 				}
 				log.trace "POST URI: ${params.uri}"
-				log.trace "Header: ${params.header}"
+				log.trace "Headers: ${params.headers}"
 				log.trace "Payload: ${params.body}"
 				try {
 					httpPostJson(params) { resp ->
@@ -385,6 +366,7 @@ def locationEventHandler(evt) {
 
 private ComputHMACValue(key, data) {
 	try {
+    	log.debug "data hased: ${data}"
 		SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA1")
 		Mac mac = Mac.getInstance("HmacSHA1")
 		mac.init(secretKeySpec)
@@ -507,7 +489,8 @@ private getDeviceType(device) {
 
 	//Loop through the device capability list to determine the device type.
 	capabilities.each { capability ->
-		switch (capability.name.toLowerCase()) {
+		switch(capability.name.toLowerCase())
+		{
 			case "switch":
 				deviceType = "switch"
 
@@ -652,7 +635,8 @@ private mapDeviceCommands(command, value) {
 			if (value == 1 || value == "1" || value == "lock") {
 				resultCommand = "lock"
 				resultValue = ""
-			} else if (value == 0 || value == "0" || value == "unlock") {
+			}
+			else if (value == 0 || value == "0" || value == "unlock") {
 				resultCommand = "unlock"
 				resultValue = ""
 			}

smartapps/smartthings/button-controller.src/button-controller.groovy

@@ -27,10 +27,9 @@ definition(
 
 preferences {
 	page(name: "selectButton")
-	page(name: "configureButton1")
+	for (def i=1; i<=8; i++) {
-	page(name: "configureButton2")
+		page(name: "configureButton$i")
-	page(name: "configureButton3")
+	}
-	page(name: "configureButton4")
 
 	page(name: "timeIntervalInput", title: "Only during a certain time") {
 		section {
@@ -60,22 +59,45 @@ def selectButton() {
 	}
 }
 
+def createPage(pageNum) {
+	if ((state.numButton == pageNum) || (pageNum == 8))
+		state.installCondition = true
+	dynamicPage(name: "configureButton$pageNum", title: "Set up button $pageNum here",
+			nextPage: "configureButton${pageNum+1}", install: state.installCondition, uninstall: configured(), getButtonSections(pageNum))
+}
+
 def configureButton1() {
-	dynamicPage(name: "configureButton1", title: "Now let's decide how to use the first button",
+	state.numButton = buttonDevice.currentState("numberOfButtons")?.longValue ?: 4
-		nextPage: "configureButton2", uninstall: configured(), getButtonSections(1))
+	log.debug "state variable numButton: ${state.numButton}"
+	state.installCondition = false
+	createPage(1)
 }
 def configureButton2() {
-	dynamicPage(name: "configureButton2", title: "If you have a second button, set it up here",
+	createPage(2)
-		nextPage: "configureButton3", uninstall: configured(), getButtonSections(2))
 }
 
 def configureButton3() {
-	dynamicPage(name: "configureButton3", title: "If you have a third button, you can do even more here",
+	createPage(3)
-		nextPage: "configureButton4", uninstall: configured(), getButtonSections(3))
 }
+
 def configureButton4() {
-	dynamicPage(name: "configureButton4", title: "If you have a fourth button, you rule, and can set it up here",
+	createPage(4)
-		install: true, uninstall: true, getButtonSections(4))
+}
+
+def configureButton5() {
+	createPage(5)
+}
+
+def configureButton6() {
+	createPage(6)
+}
+
+def configureButton7() {
+	createPage(7)
+}
+
+def configureButton8() {
+	createPage(8)
 }
 
 def getButtonSections(buttonNumber) {

smartapps/smartthings/examples/every-element.src/every-element.groovy

@@ -202,7 +202,8 @@ def inputSelectionPage() {
 
         section("options variations") {
             paragraph "tap these elements and look at the differences when selecting an option"
-            input(type: "enum", name: "selectionSimple", title: "Simple options", description: "no separators in the selectable options", groupedOptions: addGroup(englishOptions + spanishOptions))
+            input(type: "enum", name: "selectionSimple", title: "Simple options", description: "no separators in the selectable options", options: ["Thing 1", "Thing 2", "(Complicated) Thing 3"])
+            input(type: "enum", name: "selectionSimpleGrouped", title: "Simple (Grouped) options", description: "no separators in the selectable options", groupedOptions: addGroup(englishOptions + spanishOptions))
             input(type: "enum", name: "selectionGrouped", title: "Grouped options", description: "separate groups of options with headers", groupedOptions: groupedOptions)
         }
 
@@ -214,15 +215,15 @@ def inputSelectionPage() {
 
         section("segmented") {
             paragraph "segmented should only work if there are either 2 or 3 options to choose from"
-            input(type: "enum", name: "selectionSegmented1", style: "segmented", title: "1 option", groupedOptions: addGroup(["One"]))
+            input(type: "enum", name: "selectionSegmented1", style: "segmented", title: "1 option", options: ["One"])
-            input(type: "enum", name: "selectionSegmented4", style: "segmented", title: "4 options", groupedOptions: addGroup(["One", "Two", "Three", "Four"]))
+            input(type: "enum", name: "selectionSegmented4", style: "segmented", title: "4 options", options: ["One", "Two", "Three", "Four"])
 
             paragraph "multiple and required will have no effect on segmented selection elements. There will always be exactly 1 option selected"
             input(type: "enum", name: "selectionSegmented2", style: "segmented", title: "2 options", options: ["One", "Two"])
             input(type: "enum", name: "selectionSegmented3", style: "segmented", title: "3 options", options: ["One", "Two", "Three"])
 
             paragraph "specifying defaultValue still works with segmented selection elements"
-            input(type: "enum", name: "selectionSegmentedWithDefault", title: "defaulted to 'two'", groupedOptions: addGroup(["One", "Two", "Three"]), defaultValue: "Two")
+            input(type: "enum", name: "selectionSegmentedWithDefault", style: "segmented", title: "defaulted to 'two'", options: ["One", "Two", "Three"], defaultValue: "Two")
         }
 
         section("required: true") {
@@ -231,6 +232,8 @@ def inputSelectionPage() {
 
         section("multiple: true") {
             input(type: "enum", name: "selectionMultiple", title: "This allows multiple selections", description: "It should look different when nothing is selected", groupedOptions: addGroup(["an option", "another option", "no way, one more?"]), multiple: true)
+            input(type: "enum", name: "selectionMultipleDefault1", title: "This allows multiple selections with a single default", description: "It should look different when nothing is selected", groupedOptions: addGroup(["an option", "another option", "no way, one more?"]), multiple: true, defaultValue: "an option")
+            input(type: "enum", name: "selectionMultipleDefault2", title: "This allows multiple selections with multiple defaults", description: "It should look different when nothing is selected", groupedOptions: addGroup(["an option", "another option", "no way, one more?"]), multiple: true, defaultValue: ["an option", "another option"])
         }
 
         section("with image") {

smartapps/smartthings/lifx-connect.src/lifx-connect.groovy

@@ -72,7 +72,7 @@ def authPage() {
 		log.debug "have LIFX access token"
 
 		def options = locationOptions() ?: []
-		def count = options.size()
+		def count = options.size().toString()
 
 		return dynamicPage(name:"Credentials", title:"", nextPage:"", install:true, uninstall: true) {
 			section("Select your location") {