MSA-2161: Updated version: see change log in files for details

Rolling down staging to master

build.gradle

@@ -9,7 +9,7 @@ apply plugin: 'smartthings-slack'
 
 buildscript {
     dependencies {
-        classpath "com.smartthings.deployment:executable-deployment-scripts:1.0.11"
+        classpath "com.smartthings.deployment:executable-deployment-scripts:1.0.12"
     }
     repositories {
         mavenLocal()
@@ -19,7 +19,7 @@ buildscript {
                 username smartThingsArtifactoryUserName
                 password smartThingsArtifactoryPassword
             }
-            url "https://artifactory.smartthings.com/libs-release-local"
+            url "https://smartthings.jfrog.io/smartthings/libs-release-local"
         }
     }
 }
@@ -32,7 +32,7 @@ repositories {
             username smartThingsArtifactoryUserName
             password smartThingsArtifactoryPassword
         }
-        url "https://artifactory.smartthings.com/libs-release-local"
+        url "https://smartthings.jfrog.io/smartthings/libs-release-local"
     }
 }
 
@@ -51,10 +51,10 @@ sourceSets {
 
 dependencies {
     devicetypesCompile 'org.codehaus.groovy:groovy-all:2.4.7'
-    devicetypesCompile 'smartthings:appengine-z-wave:0.1.2'
-    devicetypesCompile 'smartthings:appengine-zigbee:0.1.11'
+    devicetypesCompile 'smartthings:appengine-z-wave:0.1.3'
+    devicetypesCompile 'smartthings:appengine-zigbee:0.1.12'
     smartappsCompile 'org.codehaus.groovy:groovy-all:2.4.7'
-    smartappsCompile 'smartthings:appengine-common:0.1.8'
+    smartappsCompile 'smartthings:appengine-common:0.1.9'
     smartappsCompile 'org.codehaus.groovy.modules.http-builder:http-builder:0.7.1'
     smartappsCompile 'org.grails:grails-web:2.3.11'
     smartappsCompile 'org.json:json:20140107'
@@ -74,19 +74,19 @@ slackSendMessage {
     String username
     switch (branch) {
         case 'master':
-            username = 'Hickory'
+            username = 'DEV'
             iconUrl = wolverine
             color = '#35D0F2'
             messageText = 'Began deployment of _SmartThingsPublic[master]_ branch to the _Dev_ environments.'
             break
         case 'staging':
-            username = 'Dickory'
+            username = 'STG'
             iconUrl = beach
             color = '#FFDE20'
             messageText = 'Began deployment of _SmartThingsPublic[staging]_ branch to the _Staging_ environments.'
             break
         case 'production':
-            username = 'Dock'
+            username = 'PRD'
             iconUrl = drinks
             color = '#FF1D23'
             messageText = 'Began deployment of _SmartThingsPublic[production]_ branch to the _Prod_ environments.'

devicetypes/drzwave/ezmultipli.src/ezmultipli.groovy

@@ -38,9 +38,9 @@ metadata {
     tiles (scale: 2){      
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL", icon: "st.Lighting.light18") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', icon:"st.switches.light.on", backgroundColor:"#79b821"
+				attributeState "turningOn", label:'${name}', icon:"st.switches.light.on", backgroundColor:"#00A0DC"
 				attributeState "turningOff", label:'${name}', icon:"st.switches.light.off", backgroundColor:"#ffffff"
 			}
 			tileAttribute ("device.color", key: "COLOR_CONTROL") {
@@ -52,20 +52,20 @@ metadata {
         }
 
 		standardTile("motion", "device.motion", width: 2, height: 2, canChangeIcon: true, canChangeBackground: true) {
-			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
-			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
+			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC"
+			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#cccccc"
 		}
 		valueTile("temperature", "device.temperature", width: 2, height: 2) {
 			state "temperature", label:'${currentValue}°', unit:"F", icon:"", // would be better if the units would switch to the desired units of the system (imperial or metric)
 			backgroundColors:[
-				[value: 0,  color: "#1010ff"], // blue=cold
-				[value: 65, color: "#a0a0f0"],
-				[value: 70, color: "#e0e050"],
-				[value: 75, color: "#f0d030"], // yellow
-				[value: 80, color: "#fbf020"],
-				[value: 85, color: "#fbdc01"],
-				[value: 90, color: "#fb3a01"],
-				[value: 95, color: "#fb0801"]  // red=hot
+				[value: 0,  color: "#153591"], // blue=cold
+				[value: 65, color: "#44b621"], // green
+				[value: 70, color: "#44b621"], // green
+				[value: 75, color: "#f1d801"], // yellow
+				[value: 80, color: "#f1d801"], // yellow
+				[value: 85, color: "#f1d801"], // yellow
+				[value: 90, color: "#d04e00"], // red
+				[value: 95, color: "#bc2323"]  // red=hot
 			]
 		}
 

devicetypes/erocm123/inovelli-2-channel-smart-plug.src/inovelli-2-channel-smart-plug.groovy

@@ -0,0 +1,268 @@
+/**
+ *
+ *  Inovelli 2-Channel Smart Plug
+ *
+ *  github: Eric Maycock (erocm123)
+ *  Date: 2017-04-27
+ *  Copyright Eric Maycock
+ *
+ *  Includes all configuration parameters and ease of advanced configuration.
+ *
+ *  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: "Inovelli 2-Channel Smart Plug", namespace: "erocm123", author: "Eric Maycock") {
+		capability "Actuator"
+		capability "Sensor"
+		capability "Switch"
+		capability "Polling"
+		capability "Refresh"
+		capability "Health Check"
+
+		fingerprint manufacturer: "015D", prod: "0221", model: "251C", deviceJoinName: "Show Home 2-Channel Smart Plug"
+		fingerprint manufacturer: "0312", prod: "B221", model: "251C", deviceJoinName: "Inovelli 2-Channel Smart Plug"
+	}
+	simulator {}
+	preferences {}
+	tiles {
+		multiAttributeTile(name: "switch", type: "lighting", width: 6, height: 4, canChangeIcon: true) {
+			tileAttribute("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "turningOn"
+				attributeState "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00a0dc", nextState: "turningOff"
+				attributeState "turningOff", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "turningOn"
+				attributeState "turningOn", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00a0dc", nextState: "turningOff"
+			}
+		}
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "default", label: "", action: "refresh.refresh", icon: "st.secondary.refresh"
+		}
+		main(["switch"])
+		details(["switch",
+				 childDeviceTiles("all"), "refresh"
+		])
+	}
+}
+def parse(String description) {
+	def result = []
+	def cmd = zwave.parse(description)
+	if (cmd) {
+		result += zwaveEvent(cmd)
+		logging("Parsed ${cmd} to ${result.inspect()}", 1)
+	} else {
+		logging("Non-parsed event: ${description}", 2)
+	}
+	return result
+}
+def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd, ep = null) {
+	logging("BasicReport ${cmd} - ep ${ep}", 2)
+	if (ep) {
+		def event
+		childDevices.each {
+			childDevice ->
+				if (childDevice.deviceNetworkId == "$device.deviceNetworkId-ep$ep") {
+					childDevice.sendEvent(name: "switch", value: cmd.value ? "on" : "off")
+				}
+		}
+		if (cmd.value) {
+			event = [createEvent([name: "switch", value: "on"])]
+		} else {
+			def allOff = true
+			childDevices.each {
+				n ->
+					if (n.currentState("switch").value != "off") allOff = false
+			}
+			if (allOff) {
+				event = [createEvent([name: "switch", value: "off"])]
+			} else {
+				event = [createEvent([name: "switch", value: "on"])]
+			}
+		}
+		return event
+	}
+}
+def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
+	logging("BasicSet ${cmd}", 2)
+	def result = createEvent(name: "switch", value: cmd.value ? "on" : "off", type: "digital")
+	def cmds = []
+	cmds << encap(zwave.switchBinaryV1.switchBinaryGet(), 1)
+	cmds << encap(zwave.switchBinaryV1.switchBinaryGet(), 2)
+	return [result, response(commands(cmds))] // returns the result of reponse()
+}
+def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd, ep = null) {
+	logging("SwitchBinaryReport ${cmd} - ep ${ep}", 2)
+	if (ep) {
+		def event
+		def childDevice = childDevices.find {
+			it.deviceNetworkId == "$device.deviceNetworkId-ep$ep"
+		}
+		if (childDevice) childDevice.sendEvent(name: "switch", value: cmd.value ? "on" : "off")
+		if (cmd.value) {
+			event = [createEvent([name: "switch", value: "on"])]
+		} else {
+			def allOff = true
+			childDevices.each {
+				n->
+					if (n.currentState("switch").value != "off") allOff = false
+			}
+			if (allOff) {
+				event = [createEvent([name: "switch", value: "off"])]
+			} else {
+				event = [createEvent([name: "switch", value: "on"])]
+			}
+		}
+		return event
+	} else {
+		def result = createEvent(name: "switch", value: cmd.value ? "on" : "off", type: "digital")
+		def cmds = []
+		cmds << encap(zwave.switchBinaryV1.switchBinaryGet(), 1)
+		cmds << encap(zwave.switchBinaryV1.switchBinaryGet(), 2)
+		return [result, response(commands(cmds))] // returns the result of reponse()
+	}
+}
+def zwaveEvent(physicalgraph.zwave.commands.multichannelv3.MultiChannelCmdEncap cmd) {
+	logging("MultiChannelCmdEncap ${cmd}", 2)
+	def encapsulatedCommand = cmd.encapsulatedCommand([0x32: 3, 0x25: 1, 0x20: 1])
+	if (encapsulatedCommand) {
+		zwaveEvent(encapsulatedCommand, cmd.sourceEndPoint as Integer)
+	}
+}
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
+	logging("ManufacturerSpecificReport ${cmd}", 2)
+	def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
+	logging("msr: $msr", 2)
+	updateDataValue("MSR", msr)
+}
+def zwaveEvent(physicalgraph.zwave.Command cmd) {
+	// This will capture any commands not handled by other instances of zwaveEvent
+	// and is recommended for development so you can see every command the device sends
+	logging("Unhandled Event: ${cmd}", 2)
+}
+def on() {
+	logging("on()", 1)
+	commands([
+			zwave.switchAllV1.switchAllOn(),
+			encap(zwave.switchBinaryV1.switchBinaryGet(), 1),
+			encap(zwave.switchBinaryV1.switchBinaryGet(), 2)
+	])
+}
+def off() {
+	logging("off()", 1)
+	commands([
+			zwave.switchAllV1.switchAllOff(),
+			encap(zwave.switchBinaryV1.switchBinaryGet(), 1),
+			encap(zwave.switchBinaryV1.switchBinaryGet(), 2)
+	])
+}
+void childOn(String dni) {
+	logging("childOn($dni)", 1)
+	def cmds = []
+	cmds << new physicalgraph.device.HubAction(command(encap(zwave.basicV1.basicSet(value: 0xFF), channelNumber(dni))))
+	cmds << new physicalgraph.device.HubAction(command(encap(zwave.switchBinaryV1.switchBinaryGet(), channelNumber(dni))))
+	sendHubCommand(cmds, 1000)
+}
+void childOff(String dni) {
+	logging("childOff($dni)", 1)
+	def cmds = []
+	cmds << new physicalgraph.device.HubAction(command(encap(zwave.basicV1.basicSet(value: 0x00), channelNumber(dni))))
+	cmds << new physicalgraph.device.HubAction(command(encap(zwave.switchBinaryV1.switchBinaryGet(), channelNumber(dni))))
+	sendHubCommand(cmds, 1000)
+}
+void childRefresh(String dni) {
+	logging("childRefresh($dni)", 1)
+	def cmds = []
+	cmds << new physicalgraph.device.HubAction(command(encap(zwave.switchBinaryV1.switchBinaryGet(), channelNumber(dni))))
+	sendHubCommand(cmds, 1000)
+}
+def poll() {
+	logging("poll()", 1)
+	commands([
+			encap(zwave.switchBinaryV1.switchBinaryGet(), 1),
+			encap(zwave.switchBinaryV1.switchBinaryGet(), 2),
+	])
+}
+def refresh() {
+	logging("refresh()", 1)
+	commands([
+			encap(zwave.switchBinaryV1.switchBinaryGet(), 1),
+			encap(zwave.switchBinaryV1.switchBinaryGet(), 2),
+	])
+}
+def ping() {
+	logging("ping()", 1)
+	refresh()
+}
+def installed() {
+	logging("installed()", 1)
+	command(zwave.manufacturerSpecificV1.manufacturerSpecificGet())
+	createChildDevices()
+}
+def updated() {
+	logging("updated()", 1)
+	if (!childDevices) {
+		createChildDevices()
+	} else if (device.label != state.oldLabel) {
+		childDevices.each {
+			if (it.label == "${state.oldLabel} (CH${channelNumber(it.deviceNetworkId)})") {
+				def newLabel = "${device.displayName} (CH${channelNumber(it.deviceNetworkId)})"
+				it.setLabel(newLabel)
+			}
+		}
+		state.oldLabel = device.label
+	}
+	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	sendEvent(name: "needUpdate", value: device.currentValue("needUpdate"), displayed: false, isStateChange: true)
+}
+def zwaveEvent(physicalgraph.zwave.commands.configurationv2.ConfigurationReport cmd) {
+	logging("${device.displayName} parameter '${cmd.parameterNumber}' with a byte size of '${cmd.size}' is set to '${cmd2Integer(cmd.configurationValue)}'", 2)
+}
+private encap(cmd, endpoint) {
+	if (endpoint) {
+		zwave.multiChannelV3.multiChannelCmdEncap(destinationEndPoint: endpoint).encapsulate(cmd)
+	} else {
+		cmd
+	}
+}
+private command(physicalgraph.zwave.Command cmd) {
+	if (state.sec) {
+		zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
+	} else {
+		cmd.format()
+	}
+}
+private commands(commands, delay = 1000) {
+	delayBetween(commands.collect {
+		command(it)
+	}, delay)
+}
+private channelNumber(String dni) {
+	dni.split("-ep")[-1] as Integer
+}
+private void createChildDevices() {
+	state.oldLabel = device.label
+	for (i in 1..2) {
+		addChildDevice("Switch Child Device", "${device.deviceNetworkId}-ep${i}", null, [completedSetup: true, label: "${device.displayName} (CH${i})",
+																						 isComponent: true, componentName: "ep$i", componentLabel: "Channel $i"
+		])
+	}
+}
+
+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
+		}
+	}
+}

devicetypes/erocm123/switch-child-device.src/switch-child-device.groovy

@@ -0,0 +1,49 @@
+/**
+ *  Switch Child Device
+ *
+ *  Copyright 2017 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.
+ *
+ */
+metadata {
+	definition (name: "Switch Child Device", namespace: "erocm123", author: "Eric Maycock") {
+		capability "Switch"
+		capability "Actuator"
+		capability "Sensor"
+		capability "Refresh"
+	}
+
+	tiles {
+		multiAttributeTile(name:"switch", type: "lighting", width: 3, height: 4, canChangeIcon: true){
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState:"turningOn"
+				attributeState "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00A0DC", nextState:"turningOff"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+		}
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+	}
+}
+
+void on() {
+	parent.childOn(device.deviceNetworkId)
+}
+
+void off() {
+	parent.childOff(device.deviceNetworkId)
+}
+
+void refresh() {
+	parent.childRefresh(device.deviceNetworkId)
+}

devicetypes/fibargroup/fibaro-door-window-sensor-zw5-with-temperature.src/fibaro-door-window-sensor-zw5-with-temperature.groovy

@@ -39,8 +39,8 @@ metadata {
             }
 
             tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
-				attributeState("active", label:'tamper active', backgroundColor:"#53a7c0")
-				attributeState("inactive", label:'tamper inactive', backgroundColor:"#ffffff")
+				attributeState("active", label:'tamper active', backgroundColor:"#00A0DC")
+				attributeState("inactive", label:'tamper inactive', backgroundColor:"#CCCCCC")
 			}
         }
 

devicetypes/fibargroup/fibaro-door-window-sensor-zw5.src/fibaro-door-window-sensor-zw5.groovy

@@ -37,8 +37,8 @@ metadata {
             }
 
             tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
-				attributeState("active", label:'tamper active', backgroundColor:"#53a7c0")
-				attributeState("inactive", label:'tamper inactive', backgroundColor:"#ffffff")
+				attributeState("active", label:'tamper active', backgroundColor:"#00A0DC")
+				attributeState("inactive", label:'tamper inactive', backgroundColor:"#CCCCCC")
 			}
         }
 

devicetypes/fibargroup/fibaro-motion-sensor-zw5.src/fibaro-motion-sensor-zw5.groovy

@@ -34,8 +34,8 @@ metadata {
     tiles(scale: 2) {
     	multiAttributeTile(name:"FGMS", type:"lighting", width:6, height:4) {//with generic type secondary control text is not displayed in Android app
         	tileAttribute("device.motion", key:"PRIMARY_CONTROL") {
-            	attributeState("inactive", label:"no motion", icon:"st.motion.motion.inactive", backgroundColor:"#79b821")
-            	attributeState("active", label:"motion", icon:"st.motion.motion.active", backgroundColor:"#ffa81e")
+            	attributeState("inactive", label:"no motion", icon:"st.motion.motion.inactive", backgroundColor:"#cccccc")
+            	attributeState("active", label:"motion", icon:"st.motion.motion.active", backgroundColor:"#00A0DC")
             }
 
             tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {

devicetypes/ihome-devices/ihomesmartplug-isp5.src/ihomesmartplug-isp5.groovy

@@ -0,0 +1,197 @@
+/**
+ *  iHomeSmartPlug iSP5
+ *
+ *  Copyright 2016 EVRYTHNG LTD
+ *
+ *  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.
+ *
+ * Last reviewed:20.07.2017
+ *   - Added capabilities: Health Check, Outlet, Light
+ *   - Added ocfDeviceType
+ *   - Changed background colour of tiles
+ *   - Added lifecycle functions
+ *   - Added ping method
+ */
+import groovy.json.JsonOutput
+
+metadata {
+	definition (name: "iHomeSmartPlug-iSP5", namespace: "ihome_devices", author: "iHome", ocfDeviceType: "oic.d.smartplug") {
+		capability "Actuator" 	//The device is an actuator (provides actions)
+        capability "Sensor"		//The device s a sensor (provides properties)
+   		capability "Refresh"    //Enable the refresh by the user
+
+		capability "Switch"     //Device complies to the SmartThings switch capability
+
+		capability "Health Check"
+		capability "Outlet"     //Needed for Google Home
+		capability "Light"      //Needed for Google Home
+
+        attribute "firmware","string" //Mapping the custom property firmware
+        attribute "model","string"    //Mapping the custom property model (model of the plug)
+        attribute "status", "string" //Mapping the status of the last call to the cloud in a message to the user
+	}
+
+	tiles(scale: 2){
+
+    	multiAttributeTile(name:"control", type:"generic", width:6, height:4) {
+        	tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+        	    attributeState( "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "off")
+        	    attributeState( "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00A0DC", nextState: "on")
+			}
+			tileAttribute ("device.status", key: "SECONDARY_CONTROL") {
+				attributeState "status", label:'${currentValue}'
+			}
+        }
+
+        standardTile("refresh", "device.refresh", width:2, height:2, inactiveLabel: false, decoration: "flat") {
+			state ("default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh")
+		}
+        valueTile("firmware", "device.firmware", width:2, height:2, decoration: "flat") {
+        	state "firmware", label:'Firmware v${currentValue}'
+    	}
+        valueTile("model", "device.model", width:2, height:2, decoration: "flat") {
+        	state "model", label:'${currentValue}'
+    	}
+		main (["control"])
+		details (["control","refresh","firmware","model"])
+	}
+}
+
+def initialize() {
+	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "cloud", scheme:"untracked"]), displayed: false)
+}
+
+def installed() {
+	log.debug "installed()"
+	initialize()
+}
+
+def updated() {
+	log.debug "updated()"
+	initialize()
+}
+
+/*
+* This method creates the internal SmartThings events to handle changes in the properties of the plug
+*/
+def updateProperties(Map properties) {
+
+	log.debug "Updating plug's properties: ${properties}"
+
+    def connected = (properties["~connected"]?.value == true)
+    if (connected == true){ //only update if plug is connected
+
+        //update status message
+  	    sendEvent(name: "status", value: parent.getConnectedMessage())
+       	log.info "Updating ${device.displayName}: property status set to: ${parent.getConnectedMessage()}"
+
+		//update currentpowerstate1
+        def currentpowerstate1 = properties["currentpowerstate1"].value
+        if (currentpowerstate1 != null){
+        	log.info "Updating ${device.displayName}: property currentpowerstate1 set to value: ${currentpowerstate1}"
+            currentpowerstate1 = "${currentpowerstate1}"
+        	if (currentpowerstate1 == "1") {
+    			sendEvent(name: "switch", value: "on")
+        	}
+        	else if (currentpowerstate1 == "0") {
+   				sendEvent(name: "switch", value: "off")
+        	}
+        }
+
+        //update firmware version
+        def appfwversion = properties["appfwversion"].value
+        if (appfwversion != null){
+        	log.info "Updating ${device.displayName}: property appfwversion set to value: ${appfwversion}"
+            appfwversion = "${appfwversion}"
+   			sendEvent(name: "firmware", value: appfwversion)
+        }
+
+		//update model
+    	log.info "Updating ${device.displayName}: property model set to value: iSP5"
+    	sendEvent(name:"model", value:"iSP5")
+
+    } else { //the plug is not connected
+
+        //update status message
+      	sendEvent(name: "status", value: parent.getPlugNotConnectedMessage())
+      	log.info "Updating ${device.displayName}: property status set to: ${parent.getPlugNotConnectedMessage()}"
+    }
+}
+
+// Process the polling error, changing the status message
+def pollError(){
+  	log.info "Error retrieving info from the cloud"
+	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+}
+
+/*
+* This method handles the switch.on function by updating the corresponding property in the cloud
+*/
+def on() {
+
+    //update the status of the plug before attempting to change it
+	refresh()
+
+	if (device.currentState("status")?.value == parent.getConnectedMessage()) {//only update if the plug is connected
+		//Turn on if the device is off
+		if (device.currentState("switch")?.value.toLowerCase().startsWith("off")){
+       		log.info "Updating ${device.displayName} in the cloud: property targetpowerstate1 set to value: 1"
+
+			def propertyUpdateJSON = "[{\"key\":\"targetpowerstate1\", \"value\":\"1\"}]"
+    		def success = parent.propertyUpdate(device.deviceNetworkId, propertyUpdateJSON)
+
+        	if(success){
+        		log.info "Updating ${device.displayName}: sending switch.on command"
+ 				sendEvent(name: "switch", value: "on")
+            	sendEvent(name: "status", value: parent.getConnectedMessage())
+        	} else {
+        		log.info "Cloud property update error, skipping event"
+				sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+        	}
+    	}
+    }
+}
+
+/*
+* This method handles the switch.off function by updating the corresponding property in the cloud
+*/
+def off() {
+    //update the status of the plug before attempting to change it
+	refresh()
+
+	if (device.currentState("status")?.value == parent.getConnectedMessage()) {//only update if the plug is connected
+		//Turn off if the device is on
+		if (device.currentState("switch")?.value.toLowerCase().startsWith("on")){
+        	log.info "Updating ${device.displayName} in the cloud: property targetpowerstate1 set to value: 0"
+    		def propertyUpdateJSON = "[{\"key\":\"targetpowerstate1\", \"value\":\"0\"}]"
+			def success = parent.propertyUpdate(device.deviceNetworkId, propertyUpdateJSON)
+
+        	if (success){
+	    		log.info "Updating ${device.displayName}: sending switch.off command"
+    			sendEvent(name: "switch", value: "off")
+            	sendEvent(name: "status", value: parent.getConnectedMessage())
+        	} else {
+        		log.info "Cloud property update error, skipping event"
+            	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+        	}
+   		}
+   }
+}
+
+/*
+* This method handles the refresh capability
+*/
+def refresh() {
+    parent.pollChildren(device.deviceNetworkId)
+}
+
+def ping() {
+	refresh()
+}

devicetypes/ihome-devices/ihomesmartplug-isp6.src/ihomesmartplug-isp6.groovy

@@ -0,0 +1,201 @@
+/**
+ *  iHomeSmartPlug iSP6
+ *
+ *  Copyright 2016 EVRYTHNG LTD
+ *
+ *  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.
+ *
+ * Last reviewed:20.07.2017
+ *   - Added capabilities: Health Check, Outlet, Light
+ *   - Added ocfDeviceType
+ *   - Changed background colour of tiles
+ *   - Added lifecycle functions
+ *   - Added ping method
+ */
+import groovy.json.JsonOutput
+
+metadata {
+	definition (name: "iHomeSmartPlug-iSP6", namespace: "ihome_devices", author: "iHome", ocfDeviceType: "oic.d.smartplug") {
+		capability "Actuator" 	//The device is an actuator (provides actions)
+        capability "Sensor"		//The device s a sensor (provides properties)
+   		capability "Refresh"    //Enable the refresh by the user
+
+		capability "Switch"     //Device complies to the SmartThings switch capability
+
+		capability "Health Check"
+        capability "Outlet"     //Needed for Google Home
+        capability "Light"      //Needed for Google Home
+
+        attribute "firmware","string" //Mapping the custom property firmware
+        attribute "model","string"    //Mapping the custom property model (model of the plug)
+        attribute "status", "string" //Mapping the status of the last call to the cloud
+
+	}
+
+	tiles(scale: 2){
+
+    	multiAttributeTile(name:"control", type:"generic", width:6, height:4) {
+        	tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+       		attributeState( "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "off")
+              attributeState( "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00A0DC", nextState: "on")
+			}
+			tileAttribute ("device.status", key: "SECONDARY_CONTROL") {
+				attributeState "status", label:'${currentValue}'
+			}
+        }
+
+        standardTile("refresh", "device.refresh", width:2, height:2, inactiveLabel: false, decoration: "flat") {
+			state ("default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh")
+		}
+        valueTile("firmware", "device.firmware", width:2, height:2, decoration: "flat") {
+        	state "firmware", label:'Firmware v${currentValue}'
+    	}
+        valueTile("model", "device.model", width:2, height:2, decoration: "flat") {
+        	state "model", label:'${currentValue}'
+    	}
+		main (["control"])
+		details (["control","refresh","firmware","model"])
+	}
+}
+
+def initialize() {
+	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "cloud", scheme:"untracked"]), displayed: false)
+}
+
+def installed() {
+	log.debug "installed()"
+	initialize()
+}
+
+def updated() {
+	log.debug "updated()"
+	initialize()
+}
+
+/*
+* This method creates the internal SmartThings events to handle changes in the properties of the plug
+*/
+def updateProperties(Map properties) {
+
+	log.debug "Updating plug's properties: ${properties}"
+
+    def connected = (properties["~connected"]?.value == true)
+
+    if (connected == true){ //only update if plug is connected
+
+        //update status message
+  	    sendEvent(name: "status", value: parent.getConnectedMessage())
+       	log.info "Updating ${device.displayName}: property status set to: ${parent.getConnectedMessage()}"
+
+		//update currentpowerstate1
+        def currentpowerstate1 = properties["currentpowerstate1"].value
+        if (currentpowerstate1 != null){
+        	log.info "Updating ${device.displayName}: property currentpowerstate1 set to value: ${currentpowerstate1}"
+            currentpowerstate1 = "${currentpowerstate1}"
+        	if (currentpowerstate1 == "1") {
+    			sendEvent(name: "switch", value: "on")
+        	}
+        	else if (currentpowerstate1 == "0") {
+   				sendEvent(name: "switch", value: "off")
+        	}
+        }
+
+        //update firmware version
+        def appfwversion = properties["appfwversion"].value
+        if (appfwversion != null){
+        	log.info "Updating ${device.displayName}: property appfwversion set to value: ${appfwversion}"
+            appfwversion = "${appfwversion}"
+   			sendEvent(name: "firmware", value: appfwversion)
+        }
+
+		//update model
+    	log.info "Updating ${device.displayName}: property model set to value: iSP6"
+    	sendEvent(name:"model", value:"iSP6")
+
+    } else { //the plug is not connected
+        //update status message
+      	sendEvent(name: "status", value: parent.getPlugNotConnectedMessage())
+      	log.info "Updating ${device.displayName}: property status set to: ${parent.getPlugNotConnectedMessage()}"
+    }
+}
+
+// Process the polling error, changing the status message
+def pollError(){
+  	log.info "Error retrieving info from the cloud"
+	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+}
+
+/*
+* This method handles the switch.on function by updating the corresponding property in the cloud
+*/
+def on() {
+
+    //update the status of the plug before attempting to change it
+	refresh()
+
+	if (device.currentState("status")?.value == parent.getConnectedMessage()) {//only update if the plug is connected
+		//Turn on if the device is off
+		if (device.currentState("switch")?.value.toLowerCase().startsWith("off")){
+       		log.info "Updating ${device.displayName} in the cloud: sending action _turnOn"
+
+            def actionJSON = "{\"thng\":\"${device.deviceNetworkId}\", \"type\":\"_turnOn\"}"
+    		def success = parent.sendAction("_turnOn", actionJSON)
+
+        	if(success){
+        		log.info "Updating ${device.displayName}: sending switch.on command"
+ 				sendEvent(name: "switch", value: "on")
+            	sendEvent(name: "status", value: parent.getConnectedMessage())
+        	} else {
+        		log.info "Cloud property update error, skipping event"
+            	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+        	}
+    	}
+    }
+}
+
+/*
+* This method handles the switch.off function by updating the corresponding property in the cloud
+*/
+def off() {
+
+    //update the status of the plug before attempting to change it
+	refresh()
+
+	if (device.currentState("status")?.value == parent.getConnectedMessage()) {//only update if the plug is connected
+
+		//Turn off only if the device is on
+		if (device.currentState("switch")?.value.toLowerCase().startsWith("on")){
+        	log.info "Updating ${device.displayName} in the cloud: sending action _turnOff"
+
+            def actionJSON = "{\"thng\":\"${device.deviceNetworkId}\", \"type\":\"_turnOff\"}"
+	    	def success = parent.sendAction("_turnOff", actionJSON)
+
+        	if (success) {
+	    		log.info "Updating ${device.displayName}: sending switch.off command"
+    			sendEvent(name: "switch", value: "off")
+            	sendEvent(name: "status", value: parent.getConnectedMessage())
+        	} else {
+        		log.info "Cloud property update error, skipping event"
+            	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+        	}
+   		}
+   }
+}
+
+/*
+* This method handles the refresh capability
+*/
+def refresh() {
+    parent.pollChildren(device.deviceNetworkId)
+}
+
+def ping() {
+	refresh()
+}

devicetypes/ihome-devices/ihomesmartplug-isp6x.src/ihomesmartplug-isp6x.groovy

@@ -0,0 +1,201 @@
+/**
+ *  iHomeSmartPlug iSP6X
+ *
+ *  Copyright 2016 EVRYTHNG LTD
+ *
+ *  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.
+ *
+ * Last reviewed:20.07.2017
+ *   - Added capabilities: Health Check, Outlet, Light
+ *   - Added ocfDeviceType
+ *   - Changed background colour of tiles
+ *   - Added lifecycle functions
+ *   - Added ping method
+ */
+import groovy.json.JsonOutput
+
+metadata {
+	definition (name: "iHomeSmartPlug-iSP6X", namespace: "ihome_devices", author: "iHome", ocfDeviceType: "oic.d.smartplug") {
+		capability "Actuator" 	//The device is an actuator (provides actions)
+        capability "Sensor"		//The device s a sensor (provides properties)
+   		capability "Refresh"    //Enable the refresh by the user
+
+		capability "Switch"     //Device complies to the SmartThings switch capability
+
+		capability "Health Check"
+        capability "Outlet"     //Needed for Google Home
+        capability "Light"      //Needed for Google Home
+
+        attribute "firmware","string" //Mapping the custom property firmware
+        attribute "model","string"    //Mapping the custom property model (model of the plug)
+        attribute "status", "string" //Mapping the status of the last call to the cloud
+
+	}
+
+	tiles(scale: 2){
+
+    	multiAttributeTile(name:"control", type:"generic", width:6, height:4) {
+        	tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+       			attributeState( "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "off")
+                attributeState( "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00A0DC", nextState: "on")
+			}
+			tileAttribute ("device.status", key: "SECONDARY_CONTROL") {
+				attributeState "status", label:'${currentValue}'
+			}
+        }
+
+        standardTile("refresh", "device.refresh", width:2, height:2, inactiveLabel: false, decoration: "flat") {
+			state ("default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh")
+		}
+        valueTile("firmware", "device.firmware", width:2, height:2, decoration: "flat") {
+        	state "firmware", label:'Firmware v${currentValue}'
+    	}
+        valueTile("model", "device.model", width:2, height:2, decoration: "flat") {
+        	state "model", label:'${currentValue}'
+    	}
+		main (["control"])
+		details (["control","refresh","firmware","model"])
+	}
+}
+
+def initialize() {
+	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "cloud", scheme:"untracked"]), displayed: false)
+}
+
+def installed() {
+	log.debug "installed()"
+	initialize()
+}
+
+def updated() {
+	log.debug "updated()"
+	initialize()
+}
+
+/*
+* This method creates the internal SmartThings events to handle changes in the properties of the plug
+*/
+def updateProperties(Map properties) {
+
+	log.debug "Updating plug's properties: ${properties}"
+
+    def connected = (properties["~connected"]?.value == true)
+
+    if (connected == true){ //only update if plug is connected
+
+        //update status message
+  	    sendEvent(name: "status", value: parent.getConnectedMessage())
+       	log.info "Updating ${device.displayName}: property status set to: ${parent.getConnectedMessage()}"
+
+		//update currentpowerstate1
+        def currentpowerstate1 = properties["currentpowerstate1"].value
+        if (currentpowerstate1 != null){
+        	log.info "Updating ${device.displayName}: property currentpowerstate1 set to value: ${currentpowerstate1}"
+            currentpowerstate1 = "${currentpowerstate1}"
+        	if (currentpowerstate1 == "1") {
+    			sendEvent(name: "switch", value: "on")
+        	}
+        	else if (currentpowerstate1 == "0") {
+   				sendEvent(name: "switch", value: "off")
+        	}
+        }
+
+        //update firmware version
+        def appfwversion = properties["appfwversion"].value
+        if (appfwversion != null){
+        	log.info "Updating ${device.displayName}: property appfwversion set to value: ${appfwversion}"
+            appfwversion = "${appfwversion}"
+   			sendEvent(name: "firmware", value: appfwversion)
+        }
+
+		//update model
+    	log.info "Updating ${device.displayName}: property model set to value: iSP6X"
+    	sendEvent(name:"model", value:"iSP6X")
+
+    } else { //the plug is not connected
+        //update status message
+      	sendEvent(name: "status", value: parent.getPlugNotConnectedMessage())
+      	log.info "Updating ${device.displayName}: property status set to: ${parent.getPlugNotConnectedMessage()}"
+    }
+}
+
+// Process the polling error, changing the status message
+def pollError(){
+  	log.info "Error retrieving info from the cloud"
+	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+}
+
+/*
+* This method handles the switch.on function by updating the corresponding property in the cloud
+*/
+def on() {
+
+    //update the status of the plug before attempting to change it
+	refresh()
+
+	if (device.currentState("status")?.value == parent.getConnectedMessage()) {//only update if the plug is connected
+		//Turn on if the device is off
+		if (device.currentState("switch")?.value.toLowerCase().startsWith("off")){
+       		log.info "Updating ${device.displayName} in the cloud: sending action _turnOn"
+
+            def actionJSON = "{\"thng\":\"${device.deviceNetworkId}\", \"type\":\"_turnOn\"}"
+    		def success = parent.sendAction("_turnOn", actionJSON)
+
+        	if(success){
+        		log.info "Updating ${device.displayName}: sending switch.on command"
+ 				sendEvent(name: "switch", value: "on")
+            	sendEvent(name: "status", value: parent.getConnectedMessage())
+        	} else {
+        		log.info "Cloud property update error, skipping event"
+            	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+        	}
+    	}
+    }
+}
+
+/*
+* This method handles the switch.off function by updating the corresponding property in the cloud
+*/
+def off() {
+
+    //update the status of the plug before attempting to change it
+	refresh()
+
+	if (device.currentState("status")?.value == parent.getConnectedMessage()) {//only update if the plug is connected
+
+		//Turn off only if the device is on
+		if (device.currentState("switch")?.value.toLowerCase().startsWith("on")){
+        	log.info "Updating ${device.displayName} in the cloud: sending action _turnOff"
+
+            def actionJSON = "{\"thng\":\"${device.deviceNetworkId}\", \"type\":\"_turnOff\"}"
+	    	def success = parent.sendAction("_turnOff", actionJSON)
+
+        	if (success) {
+	    		log.info "Updating ${device.displayName}: sending switch.off command"
+    			sendEvent(name: "switch", value: "off")
+            	sendEvent(name: "status", value: parent.getConnectedMessage())
+        	} else {
+        		log.info "Cloud property update error, skipping event"
+            	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+        	}
+   		}
+   }
+}
+
+/*
+* This method handles the refresh capability
+*/
+def refresh() {
+    parent.pollChildren(device.deviceNetworkId)
+}
+
+def ping() {
+	refresh()
+}

devicetypes/ihome-devices/ihomesmartplug-isp8.src/ihomesmartplug-isp8.groovy

@@ -0,0 +1,201 @@
+/**
+ *  iHomeSmartPlug iSP8
+ *
+ *  Copyright 2016 EVRYTHNG LTD
+ *
+ *  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.
+ *
+ * Last reviewed:20.07.2017
+ *   - Added capabilities: Health Check, Outlet, Light
+ *   - Added ocfDeviceType
+ *   - Changed background colour of tiles
+ *   - Added lifecycle functions
+ *   - Added ping method
+ */
+import groovy.json.JsonOutput
+
+metadata {
+	definition (name: "iHomeSmartPlug-iSP8", namespace: "ihome_devices", author: "iHome", ocfDeviceType: "oic.d.smartplug") {
+		capability "Actuator" 	//The device is an actuator (provides actions)
+        capability "Sensor"		//The device s a sensor (provides properties)
+   		capability "Refresh"    //Enable the refresh by the user
+
+		capability "Switch"     //Device complies to the SmartThings switch capability
+
+		capability "Health Check"
+        capability "Outlet"     //Needed for Google Home
+        capability "Light"      //Needed for Google Home
+
+        attribute "firmware","string" //Mapping the custom property firmware
+        attribute "model","string"    //Mapping the custom property model (model of the plug)
+        attribute "status", "string" //Mapping the status of the last call to the cloud
+
+	}
+
+	tiles(scale: 2){
+
+    	multiAttributeTile(name:"control", type:"generic", width:6, height:4) {
+        	tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+       		attributeState( "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "off")
+              attributeState( "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00A0DC", nextState: "on")
+			}
+			tileAttribute ("device.status", key: "SECONDARY_CONTROL") {
+				attributeState "status", label:'${currentValue}'
+			}
+        }
+
+        standardTile("refresh", "device.refresh", width:2, height:2, inactiveLabel: false, decoration: "flat") {
+			state ("default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh")
+		}
+        valueTile("firmware", "device.firmware", width:2, height:2, decoration: "flat") {
+        	state "firmware", label:'Firmware v${currentValue}'
+    	}
+        valueTile("model", "device.model", width:2, height:2, decoration: "flat") {
+        	state "model", label:'${currentValue}'
+    	}
+		main (["control"])
+		details (["control","refresh","firmware","model"])
+	}
+}
+
+def initialize() {
+	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "cloud", scheme:"untracked"]), displayed: false)
+}
+
+def installed() {
+	log.debug "installed()"
+	initialize()
+}
+
+def updated() {
+	log.debug "updated()"
+	initialize()
+}
+
+/*
+* This method creates the internal SmartThings events to handle changes in the properties of the plug
+*/
+def updateProperties(Map properties) {
+
+	log.debug "Updating plug's properties: ${properties}"
+
+    def connected = (properties["~connected"]?.value == true)
+
+    if (connected == true){ //only update if plug is connected
+
+        //update status message
+  	    sendEvent(name: "status", value: parent.getConnectedMessage())
+       	log.info "Updating ${device.displayName}: property status set to: ${parent.getConnectedMessage()}"
+
+		//update currentpowerstate1
+        def currentpowerstate1 = properties["currentpowerstate1"].value
+        if (currentpowerstate1 != null){
+        	log.info "Updating ${device.displayName}: property currentpowerstate1 set to value: ${currentpowerstate1}"
+            currentpowerstate1 = "${currentpowerstate1}"
+        	if (currentpowerstate1 == "1") {
+    			sendEvent(name: "switch", value: "on")
+        	}
+        	else if (currentpowerstate1 == "0") {
+   				sendEvent(name: "switch", value: "off")
+        	}
+        }
+
+        //update firmware version
+        def appfwversion = properties["appfwversion"].value
+        if (appfwversion != null){
+        	log.info "Updating ${device.displayName}: property appfwversion set to value: ${appfwversion}"
+            appfwversion = "${appfwversion}"
+   			sendEvent(name: "firmware", value: appfwversion)
+        }
+
+		//update model
+    	log.info "Updating ${device.displayName}: property model set to value: iSP8"
+    	sendEvent(name:"model", value:"iSP8")
+
+    } else { //the plug is not connected
+        //update status message
+      	sendEvent(name: "status", value: parent.getPlugNotConnectedMessage())
+      	log.info "Updating ${device.displayName}: property status set to: ${parent.getPlugNotConnectedMessage()}"
+    }
+}
+
+// Process the polling error, changing the status message
+def pollError(){
+  	log.info "Error retrieving info from the cloud"
+	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+}
+
+/*
+* This method handles the switch.on function by updating the corresponding property in the cloud
+*/
+def on() {
+
+    //update the status of the plug before attempting to change it
+	refresh()
+
+	if (device.currentState("status")?.value == parent.getConnectedMessage()) {//only update if the plug is connected
+		//Turn on if the device is off
+		if (device.currentState("switch")?.value.toLowerCase().startsWith("off")){
+       		log.info "Updating ${device.displayName} in the cloud: sending action _turnOn"
+
+            def actionJSON = "{\"thng\":\"${device.deviceNetworkId}\", \"type\":\"_turnOn\"}"
+    		def success = parent.sendAction("_turnOn", actionJSON)
+
+        	if(success){
+        		log.info "Updating ${device.displayName}: sending switch.on command"
+ 				sendEvent(name: "switch", value: "on")
+            	sendEvent(name: "status", value: parent.getConnectedMessage())
+        	} else {
+        		log.info "Cloud property update error, skipping event"
+            	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+        	}
+    	}
+    }
+}
+
+/*
+* This method handles the switch.off function by updating the corresponding property in the cloud
+*/
+def off() {
+
+    //update the status of the plug before attempting to change it
+	refresh()
+
+	if (device.currentState("status")?.value == parent.getConnectedMessage()) {//only update if the plug is connected
+
+		//Turn off only if the device is on
+		if (device.currentState("switch")?.value.toLowerCase().startsWith("on")){
+        	log.info "Updating ${device.displayName} in the cloud: sending action _turnOff"
+
+            def actionJSON = "{\"thng\":\"${device.deviceNetworkId}\", \"type\":\"_turnOff\"}"
+	    	def success = parent.sendAction("_turnOff", actionJSON)
+
+        	if (success) {
+	    		log.info "Updating ${device.displayName}: sending switch.off command"
+    			sendEvent(name: "switch", value: "off")
+            	sendEvent(name: "status", value: parent.getConnectedMessage())
+        	} else {
+        		log.info "Cloud property update error, skipping event"
+            	sendEvent(name: "status", value: parent.getConnectionErrorMessage())
+        	}
+   		}
+   }
+}
+
+/*
+* This method handles the refresh capability
+*/
+def refresh() {
+    parent.pollChildren(device.deviceNetworkId)
+}
+
+def ping() {
+	refresh()
+}

devicetypes/johnrucker/coopboss-h3vx.src/coopboss-h3vx.groovy

@@ -95,12 +95,12 @@ metadata {
 		multiAttributeTile(name:"doorCtrl", type:"generic", width:6, height:4) {tileAttribute("device.doorState", key: "PRIMARY_CONTROL") 
         	{  
 			attributeState "unknown", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", nextState:"Sent"          
-			attributeState "open", label: '${name}', action:"closeDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#0000ff" , nextState:"Sent" 
-			attributeState "opening", label: '${name}', action:"closeDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ffa81e"            
-			attributeState "closed", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#79b821", nextState:"Sent" 
-			attributeState "closing", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ffa81e" 
-			attributeState "jammed", label: '${name}', action:"closeDoorHiI", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff0000", nextState:"Sent" 
-			attributeState "forced close", label: 'forced\rclose', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff8000", nextState:"Sent"   
+			attributeState "open", label: '${name}', action:"closeDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#00A0DC" , nextState:"Sent"
+			attributeState "opening", label: '${name}', action:"closeDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#00A0DC"
+			attributeState "closed", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ffffff", nextState:"Sent"
+			attributeState "closing", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ffffff"
+			attributeState "jammed", label: '${name}', action:"closeDoorHiI", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff0000", nextState:"Sent"
+			attributeState "forced close", label: 'forced\rclose', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff8000", nextState:"Sent"
 			attributeState "fault", label: 'FAULT', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff0000", nextState:"Sent"              
 			attributeState "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"              
 			} 
@@ -135,13 +135,13 @@ metadata {
     	}        
         
 		standardTile("autoClose", "device.autoCloseEnable", width: 2, height: 2){
-			state "on", label: 'Auto', action:"autoCloseOff", icon: "st.doors.garage.garage-closing", backgroundColor: "#79b821", nextState:"Sent"
+			state "on", label: 'Auto', action:"autoCloseOff", icon: "st.doors.garage.garage-closing", backgroundColor: "#00A0DC", nextState:"Sent"
 			state "off", label: 'Auto', action:"autoCloseOn", icon: "st.doors.garage.garage-closing", nextState:"Sent"
 			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"              
 		}    
         
 		standardTile("autoOpen", "device.autoOpenEnable", width: 2, height: 2){
-			state "on", label: 'Auto', action:"autoOpenOff", icon: "st.doors.garage.garage-opening", backgroundColor: "#79b821", nextState:"Sent"
+			state "on", label: 'Auto', action:"autoOpenOff", icon: "st.doors.garage.garage-opening", backgroundColor: "#00A0DC", nextState:"Sent"
 			state "off", label: 'Auto', action:"autoOpenOn", icon: "st.doors.garage.garage-opening", nextState:"Sent"
 			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"              
 		}            
@@ -189,13 +189,13 @@ metadata {
         
 		standardTile("aux1", "device.Aux1", width: 2, height: 2, canChangeIcon: true) {
 			state "off", label:'Aux 1', action:"Aux1On", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"Sent"        
-			state "on", label:'Aux 1', action:"Aux1Off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"Sent"
+			state "on", label:'Aux 1', action:"Aux1Off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"Sent"
 			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"            
 		}        
         
 		standardTile("aux2", "device.Aux2", width: 2, height: 2, canChangeIcon: true) {
 			state "off", label:'Aux 2', action:"Aux2On", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"Sent"        
-			state "on", label:'Aux 2', action:"Aux2Off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"Sent"
+			state "on", label:'Aux 2', action:"Aux2Off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"Sent"
 			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"   
 		}            
         

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/.st-ignore

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

devicetypes/smartthings/aeon-key-fob.src/README.md

@@ -0,0 +1,34 @@
+# Aeon Labs Key Fob
+
+Cloud Execution
+
+Works with:
+
+* [Aeon Labs Key Fob](http://aeotec.com/z-wave-key-fob-remote-control)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Actuator** - represents device has commands
+* **Button** - represents a device with one or more buttons
+* **Holdable Button** - represents a device with one or more holdable buttons
+* **Configuration** - allows for configuration of devices
+* **Sensor** - detects sensor events
+* **Battery** - defines device uses a battery
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+Aeon Key Fob is a ZWave totally sleepy device and is marked offline only in the case when Hub is offline.
+
+## Troubleshooting
+
+If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the sensor is out of range.
+Pairing needs to be tried again by placing the sensor closer to the hub.
+Instructions related to pairing, resetting and removing the Aeon Labs Key Fob from SmartThings can be found in the following link:
+* [Aeotec Key Fob Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/202294120-Aeon-Labs-Key-Fob)

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

@@ -1,3 +1,4 @@
+import groovy.json.JsonOutput
 /**
  *  Copyright 2015 SmartThings
  *
@@ -19,8 +20,10 @@ metadata {
 		capability "Configuration"
 		capability "Sensor"
 		capability "Battery"
+		capability "Health Check"
 
 		fingerprint deviceId: "0x0101", inClusters: "0x86,0x72,0x70,0x80,0x84,0x85"
+		fingerprint mfr: "0086", prod: "0001", model: "0026", deviceJoinName: "Aeon Panic Button"
 	}
 
 	simulator {
@@ -130,5 +133,15 @@ def updated() {
 }
 
 def initialize() {
-	sendEvent(name: "numberOfButtons", value: 4)
+	// Device only goes OFFLINE when Hub is off
+	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "zwave", scheme:"untracked"]), displayed: false)
+
+	def zwMap = getZwaveInfo()
+	def buttons = 4 // Default for Key Fob
+
+	// Only one button for Aeon Panic Button
+	if (zwMap && zwMap.mfr == "0086" && zwMap.prod == "0001" && zwMap.model == "0026") {
+		buttons = 1
+	}
+	sendEvent(name: "numberOfButtons", value: buttons)
 }

devicetypes/smartthings/aeon-minimote.src/.st-ignore

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

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

@@ -0,0 +1,33 @@
+# Aeon Minimote
+
+Cloud Execution
+
+Works with: 
+
+* [Aeotec Minimote](http://aeotec.com/small-z-wave-remote-control)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Actuator** - represents device has commands
+* **Button** - represents a device with one or more buttons
+* **Holdable Button** - represents a device with one or more holdable buttons
+* **Configuration** - allows for configuration of devices
+* **Sensor** - detects sensor events
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+Aeon Minimote is a ZWave totally sleepy device and is marked offline only in the case when Hub is offline.
+
+## Troubleshooting
+
+If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the sensor is out of range.
+Pairing needs to be tried again by placing the sensor closer to the hub.
+Instructions related to pairing, resetting and removing the Aeotec Minimote from SmartThings can be found in the following link:
+* [Aeotec Minimote Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/202087904-Aeotec-Minimote)

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

@@ -1,3 +1,4 @@
+import groovy.json.JsonOutput
 /**
  *  Copyright 2015 SmartThings
  *
@@ -18,6 +19,7 @@ metadata {
 		capability "Holdable Button"
 		capability "Configuration"
 		capability "Sensor"
+		capability "Health Check"
 
 		fingerprint deviceId: "0x0101", inClusters: "0x86,0x72,0x70,0x9B", outClusters: "0x26,0x2B"
 		fingerprint deviceId: "0x0101", inClusters: "0x86,0x72,0x70,0x9B,0x85,0x84", outClusters: "0x26" // old style with numbered buttons
@@ -109,7 +111,6 @@ def configure() {
 	return cmds
 }
 
-
 def installed() {
 	initialize()
 }
@@ -119,5 +120,7 @@ def updated() {
 }
 
 def initialize() {
+	// Device only goes OFFLINE when Hub is off
+	sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "zwave", scheme:"untracked"]), displayed: false)
 	sendEvent(name: "numberOfButtons", value: 4)
 }

devicetypes/smartthings/aeon-multisensor-6.src/.st-ignore

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

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

@@ -0,0 +1,39 @@
+# Aeon Multisensor 6
+
+Cloud Execution
+
+Works with: 
+
+* [Aeon Labs MultiSensor 6](https://www.smartthings.com/products/aeon-labs-multisensor-6)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Motion Sensor** - can detect motion
+* **Temperature Measurement** - defines device measures current temperature
+* **Relative Humidity Measurement** - allow reading the relative humidity from devices that support it
+* **Illuminance Measurement** - gives the illuminance reading from devices that support it
+* **Ultraviolet Index** - gives the ability to get the ultraviolet index from devices that report it
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Sensor** - detects sensor events
+* **Battery** - defines device uses a battery
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+Aeon Labs MultiSensor 6 is polled by the hub.
+Aeon MultiSensor reports in once every hour.
+
+* __122min__ checkInterval
+
+## 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:
+* [Aeon Labs MultiSensor 6 Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/206157226)

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

@@ -22,6 +22,7 @@ metadata {
 		capability "Configuration"
 		capability "Sensor"
 		capability "Battery"
+		capability "Health Check"
 
 		attribute "tamper", "enum", ["detected", "clear"]
 		attribute "batteryStatus", "string"
@@ -29,6 +30,7 @@ metadata {
 
 		fingerprint deviceId: "0x2101", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x7A", outClusters: "0x5A"
 		fingerprint deviceId: "0x2101", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x7A,0x5A"
+		fingerprint mfr:"0086", prod:"0102", model:"0064", deviceJoinName: "Aeon Labs MultiSensor 6"
 	}
 
 	simulator {
@@ -103,7 +105,7 @@ metadata {
 		}
 
 		valueTile("illuminance", "device.illuminance", inactiveLabel: false, width: 2, height: 2) {
-			state "illuminance", label:'${currentValue} ${unit}', unit:"lux"
+			state "illuminance", label:'${currentValue} lux', unit:""
 		}
 
 		valueTile("ultravioletIndex", "device.ultravioletIndex", inactiveLabel: false, width: 2, height: 2) {
@@ -127,7 +129,14 @@ metadata {
 	}
 }
 
+def installed(){
+// Device-Watch simply pings if no device events received for 122min(checkInterval)
+	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 122min(checkInterval)
+	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")}"
 
@@ -326,6 +335,13 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	createEvent(descriptionText: cmd.toString(), isStateChange: false)
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	secure(zwave.batteryV1.batteryGet())
+}
+
 def configure() {
 	// This sensor joins as a secure device if you double-click the button to include it
 	log.debug "${device.displayName} is configuring its settings"
@@ -410,4 +426,4 @@ private command(physicalgraph.zwave.Command cmd) {
 private commands(commands, delay=200) {
 	log.info "sending commands: ${commands}"
 	delayBetween(commands.collect{ command(it) }, delay)
-}
+}

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.
-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.
+Aeon MultiSensor Gen5 reports in once every hour.
 
-* __32min__ checkInterval
+* __122min__ checkInterval
 
 ## Troubleshooting
 

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

@@ -22,8 +22,6 @@ metadata {
 		capability "Battery"
 		capability "Health Check"
 
-		command "configureAfterSecure"
-
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x98,0x7A", outClusters:"0x5A"
 		fingerprint mfr:"0086", prod:"0102", model:"004A", deviceJoinName: "Aeon Labs MultiSensor (Gen 5)"
 	}
@@ -86,28 +84,28 @@ metadata {
 			state "humidity", label:'${currentValue}% humidity', unit:""
 		}
 		valueTile("illuminance", "device.illuminance", inactiveLabel: false, width: 2, height: 2) {
-			state "luminosity", label:'${currentValue} ${unit}', unit:"lux"
+			state "luminosity", label:'${currentValue} lux', unit:""
 		}
 		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
 			state "battery", label:'${currentValue}% battery', unit:""
 		}
-        standardTile("configureAfterSecure", "device.configure", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "configure", label:'', action:"configureAfterSecure", icon:"st.secondary.configure"
+		standardTile("configure", "device.configure", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "configure", label:'', action:"configure", icon:"st.secondary.configure"
 		}
 
 		main(["motion", "temperature", "humidity", "illuminance"])
-		details(["motion", "temperature", "humidity", "illuminance", "battery", "configureAfterSecure"])
+		details(["motion", "temperature", "humidity", "illuminance", "battery", "configure"])
 	}
 }
 
 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)
@@ -131,8 +129,8 @@ def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd)
 
 	if (!isConfigured()) {
 		// we're still in the process of configuring a newly joined device
-		log.debug("not sending wakeUpNoMoreInformation yet")
-        result += response(configureAfterSecure())
+		log.debug("not sending wakeUpNoMoreInformation yet: late configure")
+		result += response(configure())
 	} else {
 		result += response(zwave.wakeUpV1.wakeUpNoMoreInformation())
 	}
@@ -150,11 +148,6 @@ def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulat
 	}
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityCommandsSupportedReport cmd) {
-    // log.debug "Received SecurityCommandsSupportedReport"
-	response(configureAfterSecure())
-}
-
 def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
 	def map = [ name: "battery", unit: "%" ]
 	if (cmd.batteryLevel == 0xFF) {
@@ -226,36 +219,6 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	createEvent(descriptionText: cmd.toString(), isStateChange: false)
 }
 
-def configureAfterSecure() {
-    // log.debug "configureAfterSecure()"
-
-    def request = [
-		// send temperature, humidity, and illuminance every 8 minutes
-		zwave.configurationV1.configurationSet(parameterNumber: 101, size: 4, scaledConfigurationValue: 128|64|32),
-		zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: 8*60),
-
-		// send battery every 20 hours
-		zwave.configurationV1.configurationSet(parameterNumber: 102, size: 4, scaledConfigurationValue: 1),
-		zwave.configurationV1.configurationSet(parameterNumber: 112, size: 4, scaledConfigurationValue: 20*60*60),
-
-		// send no-motion report 60 seconds after motion stops
-		zwave.configurationV1.configurationSet(parameterNumber: 3, size: 2, scaledConfigurationValue: 60),
-
-		// send binary sensor report instead of basic set for motion
-		zwave.configurationV1.configurationSet(parameterNumber: 5, size: 1, scaledConfigurationValue: 2),
-
-		// disable notification-style motion events
-		zwave.notificationV3.notificationSet(notificationType: 7, notificationStatus: 0),
-
-		zwave.batteryV1.batteryGet(),
-		zwave.sensorBinaryV2.sensorBinaryGet(sensorType:0x0C)
-    ]
-	
-    setConfigured()
-	
-    secureSequence(request) + ["delay 20000", zwave.wakeUpV1.wakeUpNoMoreInformation().format()]
-}
-
 /**
  * PING is used by Device-Watch in attempt to reach the Device
  * */
@@ -265,7 +228,36 @@ def ping() {
 
 def configure() {
 	// log.debug "configure()"
-    //["delay 30000"] + secure(zwave.securityV1.securityCommandsSupportedGet())
+	def request = []
+	// send temperature, humidity, and illuminance every 8 minutes
+	request << zwave.configurationV1.configurationSet(parameterNumber: 101, size: 4, scaledConfigurationValue: 128|64|32)
+	request << zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: 8*60)
+
+	// send battery every 20 hours
+	request << zwave.configurationV1.configurationSet(parameterNumber: 102, size: 4, scaledConfigurationValue: 1)
+	request << zwave.configurationV1.configurationSet(parameterNumber: 112, size: 4, scaledConfigurationValue: 20*60*60)
+
+	// send no-motion report 60 seconds after motion stops
+	request << zwave.configurationV1.configurationSet(parameterNumber: 3, size: 2, scaledConfigurationValue: 60)
+
+	// send binary sensor report instead of basic set for motion
+	request << zwave.configurationV1.configurationSet(parameterNumber: 5, size: 1, scaledConfigurationValue: 2)
+
+	// Turn on the Multisensor Gen5 PIR sensor
+	request << zwave.configurationV1.configurationSet(parameterNumber: 4, size: 1, scaledConfigurationValue: 1)
+
+	// disable notification-style motion events
+	request << zwave.notificationV3.notificationSet(notificationType: 7, notificationStatus: 0)
+
+	request << zwave.batteryV1.batteryGet()
+	request << zwave.sensorBinaryV2.sensorBinaryGet(sensorType: 0x0C) //motion
+	request << zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 0x01) //temperature
+	request << zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 0x03) //illuminance
+	request << zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 0x05) //humidity
+
+	setConfigured()
+
+	secureSequence(request) + ["delay 20000", zwave.wakeUpV1.wakeUpNoMoreInformation().format()]
 }
 
 private setConfigured() {
@@ -282,5 +274,4 @@ private secure(physicalgraph.zwave.Command cmd) {
 
 private secureSequence(commands, delay=200) {
 	delayBetween(commands.collect{ secure(it) }, delay)
-}
-
+}

devicetypes/smartthings/aeon-multisensor.src/.st-ignore

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

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

@@ -0,0 +1,44 @@
+# Aeon Multisensor
+
+Cloud Execution
+
+Works with: 
+
+* [Aeotec MultiSensor (DSB05-ZWUS)](https://www.smartthings.com/products/aeotec-multisensor-5)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Battery](#battery-specification)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Motion Sensor** - can detect motion
+* **Temperature Measurement** - defines device measures current temperature
+* **Relative Humidity Measurement** - allow reading the relative humidity from devices that support it
+* **Illuminance Measurement** - gives the illuminance reading from devices that support it
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Sensor** - detects sensor events
+* **Battery** - defines device uses a battery
+* **Health Check** - indicates ability to get device health notifications
+
+
+## Device Health
+
+Aeon Labs MultiSensor is polled by the hub.
+Aeon MultiSensor reports in once every hour.
+
+* __122min__ checkInterval
+
+## Battery Specification
+
+Four AAA 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:
+* [Aeon MultiSensor Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/206157226-How-to-connect-Aeon-Labs-MultiSensors)

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

@@ -20,6 +20,7 @@ metadata {
 		capability "Illuminance Measurement"
 		capability "Sensor"
 		capability "Battery"
+		capability "Health Check"
 
 		fingerprint deviceId: "0x2001", inClusters: "0x30,0x31,0x80,0x84,0x70,0x85,0x72,0x86"
 	}
@@ -79,7 +80,7 @@ metadata {
 			state "humidity", label:'${currentValue}% humidity', unit:""
 		}
 		valueTile("illuminance", "device.illuminance", inactiveLabel: false, width: 2, height: 2) {
-			state "luminosity", label:'${currentValue} ${unit}', unit:"lux"
+			state "luminosity", label:'${currentValue} lux', unit:""
 		}
 		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
 			state "battery", label:'${currentValue}% battery', unit:""
@@ -93,6 +94,16 @@ metadata {
 	}
 }
 
+def installed(){
+// Device-Watch simply pings if no device events received for 32min(checkInterval)
+	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 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+}
+
 // Parse incoming device messages to generate events
 def parse(String description)
 {
@@ -179,6 +190,13 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	[:]
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	secure(zwave.batteryV1.batteryGet())
+}
+
 def configure() {
 	delayBetween([
 		// send binary sensor report instead of basic set for motion
@@ -193,4 +211,4 @@ def configure() {
 		// set data reporting period to 5 minutes
 		zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: 300).format()
 	])
-}
+}

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

@@ -16,7 +16,7 @@
  *	Date: 2014-07-15
  */
 metadata {
- definition (name: "Aeon Siren", namespace: "smartthings", author: "SmartThings") {
+ definition (name: "Aeon Siren", namespace: "smartthings", author: "SmartThings", ocfDeviceType: "x.com.st.d.sensor.smoke") {
 	capability "Actuator"
 	capability "Alarm"
 	capability "Switch"
@@ -61,6 +61,8 @@ 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(secure(zwave.basicV1.basicGet()))
 }
 
 def updated() {
@@ -163,4 +165,4 @@ private secure(physicalgraph.zwave.Command cmd) {
  * */
 def ping() {
 	secure(zwave.basicV1.basicGet())
-}
+}

devicetypes/smartthings/bose-soundtouch.src/bose-soundtouch.groovy

@@ -1,3 +1,5 @@
+//DEPRECATED. INTEGRATION MOVED TO SUPER LAN CONNECT
+
 /**
  *  Bose SoundTouch
  *

devicetypes/smartthings/dimmer-switch.src/dimmer-switch.groovy

@@ -108,11 +108,20 @@ def updated(){
     }
 }
 
+def getCommandClassVersions() {
+	[
+		0x20: 1,  // Basic
+		0x26: 1,  // SwitchMultilevel
+		0x56: 1,  // Crc16Encap
+		0x70: 1,  // Configuration
+	]
+}
+
 def parse(String description) {
 	def result = null
 	if (description != "updated") {
 		log.debug "parse() >> zwave.parse($description)"
-		def cmd = zwave.parse(description, [0x20: 1, 0x26: 1, 0x70: 1])
+		def cmd = zwave.parse(description, commandClassVersions)
 		if (cmd) {
 			result = zwaveEvent(cmd)
 		}
@@ -179,6 +188,16 @@ def zwaveEvent(physicalgraph.zwave.commands.switchmultilevelv1.SwitchMultilevelS
 	[createEvent(name:"switch", value:"on"), response(zwave.switchMultilevelV1.switchMultilevelGet().format())]
 }
 
+def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd) {
+	def versions = commandClassVersions
+	def version = versions[cmd.commandClass as Integer]
+	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
+	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
+	if (encapsulatedCommand) {
+		zwaveEvent(encapsulatedCommand)
+	}
+}
+
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	// Handles all Z-Wave commands we aren't interested in
 	[:]

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

@@ -70,7 +70,7 @@ metadata {
 			state "heat", action:"switchMode",  nextState: "updating", icon: "st.thermostat.heat"
 			state "cool", action:"switchMode",  nextState: "updating", icon: "st.thermostat.cool"
 			state "auto", action:"switchMode",  nextState: "updating", icon: "st.thermostat.auto"
-			state "emergency heat", action:"switchMode", icon: "st.thermostat.emergency-heat" // emergency heat = auxHeatOnly
+			state "auxheatonly", action:"switchMode", icon: "st.thermostat.emergency-heat"
 			state "updating", label:"Working", icon: "st.secondary.secondary"
 		}
 		standardTile("fanMode", "device.thermostatFanMode", inactiveLabel: false, decoration: "flat") {
@@ -156,47 +156,49 @@ void poll() {
 def generateEvent(Map results) {
 	log.debug "parsing data $results"
 	if(results) {
-		results.each { name, value ->
 
 			def linkText = getLinkText(device)
-			def isChange = false
-			def isDisplayed = true
+		def supportedThermostatModes = ["off"]
+		def thermostatMode = null
+
+		results.each { name, value ->
 			def event = [name: name, linkText: linkText, descriptionText: getThermostatDescriptionText(name, value, linkText),
 						 handlerName: name]
 
 			if (name=="temperature" || name=="heatingSetpoint" || name=="coolingSetpoint" ) {
 				def sendValue =  location.temperatureScale == "C"? roundC(convertFtoC(value.toDouble())) : value.toInteger()
-				isChange = isTemperatureStateChange(device, name, value.toString())
-				isDisplayed = isChange
-				event << [value: sendValue, unit: temperatureScale, isStateChange: isChange, displayed: isDisplayed]
+				event << [value: sendValue, unit: temperatureScale]
 			}  else if (name=="maxCoolingSetpoint" || name=="minCoolingSetpoint" || name=="maxHeatingSetpoint" || name=="minHeatingSetpoint") {
 				def sendValue =  location.temperatureScale == "C"? roundC(convertFtoC(value.toDouble())) : value.toInteger()
 				event << [value: sendValue, unit: temperatureScale, displayed: false]
 			}  else if (name=="heatMode" || name=="coolMode" || name=="autoMode" || name=="auxHeatMode"){
-				isChange = isStateChange(device, name, value.toString())
-				event << [value: value.toString(), isStateChange: isChange, displayed: false]
+				if (value == true) {
+					supportedThermostatModes << ((name == "auxHeatMode") ? "auxheatonly" : name - "Mode")
+				}
+				return // as we don't want to send this event here, proceed to next name/value pair
 			}  else if (name=="thermostatFanMode"){
-				isChange = isStateChange(device, name, value.toString())
-				event << [value: value.toString(), isStateChange: isChange, displayed: false]
+				sendEvent(name: "supportedThermostatFanModes", value: fanModes(), displayed: false)
+				event << [value: value.toString(), data:[supportedThermostatFanModes: fanModes()]]
 			}  else if (name=="humidity") {
-				isChange = isStateChange(device, name, value.toString())
-				event << [value: value.toString(), isStateChange: isChange, displayed: false, unit: "%"]
+				event << [value: value.toString(), displayed: false, unit: "%"]
 			} else if (name == "deviceAlive") {
-				isChange = isStateChange(device, name, value.toString())
-				event['isStateChange'] = isChange
 				event['displayed'] = false
 			} else if (name == "thermostatMode") {
-				def mode = value.toString()
-				mode = (mode == "auxHeatOnly") ? "emergency heat" : mode
-				isChange = isStateChange(device, name, mode)
-				event << [value: mode, isStateChange: isChange, displayed: isDisplayed]
+				thermostatMode = value.toLowerCase()
+				return // as we don't want to send this event here, proceed to next name/value pair
 			} else {
-				isChange = isStateChange(device, name, value.toString())
-				isDisplayed = isChange
-				event << [value: value.toString(), isStateChange: isChange, displayed: isDisplayed]
+				event << [value: value.toString()]
 			}
 			sendEvent(event)
 		}
+		if (state.supportedThermostatModes != supportedThermostatModes) {
+			state.supportedThermostatModes = supportedThermostatModes
+			sendEvent(name: "supportedThermostatModes", value: supportedThermostatModes, displayed: false)
+		}
+		if (thermostatMode) {
+			sendEvent(name: "thermostatMode", value: thermostatMode, data:[supportedThermostatModes:state.supportedThermostatModes], linkText: linkText,
+					descriptionText: getThermostatDescriptionText("thermostatMode", thermostatMode, linkText), handlerName: "thermostatMode")
+		}
 		generateSetpointEvent ()
 		generateStatusEvent ()
 	}
@@ -322,15 +324,7 @@ void resumeProgram() {
 }
 
 def modes() {
-	if (state.modes) {
-		log.debug "Modes = ${state.modes}"
-		return state.modes
-	}
-	else {
-		state.modes = parent.availableModes(this)
-		log.debug "Modes = ${state.modes}"
-		return state.modes
-	}
+	return state.supportedThermostatModes
 }
 
 def fanModes() {
@@ -413,11 +407,13 @@ def setThermostatFanMode(String mode) {
 }
 
 def generateModeEvent(mode) {
-	sendEvent(name: "thermostatMode", value: mode, descriptionText: "$device.displayName is in ${mode} mode", displayed: true)
+	sendEvent(name: "thermostatMode", value: mode, data:[supportedThermostatModes: state.supportedThermostatModes],
+			descriptionText: "$device.displayName is in ${mode} mode")
 }
 
 def generateFanModeEvent(fanMode) {
-	sendEvent(name: "thermostatFanMode", value: fanMode, descriptionText: "$device.displayName fan is in ${fanMode} mode", displayed: true)
+	sendEvent(name: "thermostatFanMode", value: fanMode, data:[supportedThermostatFanModes: fanModes()],
+			descriptionText: "$device.displayName fan is in ${fanMode} mode")
 }
 
 def generateOperatingStateEvent(operatingState) {
@@ -453,14 +449,14 @@ def heat() {
 }
 
 def emergencyHeat() {
-	auxHeatOnly()
+	auxheatonly()
 }
 
-def auxHeatOnly() {
-	log.debug "auxHeatOnly = emergency heat"
+def auxheatonly() {
+	log.debug "auxheatonly()"
 	def deviceId = device.deviceNetworkId.split(/\./).last()
 	if (parent.setMode ("auxHeatOnly", deviceId))
-		generateModeEvent("emergency heat") // emergency heat = auxHeatOnly
+		generateModeEvent("auxheatonly")
 	else {
 		log.debug "Error setting new mode."
 		def currentMode = device.currentState("thermostatMode")?.value
@@ -593,7 +589,7 @@ def generateSetpointEvent() {
 	} else if (mode == "off") {
 		sendEvent("name":"thermostatSetpoint", "value":averageSetpoint, "unit":location.temperatureScale)
 		sendEvent("name":"displayThermostatSetpoint", "value":"Off", displayed: false)
-	} else if (mode == "emergency heat") { // emergency heat = auxHeatOnly
+	} else if (mode == "auxheatonly") {
 		sendEvent("name":"thermostatSetpoint", "value":heatingSetpoint, "unit":location.temperatureScale)
 		sendEvent("name":"displayThermostatSetpoint", "value":heatingSetpoint, "unit":location.temperatureScale, displayed: false)
 	}
@@ -632,7 +628,7 @@ void raiseSetpoint() {
 		targetvalue = thermostatSetpoint ? thermostatSetpoint : 0
 		targetvalue = location.temperatureScale == "F"? targetvalue + 1 : targetvalue + 0.5
 
-		if ((mode == "heat" || mode == "emergency heat") && targetvalue > maxHeatingSetpoint) { // emergency heat = auxHeatOnly
+		if ((mode == "heat" || mode == "auxheatonly") && targetvalue > maxHeatingSetpoint) {
 			targetvalue = maxHeatingSetpoint
 		} else if (mode == "cool" && targetvalue > maxCoolingSetpoint) {
 			targetvalue = maxCoolingSetpoint
@@ -678,7 +674,7 @@ void lowerSetpoint() {
 		targetvalue = thermostatSetpoint ? thermostatSetpoint : 0
 		targetvalue = location.temperatureScale == "F"? targetvalue - 1 : targetvalue - 0.5
 
-		if ((mode == "heat" || mode == "emergency heat") && targetvalue < minHeatingSetpoint) { // emergency heat = auxHeatOnly
+		if ((mode == "heat" || mode == "auxheatonly") && targetvalue < minHeatingSetpoint) {
 			targetvalue = minHeatingSetpoint
 		} else if (mode == "cool" && targetvalue < minCoolingSetpoint) {
 			targetvalue = minCoolingSetpoint
@@ -719,7 +715,7 @@ void alterSetpoint(temp) {
 		}
 
 		//step1: check thermostatMode, enforce limits before sending request to cloud
-		if (mode == "heat" || mode == "emergency heat"){ // emergency heat = auxHeatOnly
+		if (mode == "heat" || mode == "auxheatonly"){
 			if (temp.value > coolingSetpoint){
 				targetHeatingSetpoint = temp.value
 				targetCoolingSetpoint = temp.value
@@ -754,7 +750,7 @@ void alterSetpoint(temp) {
 			log.debug "alterSetpoint in mode $mode succeed change setpoint to= ${temp.value}"
 		} else {
 			log.error "Error alterSetpoint()"
-			if (mode == "heat" || mode == "emergency heat"){ // emergency heat = auxHeatOnly
+			if (mode == "heat" || mode == "auxheatonly"){
 				sendEvent("name": "thermostatSetpoint", "value": heatingSetpoint.toString(), displayed: false)
 				sendEvent("name": "displayThermostatSetpoint", "value": heatingSetpoint.toString(), displayed: false)
 			} else if (mode == "cool") {
@@ -783,7 +779,7 @@ def generateStatusEvent() {
 	log.debug "Cooling set point = ${coolingSetpoint}"
 	log.debug "HVAC Mode = ${mode}"
 
-	if (mode == "heat") {
+	if (mode == "heat" || mode == "auxheatonly") {
 		if (temperature >= heatingSetpoint) {
 			statusText = "Right Now: Idle"
 		} else {
@@ -806,8 +802,6 @@ def generateStatusEvent() {
 		}
 	} else if (mode == "off") {
 		statusText = "Right Now: Off"
-	} else if (mode == "emergency heat") { // emergency heat = auxHeatOnly
-		statusText = "Emergency Heat"
 	} else {
 		statusText = "?"
 	}

devicetypes/smartthings/everspring-illuminance-sensor.src/everspring-illuminance-sensor.groovy

@@ -0,0 +1,163 @@
+/**
+ *  Copyright 2017 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.
+ *
+ *  Everspring ST815 Illuminance Sensor
+ *
+ *  Author: SmartThings
+ *  Date: 2017-3-4
+ */
+
+metadata {
+	definition (name: "Everspring Illuminance Sensor", namespace: "smartthings", author: "SmartThings") {
+		capability "Illuminance Measurement"
+		capability "Battery"
+		capability "Configuration"
+		capability "Sensor"
+		capability "Health Check"
+
+		fingerprint mfr:"0060", prod:"0007", model:"0001"
+	}
+
+	simulator {
+		for( int i = 0; i <= 100; i += 20 ) {
+			status "illuminace ${i} lux": new physicalgraph.zwave.Zwave().sensorMultilevelV2.sensorMultilevelReport(
+				scaledSensorValue: i, precision: 0, sensorType: 3, scale: 1).incomingMessage()
+		}
+
+		for( int i = 0; i <= 100; i += 20 ) {
+			status "battery ${i}%": new physicalgraph.zwave.Zwave().batteryV1.batteryReport(
+				batteryLevel: i).incomingMessage()
+		}
+
+		status "wakeup":  "command: 8407, payload: "
+	}
+
+	tiles(scale: 2) {
+		valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {
+			state "temperature", label:'${currentValue}°',
+			backgroundColors:[
+				[value: 32, color: "#153591"],
+				[value: 44, color: "#1e9cbb"],
+				[value: 59, color: "#90d2a7"],
+				[value: 74, color: "#44b621"],
+				[value: 84, color: "#f1d801"],
+				[value: 92, color: "#d04e00"],
+				[value: 98, color: "#bc2323"]
+			]
+		}
+		valueTile("humidity", "device.humidity", inactiveLabel: false, width: 2, height: 2) {
+			state "humidity", label:'${currentValue}% humidity', unit:""
+		}
+		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "battery", label:'${currentValue}% battery', unit:""
+		}
+
+		main( ["temperature", "humidity"] )
+		details( ["temperature", "humidity", "battery"] )
+	}
+}
+
+def updated() {
+	state.configured = false
+}
+
+def parse(String description) {
+	def result = []
+
+	def cmd = zwave.parse(description, [0x20: 1, 0x31: 2, 0x70: 1, 0x71: 1, 0x80: 1, 0x84: 2, 0x85: 2])
+
+	if (cmd) {
+		result = zwaveEvent(cmd)
+	}
+
+	if (result instanceof List) {
+		log.debug "Parsed '$description' to ${result.collect { it.respondsTo("toHubAction") ? it.toHubAction() : it }}"
+	} else {
+		log.debug "Parsed '$description' to ${result}"
+	}
+	return result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd) {
+	def result = [
+		createEvent(descriptionText: "${device.displayName} woke up", isStateChange: false)
+	]
+	if (state.configured) {
+		result << response(zwave.batteryV1.batteryGet())
+	} else {
+		result << response(configure())
+	}
+	return result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.alarmv1.AlarmReport cmd) {
+	if (cmd.alarmType == 1 && cmd.alarmType == 0xFF) {
+		return createEvent(descriptionText: "${device.displayName} battery is low", isStateChange: true)
+	} else if (cmd.alarmType == 2 && cmd.alarmLevel == 1) {
+		return createEvent(descriptionText: "${device.displayName} powered up", isStateChange: false)
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv2.SensorMultilevelReport cmd) {
+
+	def map = [:]
+	switch( cmd.sensorType ) {
+		case 3:
+			// luminance
+			map.value = cmd.scaledSensorValue.toInteger().toString()
+			map.unit = "lux"
+			map.name = "illuminance"
+			break;
+	}
+	
+	return createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
+	def map = [ name: "battery", unit: "%" ]
+	if (cmd.batteryLevel == 0xFF) {
+		map.value = 1
+		map.descriptionText = "${device.displayName} has a low battery"
+		map.isStateChange = true
+	} else {
+		map.value = cmd.batteryLevel
+	}
+
+	def response_cmds  = []
+	if (!currentTemperature) {
+		response_cmds << zwave.sensorMultilevelV2.sensorMultilevelGet().format()
+		response_cmds << "delay 1000"
+	}
+	response_cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
+
+	return [createEvent(map), response(response_cmds)]
+}
+
+def zwaveEvent(physicalgraph.zwave.Command cmd) {
+	log.debug "Unhandled: ${cmd.toString()}"
+	return [:]
+}
+
+def configure() {
+	state.configured = true
+	sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	delayBetween([
+		// Auto report time interval in minutes
+		zwave.configurationV1.configurationSet(parameterNumber: 5, size: 2, scaledConfigurationValue: 20).format(),
+
+		// Auto report lux change threshold
+		zwave.configurationV1.configurationSet(parameterNumber: 6, size: 2, scaledConfigurationValue: 30).format(),
+
+		// Get battery – report triggers WakeUpNMI
+		zwave.batteryV1.batteryGet().format()
+	]) 
+}

devicetypes/smartthings/everspring-st814.src/everspring-st814.groovy

@@ -0,0 +1,188 @@
+/**
+ *  Copyright 2017 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.
+ *
+ *  Everspring ST814 Temperature/Humidity Sensor
+ *
+ *  Author: SmartThings
+ *  Date: 2017-3-4
+ */
+
+metadata {
+	definition (name: "Everspring ST814", namespace: "smartthings", author: "SmartThings") {
+		capability "Temperature Measurement"
+		capability "Relative Humidity Measurement"
+		capability "Battery"
+		capability "Configuration"
+		capability "Sensor"
+		capability "Health Check"
+
+		fingerprint mfr:"0060", prod:"0006", model:"0001"
+	}
+
+	simulator {
+		for( int i = 0; i <= 100; i += 20 ) {
+			status "temperature ${i}F": new physicalgraph.zwave.Zwave().sensorMultilevelV2.sensorMultilevelReport(
+				scaledSensorValue: i, precision: 1, sensorType: 1, scale: 1).incomingMessage()
+		}
+
+		for( int i = 0; i <= 100; i += 20 ) {
+			status "humidity ${i}%": new physicalgraph.zwave.Zwave().sensorMultilevelV2.sensorMultilevelReport(
+				scaledSensorValue: i, precision: 0, sensorType: 5).incomingMessage()
+		}
+
+		for( int i = 0; i <= 100; i += 20 ) {
+			status "battery ${i}%": new physicalgraph.zwave.Zwave().batteryV1.batteryReport(
+				batteryLevel: i).incomingMessage()
+		}
+		status "wakeup":  "command: 8407, payload: "
+	}
+
+	tiles(scale: 2) {
+		valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {
+			state "temperature", label:'${currentValue}°',
+			backgroundColors:[
+				[value: 32, color: "#153591"],
+				[value: 44, color: "#1e9cbb"],
+				[value: 59, color: "#90d2a7"],
+				[value: 74, color: "#44b621"],
+				[value: 84, color: "#f1d801"],
+				[value: 92, color: "#d04e00"],
+				[value: 98, color: "#bc2323"]
+			]
+		}
+		valueTile("humidity", "device.humidity", inactiveLabel: false, width: 2, height: 2) {
+			state "humidity", label:'${currentValue}% humidity', unit:""
+		}
+		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "battery", label:'${currentValue}% battery', unit:""
+		}
+
+		main( ["temperature", "humidity"] )
+		details( ["temperature", "humidity", "battery"] )
+	}
+}
+
+def updated() {
+	state.configured = false
+}
+
+def parse(String description) {
+	def result = []
+
+	def cmd = zwave.parse(description, [0x20: 1, 0x31: 2, 0x70: 1, 0x71: 1, 0x80: 1, 0x84: 2, 0x85: 2])
+
+	if (cmd) {
+		result = zwaveEvent(cmd)
+	}
+
+	if (result instanceof List) {
+		log.debug "Parsed '$description' to ${result.collect { it.respondsTo("toHubAction") ? it.toHubAction() : it }}"
+	} else {
+		log.debug "Parsed '$description' to ${result}"
+	}
+	return result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd) {
+	def result = [
+		createEvent(descriptionText: "${device.displayName} woke up", isStateChange: false)
+	]
+	if (state.configured) {
+		result << response(zwave.batteryV1.batteryGet())
+	} else {
+		result << response(configure())
+	}
+	return result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.alarmv1.AlarmReport cmd) {
+	if (cmd.alarmType == 1 && cmd.alarmType == 0xFF) {
+		return createEvent(descriptionText: "${device.displayName} battery is low", isStateChange: true)
+	} else if (cmd.alarmType == 2 && cmd.alarmLevel == 1) {
+		return createEvent(descriptionText: "${device.displayName} powered up", isStateChange: false)
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv2.SensorMultilevelReport cmd) {
+
+	def map = [:]
+	switch( cmd.sensorType ) {
+		case 1:
+			/* temperature */
+			def cmdScale = cmd.scale == 1 ? "F" : "C"
+			map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmdScale, cmd.precision)
+			map.unit = getTemperatureScale()
+			map.name = "temperature"
+			break
+		case 5:
+			/* humidity */
+			map.value = cmd.scaledSensorValue.toInteger().toString()
+			map.unit = "%"
+			map.name = "humidity"
+			break
+	}
+	
+	return createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
+	def map = [ name: "battery", unit: "%" ]
+	if (cmd.batteryLevel == 0xFF) {
+		map.value = 1
+		map.descriptionText = "${device.displayName} has a low battery"
+		map.isStateChange = true
+	} else {
+		map.value = cmd.batteryLevel
+	}
+
+	def response_cmds  = []
+	if (!currentTemperature) {
+		response_cmds << zwave.sensorMultilevelV2.sensorMultilevelGet().format()
+		response_cmds << "delay 1000"
+	}
+	response_cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
+
+	return [createEvent(map), response(response_cmds)]
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.multichannelv3.MultiChannelCmdEncap cmd) {
+	def result = null
+	def encapsulatedCommand = cmd.encapsulatedCommand([0x20: 1, 0x31: 2, 0x70: 1, 0x71: 1, 0x80: 1, 0x84: 2, 0x85: 2])
+	log.debug ("Command from endpoint ${cmd.sourceEndPoint}: ${encapsulatedCommand}")
+	if (encapsulatedCommand) {
+		result = zwaveEvent(encapsulatedCommand)
+	}
+	result
+}
+
+def zwaveEvent(physicalgraph.zwave.Command cmd) {
+	log.debug "Unhandled: ${cmd.toString()}"
+	return [:]
+}
+
+def configure() {
+	state.configured = true
+	sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	delayBetween([
+		// Auto report time interval in minutes
+		zwave.configurationV1.configurationSet(parameterNumber: 6, size: 2, scaledConfigurationValue: 20).format(),
+
+		// Auto report temperature change threshold
+		zwave.configurationV1.configurationSet(parameterNumber: 7, size: 1, scaledConfigurationValue: 2).format(),
+
+		// Auto report humidity change threshold
+		zwave.configurationV1.configurationSet(parameterNumber: 8, size: 1, scaledConfigurationValue: 5).format(),
+
+		// Get battery – report triggers WakeUpNMI
+		zwave.batteryV1.batteryGet().format()
+	]) 
+}

devicetypes/smartthings/fibaro-door-window-sensor.src/fibaro-door-window-sensor.groovy

@@ -68,8 +68,8 @@
 
 	tiles {
 		standardTile("contact", "device.contact", width: 2, height: 2) {
-			state "open",   label: '${name}', icon: "st.contact.contact.open",   backgroundColor: "#ffa81e"
-			state "closed", label: '${name}', icon: "st.contact.contact.closed", backgroundColor: "#79b821"
+			state "open",   label: '${name}', icon: "st.contact.contact.open",   backgroundColor: "#e86d13"
+			state "closed", label: '${name}', icon: "st.contact.contact.closed", backgroundColor: "#00A0DC"
 		}
 		valueTile("temperature", "device.temperature", inactiveLabel: false) {
 			state "temperature", label:'${currentValue}°',
@@ -86,7 +86,7 @@
 		}
         standardTile("tamper", "device.alarm") {
 			state("secure", label:'secure',    icon:"st.locks.lock.locked",   backgroundColor:"#ffffff")
-			state("tampered", label:'tampered', icon:"st.locks.lock.unlocked", backgroundColor:"#53a7c0")
+			state("tampered", label:'tampered', icon:"st.locks.lock.unlocked", backgroundColor:"#00a0dc")
 		}
 		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat") {
 			state "battery", label:'${currentValue}% battery', unit:""

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

@@ -107,8 +107,8 @@
 			state "configure", label:'', action:"configuration.configure", icon:"st.secondary.configure"
 		}
         standardTile("acceleration", "device.acceleration") {
-			state("active", label:'vibration', icon:"st.motion.acceleration.active", backgroundColor:"#53a7c0")
-			state("inactive", label:'still', icon:"st.motion.acceleration.inactive", backgroundColor:"#ffffff")
+			state("active", label:'vibration', icon:"st.motion.acceleration.active", backgroundColor:"#00a0dc")
+			state("inactive", label:'still', icon:"st.motion.acceleration.inactive", backgroundColor:"#cccccc")
 		}
 
 

devicetypes/smartthings/fibaro-rgbw-controller.src/fibaro-rgbw-controller.groovy

@@ -300,15 +300,21 @@ def setColor(value) {
         value.hex = "#${hex(value.red)}${hex(value.green)}${hex(value.blue)}"
     }
 
-	sendEvent(name: "hue", value: value.hue, displayed: false)
-	sendEvent(name: "saturation", value: value.saturation, displayed: false)
-	sendEvent(name: "color", value: value.hex, displayed: false)
-	if (value.level) {
-		sendEvent(name: "level", value: value.level)
-	}
-	if (value.switch) {
-		sendEvent(name: "switch", value: value.switch)
-	}
+    if(value.hue) {
+        sendEvent(name: "hue", value: value.hue, displayed: false)
+    }
+    if(value.saturation) {
+        sendEvent(name: "saturation", value: value.saturation, displayed: false)
+    }
+    if(value.hex?.trim()) {
+        sendEvent(name: "color", value: value.hex, displayed: false)
+    }
+    if (value.level) {
+        sendEvent(name: "level", value: value.level)
+    }
+    if (value.switch?.trim()) {
+        sendEvent(name: "switch", value: value.switch)
+    }
 
     sendRGB(value.rh, value.gh, value.bh)
 }

devicetypes/smartthings/fibaro-smoke-sensor.src/fibaro-smoke-sensor.groovy

@@ -18,6 +18,7 @@ metadata {
         capability "Sensor"
         capability "Smoke Detector" //attributes: smoke ("detected","clear","tested")
         capability "Temperature Measurement" //attributes: temperature
+        capability "Health Check"
         attribute "tamper", "enum", ["detected", "clear"]
         attribute "heatAlarm", "enum", ["overheat detected", "clear", "rapid temperature rise", "underheat detected"]
         fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x86, 0x72, 0x5A, 0x59, 0x85, 0x73, 0x84, 0x80, 0x71, 0x56, 0x70, 0x31, 0x8E, 0x22, 0x9C, 0x98, 0x7A", outClusters: "0x20, 0x8B"
@@ -339,6 +340,8 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 }
 
 def configure() {
+    // Device wakes up every 4 hours, this interval allows us to miss one wakeup notification before marking offline
+    sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 // This sensor joins as a secure device if you tripple-click the button to include it
     log.debug "configure() >> isSecured() : ${isSecured()}"
     if (!isSecured()) {

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

@@ -12,13 +12,13 @@
  *
  */
 metadata {
-	definition (name: "Fortrezz Water Valve", namespace: "smartthings", author: "SmartThings") {
+	definition (name: "Fortrezz Water Valve", namespace: "smartthings", author: "SmartThings", ocfDeviceType: "oic.d.watervalve") {
 		capability "Actuator"
 		capability "Health Check"
 		capability "Valve"
 		capability "Refresh"
 		capability "Sensor"
-        
+
 		fingerprint deviceId: "0x1000", inClusters: "0x25,0x72,0x86,0x71,0x22,0x70"
 		fingerprint mfr:"0084", prod:"0213", model:"0215", deviceJoinName: "FortrezZ Water Valve"
 	}
@@ -34,14 +34,17 @@ metadata {
 	}
 
 	// tile definitions
-	tiles {
-		standardTile("contact", "device.contact", width: 2, height: 2, canChangeIcon: true) {
-			state "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC", nextState:"closing"
-			state "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff", nextState:"opening"
-			state "opening", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC"
-			state "closing", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
+	tiles(scale: 2) {
+		multiAttributeTile(name:"contact", type: "generic", width: 6, height: 4, canChangeIcon: true){
+			tileAttribute ("device.contact", key: "PRIMARY_CONTROL") {
+				attributeState "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC", nextState:"closing"
+				attributeState "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff", nextState:"opening"
+				attributeState "opening", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC"
+				attributeState "closing", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
+			}
 		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
+
+		standardTile("refresh", "device.valve", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 
@@ -53,6 +56,8 @@ 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(){
@@ -62,30 +67,37 @@ def updated(){
 
 def parse(String description) {
 	log.trace description
-	def result = null
 	def cmd = zwave.parse(description)
 	if (cmd) {
-		result = createEvent(zwaveEvent(cmd))
+		return zwaveEvent(cmd)
 	}
-	log.debug "Parse returned ${result?.descriptionText}"
-	return result
+	log.debug "Could not parse message"
+	return null
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd) {
 	def value = cmd.value ? "closed" : "open"
-	[name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]
+
+	return [createEventWithDebug([name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]),
+			createEventWithDebug([name: "valve", value: value, descriptionText: "$device.displayName valve is $value"])]
 }
 
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
-	[:] // Handles all Z-Wave commands we aren't interested in
+	return createEvent([:]) // Handles all Z-Wave commands we aren't interested in
 }
 
 def open() {
-	zwave.switchBinaryV1.switchBinarySet(switchValue: 0x00).format()
+	delayBetween([
+		zwave.switchBinaryV1.switchBinarySet(switchValue: 0x00).format(),
+		zwave.switchBinaryV1.switchBinaryGet().format()
+	], 500)
 }
 
 def close() {
-	zwave.switchBinaryV1.switchBinarySet(switchValue: 0xFF).format()
+	delayBetween([
+		zwave.switchBinaryV1.switchBinarySet(switchValue: 0xFF).format(),
+		zwave.switchBinaryV1.switchBinaryGet().format()
+	], 500)
 }
 
 /**
@@ -98,3 +110,9 @@ def ping() {
 def refresh() {
 	zwave.switchBinaryV1.switchBinaryGet().format()
 }
+
+def createEventWithDebug(eventMap) {
+	def event = createEvent(eventMap)
+	log.debug "Event created with ${event?.name}:${event?.value} - ${event?.descriptionText}"
+	return event
+}

devicetypes/smartthings/hue-bloom.src/hue-bloom.groovy

@@ -1,3 +1,5 @@
+//DEPRECATED. INTEGRATION MOVED TO SUPER LAN CONNECT
+
 /**
  *  Hue Bloom
  *

devicetypes/smartthings/hue-bridge.src/hue-bridge.groovy

@@ -1,3 +1,5 @@
+//DEPRECATED. INTEGRATION MOVED TO SUPER LAN CONNECT
+
 /**
  *  Hue Bridge
  *

devicetypes/smartthings/hue-bulb.src/hue-bulb.groovy

@@ -1,3 +1,5 @@
+//DEPRECATED. INTEGRATION MOVED TO SUPER LAN CONNECT
+
 /**
  *  Hue Bulb
  *

devicetypes/smartthings/hue-lux-bulb.src/hue-lux-bulb.groovy

@@ -1,3 +1,5 @@
+//DEPRECATED. INTEGRATION MOVED TO SUPER LAN CONNECT
+
 /**
  *  Hue Lux Bulb
  *

devicetypes/smartthings/hue-white-ambiance-bulb.src/hue-white-ambiance-bulb.groovy

@@ -1,3 +1,5 @@
+//DEPRECATED. INTEGRATION MOVED TO SUPER LAN CONNECT
+
 /**
  *  Hue White Ambiance Bulb
  *

devicetypes/smartthings/mimolite-garage-door-controller.src/mimolite-garage-door-controller.groovy

@@ -62,8 +62,8 @@ metadata {
 			state "off", label: '${name}', action: "on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
         }
         standardTile("contact", "device.contact", inactiveLabel: false) {
-			state "open", label: '${name}', icon: "st.contact.contact.open", backgroundColor: "#ffa81e"
-			state "closed", label: '${name}', icon: "st.contact.contact.closed", backgroundColor: "#79b821"
+			state "open", label: '${name}', icon: "st.contact.contact.open", backgroundColor: "#e86d13"
+			state "closed", label: '${name}', icon: "st.contact.contact.closed", backgroundColor: "#00A0DC"
 		}
         standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"

devicetypes/smartthings/smartalert-siren.src/README.md

@@ -4,7 +4,7 @@ Cloud Execution
 
 Works with:
 
-* [FortrezZ Siren Strobe Alarm](https://www.smartthings.com/works-with-smartthings/other/fortrezz-water-valve)
+* [FortrezZ Siren Strobe Alarm](https://www.smartthings.com/products/fortrezz-siren-strobe-alarm)
 
 ## Table of contents
 

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

@@ -16,7 +16,7 @@
  *  Date: 2013-03-05
  */
 metadata {
-	definition (name: "SmartAlert Siren", namespace: "smartthings", author: "SmartThings", ocfDeviceType: "x.com.st.smokedetector") {
+	definition (name: "SmartAlert Siren", namespace: "smartthings", author: "SmartThings", ocfDeviceType: "x.com.st.d.sensor.smoke") {
 		capability "Actuator"
 		capability "Switch"
 		capability "Sensor"

devicetypes/smartthings/smartpower-dimming-outlet.src/smartpower-dimming-outlet.groovy

@@ -44,9 +44,9 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
 			}
 			tileAttribute ("device.level", key: "SLIDER_CONTROL") {

devicetypes/smartthings/smartpower-outlet.src/smartpower-outlet.groovy

@@ -23,12 +23,12 @@ metadata {
 		capability "Refresh"
 		capability "Sensor"
 		capability "Health Check"
-		capability "Light"
 		capability "Outlet"
 
 		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3200", deviceJoinName: "Outlet"
 		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3200-Sgb", deviceJoinName: "Outlet"
 		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "4257050-RZHAC", deviceJoinName: "Outlet"
+		fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 000F, 0B04", outClusters: "0019", manufacturer: "SmartThings", model: "outletv4", deviceJoinName: "Outlet"
 		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019"
 	}
 

devicetypes/smartthings/smartsense-garage-door-sensor-button.src/smartsense-garage-door-sensor-button.groovy

@@ -56,8 +56,8 @@ metadata {
 			state("closing", label:'${name}', icon:"st.doors.garage.garage-closing", backgroundColor:"#00A0DC")
 		}
 		standardTile("contact", "device.contact") {
-			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
-			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
+			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#e86d13")
+			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#00A0DC")
 		}
 		standardTile("acceleration", "device.acceleration", decoration: "flat") {
 			state("active", label:'${name}', icon:"st.motion.acceleration.active", backgroundColor:"#00A0DC")

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

@@ -61,8 +61,8 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name: "motion", type: "generic", width: 6, height: 4) {
 			tileAttribute("device.motion", key: "PRIMARY_CONTROL") {
-				attributeState "active", label: 'motion', icon: "st.motion.motion.active", backgroundColor: "#53a7c0"
-				attributeState "inactive", label: 'no motion', icon: "st.motion.motion.inactive", backgroundColor: "#ffffff"
+				attributeState "active", label: 'motion', icon: "st.motion.motion.active", backgroundColor: "#00A0DC"
+				attributeState "inactive", label: 'no motion', icon: "st.motion.motion.inactive", backgroundColor: "#cccccc"
 			}
 		}
 		valueTile("temperature", "device.temperature", width: 2, height: 2) {
@@ -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 maxVolts = 3.0
-			def pct = (volts - minVolts) / (maxVolts - minVolts)
-			def roundedPct = Math.round(pct * 100)
-			if (roundedPct <= 0)
-				roundedPct = 1
-			result.value = Math.min(100, roundedPct)
+			def minVolts = 2.4
+			def maxVolts = 2.7
+			// Get the current battery percentage as a multiplier 0 - 1
+			def curValVolts = Integer.parseInt(device.currentState("battery")?.value ?: "100") / 100.0
+			// Find the corresponding voltage from our range
+			curValVolts = curValVolts * (maxVolts - minVolts) + minVolts
+			// 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

@@ -87,8 +87,8 @@ metadata {
 			state("closed", label: 'Closed', icon: "st.contact.contact.closed", backgroundColor: "#00a0dc")
 		}
 		standardTile("acceleration", "device.acceleration", width: 2, height: 2) {
-			state("active", label: 'Active', icon: "st.motion.acceleration.active", backgroundColor: "#53a7c0")
-			state("inactive", label: 'Inactive', icon: "st.motion.acceleration.inactive", backgroundColor: "#ffffff")
+			state("active", label: 'Active', icon: "st.motion.acceleration.active", backgroundColor: "#00a0dc")
+			state("inactive", label: 'Inactive', icon: "st.motion.acceleration.inactive", backgroundColor: "#cccccc")
 		}
 		valueTile("temperature", "device.temperature", width: 2, height: 2) {
 			state("temperature", label: '${currentValue}°',
@@ -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)
 			}
 		}
@@ -178,7 +179,7 @@ private List<Map> handleAcceleration(descMap) {
 			result += parseAxis(descMap.additionalAttrs)
 		}
 	} else if (descMap.clusterInt == 0xFC02 && descMap.attrInt == 0x0012) {
-		def addAttrs = descMap.additionalAttrs
+		def addAttrs = descMap.additionalAttrs ?: []
 		addAttrs << ["attrInt": descMap.attrInt, "value": descMap.value]
 		result += parseAxis(addAttrs)
 	}
@@ -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 pct = (volts - minVolts) / (maxVolts - minVolts)
-			def roundedPct = Math.round(pct * 100)
-			if (roundedPct <= 0)
-				roundedPct = 1
-			result.value = Math.min(100, roundedPct)
+			def maxVolts = 2.7
+			// Get the current battery percentage as a multiplier 0 - 1
+			def curValVolts = Integer.parseInt(device.currentState("battery")?.value ?: "100") / 100.0
+			// Find the corresponding voltage from our range
+			curValVolts = curValVolts * (maxVolts - minVolts) + minVolts
+			// 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/testing/simulated-presence-sensor.src/simulated-presence-sensor.groovy

@@ -49,6 +49,6 @@ def arrived() {
 
 
 def departed() {
-	log.trace "Executing 'arrived'"
+	log.trace "Executing 'departed'"
 	sendEvent(name: "presence", value: "not present")
 }

devicetypes/smartthings/testing/simulated-refrigerator-door.src/simulated-refrigerator-door.groovy

@@ -22,16 +22,16 @@ metadata {
 
 	tiles {
 		standardTile("contact", "device.contact", width: 2, height: 2) {
-			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821", action: "open")
-			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e", action: "close")
+			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#00A0DC", action: "open")
+			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#e86d13", action: "close")
 		}
 		standardTile("freezerDoor", "device.contact", width: 2, height: 2, decoration: "flat") {
-			state("closed", label:'Freezer', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
-			state("open", label:'Freezer', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
+			state("closed", label:'Freezer', icon:"st.contact.contact.closed", backgroundColor:"#00A0DC")
+			state("open", label:'Freezer', icon:"st.contact.contact.open", backgroundColor:"#e86d13")
 		}
 		standardTile("mainDoor", "device.contact", width: 2, height: 2, decoration: "flat") {
-			state("closed", label:'Fridge', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
-			state("open", label:'Fridge', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
+			state("closed", label:'Fridge', icon:"st.contact.contact.closed", backgroundColor:"#00A0DC")
+			state("open", label:'Fridge', icon:"st.contact.contact.open", backgroundColor:"#e86d13")
 		}
 		standardTile("control", "device.contact", width: 1, height: 1, decoration: "flat") {
 			state("closed", label:'${name}', icon:"st.contact.contact.closed", action: "open")

devicetypes/smartthings/testing/simulated-refrigerator.src/simulated-refrigerator.groovy

@@ -25,8 +25,8 @@ metadata {
 
 	tiles(scale: 2) {
 		standardTile("contact", "device.contact", width: 4, height: 4) {
-			state("closed", label:'${name}', icon:"st.fridge.fridge-closed", backgroundColor:"#79b821")
-			state("open", label:'${name}', icon:"st.fridge.fridge-open", backgroundColor:"#ffa81e")
+			state("closed", label:'${name}', icon:"st.fridge.fridge-closed", backgroundColor:"#00A0DC")
+			state("open", label:'${name}', icon:"st.fridge.fridge-open", backgroundColor:"#e86d13")
 		}
 		childDeviceTile("freezerDoor", "freezerDoor", height: 2, width: 2, childTileName: "freezerDoor")
 		childDeviceTile("mainDoor", "mainDoor", height: 2, width: 2, childTileName: "mainDoor")

devicetypes/smartthings/tile-ux/tile-multiattribute-generic.src/tile-multiattribute-generic.groovy

@@ -27,7 +27,7 @@ metadata {
 			tileAttribute("device.switch", key: "PRIMARY_CONTROL") {
 				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
 			}
 		}
@@ -35,7 +35,7 @@ metadata {
 			tileAttribute("device.switch", key: "PRIMARY_CONTROL") {
 				attributeState "on", label:'${name}', backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "off", label:'${name}', backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOn", label:'${name}', backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "turningOff", label:'${name}', backgroundColor:"#ffffff", nextState:"turningOn"
 			}
 			tileAttribute("device.level", key: "SECONDARY_CONTROL") {
@@ -59,7 +59,7 @@ metadata {
 			tileAttribute("device.switch", key: "SECONDARY_CONTROL") {
 				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'…', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOn", label:'…', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "turningOff", label:'…', action:"switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
 			}
 			tileAttribute("device.level", key: "VALUE_CONTROL") {

devicetypes/smartthings/wemo-light-switch.src/wemo-light-switch.groovy

@@ -1,3 +1,5 @@
+//DEPRECATED. INTEGRATION MOVED TO SUPER LAN CONNECT
+
 /**
  *  Copyright 2015 SmartThings
  *
@@ -40,11 +42,11 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"rich-control", type: "switch", canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                 attributeState "on", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#79b821", nextState:"turningOff"
+                 attributeState "on", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#00A0DC", nextState:"turningOff"
                  attributeState "off", label:'${name}', action:"switch.on", icon:"st.Home.home30", backgroundColor:"#ffffff", nextState:"turningOn"
-                 attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#79b821", nextState:"turningOff"
+                 attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#00A0DC", nextState:"turningOff"
                  attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.Home.home30", backgroundColor:"#ffffff", nextState:"turningOn"
-                 attributeState "offline", label:'${name}', icon:"st.Home.home30", backgroundColor:"#ff0000"
+                 attributeState "offline", label:'${name}', icon:"st.Home.home30", backgroundColor:"#cccccc"
  			}
             tileAttribute ("currentIP", key: "SECONDARY_CONTROL") {
              	 attributeState "currentIP", label: ''

devicetypes/smartthings/wemo-motion.src/wemo-motion.groovy

@@ -1,3 +1,5 @@
+//DEPRECATED. INTEGRATION MOVED TO SUPER LAN CONNECT
+
 /**
  *  Copyright 2015 SmartThings
  *
@@ -46,8 +48,8 @@
         }
 
 		standardTile("motion", "device.motion", width: 2, height: 2) {
-			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0")
-			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff")
+			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC")
+			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#CCCCCC")
       		state("offline", label:'${name}', icon:"st.motion.motion.inactive", backgroundColor:"#ff0000")
 		}
 

devicetypes/smartthings/wemo-switch.src/wemo-switch.groovy

@@ -1,3 +1,5 @@
+//DEPRECATED. INTEGRATION MOVED TO SUPER LAN CONNECT
+
 /**
  *  Copyright 2015 SmartThings
  *
@@ -38,11 +40,11 @@
     tiles(scale: 2) {
         multiAttributeTile(name:"rich-control", type: "switch", canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                 attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
+                 attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#00A0DC", nextState:"turningOff"
                  attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-                 attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
+                 attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#00A0DC", nextState:"turningOff"
                  attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-                 attributeState "offline", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ff0000"
+                 attributeState "offline", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#cccccc"
  			}
             tileAttribute ("currentIP", key: "SECONDARY_CONTROL") {
              	 attributeState "currentIP", label: ''
@@ -50,11 +52,11 @@
         }
 
         standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-            state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
+            state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#00A0DC", nextState:"turningOff"
             state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-            state "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
+            state "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#00A0DC", nextState:"turningOff"
             state "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-            state "offline", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ff0000"
+            state "offline", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#cccccc"
         }
 
         standardTile("refresh", "device.switch", inactiveLabel: false, height: 2, width: 2, decoration: "flat") {

devicetypes/smartthings/zigbee-button.src/.st-ignore

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

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

@@ -0,0 +1,42 @@
+# ZigBee Button
+
+Cloud Execution
+
+Works with: 
+
+* [OSRAM LIGHTIFY Dimming Switch](https://support.smartthings.com/hc/en-us/articles/115000236823-SYLVANIA-Dimming-Switch)
+* [Iris Smart Button](https://support.smartthings.com/hc/en-us/articles/115000190186-Iris-Smart-Button)
+* [Iris KeyFob](https://support.smartthings.com/hc/en-us/articles/217409686-Iris-Smart-Fob)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Actuator** - It represents that a device has commands.
+* **Battery** - It defines that the device has a battery
+* **Button** - It defines that a device has one or more buttons
+* **Holdable Button** - It defines that a device has one or more holdable buttons
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - it represents that a Device has attributes.
+* **Health Check** - indicates ability to get device health notifications
+
+
+## Device Health
+
+ZigBee Button is marked offline only in the case when Hub is offline.
+
+
+## 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.
+It may also happen that you need to reset the device.
+Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following link:
+* [OSRAM LIGHTIFY Dimming Switch Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/115000236823-SYLVANIA-Dimming-Switch)
+* [Iris Smart Button Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/115000190186-Iris-Smart-Button)
+* [Iris KeyFob Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/217409686-Iris-Smart-Fob)

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 {
@@ -24,6 +26,7 @@ metadata {
         capability "Configuration"
         capability "Refresh"
         capability "Sensor"
+        capability "Health Check"
 
         command "enrollResponse"
 
@@ -249,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/zigbee-dimmer.src/zigbee-dimmer.groovy

@@ -25,6 +25,7 @@ metadata {
 
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY A19 ON/OFF/DIM", deviceJoinName: "SYLVANIA Smart A19 Soft White"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY A19 ON/OFF/DIM 10 Year", deviceJoinName: "SYLVANIA Smart 10-Year A19"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FF00", outClusters: "0019", manufacturer: "MRVL", model: "MZ100", deviceJoinName: "Wemo Bulb"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B05", outClusters: "0019", manufacturer: "OSRAM SYLVANIA", model: "iQBR30", deviceJoinName: "Sylvania Ultra iQ"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY PAR38 ON/OFF/DIM", deviceJoinName: "SYLVANIA Smart PAR38 Soft White"
@@ -65,22 +66,29 @@ def parse(String description) {
         else {
             sendEvent(event)
         }
-    }
-    else {
-        def cluster = zigbee.parse(description)
-
-        if (cluster && cluster.clusterId == 0x0006 && cluster.command == 0x07) {
-            if (cluster.data[0] == 0x00) {
+    } else {
+        def descMap = zigbee.parseDescriptionAsMap(description)
+        if (descMap && descMap.clusterInt == 0x0006 && descMap.commandInt == 0x07) {
+            if (descMap.data[0] == "00") {
                 log.debug "ON/OFF REPORTING CONFIG RESPONSE: " + cluster
                 sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-            }
-            else {
+            } else {
                 log.warn "ON/OFF REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
             }
-        }
-        else {
+        } else if (device.getDataValue("manufacturer") == "sengled" && descMap && descMap.clusterInt == 0x0008 && descMap.attrInt == 0x0000) {
+            // This is being done because the sengled element touch/classic incorrectly uses the value 0xFF for the max level.
+            // Per the ZCL spec for the UINT8 data type 0xFF is an invalid value, and 0xFE should be the max.  Here we
+            // manually handle the invalid attribute value since it will be ignored by getEvent as an invalid value.
+            // We also set the level of the bulb to 0xFE so future level reports will be 0xFE until it is changed by
+            // something else.
+            if (descMap.value.toUpperCase() == "FF") {
+                descMap.value = "FE"
+            }
+            sendHubCommand(zigbee.command(zigbee.LEVEL_CONTROL_CLUSTER, 0x00, "FE0000").collect { new physicalgraph.device.HubAction(it) }, 0)
+            sendEvent(zigbee.getEventFromAttrData(descMap.clusterInt, descMap.attrInt, descMap.encoding, descMap.value))
+        } else {
             log.warn "DID NOT PARSE MESSAGE for description : $description"
-            log.debug "${cluster}"
+            log.debug "${descMap}"
         }
     }
 }

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

@@ -34,7 +34,7 @@ import physicalgraph.zigbee.zcl.DataType
         fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD210 PB DB", deviceJoinName: "Yale Push Button Deadbolt Lock"
         fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD220/240 TSDB", deviceJoinName: "Yale Touch Screen Deadbolt Lock"
         fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRL210 PB LL", deviceJoinName: "Yale Push Button Lever Lock"
-	fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD226/246 TSDB", deviceJoinName: "Yale Touch Screen Deadbolt Lock"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD226/246 TSDB", deviceJoinName: "Yale Touch Screen Deadbolt Lock"
 	}
 
     tiles(scale: 2) {

devicetypes/smartthings/zigbee-rgbw-bulb.src/zigbee-rgbw-bulb.groovy

@@ -46,9 +46,9 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#00A0DC", nextState:"turningOff"
                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#00A0DC", nextState:"turningOff"
                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
             }
             tileAttribute ("device.level", key: "SLIDER_CONTROL") {
@@ -103,12 +103,12 @@ def parse(String description) {
 
         if (zigbeeMap?.clusterInt == COLOR_CONTROL_CLUSTER) {
             if(zigbeeMap.attrInt == ATTRIBUTE_HUE){  //Hue Attribute
-                def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
-                sendEvent(name: "hue", value: hueValue, descriptionText: "Color has changed")
+                state.hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
+                runIn(5, updateColor, [overwrite: true])
             }
             else if(zigbeeMap.attrInt == ATTRIBUTE_SATURATION){ //Saturation Attribute
-                def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
-                sendEvent(name: "saturation", value: saturationValue, descriptionText: "Color has changed", displayed: false)
+                state.saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 0xfe * 100)
+                runIn(5, updateColor, [overwrite: true])
             }
         }
         else if (cluster && cluster.clusterId == 0x0006 && cluster.command == 0x07) {
@@ -127,6 +127,11 @@ def parse(String description) {
     }
 }
 
+def updateColor() {
+	sendEvent(name: "hue", value: state.hueValue, descriptionText: "Color has changed")
+	sendEvent(name: "saturation", value: state.saturationValue, descriptionText: "Color has changed", displayed: false)
+}
+
 def on() {
     zigbee.on()
 }
@@ -204,9 +209,9 @@ def setColor(value){
     log.trace "setColor($value)"
     zigbee.on() +
     zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_HUE_AND_SATURATION_COMMAND,
-        getScaledHue(value.hue), getScaledSaturation(value.saturation), "0000") +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) +
-    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+    getScaledHue(value.hue), getScaledSaturation(value.saturation), "0000") +
+    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION) +
+    zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE)
 }
 
 def setHue(value) {

devicetypes/smartthings/zigbee-switch-power.src/zigbee-switch-power.groovy

@@ -27,7 +27,6 @@ metadata {
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0702"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0702, 0B05", outClusters: "0003, 000A, 0019", manufacturer: "Jasco Products", model: "45853", deviceJoinName: "GE ZigBee Plug-In Switch"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0702, 0B05", outClusters: "000A, 0019", manufacturer: "Jasco Products", model: "45856", deviceJoinName: "GE ZigBee In-Wall Switch"
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 000F, 0B04", outClusters: "0019", manufacturer: "SmartThings", model: "outletv4", deviceJoinName: "Outlet"
     }
 
     tiles(scale: 2) {

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

@@ -41,9 +41,9 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
             }
         }

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

@@ -38,7 +38,7 @@ metadata {
     }
 
     tiles(scale: 2) {
-        multiAttributeTile(name:"valve", type: "generic", width: 6, height: 4, canChangeIcon: true){
+        multiAttributeTile(name:"contact", type: "generic", width: 6, height: 4, canChangeIcon: true){
             tileAttribute ("device.contact", key: "PRIMARY_CONTROL") {
                 attributeState "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC", nextState:"closing"
                 attributeState "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff", nextState:"opening"
@@ -58,8 +58,8 @@ metadata {
             state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
         }
 
-        main(["valve"])
-        details(["valve", "battery", "refresh"])
+        main(["contact"])
+        details(["contact", "battery", "refresh"])
     }
 }
 
@@ -83,6 +83,9 @@ def parse(String description) {
             }
         }
         sendEvent(event)
+        //handle valve attribute
+        event.name = "valve"
+        sendEvent(event)
     }
     else {
         def descMap = zigbee.parseDescriptionAsMap(description)

devicetypes/smartthings/zigbee-white-color-temperature-bulb.src/zigbee-white-color-temperature-bulb.groovy

@@ -45,9 +45,9 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
             }
             tileAttribute ("device.level", key: "SLIDER_CONTROL") {
@@ -71,6 +71,11 @@ metadata {
     }
 }
 
+// Globals
+private getMOVE_TO_COLOR_TEMPERATURE_COMMAND() { 0x0A }
+private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
+private getATTRIBUTE_COLOR_TEMPERATURE() { 0x0007 }
+
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
@@ -146,7 +151,7 @@ def setColorTemperature(value) {
     def tempInMired = (1000000 / value) as Integer
     def finalHex = zigbee.swapEndianHex(zigbee.convertToHexString(tempInMired, 4))
 
-    zigbee.command(COLOR_CONTROL_CLUSTER, 0x0A, "$finalHex 0000") +
+    zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_COLOR_TEMPERATURE_COMMAND, "$finalHex 0000") +
     zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE)
 }
 

devicetypes/smartthings/zll-dimmer-bulb.src/zll-dimmer-bulb.groovy

@@ -49,9 +49,9 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
             }
             tileAttribute ("device.level", key: "SLIDER_CONTROL") {

devicetypes/smartthings/zll-white-color-temperature-bulb-5000k.src/zll-white-color-temperature-bulb-5000k.groovy

@@ -66,6 +66,11 @@ metadata {
     }
 }
 
+// Globals
+private getMOVE_TO_COLOR_TEMPERATURE_COMMAND() { 0x0A }
+private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
+private getATTRIBUTE_COLOR_TEMPERATURE() { 0x0007 }
+
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
@@ -152,7 +157,7 @@ def setColorTemperature(value) {
     def tempInMired = (1000000 / value) as Integer
     def finalHex = zigbee.swapEndianHex(zigbee.convertToHexString(tempInMired, 4))
 
-    zigbee.command(COLOR_CONTROL_CLUSTER, 0x0A, "$finalHex 0000") +
+    zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_COLOR_TEMPERATURE_COMMAND, "$finalHex 0000") +
     zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE)
 }
 

devicetypes/smartthings/zll-white-color-temperature-bulb.src/zll-white-color-temperature-bulb.groovy

@@ -68,6 +68,11 @@ metadata {
     }
 }
 
+// Globals
+private getMOVE_TO_COLOR_TEMPERATURE_COMMAND() { 0x0A }
+private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
+private getATTRIBUTE_COLOR_TEMPERATURE() { 0x0007 }
+
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
@@ -147,7 +152,7 @@ def setColorTemperature(value) {
     def tempInMired = (1000000 / value) as Integer
     def finalHex = zigbee.swapEndianHex(zigbee.convertToHexString(tempInMired, 4))
 
-    zigbee.command(COLOR_CONTROL_CLUSTER, 0x0A, "$finalHex 0000") +
+    zigbee.command(COLOR_CONTROL_CLUSTER, MOVE_TO_COLOR_TEMPERATURE_COMMAND, "$finalHex 0000") +
     zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE)
 }
 

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-device-multichannel.src/zwave-device-multichannel.groovy

@@ -75,6 +75,10 @@ def parse(String description) {
 	return result
 }
 
+def uninstalled() {
+	sendEvent(name: "epEvent", value: "delete all", isStateChange: true, displayed: false, descriptionText: "Delete endpoint devices")
+}
+
 def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd) {
 	[ createEvent(descriptionText: "${device.displayName} woke up", isStateChange:true),
 	  response(["delay 2000", zwave.wakeUpV1.wakeUpNoMoreInformation().format()]) ]

devicetypes/smartthings/zwave-dimmer-switch-generic.src/zwave-dimmer-switch-generic.groovy

@@ -88,11 +88,20 @@ def updated(){
 	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 }
 
+def getCommandClassVersions() {
+	[
+		0x20: 1,  // Basic
+		0x26: 1,  // SwitchMultilevel
+		0x56: 1,  // Crc16Encap
+		0x70: 1,  // Configuration
+	]
+}
+
 def parse(String description) {
 	def result = null
 	if (description != "updated") {
 		log.debug "parse() >> zwave.parse($description)"
-		def cmd = zwave.parse(description, [0x20: 1, 0x26: 1, 0x70: 1])
+		def cmd = zwave.parse(description, commandClassVersions)
 		if (cmd) {
 			result = zwaveEvent(cmd)
 		}
@@ -159,6 +168,16 @@ def zwaveEvent(physicalgraph.zwave.commands.switchmultilevelv1.SwitchMultilevelS
 	[createEvent(name:"switch", value:"on"), response(zwave.switchMultilevelV1.switchMultilevelGet().format())]
 }
 
+def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd) {
+	def versions = commandClassVersions
+	def version = versions[cmd.commandClass as Integer]
+	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
+	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
+	if (encapsulatedCommand) {
+		zwaveEvent(encapsulatedCommand)
+	}
+}
+
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	// Handles all Z-Wave commands we aren't interested in
 	[:]

devicetypes/smartthings/zwave-door-window-sensor.src/zwave-door-window-sensor.groovy

@@ -30,9 +30,15 @@ metadata {
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x86,0x72,0x98", outClusters: "0x5A,0x82"
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x80,0x71,0x85,0x70,0x72,0x86,0x30,0x31,0x84,0x59,0x73,0x5A,0x8F,0x98,0x7A", outClusters:"0x20" // Philio multi+
 		fingerprint mfr:"0086", prod:"0002", model:"001D", deviceJoinName: "Aeon Labs Door/Window Sensor (Gen 5)"
-		fingerprint mfr:"014A", prod:"0001", model:"0002", deviceJoinName: "Ecolink Door/Window Sensor"
 		fingerprint mfr:"0086", prod:"0102", model:"0070", deviceJoinName:  "Aeon Labs Door/Window Sensor 6"
+		fingerprint mfr:"0086", prod:"0102", model:"0059", deviceJoinName: "Aeon Labs Recessed Door Sensor"
+		fingerprint mfr:"014A", prod:"0001", model:"0002", deviceJoinName: "Ecolink Door/Window Sensor"
+		fingerprint mfr:"014A", prod:"0001", model:"0003", deviceJoinName: "Ecolink Tilt Sensor"
 		fingerprint mfr:"011A", prod:"0601", model:"0903", deviceJoinName: "Enerwave Magnetic Door/Window Sensor"
+		fingerprint mfr:"014F", prod:"2001", model:"0102", deviceJoinName: "Nortek GoControl Door/Window Sensor"
+		fingerprint mfr:"0063", prod:"4953", model:"3031", deviceJoinName: "Jasco Hinge Pin Door Sensor"
+		fingerprint mfr:"019A", prod:"0003", model:"0003", deviceJoinName: "Sensative Strips"
+
 	}
 
 	// simulator metadata
@@ -107,9 +113,9 @@ def updated() {
 
 def configure() {
 	commands([
-		zwave.manufacturerSpecificV2.manufacturerSpecificGet(),
-		zwave.batteryV1.batteryGet()
-	], 6000)
+		zwave.sensorBinaryV2.sensorBinaryGet(sensorType: zwave.sensorBinaryV2.SENSOR_TYPE_DOOR_WINDOW),
+		zwave.manufacturerSpecificV2.manufacturerSpecificGet()
+	], 1000)
 }
 
 def sensorValueEvent(value) {
@@ -184,11 +190,17 @@ def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd)
 		cmds << command(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
 		cmds << "delay 1200"
 	}
+
+	if (device.currentValue("contact") == null) { // Incase our initial request didn't make it
+		cmds << command(zwave.sensorBinaryV2.sensorBinaryGet(sensorType: zwave.sensorBinaryV2.SENSOR_TYPE_DOOR_WINDOW))
+	}
+
 	if (!state.lastbat || now() - state.lastbat > 53*60*60*1000) {
 		cmds << command(zwave.batteryV1.batteryGet())
-	} else {
+	} else { // If we check the battery state we will send NoMoreInfo in the handler for BatteryReport so that we definitely get the report
 		cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
 	}
+
 	[event, response(cmds)]
 }
 

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

@@ -26,7 +26,24 @@ metadata {
 
 		fingerprint deviceId: "0x4003", inClusters: "0x98"
 		fingerprint deviceId: "0x4004", inClusters: "0x98"
-		fingerprint mfr:"0129", prod:"0002", model:"0000", deviceJoinName: "Yale Key Free Touchscreen Deadbolt"
+		fingerprint mfr:"0090", prod:"0001", model:"0236", deviceJoinName: "KwikSet SmartCode 910 Deadbolt Door Lock"
+		fingerprint mfr:"0090", prod:"0003", model:"0238", deviceJoinName: "KwikSet SmartCode 910 Deadbolt Door Lock"
+		fingerprint mfr:"0090", prod:"0001", model:"0001", deviceJoinName: "KwikSet SmartCode 910 Contemporary Deadbolt Door Lock"
+		fingerprint mfr:"0090", prod:"0003", model:"0339", deviceJoinName: "KwikSet SmartCode 912 Lever Door Lock"
+		fingerprint mfr:"0090", prod:"0003", model:"4006", deviceJoinName: "KwikSet SmartCode 914 Deadbolt Door Lock" //backlit version
+		fingerprint mfr:"0090", prod:"0003", model:"0440", deviceJoinName: "KwikSet SmartCode 914 Deadbolt Door Lock"
+		fingerprint mfr:"0090", prod:"0001", model:"0642", deviceJoinName: "KwikSet SmartCode 916 Touchscreen Deadbolt Door Lock"
+		fingerprint mfr:"0090", prod:"0003", model:"0642", deviceJoinName: "KwikSet SmartCode 916 Touchscreen Deadbolt Door Lock"
+		fingerprint mfr:"003B", prod:"6341", model:"0544", deviceJoinName: "Schlage Camelot Touchscreen Deadbolt Door Lock"
+		fingerprint mfr:"003B", prod:"6341", model:"5044", deviceJoinName: "Schlage Century Touchscreen Deadbolt Door Lock"
+		fingerprint mfr:"003B", prod:"634B", model:"504C", deviceJoinName: "Schlage Connected Keypad Lever Door Lock"
+		fingerprint mfr:"0129", prod:"0002", model:"0800", deviceJoinName: "Yale Touchscreen Deadbolt Door Lock" // YRD120
+		fingerprint mfr:"0129", prod:"0002", model:"0000", deviceJoinName: "Yale Touchscreen Deadbolt Door Lock" // YRD220, YRD240
+		fingerprint mfr:"0129", prod:"0002", model:"FFFF", deviceJoinName: "Yale Touchscreen Lever Door Lock" // YRD220
+		fingerprint mfr:"0129", prod:"0004", model:"0800", deviceJoinName: "Yale Push Button Deadbolt Door Lock" // YRD110
+		fingerprint mfr:"0129", prod:"0004", model:"0000", deviceJoinName: "Yale Push Button Deadbolt Door Lock" // YRD210
+		fingerprint mfr:"0129", prod:"0001", model:"0000", deviceJoinName: "Yale Push Button Lever Door Lock" // YRD210
+		fingerprint mfr:"0129", prod:"8002", model:"0600", deviceJoinName: "Yale Assure Lock with Bluetooth"
 	}
 
 	simulator {
@@ -69,23 +86,25 @@ import physicalgraph.zwave.commands.doorlockv1.*
 import physicalgraph.zwave.commands.usercodev1.*
 
 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])
-}
+	// 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])
 
-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])
 	try {
 		if (!state.init) {
 			state.init = true
-			response(secureSequence([zwave.doorLockV1.doorLockOperationGet(), zwave.batteryV1.batteryGet()]))
+			// 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 "updated() threw $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])
+}
+
 def parse(String description) {
 	def result = null
 	if (description.startsWith("Err 106")) {
@@ -135,6 +154,10 @@ def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityCommandsSupported
 
 def zwaveEvent(DoorLockOperationReport cmd) {
 	def result = []
+
+	unschedule("followupStateCheck")
+	unschedule("stateCheck")
+
 	def map = [ name: "lock" ]
 	if (cmd.doorLockMode == 0xFF) {
 		map.value = "locked"
@@ -348,7 +371,7 @@ def zwaveEvent(UserCodeReport cmd) {
 			code = state["set$name"] ?: decrypt(state[name]) ?: "****"
 			state.remove("set$name".toString())
 		} else {
-			map = [ name: "codeReport", value: cmd.userIdentifier, data: [ code: code ] ]
+			map = [ name: "codeReport", value: cmd.userIdentifier, data: [ code: code ], isStateChange: true ]
 			map.descriptionText = "$device.displayName code $cmd.userIdentifier is set"
 			map.displayed = (cmd.userIdentifier != state.requestCode && cmd.userIdentifier != state.pollCode)
 			map.isStateChange = true
@@ -439,11 +462,12 @@ def zwaveEvent(physicalgraph.zwave.commands.timev1.TimeGet cmd) {
 def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
 	// The old Schlage locks use group 1 for basic control - we don't want that, so unsubscribe from group 1
 	def result = [ createEvent(name: "lock", value: cmd.value ? "unlocked" : "locked") ]
-	result << response(zwave.associationV1.associationRemove(groupingIdentifier:1, nodeId:zwaveHubNodeId))
-	if (state.assoc != zwaveHubNodeId) {
-		result << response(zwave.associationV1.associationGet(groupingIdentifier:2))
-	}
-	result
+	def cmds = [
+			zwave.associationV1.associationRemove(groupingIdentifier:1, nodeId:zwaveHubNodeId).format(),
+			"delay 1200",
+			zwave.associationV1.associationGet(groupingIdentifier:2).format()
+	]
+	[result, response(cmds)]
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
@@ -513,11 +537,18 @@ def unlockwtimeout() {
 	lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_UNSECURED_WITH_TIMEOUT)
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
 def ping() {
-	refresh()
+	runIn(30, followupStateCheck)
+	secure(zwave.doorLockV1.doorLockOperationGet())
+}
+
+def followupStateCheck() {
+	runEvery1Hour(stateCheck)
+	stateCheck()
+}
+
+def stateCheck() {
+	sendHubCommand(new physicalgraph.device.HubAction(secure(zwave.doorLockV1.doorLockOperationGet())))
 }
 
 def refresh() {

devicetypes/smartthings/zwave-metering-dimmer.src/zwave-metering-dimmer.groovy

@@ -85,11 +85,21 @@ metadata {
 	details(["switch", "power", "energy", "levelSliderControl", "refresh", "reset"])
 }
 
+def getCommandClassVersions() {
+	[
+		0x20: 1,  // Basic
+		0x26: 3,  // SwitchMultilevel
+		0x56: 1,  // Crc16Encap
+		0x70: 1,  // Configuration
+		0x32: 3,  // Meter
+	]
+}
+
 // parse events into attributes
 def parse(String description) {
 	def result = null
 	if (description != "updated") {
-		def cmd = zwave.parse(description, [0x20: 1, 0x26: 3, 0x70: 1, 0x32:3])
+		def cmd = zwave.parse(description, commandClassVersions)
 		if (cmd) {
 			result = zwaveEvent(cmd)
 	        log.debug("'$description' parsed to $result")
@@ -124,6 +134,21 @@ def zwaveEvent(physicalgraph.zwave.commands.switchmultilevelv3.SwitchMultilevelR
 	dimmerEvents(cmd)
 }
 
+def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd) {
+	def versions = commandClassVersions
+	def version = versions[cmd.commandClass as Integer]
+	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
+	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
+	if (encapsulatedCommand) {
+		zwaveEvent(encapsulatedCommand)
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.Command cmd) {
+	// Handles all Z-Wave commands we aren't interested in
+	[:]
+}
+
 def dimmerEvents(physicalgraph.zwave.Command cmd) {
 	def result = []
 	def value = (cmd.value ? "on" : "off")

devicetypes/smartthings/zwave-metering-switch.src/zwave-metering-switch.groovy

@@ -89,10 +89,19 @@ def updated() {
 	} catch (e) { log.debug e }
 }
 
+def getCommandClassVersions() {
+	[
+		0x20: 1,  // Basic
+		0x32: 1,  // SwitchMultilevel
+		0x56: 1,  // Crc16Encap
+		0x72: 2,  // ManufacturerSpecific
+	]
+}
+
 def parse(String description) {
 	def result = null
 	if(description == "updated") return
-	def cmd = zwave.parse(description, [0x20: 1, 0x32: 1, 0x72: 2])
+	def cmd = zwave.parse(description, commandClassVersions)
 	if (cmd) {
 		result = zwaveEvent(cmd)
 	}
@@ -157,6 +166,16 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
 	result
 }
 
+def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd) {
+	def versions = commandClassVersions
+	def version = versions[cmd.commandClass as Integer]
+	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
+	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
+	if (encapsulatedCommand) {
+		zwaveEvent(encapsulatedCommand)
+	}
+}
+
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	log.debug "$device.displayName: Unhandled: $cmd"
 	[:]

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

@@ -29,7 +29,7 @@ metadata {
 		fingerprint mfr: "0060", prod: "0001", model: "0002", deviceJoinName: "Everspring Motion Sensor"  // Everspring SP814
 		fingerprint mfr: "0060", prod: "0001", model: "0003", deviceJoinName: "Everspring Motion Sensor"  // Everspring HSP02
 		fingerprint mfr: "011A", prod: "0601", model: "0901", deviceJoinName: "Enerwave Motion Sensor"  // Enerwave ZWN-BPC
-		fingerprint mfr: "0063", prod: "4953", model: "3133", deviceJoinName: "GE Smart Motion Sensor"
+		fingerprint mfr: "0063", prod: "4953", model: "3133", deviceJoinName: "GE Portable Smart Motion Sensor"
 	}
 
 	simulator {

devicetypes/smartthings/zwave-plus-motion-temp-sensor.src/zwave-plus-motion-temp-sensor.groovy

@@ -37,8 +37,8 @@ metadata {
 
 	tiles {
 		standardTile("motion", "device.motion", width: 3, height: 2) {
-			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
-			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
+			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC"
+			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#CCCCCC"
 		}
 
 		valueTile("temperature", "device.temperature", inactiveLabel: false) {

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

@@ -16,7 +16,7 @@
  *  Date: 2014-07-15
  */
 metadata {
-	definition (name: "Z-Wave Siren", namespace: "smartthings", author: "SmartThings") {
+	definition (name: "Z-Wave Siren", namespace: "smartthings", author: "SmartThings", ocfDeviceType: "x.com.st.d.sensor.smoke") {
 		capability "Actuator"
         capability "Alarm"
         capability "Battery"
@@ -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,7 +21,6 @@ metadata {
 
 		attribute "alarmState", "string"
 
-		fingerprint deviceId: "0xA100", inClusters: "0x20,0x80,0x70,0x85,0x71,0x72,0x86"
 		fingerprint mfr:"0138", prod:"0001", model:"0002", deviceJoinName: "First Alert Smoke Detector and Carbon Monoxide Alarm (ZCOMBO)"
 	}
 
@@ -56,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() {
@@ -104,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-switch-generic.src/zwave-switch-generic.groovy

@@ -71,9 +71,17 @@ def updated(){
 	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 }
 
+def getCommandClassVersions() {
+	[
+		0x20: 1,  // Basic
+		0x56: 1,  // Crc16Encap
+		0x70: 1,  // Configuration
+	]
+}
+
 def parse(String description) {
 	def result = null
-	def cmd = zwave.parse(description, [0x20: 1, 0x70: 1])
+	def cmd = zwave.parse(description, commandClassVersions)
 	if (cmd) {
 		result = createEvent(zwaveEvent(cmd))
 	}
@@ -120,6 +128,15 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
 	createEvent([descriptionText: "$device.displayName MSR: $msr", isStateChange: false])
 }
 
+def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd) {
+	def versions = commandClassVersions
+	def version = versions[cmd.commandClass as Integer]
+	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
+	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
+	if (encapsulatedCommand) {
+		zwaveEvent(encapsulatedCommand)
+	}
+}
 
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	// Handles all Z-Wave commands we aren't interested in

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

@@ -89,9 +89,17 @@ def updated(){
     }
 }
 
+def getCommandClassVersions() {
+	[
+		0x20: 1,  // Basic
+		0x56: 1,  // Crc16Encap
+		0x70: 1,  // Configuration
+	]
+}
+
 def parse(String description) {
 	def result = null
-	def cmd = zwave.parse(description, [0x20: 1, 0x70: 1])
+	def cmd = zwave.parse(description, commandClassVersions)
 	if (cmd) {
 		result = createEvent(zwaveEvent(cmd))
 	}
@@ -138,6 +146,16 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
 	createEvent([descriptionText: "$device.displayName MSR: $msr", isStateChange: false])
 }
 
+def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd) {
+	def versions = commandClassVersions
+	def version = versions[cmd.commandClass as Integer]
+	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
+	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
+	if (encapsulatedCommand) {
+		zwaveEvent(encapsulatedCommand)
+	}
+}
+
 
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	// Handles all Z-Wave commands we aren't interested in

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

@@ -15,10 +15,8 @@ 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"
 		
@@ -26,200 +24,175 @@ metadata {
 
 		command "switchMode"
 		command "switchFanMode"
-        command "quickSetCool"
-        command "quickSetHeat"
+		command "lowerHeatingSetpoint"
+		command "raiseHeatingSetpoint"
+		command "lowerCoolSetpoint"
+		command "raiseCoolSetpoint"
 
 		fingerprint deviceId: "0x08"
 		fingerprint inClusters: "0x43,0x40,0x44,0x31"
 		fingerprint mfr:"0039", prod:"0011", model:"0001", deviceJoinName: "Honeywell Z-Wave 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 "auto"			: "command: 4403, payload: 00" // "fanAuto"
-		status "on"				: "command: 4403, payload: 01" // "fanOn"
-		status "circulate"		: "command: 4403, payload: 06" // "fanCirculate
-
-		status "heat 60"        : "command: 4303, payload: 01 09 3C"
-		status "heat 68"        : "command: 4303, payload: 01 09 44"
-		status "heat 72"        : "command: 4303, payload: 01 09 48"
-
-		status "cool 72"        : "command: 4303, payload: 02 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 70"        : "command: 3105, payload: 01 2A 02 BC"
-		status "temp 74"        : "command: 3105, payload: 01 2A 02 E4"
-		status "temp 78"        : "command: 3105, payload: 01 2A 03 0C"
-		status "temp 82"        : "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"
-		status "fan only"		: "command: 4203, payload: 03"
-		status "pending heat"	: "command: 4203, payload: 04"
-		status "pending cool"	: "command: 4203, payload: 05"
-		status "vent economizer": "command: 4203, payload: 06"
-
-		// reply messages
-		reply "2502": "command: 2503, payload: FF"
-	}
-
 	tiles {
-		// Using standardTile instead of valueTile as it renders the icon better
-		standardTile("temperature", "device.temperature", width: 2, height: 2) {
-			state("temperature", label:'${currentValue}°', icon: "st.thermostat.ac.air-conditioning",
-				backgroundColors:[
-					[value: 31, color: "#153591"],
-					[value: 44, color: "#1e9cbb"],
-					[value: 59, color: "#90d2a7"],
-					[value: 74, color: "#44b621"],
-					[value: 84, color: "#f1d801"],
-					[value: 95, color: "#d04e00"],
-					[value: 96, color: "#bc2323"]
-				]
-			)
+		multiAttributeTile(name:"temperature", type:"generic", width:3, height:2, canChangeIcon: true) {
+			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
+				attributeState("temperature", label:'${currentValue}°', icon: "st.alarm.temperature.normal",
+					backgroundColors:[
+							// Celsius
+							[value: 0, color: "#153591"],
+							[value: 7, color: "#1e9cbb"],
+							[value: 15, color: "#90d2a7"],
+							[value: 23, color: "#44b621"],
+							[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"]
+					]
+				)
+			}
 		}
-		standardTile("mode", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
-			state "off", action:"switchMode", nextState:"to_heat", icon: "st.thermostat.heating-cooling-off"
-			state "heat", action:"switchMode", nextState:"to_cool", icon: "st.thermostat.heat"
+		standardTile("mode", "device.thermostatMode", width:2, height:2, inactiveLabel: false, decoration: "flat") {
+			state "off", action:"switchMode", nextState:"...", icon: "st.thermostat.heating-cooling-off"
+			state "heat", action:"switchMode", nextState:"...", icon: "st.thermostat.heat"
 			state "cool", action:"switchMode", nextState:"...", icon: "st.thermostat.cool"
 			state "auto", action:"switchMode", nextState:"...", icon: "st.thermostat.auto"
 			state "emergency heat", action:"switchMode", nextState:"...", icon: "st.thermostat.emergency-heat"
-			state "to_heat", action:"switchMode", nextState:"to_cool", icon: "st.thermostat.heat"
-			state "to_cool", action:"switchMode", nextState:"...", icon: "st.thermostat.cool"
-			state "...", label: "...", action:"off", nextState:"off"
+			state "...", label: "Updating...",nextState:"...", backgroundColor:"#ffffff"
 		}
-		standardTile("fanMode", "device.thermostatFanMode", inactiveLabel: false, decoration: "flat") {
-			state "auto", action:"switchFanMode", nextState:"...", icon: "st.thermostat.fan-auto" // "fanAuto"
-			state "on", action:"switchFanMode", nextState:"...", icon: "st.thermostat.fan-on" // "fanOn"
-			state "circulate", action:"switchFanMode", nextState:"...", icon: "st.thermostat.fan-circulate" // "fanCirculate"
-			state "...", label: "...", nextState:"..."
+		standardTile("fanMode", "device.thermostatFanMode", width:2, height:2, inactiveLabel: false, decoration: "flat") {
+			state "auto", action:"switchFanMode", nextState:"...", icon: "st.thermostat.fan-auto"
+			state "on", action:"switchFanMode", nextState:"...", icon: "st.thermostat.fan-on"
+			state "circulate", action:"switchFanMode", nextState:"...", icon: "st.thermostat.fan-circulate"
+			state "...", label: "Updating...", nextState:"...", backgroundColor:"#ffffff"
 		}
-		controlTile("heatSliderControl", "device.heatingSetpoint", "slider", height: 1, width: 2, inactiveLabel: false) {
-			state "setHeatingSetpoint", action:"quickSetHeat", backgroundColor:"#d04e00"
+		standardTile("lowerHeatingSetpoint", "device.heatingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
+			state "heatingSetpoint", action:"lowerHeatingSetpoint", icon:"st.thermostat.thermostat-left"
 		}
-		valueTile("heatingSetpoint", "device.heatingSetpoint", inactiveLabel: false, decoration: "flat") {
-			state "heat", label:'${currentValue}° heat', backgroundColor:"#ffffff"
+		valueTile("heatingSetpoint", "device.heatingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
+			state "heatingSetpoint", label:'${currentValue}° heat', backgroundColor:"#ffffff"
 		}
-		controlTile("coolSliderControl", "device.coolingSetpoint", "slider", height: 1, width: 2, inactiveLabel: false) {
-			state "setCoolingSetpoint", action:"quickSetCool", backgroundColor: "#1e9cbb"
+		standardTile("raiseHeatingSetpoint", "device.heatingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
+			state "heatingSetpoint", action:"raiseHeatingSetpoint", icon:"st.thermostat.thermostat-right"
 		}
-		valueTile("coolingSetpoint", "device.coolingSetpoint", inactiveLabel: false, decoration: "flat") {
-			state "cool", label:'${currentValue}° cool', backgroundColor:"#ffffff"
+		standardTile("lowerCoolSetpoint", "device.coolingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
+			state "coolingSetpoint", action:"lowerCoolSetpoint", icon:"st.thermostat.thermostat-left"
 		}
-		standardTile("refresh", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
-			state "default", action:"polling.poll", icon:"st.secondary.refresh"
+		valueTile("coolingSetpoint", "device.coolingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
+			state "coolingSetpoint", label:'${currentValue}° cool', backgroundColor:"#ffffff"
+		}
+		standardTile("raiseCoolSetpoint", "device.heatingSetpoint", width:2, height:1, inactiveLabel: false, decoration: "flat") {
+			state "heatingSetpoint", action:"raiseCoolSetpoint", icon:"st.thermostat.thermostat-right"
+		}
+		valueTile("thermostatOperatingState", "device.thermostatOperatingState", width: 2, height:1, decoration: "flat") {
+			state "thermostatOperatingState", label:'${currentValue}', backgroundColor:"#ffffff"
+		}
+		standardTile("refresh", "device.thermostatMode", width:2, height:1, inactiveLabel: false, decoration: "flat") {
+			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 		main "temperature"
-		details(["temperature", "mode", "fanMode", "heatSliderControl", "heatingSetpoint", "coolSliderControl", "coolingSetpoint", "refresh"])
+		details(["temperature", "lowerHeatingSetpoint", "heatingSetpoint", "raiseHeatingSetpoint", "lowerCoolSetpoint",
+				"coolingSetpoint", "raiseCoolSetpoint", "mode", "fanMode", "thermostatOperatingState", "refresh"])
 	}
 }
 
-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])
+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)
+	runIn(3, "initialize", [overwrite: true])  // Allow configure command to be sent and acknowledged before proceeding
 }
 
-def updated(){
+def updated() {
+	// If not set update ManufacturerSpecific data
+	if (!getDataValue("manufacturer")) {
+		sendHubCommand(new physicalgraph.device.HubAction(zwave.manufacturerSpecificV2.manufacturerSpecificGet().format()))
+		runIn(2, "initialize", [overwrite: true])  // Allow configure command to be sent and acknowledged before proceeding
+	} else {
+		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()
+	if (getDataValue("manufacturer") != "Honeywell") {
+		runEvery5Minutes("poll")  // This is not necessary for Honeywell Z-wave, but could be for other Z-wave thermostats
+	}
+	poll()
 }
 
 def parse(String description)
 {
-	def map = createEvent(zwaveEvent(zwave.parse(description, [0x42:1, 0x43:2, 0x31: 3])))
-	if (!map) {
-		return null
+	def result = null
+	if (description == "updated") {
+	} else {
+		def zwcmd = zwave.parse(description, [0x42:1, 0x43:2, 0x31: 3])
+		if (zwcmd) {
+			result = zwaveEvent(zwcmd)
+		} else {
+			log.debug "$device.displayName couldn't parse $description"
+		}
 	}
-
-	def result = [map]
-	if (map.isStateChange && map.name in ["heatingSetpoint","coolingSetpoint","thermostatMode"]) {
-		def map2 = [
-			name: "thermostatSetpoint",
-			unit: getTemperatureScale()
-		]
-		if (map.name == "thermostatMode") {
-			state.lastTriedMode = map.value
-			if (map.value == "cool") {
-				map2.value = device.latestValue("coolingSetpoint")
-				log.info "THERMOSTAT, latest cooling setpoint = ${map2.value}"
-			}
-			else {
-				map2.value = device.latestValue("heatingSetpoint")
-				log.info "THERMOSTAT, latest heating setpoint = ${map2.value}"
-			}
-		}
-		else {
-			def mode = device.latestValue("thermostatMode")
-			log.info "THERMOSTAT, latest mode = ${mode}"
-			if ((map.name == "heatingSetpoint" && mode == "heat") || (map.name == "coolingSetpoint" && mode == "cool")) {
-				map2.value = map.value
-				map2.unit = map.unit
-			}
-		}
-		if (map2.value != null) {
-			log.debug "THERMOSTAT, adding setpoint event: $map"
-			result << createEvent(map2)
-		}
-	} else if (map.name == "thermostatFanMode" && map.isStateChange) {
-		state.lastTriedFanMode = map.value
+	if (!result) {
+		return []
 	}
-	log.debug "Parse returned $result"
-	result
+	return [result]
 }
 
 // Event Generation
-def zwaveEvent(physicalgraph.zwave.commands.thermostatsetpointv2.ThermostatSetpointReport cmd)
-{
+def zwaveEvent(physicalgraph.zwave.commands.thermostatsetpointv2.ThermostatSetpointReport cmd) {
 	def cmdScale = cmd.scale == 1 ? "F" : "C"
-	def map = [:]
-	map.value = convertTemperatureIfNeeded(cmd.scaledValue, cmdScale, cmd.precision)
-	map.unit = getTemperatureScale()
-	map.displayed = false
+	def setpoint = getTempInLocalScale(cmd.scaledValue, cmdScale)
+	def unit = getTemperatureScale()
 	switch (cmd.setpointType) {
 		case 1:
-			map.name = "heatingSetpoint"
+			sendEvent(name: "heatingSetpoint", value: setpoint, unit: unit, displayed: false)
+			updateThermostatSetpoint("heatingSetpoint", setpoint)
 			break;
 		case 2:
-			map.name = "coolingSetpoint"
+			sendEvent(name: "coolingSetpoint", value: setpoint, unit: unit, displayed: false)
+			updateThermostatSetpoint("coolingSetpoint", setpoint)
 			break;
 		default:
-			return [:]
+			log.debug "unknown setpointType $cmd.setpointType"
+			return
 	}
 	// So we can respond with same format
 	state.size = cmd.size
 	state.scale = cmd.scale
 	state.precision = cmd.precision
-	map
+	// Make sure return value is not result from above expresion
+	return 0
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv3.SensorMultilevelReport cmd)
-{
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv3.SensorMultilevelReport cmd) {
 	def map = [:]
 	if (cmd.sensorType == 1) {
-		map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmd.scale == 1 ? "F" : "C", cmd.precision)
+		map.value = getTempInLocalScale(cmd.scaledSensorValue, cmd.scale == 1 ? "F" : "C")
 		map.unit = getTemperatureScale()
 		map.name = "temperature"
+		updateThermostatSetpoint(null, null)
 	} else if (cmd.sensorType == 5) {
 		map.value = cmd.scaledSensorValue
 		map.unit = "%"
 		map.name = "humidity"
 	}
-	map
+	sendEvent(map)
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport cmd)
-{
-	def map = [:]
+def zwaveEvent(physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport cmd) {
+	def map = [name: "thermostatOperatingState"]
 	switch (cmd.operatingState) {
 		case physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport.OPERATING_STATE_IDLE:
 			map.value = "idle"
@@ -243,8 +216,9 @@ def zwaveEvent(physicalgraph.zwave.commands.thermostatoperatingstatev1.Thermosta
 			map.value = "vent economizer"
 			break
 	}
-	map.name = "thermostatOperatingState"
-	map
+	// Makes sure we have the correct thermostat mode
+	sendHubCommand(new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeGet().format()))
+	sendEvent(map)
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatfanstatev1.ThermostatFanStateReport cmd) {
@@ -260,11 +234,11 @@ def zwaveEvent(physicalgraph.zwave.commands.thermostatfanstatev1.ThermostatFanSt
 			map.value = "running high"
 			break
 	}
-	map
+	sendEvent(map)
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport cmd) {
-	def map = [:]
+	def map = [name: "thermostatMode", data:[supportedThermostatModes: state.supportedModes]]
 	switch (cmd.mode) {
 		case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_OFF:
 			map.value = "off"
@@ -282,54 +256,62 @@ def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeRepor
 			map.value = "auto"
 			break
 	}
-	map.name = "thermostatMode"
-	map
+	sendEvent(map)
+	updateThermostatSetpoint(null, null)
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport cmd) {
-	def map = [:]
+	def map = [name: "thermostatFanMode", data:[supportedThermostatFanModes: state.supportedFanModes]]
 	switch (cmd.fanMode) {
 		case physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport.FAN_MODE_AUTO_LOW:
-			map.value = "auto" // "fanAuto"
+			map.value = "auto"
 			break
 		case physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport.FAN_MODE_LOW:
-			map.value = "on" // "fanOn"
+			map.value = "on"
 			break
 		case physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport.FAN_MODE_CIRCULATION:
-			map.value = "circulate" // "fanCirculate"
+			map.value = "circulate"
 			break
 	}
-	map.name = "thermostatFanMode"
-	map.displayed = false
-	map
+	sendEvent(map)
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeSupportedReport cmd) {
-	def supportedModes = ""
-	if(cmd.off) { supportedModes += "off " }
-	if(cmd.heat) { supportedModes += "heat " }
-	if(cmd.auxiliaryemergencyHeat) { supportedModes += "emergency heat " }
-	if(cmd.cool) { supportedModes += "cool " }
-	if(cmd.auto) { supportedModes += "auto " }
+	def supportedModes = []
+	if(cmd.off) { supportedModes << "off" }
+	if(cmd.heat) { supportedModes << "heat" }
+	if(cmd.cool) { supportedModes << "cool" }
+	if(cmd.auto) { supportedModes << "auto" }
+	if(cmd.auxiliaryemergencyHeat) { supportedModes << "emergency heat" }
 
 	state.supportedModes = supportedModes
-	// No events to be generated, return empty map
-	return [:]
+	sendEvent(name: "supportedThermostatModes", value: supportedModes, displayed: false)
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeSupportedReport cmd) {
-	def supportedFanModes = ""
-	if(cmd.auto) { supportedFanModes += "auto " } // "fanAuto "
-	if(cmd.low) { supportedFanModes += "on " } // "fanOn"
-	if(cmd.circulation) { supportedFanModes += "circulate " } // "fanCirculate"
+	def supportedFanModes = []
+	if(cmd.auto) { supportedFanModes << "auto" }
+	if(cmd.circulation) { supportedFanModes << "circulate" }
+	if(cmd.low) { supportedFanModes << "on" }
 
 	state.supportedFanModes = supportedFanModes
-	// No events to be generated, return empty map
-	return [:]
+	sendEvent(name: "supportedThermostatFanModes", value: supportedFanModes, displayed: false)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport 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 zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
-	log.debug "Zwave event received: $cmd"
+	log.debug "Zwave BasicReport: $cmd"
 }
 
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
@@ -337,75 +319,175 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 }
 
 // Command Implementations
+def refresh() {
+	// Only allow refresh every 2 minutes to prevent flooding the Zwave network
+	def timeNow = now()
+	if (!state.refreshTriggeredAt || (2 * 60 * 1000 < (timeNow - state.refreshTriggeredAt))) {
+		state.refreshTriggeredAt = timeNow
+		// use runIn with overwrite to prevent multiple DTH instances run before state.refreshTriggeredAt has been saved
+		runIn(2, "poll", [overwrite: true])
+	}
+}
+
 def poll() {
-	delayBetween([
-		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 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.thermostatModeV2.thermostatModeGet().format())
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeGet().format())
+	cmds << new physicalgraph.device.HubAction(zwave.sensorMultilevelV2.sensorMultilevelGet().format()) // current temperature
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format())
+	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) {
-	setHeatingSetpoint(degrees, 1000)
+def raiseHeatingSetpoint() {
+	alterSetpoint(true, "heatingSetpoint")
 }
 
-def setHeatingSetpoint(degrees, delay = 30000) {
-	setHeatingSetpoint(degrees.toDouble(), delay)
+def lowerHeatingSetpoint() {
+	alterSetpoint(false, "heatingSetpoint")
 }
 
-def setHeatingSetpoint(Double degrees, Integer delay = 30000) {
-	log.trace "setHeatingSetpoint($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 convertedDegrees
-    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: 1, scale: deviceScale, precision: p, scaledValue: convertedDegrees).format(),
-		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format()
-	], delay)
+def raiseCoolSetpoint() {
+	alterSetpoint(true, "coolingSetpoint")
 }
 
-def quickSetCool(degrees) {
-	setCoolingSetpoint(degrees, 1000)
+def lowerCoolSetpoint() {
+	alterSetpoint(false, "coolingSetpoint")
 }
 
-def setCoolingSetpoint(degrees, delay = 30000) {
-	setCoolingSetpoint(degrees.toDouble(), delay)
+// Adjusts nextHeatingSetpoint either .5° C/1° F) if raise true/false
+def alterSetpoint(raise, setpoint) {
+	def locationScale = getTemperatureScale()
+	def deviceScale = (state.scale == 1) ? "F" : "C"
+	def heatingSetpoint = getTempInLocalScale("heatingSetpoint")
+	def coolingSetpoint = getTempInLocalScale("coolingSetpoint")
+	def targetValue = (setpoint == "heatingSetpoint") ? heatingSetpoint : coolingSetpoint
+	def delta = (locationScale == "F") ? 1 : 0.5
+	targetValue += raise ? delta : - delta
+
+	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": getTempInLocalScale(data.targetHeatingSetpoint, deviceScale),
+				unit: getTemperatureScale(), eventType: "ENTITY_UPDATE", displayed: false)
+	}
+	if (data.targetCoolingSetpoint) {
+		sendEvent("name": "coolingSetpoint", "value": getTempInLocalScale(data.targetCoolingSetpoint, deviceScale),
+				unit: getTemperatureScale(), eventType: "ENTITY_UPDATE", displayed: false)
+	}
+	if (data.targetHeatingSetpoint && data.targetCoolingSetpoint) {
+		runIn(5, "updateHeatingSetpoint", [data: data, overwrite: true])
+	} else if (setpoint == "heatingSetpoint" && data.targetHeatingSetpoint) {
+		runIn(5, "updateHeatingSetpoint", [data: data, overwrite: true])
+	} else if (setpoint == "coolingSetpoint" && data.targetCoolingSetpoint) {
+		runIn(5, "updateCoolingSetpoint", [data: data, overwrite: true])
+	}
 }
 
-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 updateHeatingSetpoint(data) {
+	updateSetpoints(data)
+}
 
-    def convertedDegrees
-    if (locationScale == "C" && deviceScaleString == "F") {
-    	convertedDegrees = celsiusToFahrenheit(degrees)
-    } else if (locationScale == "F" && deviceScaleString == "C") {
-    	convertedDegrees = fahrenheitToCelsius(degrees)
-    } else {
-    	convertedDegrees = degrees
-    }
+def updateCoolingSetpoint(data) {
+	updateSetpoints(data)
+}
 
-	delayBetween([
-		zwave.thermostatSetpointV1.thermostatSetpointSet(setpointType: 2, scale: deviceScale, precision: p,  scaledValue: convertedDegrees).format(),
-		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format()
-	], delay)
+def enforceSetpointLimits(setpoint, data) {
+	def locationScale = getTemperatureScale() 
+	def minSetpoint = (setpoint == "heatingSetpoint") ? getTempInDeviceScale(40, "F") : getTempInDeviceScale(50, "F")
+	def maxSetpoint = (setpoint == "heatingSetpoint") ? getTempInDeviceScale(90, "F") : getTempInDeviceScale(99, "F")
+	def deadband = (state.scale == 1) ? 3 : 2  // 3°F, 2°C
+	def targetValue = getTempInDeviceScale(data.targetValue, locationScale)
+	def heatingSetpoint = null
+	def coolingSetpoint = null
+	// Enforce min/mix for setpoints
+	if (targetValue > maxSetpoint) {
+		targetValue = maxSetpoint
+	} else if (targetValue < minSetpoint) {
+		targetValue = minSetpoint
+	}
+	// Enforce 3 degrees F deadband between setpoints
+	if (setpoint == "heatingSetpoint") {
+		heatingSetpoint = targetValue 
+		coolingSetpoint = (heatingSetpoint + deadband > getTempInDeviceScale(data.coolingSetpoint, locationScale)) ? heatingSetpoint + deadband : null
+	}
+	if (setpoint == "coolingSetpoint") {
+		coolingSetpoint = targetValue
+		heatingSetpoint = (coolingSetpoint - deadband < getTempInDeviceScale(data.heatingSetpoint, locationScale)) ? coolingSetpoint - deadband : null
+	}
+	return [targetHeatingSetpoint: heatingSetpoint, targetCoolingSetpoint: coolingSetpoint]
+}
+
+def setHeatingSetpoint(degrees) {
+	if (degrees) {
+		state.heatingSetpoint = degrees.toDouble()
+		runIn(2, "updateSetpoints", [overwrite: true])
+	}
+}
+
+def setCoolingSetpoint(degrees) {
+	if (degrees) {
+		state.coolingSetpoint = degrees.toDouble()
+		runIn(2, "updateSetpoints", [overwrite: true])
+	}
+}
+
+def updateSetpoints() {
+	def deviceScale = (state.scale == 1) ? "F" : "C"
+	def data = [targetHeatingSetpoint: null, targetCoolingSetpoint: null]
+	def heatingSetpoint = getTempInLocalScale("heatingSetpoint")
+	def coolingSetpoint = getTempInLocalScale("coolingSetpoint")
+	if (state.heatingSetpoint) {
+		data = enforceSetpointLimits("heatingSetpoint", [targetValue: state.heatingSetpoint,
+				heatingSetpoint: heatingSetpoint, coolingSetpoint: coolingSetpoint])
+	}
+	if (state.coolingSetpoint) {
+		heatingSetpoint = data.targetHeatingSetpoint ? getTempInLocalScale(data.targetHeatingSetpoint, deviceScale) : heatingSetpoint
+		coolingSetpoint = data.targetCoolingSetpoint ? getTempInLocalScale(data.targetCoolingSetpoint, deviceScale) : coolingSetpoint
+		data = enforceSetpointLimits("coolingSetpoint", [targetValue: state.coolingSetpoint,
+				heatingSetpoint: heatingSetpoint, coolingSetpoint: coolingSetpoint])
+		data.targetHeatingSetpoint = data.targetHeatingSetpoint ?: heatingSetpoint
+	}
+	state.heatingSetpoint = null
+	state.coolingSetpoint = null
+	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: data.targetHeatingSetpoint).format())
+	}
+	if (data.targetCoolingSetpoint) {
+		cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointSet(
+					setpointType: 2, scale: state.scale, precision: state.precision, scaledValue: data.targetCoolingSetpoint).format())
+	}
+	sendHubCommand(cmds)
+}
+
+// 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
+	} else if (mode == "auto" || mode == "off") {
+		// Set thermostatSetpoint to the setpoint closest to the current temperature
+		def currentTemperature = getTempInLocalScale("temperature")
+		if (currentTemperature > (heatingSetpoint + coolingSetpoint)/2) {
+			thermostatSetpoint = coolingSetpoint
+		}
+	}
+	sendEvent(name: "thermostatSetpoint", value: thermostatSetpoint, unit: getTemperatureScale())
 }
 
 /**
@@ -413,90 +495,74 @@ def setCoolingSetpoint(Double degrees, Integer delay = 30000) {
  * */
 def ping() {
 	log.debug "ping() called"
-	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"]
+	// Just get Operating State there's no need to flood more commands
+	sendHubCommand(new physicalgraph.device.HubAction(zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format()))
 }
 
 def switchMode() {
-	def currentMode = device.currentState("thermostatMode")?.value
-	def lastTriedMode = state.lastTriedMode ?: currentMode ?: "off"
-	def supportedModes = getDataByName("supportedModes")
-	def modeOrder = modes()
-	def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
-	def nextMode = next(lastTriedMode)
-	if (supportedModes?.contains(currentMode)) {
-		while (!supportedModes.contains(nextMode) && nextMode != "off") {
-			nextMode = next(nextMode)
-		}
+	def currentMode = device.currentValue("thermostatMode")
+	def supportedModes = state.supportedModes
+	if (supportedModes) {
+		def next = { supportedModes[supportedModes.indexOf(it) + 1] ?: supportedModes[0] }
+		def nextMode = next(currentMode)
+		runIn(2, "setThermostatMode", [data: [nextMode: nextMode], overwrite: true])
+	} else {
+		log.warn "supportedModes not defined"
+		getSupportedModes()
 	}
-	state.lastTriedMode = nextMode
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: modeMap[nextMode]).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], 1000)
 }
 
 def switchToMode(nextMode) {
-	def supportedModes = getDataByName("supportedModes")
-	if(supportedModes && !supportedModes.contains(nextMode)) log.warn "thermostat mode '$nextMode' is not supported"
-	if (nextMode in modes()) {
-		state.lastTriedMode = nextMode
-		"$nextMode"()
+	def supportedModes = state.supportedModes
+	if (supportedModes) {
+		if (supportedModes.contains(nextMode)) {
+			runIn(2, "setThermostatMode", [data: [nextMode: nextMode], overwrite: true])
+		} else {
+			log.debug("ThermostatMode $nextMode is not supported by ${device.displayName}")
+		}
 	} else {
-		log.debug("no mode method '$nextMode'")
+		log.warn "supportedModes not defined"
+		getSupportedModes()
 	}
 }
 
+def getSupportedModes() {
+	def cmds = []
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeSupportedGet().format())
+	sendHubCommand(cmds)
+}
+
 def switchFanMode() {
-	def currentMode = device.currentState("thermostatFanMode")?.value
-	def lastTriedMode = state.lastTriedFanMode ?: currentMode ?: "off"
-	def supportedModes = getDataByName("supportedFanModes") ?: "auto on" // "fanAuto fanOn"
-	def modeOrder = ["auto", "circulate", "on"]                 // "fanAuto", "fanCirculate", "fanOn"
-	def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
-	def nextMode = next(lastTriedMode)
-	while (!supportedModes?.contains(nextMode) && nextMode != "auto") { // "fanAuto"
-		nextMode = next(nextMode)
+	def currentMode = device.currentValue("thermostatFanMode")
+	def supportedFanModes = state.supportedFanModes
+	if (supportedFanModes) {
+		def next = { supportedFanModes[supportedFanModes.indexOf(it) + 1] ?: supportedFanModes[0] }
+		def nextMode = next(currentMode)
+		runIn(2, "setThermostatFanMode", [data: [nextMode: nextMode], overwrite: true])
+	} else {
+		log.warn "supportedFanModes not defined"
+		getSupportedFanModes()
 	}
-	switchToFanMode(nextMode)
 }
 
 def switchToFanMode(nextMode) {
-	def supportedFanModes = getDataByName("supportedFanModes")
-	if(supportedFanModes && !supportedFanModes.contains(nextMode)) log.warn "thermostat mode '$nextMode' is not supported"
-
-	def returnCommand
-	if (nextMode == "auto") { // "fanAuto"
-		returnCommand = fanAuto()
-	} else if (nextMode == "on") { // "fanOn"
-		returnCommand = fanOn()
-	} else if (nextMode == "circulate") { // "fanCirculate"
-		returnCommand = fanCirculate()
+	def supportedFanModes = state.supportedFanModes
+	if (supportedFanModes) {
+		if (supportedFanModes.contains(nextMode)) {
+			runIn(2, "setThermostatFanMode", [data: [nextMode: nextMode], overwrite: true])
+		} else {
+			log.debug("FanMode $nextMode is not supported by ${device.displayName}")
+		}
 	} else {
-		log.debug("no fan mode '$nextMode'")
+		log.warn "supportedFanModes not defined"
+		getSupportedFanModes()
 	}
-	if(returnCommand) state.lastTriedFanMode = nextMode
-	returnCommand
 }
 
-def getDataByName(String name) {
-	state[name] ?: device.getDataValue(name)
+def getSupportedFanModes() {
+	def cmds = []
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeSupportedGet().format())
+	sendHubCommand(cmds)
 }
 
 def getModeMap() { [
@@ -508,10 +574,14 @@ def getModeMap() { [
 ]}
 
 def setThermostatMode(String value) {
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: modeMap[value]).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
+	switchToMode(value)
+}
+
+def setThermostatMode(data) {
+	def cmds = []
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeSet(mode: modeMap[data.nextMode]).format())
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeGet().format())
+	sendHubCommand(cmds)
 }
 
 def getFanModeMap() { [
@@ -521,69 +591,83 @@ def getFanModeMap() { [
 ]}
 
 def setThermostatFanMode(String value) {
-	delayBetween([
-		zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: fanModeMap[value]).format(),
-		zwave.thermostatFanModeV3.thermostatFanModeGet().format()
-	], standardDelay)
+	switchToFanMode(value)
+}
+
+def setThermostatFanMode(data) {
+	def cmds = []
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: fanModeMap[data.nextMode]).format())
+	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeGet().format())
+	sendHubCommand(cmds)
 }
 
 def off() {
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: 0).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
+	switchToMode("off")
 }
 
 def heat() {
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: 1).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
+	switchToMode("heat")
 }
 
 def emergencyHeat() {
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: 4).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
+	switchToMode("emergency heat")
 }
 
 def cool() {
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: 2).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
+	switchToMode("cool")
 }
 
 def auto() {
-	delayBetween([
-		zwave.thermostatModeV2.thermostatModeSet(mode: 3).format(),
-		zwave.thermostatModeV2.thermostatModeGet().format()
-	], standardDelay)
+	switchToMode("auto")
 }
 
 def fanOn() {
-	delayBetween([
-		zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: 1).format(),
-		zwave.thermostatFanModeV3.thermostatFanModeGet().format()
-	], standardDelay)
+	switchToFanMode("on")
 }
 
 def fanAuto() {
-	delayBetween([
-		zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: 0).format(),
-		zwave.thermostatFanModeV3.thermostatFanModeGet().format()
-	], standardDelay)
+	switchToFanMode("auto")
 }
 
 def fanCirculate() {
-	delayBetween([
-		zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: 6).format(),
-		zwave.thermostatFanModeV3.thermostatFanModeGet().format()
-	], standardDelay)
+	switchToFanMode("circulate")
 }
 
-private getStandardDelay() {
-	1000
+// 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) {
+	if (temp && scale) {
+		def scaledTemp = convertTemperatureIfNeeded(temp.toBigDecimal(), scale).toDouble()
+		return (getTemperatureScale() == "F" ? scaledTemp.round(0).toInteger() : roundC(scaledTemp))
+	}
+	return 0
+}
+
+def getTempInDeviceScale(state) {
+	def temp = device.currentState(state)
+	if (temp && temp.value && temp.unit) {
+		return getTempInDeviceScale(temp.value.toBigDecimal(), temp.unit)
+	}
+	return 0
+}
+
+def getTempInDeviceScale(temp, scale) {
+	if (temp && scale) {
+		def deviceScale = (state.scale == 1) ? "F" : "C"
+		return (deviceScale == scale) ? temp :
+				(deviceScale == "F" ? celsiusToFahrenheit(temp) : roundC(fahrenheitToCelsius(temp)))
+	}
+	return 0
+}
+
+def roundC (tempC) {
+	return (Math.round(tempC.toDouble() * 2))/2
+}

devicetypes/smartthings/zwave-water-valve.src/.st-ignore

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

devicetypes/smartthings/zwave-water-valve.src/README.md

@@ -0,0 +1,38 @@
+# Z-Wave Water Valve
+
+Cloud Execution
+
+Works with: 
+
+* [Leak Intelligence Leak Gopher Water Shutoff Valve](https://www.smartthings.com/works-with-smartthings/other/leak-intelligence-leak-gopher-water-shutoff-valve)
+
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#Troubleshooting)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Health Check** - indicates ability to get device health notifications
+* **Valve** - allows for the control of a valve device
+* **Polling** - represents that poll() can be implemented for the device
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - detects sensor events
+
+## Device Health
+
+SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE`
+
+* __32min__ checkInterval
+
+## 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:
+* [Leak Intelligence Leak Gopher Water Shutoff Valve Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/209631423-Leak-Gopher-Z-Wave-Valve-Control)
+
+

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

@@ -12,14 +12,16 @@
  *
  */
 metadata {
-	definition (name: "Z-Wave Water Valve", namespace: "smartthings", author: "SmartThings") {
+	definition (name: "Z-Wave Water Valve", namespace: "smartthings", author: "SmartThings", ocfDeviceType: "oic.d.watervalve") {
 		capability "Actuator"
+		capability "Health Check"
 		capability "Valve"
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
 
 		fingerprint deviceId: "0x1006", inClusters: "0x25"
+		fingerprint mfr:"0173", prod:"0003", model:"0002", deviceJoinName: "Leak Intelligence Leak Gopher Water Shutoff Valve"
 	}
 
 	// simulator metadata
@@ -35,7 +37,7 @@ metadata {
 	// tile definitions
 	tiles(scale: 2) {
 		multiAttributeTile(name:"valve", type: "generic", width: 6, height: 4, canChangeIcon: true){
-			tileAttribute ("device.contact", key: "PRIMARY_CONTROL") {
+			tileAttribute ("device.valve", key: "PRIMARY_CONTROL") {
 				attributeState "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC", nextState:"closing"
 				attributeState "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff", nextState:"opening"
 				attributeState "opening", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC"
@@ -43,7 +45,7 @@ metadata {
 			}
 		}
 
-		standardTile("refresh", "device.contact", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+		standardTile("refresh", "device.valve", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 
@@ -53,24 +55,33 @@ 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() {
+	// 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 parse(String description) {
 	log.trace "parse description : $description"
-	def result = null
 	def cmd = zwave.parse(description, [0x20: 1])
 	if (cmd) {
-		result = createEvent(zwaveEvent(cmd))
+		return zwaveEvent(cmd)
 	}
-	log.debug "Parse returned ${result?.descriptionText}"
-	return result
+	log.debug "Could not parse message"
+	return null
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
-    def value = cmd.value == 0xFF ?  "open" : cmd.value == 0x00 ? "closed" : "unknown"
-    [name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]
+	def value = cmd.value == 0xFF ?  "open" : cmd.value == 0x00 ? "closed" : "unknown"
+
+	return [createEventWithDebug([name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]),
+			createEventWithDebug([name: "valve", value: value, descriptionText: "$device.displayName valve is $value"])]
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {   //TODO should show MSR when device is discovered
@@ -80,20 +91,22 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
     log.debug "productTypeId:    ${cmd.productTypeId}"
     def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
     updateDataValue("MSR", msr)
-    [descriptionText: "$device.displayName MSR: $msr", isStateChange: false]
+    return createEventWithDebug([descriptionText: "$device.displayName MSR: $msr", isStateChange: false])
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLocallyNotification cmd) {
-    [descriptionText: cmd.toString(), isStateChange: true, displayed: true]
+    return createEventWithDebug([descriptionText: cmd.toString(), isStateChange: true, displayed: true])
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd) {
 	def value = cmd.value == 0xFF ?  "open" : cmd.value == 0x00 ? "closed" : "unknown"
-	[name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]
+
+	return [createEventWithDebug([name: "contact", value: value, descriptionText: "$device.displayName valve is $value"]),
+			createEventWithDebug([name: "valve", value: value, descriptionText: "$device.displayName valve is $value"])]
 }
 
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
-	[:] // Handles all Z-Wave commands we aren't interested in
+	return createEvent([:]) // Handles all Z-Wave commands we aren't interested in
 }
 
 def open() {
@@ -114,6 +127,13 @@ def poll() {
     zwave.switchBinaryV1.switchBinaryGet().format()
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	refresh()
+}
+
 def refresh() {
     log.debug "refresh() is called"
     def commands = [zwave.switchBinaryV1.switchBinaryGet().format()]
@@ -122,3 +142,9 @@ def refresh() {
     }
     delayBetween(commands,100)
 }
+
+def createEventWithDebug(eventMap) {
+	def event = createEvent(eventMap)
+	log.debug "Event created with ${event?.descriptionText}"
+	return event
+}

smartapps/gideon-api/gideon-smart-home.src/gideon-smart-home.groovy

@@ -765,7 +765,6 @@ def turnOffSwitch() {
         } else {
             
             device.off();
-                  
             return [Device_id: params.id, result_action: "200"]
         }
 }
@@ -789,6 +788,7 @@ def getTempSensorsStatus(id) {
             return []
         } else {
         	def bat = getBatteryStatus(device.id)
-        	return [temperature: device.currentValue('temperature')] + bat
+            def scale = [Scale: location.temperatureScale]
+        	return [temperature: device.currentValue('temperature')] + bat + scale
    		}
-   }
+   }

smartapps/ihome-control/ihome-control-connect.src/ihome-control-connect.groovy

@@ -0,0 +1,707 @@
+/**
+ *  iHome (Connect)
+ *
+ *  Copyright 2016 EVRYTHNG LTD.
+ *
+ *  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.
+ *
+ *  Last reviewed: 11.08.2017
+ *   - Use of variable serverUrl in the URLs. 
+ *  Reviewed:20.07.2017
+ *   - Merged content with the old version modified by SmartThings
+ *   - Removed selection of plugs, all available plugs are imported by default
+ *   - Added location selection
+ *   - Added DeviceWatch-DeviceStatus event
+ *   - Added unschedule call on initialising
+ *   - Changed from schedule to runEvery5Minutes
+ *   - Updated refreshThngs method to support add/delete plugs automatically when they are added/removed in iHome app
+ *	Reviewed: 04.07.2017
+ *   - Added support for iSP6X
+ *   - Reimplemented the import with filtering using the new tag "Active" (removed serial and use thngId)
+ *	Review: 20.04.2017
+ *   - Added filter by deactive property
+ *   - Removed duplicates by creation date
+ *
+ */
+include 'localization'
+
+definition(
+    name: "iHome Control (Connect)",
+    namespace: "ihome_control",
+    author: "iHome",
+    description: "Control your iHome Control devices within the SmartThings app!",
+    category: "Convenience",
+    iconUrl: "https://www.ihomeaudio.com/media/uploads/product/logos/iH_iHomeControlicon.png",
+    iconX2Url: "https://www.ihomeaudio.com/media/uploads/product/logos/iH_iHomeControlicon.png",
+    iconX3Url: "https://www.ihomeaudio.com/media/uploads/product/logos/iH_iHomeControlicon.png",
+    singleInstance: true
+)
+{
+	appSetting "clientId"       //Client Id of the SmartThings App in the iHome System
+	appSetting "clientSecret"   //Client Secret of the SmartThings app in the iHome System
+    appSetting "iHomeServer"    //URL of the iHome API
+    appSetting "serverUrl"   	//Base URL of the server hosting the redirection URI
+    appSetting "evrythngServer" //URL of the EVRYTHNG API (cloud control)
+}
+
+preferences {
+	page(name: "iHomeAuth", content:"authenticationPage", install: false)
+	page(name: "iHomeConnectDevices", title: "Import your iHome devices", content:"connectPage", install:false)
+}
+
+private getVendorName() { "iHome" }
+
+/**********************************************************************************************
+*
+* AUTHENTICATION
+*
+* This block contains all the functions needed to carry out the OAuth Authentication
+*
+**********************************************************************************************/
+
+/*
+ * Authentication endpoints (needed for OAuth)
+*/
+mappings {
+    path("/oauth/initialize") {action: [GET: "oauthInitUrl"]}
+    path("/oauth/callback") {action: [GET: "callback"]}
+}
+
+/*
+ * Authentication Page
+ * Implements OAuth authentication with the Authorization Code Grant flow
+*/
+def authenticationPage()
+{
+	log.debug "Checking authorisation..."
+
+	//Check first if the authorisation was already done before
+    if(state.iHomeAccessToken == null)
+	{
+    	log.debug "iHome token not found, starting authorisation request"
+
+    	//Check if the internal OAuth tokens have been created already
+    	if (!state.accessToken){
+           	log.debug "Creating access token for the callback"
+			createAccessToken()
+        }
+
+        //Create the OAuth URL of the authorisation server
+	    def redirectUrl = "${appSettings.serverUrl}/oauth/initialize?appId=${app.id}&access_token=${state.accessToken}&apiServerUrl=${getApiServerUrl()}"
+        log.debug "Redirecting to OAuth URL initializer: ${redirectUrl}"
+
+        //Display the connect your account section, it will redirect to the OAuth Authentication Server
+        return dynamicPage(name: "iHomeAuth", title:"iHome Control", install:false) {
+    		section ("") {
+
+				paragraph "Welcome! In order to connect SmartThings to your ${vendorName} devices, you need to have already set up your devices using the ${vendorName} app."
+        		href (url:redirectUrl,
+                		style:"embedded",
+                		required:true,
+                        image:"https://www.ihomeaudio.com/media/uploads/product/logos/iH_iHomeControl_icon.png",
+                		title:"Connect your iHome Account",
+                        description:""
+                		)
+    		}
+    	}
+	}
+    else
+    {
+    	log.debug "iHome token found. Loading connect page"
+        loadThngs()
+	   	return connectPage()
+    }
+}
+
+/*
+ * Authentication OAuth URL
+ *   Creates the OAuth compliant URL to the Authorisation Server
+ */
+def oauthInitUrl() {
+
+    log.debug "Creating OAuth URL..."
+
+    // Generate a random ID to use as a our state value. This value will be used to verify the response we get back from the 3rd party service.
+    state.oauthState = UUID.randomUUID().toString()
+
+    def oauthParams = [
+    		response_type: "code",
+            client_id: appSettings.clientId,
+    		state: state.oauthState,
+            redirect_uri: "${appSettings.serverUrl}/oauth/callback"
+    ]
+
+    redirect(location: "${appSettings.iHomeServer}/oauth/authorize?${toQueryString(oauthParams)}")
+}
+
+/*
+ * Helper class to provide feedback to the user about the authentication process
+ *
+ */
+def connectionStatus(message, redirectUrl = null) {
+	def redirectHtml = ""
+	if (redirectUrl) {
+		redirectHtml = """
+			<meta http-equiv="refresh" content="3; url=${redirectUrl}" />
+		"""
+	}
+
+    def html = """
+<!DOCTYPE html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0">
+    <title>SmartThings Connection</title>
+    <style type="text/css">
+        @font-face {
+            font-family: 'Swiss 721 W01 Thin';
+            src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.eot');
+            src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.eot?#iefix') format('embedded-opentype'),
+            url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.woff') format('woff'),
+            url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.ttf') format('truetype'),
+            url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.svg#swis721_th_btthin') format('svg');
+            font-weight: normal;
+            font-style: normal;
+        }
+        @font-face {
+            font-family: 'Swiss 721 W01 Light';
+            src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.eot');
+            src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.eot?#iefix') format('embedded-opentype'),
+            url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.woff') format('woff'),
+            url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.ttf') format('truetype'),
+            url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.svg#swis721_lt_btlight') format('svg');
+            font-weight: normal;
+            font-style: normal;
+        }
+        .container {
+         /*   width: 440px;
+            padding: 40px;
+            /!*background: #eee;*!/*/
+            text-align: center;
+        }
+        img {
+            vertical-align: middle;
+        }
+        img:nth-child(2) {
+            margin: 0 30px;
+        }
+        p {
+            font-size: 2em;
+            font-family: 'Swiss 721 W01 Thin';
+            text-align: center;
+            color: #666666;
+            padding: 0 40px;
+            margin-bottom: 0;
+        }
+        /*
+            p:last-child {
+                margin-top: 0px;
+            }
+        */
+        span {
+            font-family: 'Swiss 721 W01 Light';
+        }
+        .image{
+            width: 20%;
+            /*height: 70px;*/
+        }
+    </style>
+</head>
+<body>
+<div class="container">
+    <img class="image" src="https://www.ihomeaudio.com/media/uploads/product/logos/iH_iHomeControlicon.png" alt="iHome icon" />
+    <img src="https://s3.amazonaws.com/smartapp-icons/Partner/support/connected-device-icn%402x.png" alt="connected device icon" />
+    <img class="image" src="https://s3.amazonaws.com/smartapp-icons/Partner/support/st-logo%402x.png" alt="SmartThings logo" />
+    ${message}
+</div>
+</body>
+</html>
+	"""
+	render contentType: 'text/html', data: html
+}
+
+
+/*
+ * Handler of the OAuth redirection URI
+ *
+ */
+def callback() {
+
+	log.debug "OAuth callback received..."
+
+    //OAuth server returns a code in the URL as a parameter
+    state.iHomeAccessCode = params.code
+    log.debug "Received authorization code ${state.iHomeAccessCode}"
+
+    def oauthState = params.state
+
+    def successMessage = """
+			<p>Your iHome Account is now connected to SmartThings!</p>
+            <p>Click 'Done' in the top corner to complete the setup.</p>
+	"""
+
+    def errorMessage = """
+			<p>Your iHome Account couldn't be connected to SmartThings!</p>
+            <p>Click 'Done' in the top corner and try again.</p>
+	"""
+
+    // Validate the response from the 3rd party by making sure oauthState == state.oauthInitState as expected
+    if (oauthState == state.oauthState){
+
+    	if (state.iHomeAccessCode == null) {
+            log.debug "OAuth error: Access code is not present"
+			connectionStatus(errorMessage)
+    	}
+    	else {
+       		getAccessToken();
+	       	if (state.iHomeAccessToken){
+    	   		getEVTApiKey();
+        	    if(state.evtApiKey){
+       				 connectionStatus(successMessage)
+            	}
+            	else{
+                     log.debug "OAuth error: EVT API KEY could not be retrieved"
+                	 connectionStatus(errorMessage)
+            	}
+       		}
+       		else {
+                log.debug "OAuth error: Access Token could not be retrieved"
+		       	connectionStatus(errorMessage)
+       		}
+    	}
+	}
+    else{
+        log.debug "OAuth error: initial state does not match"
+		connectionStatus(errorMessage)
+    }
+}
+
+/**
+* Exchanges the authorization code for an access token
+*/
+def getAccessToken(){
+	log.debug "Getting iHome access token..."
+
+    def tokenParams = [
+        	grant_type: "authorization_code",
+            code: state.iHomeAccessCode,
+            client_id: appSettings.clientId,
+            client_secret: appSettings.clientSecret,
+            redirect_uri: "${appSettings.serverUrl}/oauth/callback"
+	]
+    def tokenUrl = "${appSettings.iHomeServer}/oauth/token/?" + toQueryString(tokenParams)
+
+    log.debug "Invoking token URL: ${tokenUrl}"
+
+    try{
+        def jsonMap
+        httpPost(uri:tokenUrl) { resp ->
+            if(resp.status == 200)
+            {
+                jsonMap = resp.data
+                if (resp.data) {
+                    state.iHomeRefreshToken = resp?.data?.refresh_token
+                    state.iHomeAccessToken = resp?.data?.access_token
+                    log.debug "Access token received ${state.iHomeAccessToken}"
+            	}
+            }
+        }
+    }catch (groovyx.net.http.HttpResponseException e) {
+    	log.warn "Error! Status Code was: ${e}"
+    } catch (java.net.SocketTimeoutException e) {
+        log.warn "Connection timed out, not much we can do here."
+    }
+}
+
+def getEVTApiKey() {
+
+	log.debug "Getting api key from the cloud"
+
+    def apiKeyParams = [
+        uri: "${appSettings.iHomeServer}/v3/evrythng/",
+        headers: [
+        	"Accept": "application/json",
+            "Authorization": "Bearer ${state.iHomeAccessToken}"]
+	]
+
+    try {
+        def jsonMap
+        httpGet(apiKeyParams)
+        { resp ->
+            if(resp.status == 200)
+            {
+                jsonMap = resp.data
+                if (resp.data)
+                {
+                    state.evtUserId = resp?.data?.evrythng_user_id
+                    state.evtApiKey = resp?.data?.evrythng_api_key
+                    log.debug "Api key received: ${state.evtUserId}/${state.evtApiKey}"
+
+                    //Preload thngs after getting the api key
+                    loadThngs()
+	            }
+    	    }
+    	}
+  	}catch (groovyx.net.http.HttpResponseException e) {
+    	log.warn "Error! Status Code was: ${e.statusCode}"
+    } catch (java.net.SocketTimeoutException e) {
+        log.warn "Connection timed out, not much we can do here"
+    }
+}
+
+/*
+ * Maps the map to query parameters for the URL
+ *
+ */
+def toQueryString(Map m)
+{
+	return m.collect { k, v -> "${k}=${URLEncoder.encode(v.toString())}" }.sort().join("&")
+}
+
+/**********************************************************************************************
+* IMPORT
+*  This block contains all the functions needed to import the plugs from the cloud into SmartThings
+**********************************************************************************************/
+def loadThngs()
+{
+    //Products in production account
+    state.product = [:]
+    state.product["UCfXBRHnse5Rpw7PySPYNq7b"] = "iHomeSmartPlug-iSP5"
+    state.product["Ugrtyq8pAFVEqGSAAptgtqkc"] = "iHomeSmartPlug-iSP6"
+    state.product["UXNtyNexVyRrWpAQeNHq9xad"] = "iHomeSmartPlug-iSP8"
+    state.product["UF4NsmAEM3PhY6wwRgehdg5n"] = "iHomeSmartPlug-iSP6X"
+
+	//Save the all the plugs in the state for later use
+    state.thngs = [:]
+
+	log.debug "Loading available devices..."
+	def thngs = getThngs()
+
+	thngs.each { thng ->
+        //Check that the plug is compatible with a Device Type
+        log.debug "Checking if ${thng.id} is a compatible Device Type"
+        if (state.product[thng.product])
+        {
+        	thng.st_devicetype = state.product[thng.product]
+   	  		state.thngs["${thng.id}"] = thng
+   			log.info "Found compatible device ${state.thngs["${thng.id}"].name}"
+        }
+	}
+}
+
+/*
+ * Import thngs page
+ *  Loads the thngs available from the user, checks that they have a DeviceType associated
+ *  and presents a list to the user
+ *
+ */
+def connectPage()
+{
+	return dynamicPage(name: "iHomeConnectDevices", uninstall: true, install:true) {
+        section(""){
+           	input "selectedLocationId", "enum", required:false, title:"", multiple:false, options:["Default Location"], defaultValue: "Default Location", submitOnChange: true
+           	paragraph "Devices will be added automatically from your ${vendorName} account. To add or delete devices please use the Official ${vendorName} App."
+		}
+	}
+}
+
+/*
+ *  Gets the thngs from the cloud
+ *  This is used as the discovery process
+ */
+def getThngs(){
+
+    log.debug "Getting available devices..."
+
+    def url = "${appSettings.evrythngServer}/thngs?filter=tags=Active"
+
+    try {
+
+    	httpGet(uri: url, headers: ["Accept": "application/json", "Authorization": state.evtApiKey]) {response ->
+            if (response.status == 200) {
+                log.debug "GET on /thngs was succesful"
+                log.debug "Response to GET /thngs ${response.data}"
+                return response.data
+            }
+        }
+    } catch (groovyx.net.http.HttpResponseException e) {
+    	log.warn "Error! Status Code was: ${e.statusCode}"
+    } catch (java.net.SocketTimeoutException e) {
+        log.warn "Connection timed out, not much we can do here"
+    }
+}
+
+/*
+ *  Gets a thng by id from EVRYTHNG
+ *    Used for updates
+ */
+def getThng(thngId){
+
+    log.trace "Getting device information..."
+
+    def url = "${appSettings.evrythngServer}/thngs/" + thngId
+
+    try {
+        httpGet(uri: url, headers: ["Accept": "application/json", "Authorization": state.evtApiKey]) {response ->
+            if (response.status == 200) {
+                log.debug "GET on /thngs was succesful: ${response.data}"
+
+				def isAlive = response.data.properties["~connected"]
+				def d = getChildDevice(thngId)
+				d?.sendEvent(name: "DeviceWatch-DeviceStatus", value: isAlive? "online":"offline", displayed: false, isStateChange: true)
+
+                return response.data
+            }
+            else{
+            	log.warn "Error! Status Code was: ${response.status}"
+            }
+        }
+    } catch (groovyx.net.http.HttpResponseException e) {
+    	log.warn "Error! Status Code was: ${e.statusCode}"
+    } catch (java.net.SocketTimeoutException e) {
+        log.warn "Connection timed out, not much we can do here"
+    }
+}
+
+/*
+ *  Adds all the available devices to SmartThings
+ *  Invoked by the lifecycle initialise
+ */
+def importThngs() {
+
+    def thngsToImport = []
+
+    state.thngs.each { thng ->
+    	thngsToImport.add(thng.key)
+	}
+	log.debug "Adding all available plugs...${thngsToImport}"
+
+    //Remove unselected plugs
+    log.debug "Checking to delete ${state.imported}"
+    state.imported.each{ id ->
+        if(thngsToImport){
+        	if (thngsToImport.contains(id)){
+   	        	log.debug "${id} is already imported"
+        	} else{
+	            log.debug "Removing device not longer available: ${id}"
+				// Error can occur if device has already been deleted or is in-use by SmartApps. Should it be force-deleted?		 +        		deleteChildDevice(thng)
+				try {
+					deleteChildDevice(id)
+				} catch (Exception e) {
+					log.error "Error deleting device with DNI $thng: $e"
+				}
+            }
+      	} else {
+           	log.trace "Removing unselected device with id: ${id}"
+        	try {
+                deleteChildDevice(id)
+            }
+            catch(Exception error){
+                log.error "Error deleting device with id -> ${id}: $error"
+            }
+        }
+    }
+
+    state.imported = [];
+
+    thngsToImport.each { id ->
+	   	log.debug "Importing plug with id: ${id} and serial: ${state.thngs["${id}"].identifiers.serial_num}"
+		def smartThing = getChildDevice(id)
+
+	    if(!smartThing) {
+           	def newSmartThing = state.thngs.find { it.key == id }
+	    	log.debug "Creating SmartThing: ${newSmartThing}"
+
+			smartThing = addChildDevice("ihome_devices",
+            	newSmartThing.value.st_devicetype,
+                newSmartThing.value.id,
+                null,
+                [label:"${newSmartThing.value.name}"])
+
+	        log.info "Created ${smartThing.displayName} with id ${smartThing.deviceNetworkId}"
+    	}
+        else {
+            log.trace "${smartThing.displayName} with id ${id} already exists, skipping creation"
+        }
+
+        //save plug in state
+        state.imported.add(id);
+
+        //We need to get the current status of the plug
+    	pollChildren(smartThing.deviceNetworkId)
+	}
+}
+
+
+/**********************************************************************************************
+*
+* LIFECYCLE
+*
+**********************************************************************************************/
+
+def installed() {
+	log.debug "Application installed..."
+	initialize()
+}
+
+def updated() {
+	log.debug "Application updated..."
+	unsubscribe()
+    initialize()
+}
+
+def initialize() {
+	log.debug "Application initialising..."
+    importThngs()
+	unschedule()
+    //Refresh every five minutes for external changes in the thngs
+    runEvery5Minutes("refreshThngs")
+}
+
+def uninstalled() {
+	log.debug "Removing installed plugs..."
+	getChildDevices().each {
+    	log.debug "Deleting ${it.deviceNetworkId}"
+        try {
+       		deleteChildDevice(it.deviceNetworkId)
+            }
+        catch (e) {
+        	log.warn "Error deleting device, ignoring ${e}"
+    	}
+    }
+}
+
+/**********************************************************************************************
+* Properties and Actions UPDATES
+*	This block contains the functionality to update property values and send actions in EVRYTHNG cloud
+*   This methods are generic based on the EVRYTHNG API specification and are invoked from
+*   the specific Device Type that handles the properties and action types
+**********************************************************************************************/
+
+/*
+ *  Updates a property in EVRYTHNG
+ */
+def propertyUpdate(thngId, propertyUpdate){
+
+	def url = "${appSettings.evrythngServer}/thngs/${thngId}/properties"
+
+    def params = [
+       	uri: url,
+       	headers: [
+            "Authorization": state.evtApiKey
+       ],
+      	body: propertyUpdate
+    ]
+
+	log.debug "Sending property update to the cloud: ${params}"
+
+    try {
+    	httpPutJson(params) { resp ->
+        	if (resp.status == 200) {
+	         	log.debug "Response from the cloud: ${resp}"
+    			return true
+    		}
+            else {
+	         	log.debug "Response status from the cloud not valid: ${resp}"
+	            return false
+            }
+        }
+    }
+    catch (e) {
+        log.debug "Something went wrong with the property update: ${e}"
+        return false
+    }
+}
+
+/*
+ *  Sends an action to EVRYTHNG
+ */
+def sendAction(actionType, actionPayload){
+
+	def url = "${appSettings.evrythngServer}/actions/${actionType}"
+
+    def params = [
+       	uri: url,
+       	headers: [
+            "Authorization": state.evtApiKey
+       ],
+       body: actionPayload
+    ]
+
+	log.debug "Sending action to the cloud: ${params}"
+
+    try {
+    	httpPostJson(params) { resp ->
+        	if (resp.status == 201) {
+	         	log.debug "Response from the cloud: ${resp}"
+    			return true
+    		}
+            else {
+	         	log.debug "Response status from the cloud not valid: ${resp}"
+	            return false
+            }
+      }
+    }
+    catch (e) {
+        log.debug "Something went wrong with sending the action: ${e}"
+        return false
+    }
+}
+
+/**
+* Handler of the refreshing of all the imported things
+*/
+def refreshThngs(){
+	log.debug "Refreshing thngs"
+
+	//loading thngs to get plugs recently added or removed
+	loadThngs()
+
+	//import the plugs into SmartThings
+	importThngs()
+}
+
+/*
+ *  Utility function to poll for a Thng and update its properties
+ */
+def pollChildren(thngId){
+    //get plug device
+    def smartThing = getChildDevice(thngId)
+
+	if (smartThing){
+		//Get plug's latest state from the cloud
+    	log.debug "Getting updates for ${thngId}"
+    	def plug = getThng(thngId)
+
+        if (plug == null){
+        	smartThing.pollError()
+        }
+        else
+        {
+        	//Update name
+        	smartThing.label = plug.name
+        	smartThing.name = plug.name
+
+ 		   	//Update properties
+			smartThing.updateProperties(plug.properties)
+        }
+    }
+}
+
+/* Status messages for all types of plugs */
+def getConnectedMessage(){
+	return "Connected"
+}
+def getConnectionErrorMessage(){
+	return "Connection error. Please try again."
+}
+def getPlugNotConnectedMessage(){
+	return "Your plug seems to be disconnected."
+}

smartapps/naissan/lights-off-with-no-motion-and-presence.src/lights-off-with-no-motion-and-presence.groovy

@@ -15,66 +15,66 @@ definition(
 )
 
 preferences {
-	section("Light switches to turn off") {
-		input "switches", "capability.switch", title: "Choose light switches", multiple: true
-	}
-	section("Turn off when there is no motion and presence") {
-		input "motionSensor", "capability.motionSensor", title: "Choose motion sensor"
-   		input "presenceSensors", "capability.presenceSensor", title: "Choose presence sensors", multiple: true
-	}
-	section("Delay before turning off") {                    
-		input "delayMins", "number", title: "Minutes of inactivity?"
-	}
+  section("Light switches to turn off") {
+    input "switches", "capability.switch", title: "Choose light switches", multiple: true
+  }
+  section("Turn off when there is no motion and presence") {
+    input "motionSensor", "capability.motionSensor", title: "Choose motion sensor"
+    input "presenceSensors", "capability.presenceSensor", title: "Choose presence sensors", multiple: true
+  }
+  section("Delay before turning off") {
+    input "delayMins", "number", title: "Minutes of inactivity?"
+  }
 }
 
 def installed() {
-	subscribe(motionSensor, "motion", motionHandler)
-    subscribe(presenceSensors, "presence", presenceHandler)
+  subscribe(motionSensor, "motion", motionHandler)
+  subscribe(presenceSensors, "presence", presenceHandler)
 }
 
 def updated() {
-	unsubscribe()
-	subscribe(motionSensor, "motion", motionHandler)
-    subscribe(presenceSensors, "presence", presenceHandler)
+  unsubscribe()
+  subscribe(motionSensor, "motion", motionHandler)
+  subscribe(presenceSensors, "presence", presenceHandler)
 }
 
 def motionHandler(evt) {
-	log.debug "handler $evt.name: $evt.value"
-	if (evt.value == "inactive") {
-		runIn(delayMins * 60, scheduleCheck, [overwrite: false])
-	}
+  log.debug "handler $evt.name: $evt.value"
+  if (evt.value == "inactive") {
+    runIn(delayMins * 60, scheduleCheck, [overwrite: true])
+  }
 }
 
 def presenceHandler(evt) {
-	log.debug "handler $evt.name: $evt.value"
-	if (evt.value == "not present") {
-		runIn(delayMins * 60, scheduleCheck, [overwrite: false])
-	}
+  log.debug "handler $evt.name: $evt.value"
+  if (evt.value == "not present") {
+    runIn(delayMins * 60, scheduleCheck, [overwrite: true])
+  }
 }
 
 def isActivePresence() {
-	// check all the presence sensors, make sure none are present
-	def noPresence = presenceSensors.find{it.currentPresence == "present"} == null
-	!noPresence		
+  // check all the presence sensors, make sure none are present
+  def noPresence = presenceSensors.find{it.currentPresence == "present"} == null
+  !noPresence
 }
 
 def scheduleCheck() {
-	log.debug "scheduled check"
-	def motionState = motionSensor.currentState("motion")
+  log.debug "scheduled check"
+  def motionState = motionSensor.currentState("motion")
     if (motionState.value == "inactive") {
-        def elapsed = now() - motionState.rawDateCreated.time
-    	def threshold = 1000 * 60 * delayMins - 1000
-    	if (elapsed >= threshold) {
-        	if (!isActivePresence()) {
-            	log.debug "Motion has stayed inactive since last check ($elapsed ms) and no presence:  turning lights off"
-            	switches.off()
-            } else {
-            	log.debug "Presence is active: do nothing"
-            }
-    	} else {
-        	log.debug "Motion has not stayed inactive long enough since last check ($elapsed ms): do nothing"
+      def elapsed = now() - motionState.rawDateCreated.time
+      def threshold = 1000 * 60 * delayMins - 1000
+      if (elapsed >= threshold) {
+        if (!isActivePresence()) {
+          log.debug "Motion has stayed inactive since last check ($elapsed ms) and no presence:  turning lights off"
+          switches.off()
+        } else {
+          log.debug "Presence is active: do nothing"
         }
+      } else {
+        log.debug "Motion has not stayed inactive long enough since last check ($elapsed ms): do nothing"
+      }
     } else {
-    	log.debug "Motion is active: do nothing"
+      log.debug "Motion is active: do nothing"
     }
-}
+}

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

@@ -1,23 +1,12 @@
-/**
- *  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.
- *
- */
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+import java.security.InvalidKeyException;
+
 definition(
 		name: "OpenT2T SmartApp Test",
 		namespace: "opent2t",
-		author: "OpenT2T",
-		description: "Test app to test end to end SmartThings scenarios via OpenT2T",
+		author: "Microsoft",
+		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",
@@ -39,7 +28,7 @@ definition(
  *  garageDoors         | door          | open, close           | unknown, closed, open, closing, opening
  *  cameras             | image         | take                  | <String>
  *  thermostats         | thermostat    | setHeatingSetpoint,   | temperature, heatingSetpoint, coolingSetpoint,
- *	                    |				| setCoolingSetpoint,   | thermostatSetpoint, thermostatMode,
+ * 	                    |				| setCoolingSetpoint,   | thermostatSetpoint, thermostatMode,
  *                      |				| off, heat, cool, auto,| thermostatFanMode, thermostatOperatingState
  *                      |				| emergencyHeat,        |
  *                      |				| setThermostatMode,    |
@@ -51,33 +40,34 @@ definition(
 
 //Device Inputs
 preferences {
-	section("Allow OpenT2T to control these things...") {
-		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 "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 "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
+	section("Allow Microsoft to control these things...") {
+//		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 "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 "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 "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
 	}
 }
 
 def getInputs() {
 	def inputList = []
-	inputList += contactSensors?: []
-	inputList += garageDoors?: []
-	inputList += locks?: []
-	inputList += cameras?: []
-	inputList += motionSensors?: []
-	inputList += presenceSensors?: []
-	inputList += switches?: []
-	inputList += thermostats?: []
-	inputList += waterSensors?: []
+	inputList += contactSensors ?: []
+	inputList += garageDoors ?: []
+	inputList += locks ?: []
+	inputList += cameras ?: []
+	inputList += motionSensors ?: []
+	inputList += presenceSensors ?: []
+	inputList += switches ?: []
+	inputList += thermostats ?: []
+	inputList += waterSensors ?: []
 	return inputList
 }
 
+
 //API external Endpoints
 mappings {
 	path("/devices") {
@@ -97,13 +87,13 @@ mappings {
 	}
 	path("/deviceSubscription") {
 		action: [
-				POST: "registerDeviceChange",
+				POST  : "registerDeviceChange",
 				DELETE: "unregisterDeviceChange"
 		]
 	}
 	path("/locationSubscription") {
 		action: [
-				POST: "registerDeviceGraph",
+				POST  : "registerDeviceGraph",
 				DELETE: "unregisterDeviceGraph"
 		]
 	}
@@ -116,14 +106,21 @@ def installed() {
 
 def updated() {
 	log.debug "Updating with settings: ${settings}"
-	if(state.deviceSubscriptionMap == null){
+
+	//Initialize state variables if didn't exist.
+	if (state.deviceSubscriptionMap == null) {
 		state.deviceSubscriptionMap = [:]
 		log.debug "deviceSubscriptionMap created."
 	}
-	if( state.locationSubscriptionMap == null){
+	if (state.locationSubscriptionMap == null) {
 		state.locationSubscriptionMap = [:]
 		log.debug "locationSubscriptionMap created."
 	}
+	if (state.verificationKeyMap == null) {
+		state.verificationKeyMap = [:]
+		log.debug "verificationKeyMap created."
+	}
+
 	unsubscribe()
 	registerAllDeviceSubscriptions()
 }
@@ -132,9 +129,11 @@ def initialize() {
 	log.debug "Initializing with settings: ${settings}"
 	state.deviceSubscriptionMap = [:]
 	log.debug "deviceSubscriptionMap created."
-	registerAllDeviceSubscriptions()
 	state.locationSubscriptionMap = [:]
 	log.debug "locationSubscriptionMap created."
+	state.verificationKeyMap = [:]
+	log.debug "verificationKeyMap created."
+	registerAllDeviceSubscriptions()
 }
 
 /*** Subscription Functions  ***/
@@ -148,7 +147,7 @@ def registerAllDeviceSubscriptions() {
 def registerChangeHandler(myList) {
 	myList.each { myDevice ->
 		def theAtts = myDevice.supportedAttributes
-		theAtts.each {att ->
+		theAtts.each { att ->
 			subscribe(myDevice, att.name, deviceEventHandler)
 			log.info "Registering for ${myDevice.displayName}.${att.name}"
 		}
@@ -160,31 +159,41 @@ def registerDeviceChange() {
 	def subscriptionEndpt = params.subscriptionURL
 	def deviceId = params.deviceId
 	def myDevice = findDevice(deviceId)
-	if( myDevice == null ){
+
+	if (myDevice == null) {
 		httpError(404, "Cannot find device with device ID ${deviceId}.")
 	}
 
 	def theAtts = myDevice.supportedAttributes
 	try {
-		theAtts.each {att ->
+		theAtts.each { att ->
 			subscribe(myDevice, att.name, deviceEventHandler)
 		}
 		log.info "Subscribing for ${myDevice.displayName}"
 
-		if(subscriptionEndpt != null){
-			if(state.deviceSubscriptionMap[deviceId] == null){
+		if (subscriptionEndpt != null) {
+			if (state.deviceSubscriptionMap[deviceId] == null) {
 				state.deviceSubscriptionMap.put(deviceId, [subscriptionEndpt])
 				log.info "Added subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
-			} else if (!state.deviceSubscriptionMap[deviceId].contains(subscriptionEndpt)){
-				state.deviceSubscriptionMap[deviceId] << subscriptionEndpt
+			} else if (!state.deviceSubscriptionMap[deviceId].contains(subscriptionEndpt)) {
+				// state.deviceSubscriptionMap[deviceId] << subscriptionEndpt
+                // 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}"
 			}
+
+			if (params.key != null) {
+				state.verificationKeyMap[subscriptionEndpt] = params.key
+				log.info "Added verification key: ${params.key} for ${subscriptionEndpt}"
+			}
 		}
 	} catch (e) {
 		httpError(500, "something went wrong: $e")
 	}
 
 	log.info "Current subscription map is ${state.deviceSubscriptionMap}"
+	log.info "Current verification key map is ${state.verificationKeyMap}"
 	return ["succeed"]
 }
 
@@ -194,18 +203,19 @@ def unregisterDeviceChange() {
 	def deviceId = params.deviceId
 	def myDevice = findDevice(deviceId)
 
-	if( myDevice == null ){
+	if (myDevice == null) {
 		httpError(404, "Cannot find device with device ID ${deviceId}.")
 	}
 
 	try {
-		if(subscriptionEndpt != null && subscriptionEndpt != "undefined"){
-			if (state.deviceSubscriptionMap[deviceId]?.contains(subscriptionEndpt)){
-				if(state.deviceSubscriptionMap[deviceId].size() == 1){
+		if (subscriptionEndpt != null && subscriptionEndpt != "undefined") {
+			if (state.deviceSubscriptionMap[deviceId]?.contains(subscriptionEndpt)) {
+				if (state.deviceSubscriptionMap[deviceId].size() == 1) {
 					state.deviceSubscriptionMap.remove(deviceId)
 				} else {
 					state.deviceSubscriptionMap[deviceId].remove(subscriptionEndpt)
 				}
+				state.verificationKeyMap.remove(subscriptionEndpt)
 				log.info "Removed subscription URL: ${subscriptionEndpt} for ${myDevice.displayName}"
 			}
 		} else {
@@ -217,25 +227,33 @@ def unregisterDeviceChange() {
 	}
 
 	log.info "Current subscription map is ${state.deviceSubscriptionMap}"
+	log.info "Current verification key map is ${state.verificationKeyMap}"
 }
 
 //Endpoints function: Subscribe to device additiona/removal updated in a location
 def registerDeviceGraph() {
 	def subscriptionEndpt = params.subscriptionURL
 
-	if (subscriptionEndpt != null && subscriptionEndpt != "undefined"){
+	if (subscriptionEndpt != null && subscriptionEndpt != "undefined") {
 		subscribe(location, "DeviceCreated", locationEventHandler, [filterEvents: false])
 		subscribe(location, "DeviceUpdated", locationEventHandler, [filterEvents: false])
 		subscribe(location, "DeviceDeleted", locationEventHandler, [filterEvents: false])
 
-		if(state.locationSubscriptionMap[location.id] == null){
+		if (state.locationSubscriptionMap[location.id] == null) {
 			state.locationSubscriptionMap.put(location.id, [subscriptionEndpt])
 			log.info "Added subscription URL: ${subscriptionEndpt} for Location ${location.name}"
-		} else if (!state.locationSubscriptionMap[location.id].contains(subscriptionEndpt)){
+		} else if (!state.locationSubscriptionMap[location.id].contains(subscriptionEndpt)) {
 			state.locationSubscriptionMap[location.id] << subscriptionEndpt
 			log.info "Added subscription URL: ${subscriptionEndpt} for Location ${location.name}"
 		}
+
+		if (params.key != null) {
+			state.verificationKeyMap[subscriptionEndpt] = params.key
+			log.info "Added verification key: ${params.key} for ${subscriptionEndpt}"
+		}
+
 		log.info "Current location subscription map is ${state.locationSubscriptionMap}"
+		log.info "Current verification key map is ${state.verificationKeyMap}"
 		return ["succeed"]
 	} else {
 		httpError(400, "missing input parameter: subscriptionURL")
@@ -247,16 +265,17 @@ def unregisterDeviceGraph() {
 	def subscriptionEndpt = params.subscriptionURL
 
 	try {
-		if(subscriptionEndpt != null && subscriptionEndpt != "undefined"){
-			if (state.locationSubscriptionMap[location.id]?.contains(subscriptionEndpt)){
-				if(state.locationSubscriptionMap[location.id].size() == 1){
+		if (subscriptionEndpt != null && subscriptionEndpt != "undefined") {
+			if (state.locationSubscriptionMap[location.id]?.contains(subscriptionEndpt)) {
+				if (state.locationSubscriptionMap[location.id].size() == 1) {
 					state.locationSubscriptionMap.remove(location.id)
 				} else {
 					state.locationSubscriptionMap[location.id].remove(subscriptionEndpt)
 				}
+				state.verificationKeyMap.remove(subscriptionEndpt)
 				log.info "Removed subscription URL: ${subscriptionEndpt} for Location ${location.name}"
 			}
-		}else{
+		} else {
 			httpError(400, "missing input parameter: subscriptionURL")
 		}
 	} catch (e) {
@@ -264,28 +283,40 @@ def unregisterDeviceGraph() {
 	}
 
 	log.info "Current location subscription map is ${state.locationSubscriptionMap}"
+	log.info "Current verification key map is ${state.verificationKeyMap}"
 }
 
 //When events are triggered, send HTTP post to web socket servers
 def deviceEventHandler(evt) {
-	def evt_device = evt.device
-	def evt_deviceType = getDeviceType(evt_device)
-	def deviceInfo
+	def evtDevice = evt.device
+	def evtDeviceType = getDeviceType(evtDevice)
+	def deviceData = [];
 
-	def params = [ body: [deviceName: evt_device.displayName, deviceId: evt_device.id,  locationId: location.id] ]
-
-	if(evt.data != null){
+	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 ${evt_device.displayName}, data: ${evtData},  description: ${evt.descriptionText}"
+		log.info "Received event for ${evtDevice.displayName}, data: ${evtData},  description: ${evt.descriptionText}"
 	}
 
+	def params = [body: deviceData]
+
 	//send event to all subscriptions urls
-	log.debug "Current subscription urls for ${evt_device.displayName} is ${state.deviceSubscriptionMap[evt_device.id]}"
-	state.deviceSubscriptionMap[evt_device.id].each {
+	log.debug "Current subscription urls for ${evtDevice.displayName} is ${state.deviceSubscriptionMap[evtDevice.id]}"
+	state.deviceSubscriptionMap[evtDevice.id].each {
 		params.uri = "${it}"
+		if (state.verificationKeyMap[it] != null) {
+			def key = state.verificationKeyMap[it]
+            params.headers = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
+		}
 		log.trace "POST URI: ${params.uri}"
+        log.trace "Headers: ${params.headers}"
 		log.trace "Payload: ${params.body}"
-		try{
+		try {
 			httpPostJson(params) { resp ->
 				log.trace "response status code: ${resp.status}"
 				log.trace "response data: ${resp.data}"
@@ -298,20 +329,27 @@ def deviceEventHandler(evt) {
 
 def locationEventHandler(evt) {
 	log.info "Received event for location ${location.name}/${location.id}, Event: ${evt.name}, description: ${evt.descriptionText}, apiServerUrl: ${apiServerUrl("")}"
-	switch(evt.name){
+	switch (evt.name) {
 		case "DeviceCreated":
 		case "DeviceDeleted":
-			def evt_device = evt.device
-			def evt_deviceType = getDeviceType(evt_device)
-			log.info "DeviceName: ${evt_device.displayName}, DeviceID: ${evt_device.id}, deviceType: ${evt_deviceType}"
+			def evtDevice = evt.device
+			def evtDeviceType = getDeviceType(evtDevice)
+			def params = [body: [eventType: evt.name, deviceId: evtDevice.id, locationId: location.id]]
 
-			def params = [ body: [ eventType:evt.name, deviceId: evt_device.id, locationId: location.id ] ]
+			if (evt.name == "DeviceDeleted" && state.deviceSubscriptionMap[deviceId] != null) {
+				state.deviceSubscriptionMap.remove(evtDevice.id)
+			}
 
 			state.locationSubscriptionMap[location.id].each {
 				params.uri = "${it}"
+				if (state.verificationKeyMap[it] != null) {
+					def key = state.verificationKeyMap[it]
+                    params.headers = [Signature: ComputHMACValue(key, groovy.json.JsonOutput.toJson(params.body))]
+				}
 				log.trace "POST URI: ${params.uri}"
+				log.trace "Headers: ${params.headers}"
 				log.trace "Payload: ${params.body}"
-				try{
+				try {
 					httpPostJson(params) { resp ->
 						log.trace "response status code: ${resp.status}"
 						log.trace "response data: ${resp.data}"
@@ -326,6 +364,24 @@ 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)
+		byte[] digest = mac.doFinal(data.getBytes("UTF-8"))
+		return byteArrayToString(digest)
+	} catch (InvalidKeyException e) {
+		log.error "Invalid key exception while converting to HMac SHA1"
+	}
+}
+
+private def byteArrayToString(byte[] data) {
+	BigInteger bigInteger = new BigInteger(1, data)
+	String hash = bigInteger.toString(16)
+	return hash
+}
 
 /*** Device Query/Update Functions  ***/
 
@@ -334,10 +390,10 @@ def getDevices() {
 	def deviceData = []
 	inputs?.each {
 		def deviceType = getDeviceType(it)
-		if(deviceType == "thermostat") {
-			deviceData << [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it, deviceType), locationMode: getLocationModeInfo()]
+		if (deviceType == "thermostat") {
+			deviceData << [name: it.displayName, id: it.id, status: it.status, deviceType: deviceType, manufacturer: it.manufacturerName, model: it.modelName, attributes: deviceAttributeList(it, deviceType), locationMode: getLocationModeInfo()]
 		} else {
-			deviceData << [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it, deviceType)]
+			deviceData << [name: it.displayName, id: it.id, status: it.status, deviceType: deviceType, manufacturer: it.manufacturerName, model: it.modelName, attributes: deviceAttributeList(it, deviceType)]
 		}
 	}
 
@@ -350,10 +406,10 @@ def getDevice() {
 	def it = findDevice(params.id)
 	def deviceType = getDeviceType(it)
 	def device
-	if(deviceType == "thermostat") {
-		device = [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it,deviceType), locationMode: getLocationModeInfo()]
+	if (deviceType == "thermostat") {
+		device = [name: it.displayName, id: it.id, status: it.status, deviceType: deviceType, manufacturer: it.manufacturerName, model: it.modelName, attributes: deviceAttributeList(it, deviceType), locationMode: getLocationModeInfo()]
 	} else {
-		device = [name: it.displayName, id: it.id, status:it.status, deviceType:deviceType, manufacturer:it.manufacturerName, model:it.modelName, attributes: deviceAttributeList(it, deviceType)]
+		device = [name: it.displayName, id: it.id, status: it.status, deviceType: deviceType, manufacturer: it.manufacturerName, model: it.modelName, attributes: deviceAttributeList(it, deviceType)]
 	}
 
 	log.debug "getDevice, return: ${device}"
@@ -366,18 +422,18 @@ void updateDevice() {
 	request.JSON.each {
 		def command = it.key
 		def value = it.value
-		if (command){
+		if (command) {
 			def commandList = mapDeviceCommands(command, value)
 			command = commandList[0]
 			value = commandList[1]
 
 			if (command == "setAwayMode") {
 				log.info "Setting away mode to ${value}"
-				if (location.modes?.find {it.name == value}) {
+				if (location.modes?.find { it.name == value }) {
 					location.setMode(value)
 				}
-			}else if (command == "thermostatSetpoint"){
-				switch(device.currentThermostatMode){
+			} else if (command == "thermostatSetpoint") {
+				switch (device.currentThermostatMode) {
 					case "cool":
 						log.info "Update: ${device.displayName}, [${command}, ${value}]"
 						device.setCoolingSetpoint(value)
@@ -391,7 +447,7 @@ void updateDevice() {
 						httpError(501, "this mode: ${device.currentThermostatMode} does not allow changing thermostat setpoint.")
 						break
 				}
-			}else if (!device) {
+			} else if (!device) {
 				log.error "updateDevice, Device not found"
 				httpError(404, "Device not found")
 			} else if (!device.hasCommand(command)) {
@@ -401,11 +457,11 @@ void updateDevice() {
 				if (command == "setColor") {
 					log.info "Update: ${device.displayName}, [${command}, ${value}]"
 					device."$command"(hex: value)
-				} else if(value.isNumber()) {
+				} else if (value.isNumber()) {
 					def intValue = value as Integer
 					log.info "Update: ${device.displayName}, [${command}, ${intValue}(int)]"
 					device."$command"(intValue)
-				} else if (value){
+				} else if (value) {
 					log.info "Update: ${device.displayName}, [${command}, ${value}]"
 					device."$command"(value)
 				} else {
@@ -432,17 +488,17 @@ private getDeviceType(device) {
 	log.debug "supported commands: [${device}, ${device.supportedCommands}]"
 
 	//Loop through the device capability list to determine the device type.
-	capabilities.each {capability ->
+	capabilities.each { capability ->
 		switch(capability.name.toLowerCase())
 		{
 			case "switch":
 				deviceType = "switch"
 
 				//If the device also contains "Switch Level" capability, identify it as a "light" device.
-				if (capabilities.any{it.name.toLowerCase() == "switch level"}){
+				if (capabilities.any { it.name.toLowerCase() == "switch level" }) {
 
 					//If the device also contains "Power Meter" capability, identify it as a "dimmerSwitch" device.
-					if (capabilities.any{it.name.toLowerCase() == "power meter"}){
+					if (capabilities.any { it.name.toLowerCase() == "power meter" }) {
 						deviceType = "dimmerSwitch"
 						return deviceType
 					} else {
@@ -489,24 +545,24 @@ private deviceAttributeList(device, deviceType) {
 	allAttributes.each { attribute ->
 		try {
 			def currentState = device.currentState(attribute.name)
-			if(currentState != null ){
-				switch(attribute.name){
+			if (currentState != null) {
+				switch (attribute.name) {
 					case 'temperature':
-						attributeList.putAll([ (attribute.name): currentState.value, 'temperatureScale':location.temperatureScale ])
+						attributeList.putAll([(attribute.name): currentState.value, 'temperatureScale': location.temperatureScale])
 						break;
 					default:
-						attributeList.putAll([(attribute.name): currentState.value ])
+						attributeList.putAll([(attribute.name): currentState.value])
 						break;
 				}
-				if( deviceType == "genericSensor" ){
+				if (deviceType == "genericSensor") {
 					def key = attribute.name + "_lastUpdated"
-					attributeList.putAll([ (key): currentState.isoDate ])
+					attributeList.putAll([(key): currentState.isoDate])
 				}
 			} else {
-				attributeList.putAll([ (attribute.name): null ]);
+				attributeList.putAll([(attribute.name): null]);
 			}
-		} catch(e) {
-			attributeList.putAll([ (attribute.name): null ]);
+		} catch (e) {
+			attributeList.putAll([(attribute.name): null]);
 		}
 	}
 	return attributeList
@@ -589,5 +645,5 @@ private mapDeviceCommands(command, value) {
 			break
 	}
 
-	return [resultCommand,resultValue]
+	return [resultCommand, resultValue]
 }

smartapps/smartthings/bose-soundtouch-connect.src/bose-soundtouch-connect.groovy

@@ -1,609 +0,0 @@
-/**
- *  Bose SoundTouch (Connect)
- *
- *  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.
- *
- */
- definition(
-    name: "Bose SoundTouch (Connect)",
-    namespace: "smartthings",
-    author: "SmartThings",
-    description: "Control your Bose SoundTouch speakers",
-    category: "SmartThings Labs",
-    iconUrl: "https://d3azp77rte0gip.cloudfront.net/smartapps/fcf1d93a-ba0b-4324-b96f-e5b5487dfaf5/images/BoseST_icon.png",
-    iconX2Url: "https://d3azp77rte0gip.cloudfront.net/smartapps/fcf1d93a-ba0b-4324-b96f-e5b5487dfaf5/images/BoseST_icon@2x.png",
-    iconX3Url: "https://d3azp77rte0gip.cloudfront.net/smartapps/fcf1d93a-ba0b-4324-b96f-e5b5487dfaf5/images/BoseST_icon@2x-1.png",
-    singleInstance: true
-)
-
-preferences {
-    page(name:"deviceDiscovery", title:"Device Setup", content:"deviceDiscovery", refreshTimeout:5)
-}
-
-/**
- * Get the urn that we're looking for
- *
- * @return URN which we are looking for
- *
- * @todo This + getUSNQualifier should be one and should use regular expressions
- */
-def getDeviceType() {
-    return "urn:schemas-upnp-org:device:MediaRenderer:1" // Bose
-}
-
-/**
- * If not null, returns an additional qualifier for ssdUSN
- * to avoid spamming the network
- *
- * @return Additional qualifier OR null if not needed
- */
-def getUSNQualifier() {
-    return "uuid:BO5EBO5E-F00D-F00D-FEED-"
-}
-
-/**
- * Get the name of the new device to instantiate in the user's smartapps
- * This must be an app owned by the namespace (see #getNameSpace).
- *
- * @return name
- */
-def getDeviceName() {
-    return "Bose SoundTouch"
-}
-
-/**
- * Returns the namespace this app and siblings use
- *
- * @return namespace
- */
-def getNameSpace() {
-    return "smartthings"
-}
-
-/**
- * The deviceDiscovery page used by preferences. Will automatically
- * make calls to the underlying discovery mechanisms as well as update
- * whenever new devices are discovered AND verified.
- *
- * @return a dynamicPage() object
- */
-def deviceDiscovery()
-{
-    if(canInstallLabs())
-    {
-        def refreshInterval = 3 // Number of seconds between refresh
-        int deviceRefreshCount = !state.deviceRefreshCount ? 0 : state.deviceRefreshCount as int
-        state.deviceRefreshCount = deviceRefreshCount + refreshInterval
-
-        def devices = getSelectableDevice()
-        def numFound = devices.size() ?: 0
-
-        // Make sure we get location updates (contains LAN data such as SSDP results, etc)
-        subscribeNetworkEvents()
-
-        //device discovery request every 15s
-        if((deviceRefreshCount % 15) == 0) {
-            discoverDevices()
-        }
-
-        // Verify request every 3 seconds except on discoveries
-        if(((deviceRefreshCount % 3) == 0) && ((deviceRefreshCount % 15) != 0)) {
-            verifyDevices()
-        }
-
-        log.trace "Discovered devices: ${devices}"
-
-        return dynamicPage(name:"deviceDiscovery", title:"Discovery Started!", nextPage:"", refreshInterval:refreshInterval, install:true, uninstall: true) {
-            section("Please wait while we discover your ${getDeviceName()}. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
-                input "selecteddevice", "enum", required:false, title:"Select ${getDeviceName()} (${numFound} found)", multiple:true, options:devices, submitOnChange: true
-            }
-        }
-    }
-    else
-    {
-        def upgradeNeeded = """To use SmartThings Labs, your Hub should be completely up to date.
-
-To update your Hub, access Location Settings in the Main Menu (tap the gear next to your location name), select your Hub, and choose "Update Hub"."""
-
-        return dynamicPage(name:"deviceDiscovery", title:"Upgrade needed!", nextPage:"", install:true, uninstall: true) {
-            section("Upgrade") {
-                paragraph "$upgradeNeeded"
-            }
-        }
-    }
-}
-
-/**
- * Called by SmartThings Cloud when user has selected device(s) and
- * pressed "Install".
- */
-def installed() {
-    log.trace "Installed with settings: ${settings}"
-    initialize()
-}
-
-/**
- * Called by SmartThings Cloud when app has been updated
- */
-def updated() {
-    log.trace "Updated with settings: ${settings}"
-    unsubscribe()
-    initialize()
-}
-
-/**
- * Called by SmartThings Cloud when user uninstalls the app
- *
- * We don't need to manually do anything here because any children
- * are automatically removed upon the removal of the parent.
- *
- * Only time to do anything here is when you need to notify
- * the remote end. And even then you're discouraged from removing
- * the children manually.
- */
-def uninstalled() {
-}
-
-/**
- * If user has selected devices, will start monitoring devices
- * for changes (new address, port, etc...)
- */
-def initialize() {
-    log.trace "initialize()"
-    state.subscribe = false
-    if (selecteddevice) {
-        addDevice()
-        refreshDevices()
-        subscribeNetworkEvents(true)
-    }
-}
-
-/**
- * Adds the child devices based on the user's selection
- *
- * Uses selecteddevice defined in the deviceDiscovery() page
- */
-def addDevice(){
-    def devices = getVerifiedDevices()
-    def devlist
-    log.trace "Adding childs"
-
-    // If only one device is selected, we don't get a list (when using simulator)
-    if (!(selecteddevice instanceof List)) {
-        devlist = [selecteddevice]
-    } else {
-        devlist = selecteddevice
-    }
-
-    log.trace "These are being installed: ${devlist}"
-
-    devlist.each { dni ->
-        def d = getChildDevice(dni)
-        if(!d) {
-            def newDevice = devices.find { (it.value.mac) == dni }
-            def deviceName = newDevice?.value.name
-            if (!deviceName)
-                deviceName = getDeviceName() + "[${newDevice?.value.name}]"
-            d = addChildDevice(getNameSpace(), getDeviceName(), dni, newDevice?.value.hub, [label:"${deviceName}"])
-            d.boseSetDeviceID(newDevice.value.deviceID)
-            log.trace "Created ${d.displayName} with id $dni"
-            // sync DTH with device, done here as it currently don't work from the DTH's installed() method
-            d.refresh()
-        } else {
-            log.trace "${d.displayName} with id $dni already exists"
-        }
-    }
-}
-
-/**
- * Resolves a DeviceNetworkId to an address. Primarily used by children
- *
- * @param dni Device Network id
- * @return address or null
- */
-def resolveDNI2Address(dni) {
-    def device = getVerifiedDevices().find { (it.value.mac) == dni }
-    if (device) {
-        return convertHexToIP(device.value.networkAddress)
-    }
-    return null
-}
-
-/**
- * Joins a child to the "Play Everywhere" zone
- *
- * @param child The speaker joining the zone
- * @return A list of maps with POST data
- */
-def boseZoneJoin(child) {
-    log = child.log // So we can debug this function
-
-    def results = []
-    def result = [:]
-
-    // Find the master (if any)
-    def server = getChildDevices().find{ it.boseGetZone() == "server" }
-
-    if (server) {
-        log.debug "boseJoinZone() We have a server already, so lets add the new speaker"
-        child.boseSetZone("client")
-
-        result['endpoint'] = "/setZone"
-        result['host'] = server.getDeviceIP() + ":8090"
-        result['body'] = "<zone master=\"${server.boseGetDeviceID()}\" senderIPAddress=\"${server.getDeviceIP()}\">"
-        getChildDevices().each{ it ->
-            log.trace "child: " + child
-            log.trace "zone : " + it.boseGetZone()
-            if (it.boseGetZone() || it.boseGetDeviceID() == child.boseGetDeviceID())
-                result['body'] = result['body'] + "<member ipaddress=\"${it.getDeviceIP()}\">${it.boseGetDeviceID()}</member>"
-        }
-        result['body'] = result['body'] + '</zone>'
-    } else {
-        log.debug "boseJoinZone() No server, add it!"
-        result['endpoint'] = "/setZone"
-        result['host'] = child.getDeviceIP() + ":8090"
-        result['body'] = "<zone master=\"${child.boseGetDeviceID()}\" senderIPAddress=\"${child.getDeviceIP()}\">"
-        result['body'] = result['body'] + "<member ipaddress=\"${child.getDeviceIP()}\">${child.boseGetDeviceID()}</member>"
-        result['body'] = result['body'] + '</zone>'
-        child.boseSetZone("server")
-    }
-    results << result
-    return results
-}
-
-def boseZoneReset() {
-    getChildDevices().each{ it.boseSetZone(null) }
-}
-
-def boseZoneHasMaster() {
-    return getChildDevices().find{ it.boseGetZone() == "server" } != null
-}
-
-/**
- * Removes a speaker from the play everywhere zone.
- *
- * @param child Which speaker is leaving
- * @return a list of maps with POST data
- */
-def boseZoneLeave(child) {
-    log = child.log // So we can debug this function
-
-    def results = []
-    def result = [:]
-
-    // First, tag us as a non-member
-    child.boseSetZone(null)
-
-    // Find the master (if any)
-    def server = getChildDevices().find{ it.boseGetZone() == "server" }
-
-    if (server && server.boseGetDeviceID() != child.boseGetDeviceID()) {
-        log.debug "boseLeaveZone() We have a server, so tell him we're leaving"
-        result['endpoint'] = "/removeZoneSlave"
-        result['host'] = server.getDeviceIP() + ":8090"
-        result['body'] = "<zone master=\"${server.boseGetDeviceID()}\" senderIPAddress=\"${server.getDeviceIP()}\">"
-        result['body'] = result['body'] + "<member ipaddress=\"${child.getDeviceIP()}\">${child.boseGetDeviceID()}</member>"
-        result['body'] = result['body'] + '</zone>'
-        results << result
-    } else {
-        log.debug "boseLeaveZone() No server, then...uhm, we probably were it!"
-        // Dismantle the entire thing, first send this to master
-        result['endpoint'] = "/removeZoneSlave"
-        result['host'] = child.getDeviceIP() + ":8090"
-        result['body'] = "<zone master=\"${child.boseGetDeviceID()}\" senderIPAddress=\"${child.getDeviceIP()}\">"
-        getChildDevices().each{ dev ->
-            if (dev.boseGetZone() || dev.boseGetDeviceID() == child.boseGetDeviceID())
-                result['body'] = result['body'] + "<member ipaddress=\"${dev.getDeviceIP()}\">${dev.boseGetDeviceID()}</member>"
-        }
-        result['body'] = result['body'] + '</zone>'
-        results << result
-
-        // Also issue this to each individual client
-        getChildDevices().each{ dev ->
-            if (dev.boseGetZone() && dev.boseGetDeviceID() != child.boseGetDeviceID()) {
-                log.trace "Additional device: " + dev
-                result['host'] = dev.getDeviceIP() + ":8090"
-                results << result
-            }
-        }
-    }
-
-    return results
-}
-
-/**
- * Define our XML parsers
- *
- * @return mapping of root-node <-> parser function
- */
-def getParsers() {
-    [
-        "root" : "parseDESC",
-        "info" : "parseINFO"
-    ]
-}
-
-/**
- * Called when location has changed, contains information from
- * network transactions. See deviceDiscovery() for where it is
- * registered.
- *
- * @param evt Holds event information
- */
-def onLocation(evt) {
-    // Convert the event into something we can use
-    def lanEvent = parseLanMessage(evt.description, true)
-    lanEvent << ["hub":evt?.hubId]
-
-    // Determine what we need to do...
-    if (lanEvent?.ssdpTerm?.contains(getDeviceType()) &&
-        (getUSNQualifier() == null ||
-         lanEvent?.ssdpUSN?.contains(getUSNQualifier())
-        )
-       )
-    {
-        parseSSDP(lanEvent)
-    }
-    else if (
-        lanEvent.headers && lanEvent.body &&
-        lanEvent.headers."content-type"?.contains("xml")
-        )
-    {
-        def parsers = getParsers()
-        def xmlData = new XmlSlurper().parseText(lanEvent.body)
-
-        // Let each parser take a stab at it
-        parsers.each { node,func ->
-            if (xmlData.name() == node)
-                "$func"(xmlData)
-        }
-    }
-}
-
-/**
- * Handles SSDP description file.
- *
- * @param xmlData
- */
-private def parseDESC(xmlData) {
-    log.info "parseDESC()"
-
-    def devicetype = getDeviceType().toLowerCase()
-    def devicetxml = body.device.deviceType.text().toLowerCase()
-
-    // Make sure it's the type we want
-    if (devicetxml == devicetype) {
-        def devices = getDevices()
-        def device = devices.find {it?.key?.contains(xmlData?.device?.UDN?.text())}
-        if (device && !device.value?.verified) {
-            // Unlike regular DESC, we cannot trust this just yet, parseINFO() decides all
-            device.value << [name:xmlData?.device?.friendlyName?.text(),model:xmlData?.device?.modelName?.text(), serialNumber:xmlData?.device?.serialNum?.text()]
-        } else {
-            log.error "parseDESC(): The xml file returned a device that didn't exist"
-        }
-    }
-}
-
-/**
- * Handle BOSE <info></info> result. This is an alternative to
- * using the SSDP description standard. Some of the speakers do
- * not support SSDP description, so we need this as well.
- *
- * @param xmlData
- */
-private def parseINFO(xmlData) {
-    log.info "parseINFO()"
-    def devicetype = getDeviceType().toLowerCase()
-
-    def deviceID = xmlData.attributes()['deviceID']
-    def device = getDevices().find {it?.key?.contains(deviceID)}
-    if (device && !device.value?.verified) {
-        device.value << [name:xmlData?.name?.text(),model:xmlData?.type?.text(), serialNumber:xmlData?.serialNumber?.text(), "deviceID":deviceID, verified: true]
-    }
-}
-
-/**
- * Handles SSDP discovery messages and adds them to the list
- * of discovered devices. If it already exists, it will update
- * the port and location (in case it was moved).
- *
- * @param lanEvent
- */
-def parseSSDP(lanEvent) {
-    //SSDP DISCOVERY EVENTS
-    def USN = lanEvent.ssdpUSN.toString()
-    def devices = getDevices()
-
-    if (!(devices."${USN}")) {
-        //device does not exist
-        log.trace "parseSDDP() Adding Device \"${USN}\" to known list"
-        devices << ["${USN}":lanEvent]
-    } else {
-        // update the values
-        def d = devices."${USN}"
-        if (d.networkAddress != lanEvent.networkAddress || d.deviceAddress != lanEvent.deviceAddress) {
-            log.trace "parseSSDP() Updating device location (ip & port)"
-            d.networkAddress = lanEvent.networkAddress
-            d.deviceAddress = lanEvent.deviceAddress
-        }
-    }
-}
-
-/**
- * Generates a Map object which can be used with a preference page
- * to represent a list of devices detected and verified.
- *
- * @return Map with zero or more devices
- */
-Map getSelectableDevice() {
-    def devices = getVerifiedDevices()
-    def map = [:]
-    devices.each {
-        def value = "${it.value.name}"
-        def key = it.value.mac
-        map["${key}"] = value
-    }
-    map
-}
-
-/**
- * Starts the refresh loop, making sure to keep us up-to-date with changes
- *
- */
-private refreshDevices() {
-    discoverDevices()
-    verifyDevices()
-    runIn(300, "refreshDevices")
-}
-
-/**
- * Starts a subscription for network events
- *
- * @param force If true, will unsubscribe and subscribe if necessary (Optional, default false)
- */
-private subscribeNetworkEvents(force=false) {
-    if (force) {
-        unsubscribe()
-        state.subscribe = false
-    }
-
-    if(!state.subscribe) {
-        subscribe(location, null, onLocation, [filterEvents:false])
-        state.subscribe = true
-    }
-}
-
-/**
- * Issues a SSDP M-SEARCH over the LAN for a specific type (see getDeviceType())
- */
-private discoverDevices() {
-    log.trace "discoverDevice() Issuing SSDP request"
-    sendHubCommand(new physicalgraph.device.HubAction("lan discovery ${getDeviceType()}", physicalgraph.device.Protocol.LAN))
-}
-
-/**
- * Walks through the list of unverified devices and issues a verification
- * request for each of them (basically calling verifyDevice() per unverified)
- */
-private verifyDevices() {
-    def devices = getDevices().findAll { it?.value?.verified != true }
-
-    devices.each {
-        verifyDevice(
-            it?.value?.mac,
-            convertHexToIP(it?.value?.networkAddress),
-            convertHexToInt(it?.value?.deviceAddress),
-            it?.value?.ssdpPath
-        )
-    }
-}
-
-/**
- * Verify the device, in this case, we need to obtain the info block which
- * holds information such as the actual mac to use in certain scenarios.
- *
- * Without this mac (henceforth referred to as deviceID), we can't do multi-speaker
- * functions.
- *
- * @param deviceNetworkId The DNI of the device
- * @param ip The address of the device on the network (not the same as DNI)
- * @param port The port to use (0 will be treated as invalid and will use 80)
- * @param devicessdpPath The URL path (for example, /desc)
- *
- * @note Result is captured in locationHandler()
- */
-private verifyDevice(String deviceNetworkId, String ip, int port, String devicessdpPath) {
-    if(ip) {
-        def address = ip + ":8090"
-        sendHubCommand(new physicalgraph.device.HubAction([
-            method: "GET",
-            path: "/info",
-            headers: [
-                HOST: address,
-            ]]))
-    } else {
-        log.warn("verifyDevice() IP address was empty")
-    }
-}
-
-/**
- * Returns an array of devices which have been verified
- *
- * @return array of verified devices
- */
-def getVerifiedDevices() {
-    getDevices().findAll{ it?.value?.verified == true }
-}
-
-/**
- * Returns all discovered devices or an empty array if none
- *
- * @return array of devices
- */
-def getDevices() {
-    state.devices = state.devices ?: [:]
-}
-
-/**
- * Converts a hexadecimal string to an integer
- *
- * @param hex The string with a hexadecimal value
- * @return An integer
- */
-private Integer convertHexToInt(hex) {
-    Integer.parseInt(hex,16)
-}
-
-/**
- * Converts an IP address represented as 0xAABBCCDD to AAA.BBB.CCC.DDD
- *
- * @param hex Address represented in hex
- * @return String containing normal IPv4 dot notation
- */
-private String convertHexToIP(hex) {
-    if (hex)
-        [convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
-    else
-        hex
-}
-
-/**
- * Tests if this setup can support SmarthThing Labs items
- *
- * @return true if it supports it.
- */
-private Boolean canInstallLabs()
-{
-    return hasAllHubsOver("000.011.00603")
-}
-
-/**
- * Tests if the firmwares on all hubs owned by user match or exceed the
- * provided version number.
- *
- * @param desiredFirmware The version that must match or exceed
- * @return true if hub has same or newer
- */
-private Boolean hasAllHubsOver(String desiredFirmware)
-{
-    return realHubFirmwareVersions.every { fw -> fw >= desiredFirmware }
-}
-
-/**
- * Creates a list of firmware version for every hub the user has
- *
- * @return List of firmwares
- */
-private List getRealHubFirmwareVersions()
-{
-    return location.hubs*.firmwareVersionString.findAll { it }
-}

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

@@ -27,10 +27,9 @@ definition(
 
 preferences {
 	page(name: "selectButton")
-	page(name: "configureButton1")
-	page(name: "configureButton2")
-	page(name: "configureButton3")
-	page(name: "configureButton4")
+	for (def i=1; i<=8; i++) {
+		page(name: "configureButton$i")
+	}
 
 	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",
-		nextPage: "configureButton2", uninstall: configured(), getButtonSections(1))
+	state.numButton = buttonDevice.currentState("numberOfButtons")?.longValue ?: 4
+	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",
-		nextPage: "configureButton3", uninstall: configured(), getButtonSections(2))
+	createPage(2)
 }
 
 def configureButton3() {
-	dynamicPage(name: "configureButton3", title: "If you have a third button, you can do even more here",
-		nextPage: "configureButton4", uninstall: configured(), getButtonSections(3))
+	createPage(3)
 }
+
 def configureButton4() {
-	dynamicPage(name: "configureButton4", title: "If you have a fourth button, you rule, and can set it up here",
-		install: true, uninstall: true, getButtonSections(4))
+	createPage(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: "selectionSegmented4", style: "segmented", title: "4 options", groupedOptions: addGroup(["One", "Two", "Three", "Four"]))
+            input(type: "enum", name: "selectionSegmented1", style: "segmented", title: "1 option", options: ["One"])
+            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") {