MSA-1559: Trend Setter is a SmartApp for grouping together devices for synchronised control and/or data aggregation using virtual devices that act as a controller device and interface for other devices in the group. At present there are 4 group types:

Switch - Group switch control
Dimmer - Group level/switch control
Colorful Light - Group colour/level/switch control
Power Meter - Averaged total power usage for group with High/Medium/Low usage indicator based on previous data (Experimental, possibly very inaccurate)

More information is better found here:
https://community.smartthings.com/t/release-trend-setter/31286

The SmartApp seems to be quite popular now so I thought I would submit it for publication as some people aren't keen on having to install multiple SmartApps and Device Handlers.

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

@@ -127,9 +127,10 @@ def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelR
 	def map = [ displayed: true ]
     switch (cmd.sensorType) {
     	case 1:
-        	map.name = "temperature"
-            map.unit = cmd.scale == 1 ? "F" : "C"
-            map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, map.unit, cmd.precision)
+			def cmdScale = cmd.scale == 1 ? "F" : "C"
+			map.name = "temperature"
+            map.unit = getTemperatureScale()
+            map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmdScale, cmd.precision)
             break
     	case 3:
         	map.name = "illuminance"

devicetypes/kriskit-trendsetter/colorful-light-group-device.src/colorful-light-group-device.groovy

@@ -0,0 +1,394 @@
+/**
+ *  Trend Setter - Colorful Light Group Device
+ *
+ *  Copyright 2015 Chris Kitch
+ *
+ *  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: "Colorful Light Group Device", namespace: "kriskit.trendSetter", author: "Chris Kitch") {
+		capability "Actuator"
+		capability "Sensor"
+		capability "Switch"
+		capability "Switch Level"
+        capability "Color Control"
+        
+        command "adjustLevel"
+        command "adjustSaturation"
+        command "adjustHue"
+        
+        attribute "onPercentage", "number"
+        attribute "levelSync", "string"
+        attribute "colorSync", "string"
+        attribute "saturationSync", "string"
+        attribute "hueSync", "string"
+	}
+
+	simulator {
+		// TODO: define status and reply messages here
+	}
+
+	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.multi-light-bulb-on", backgroundColor: "#79b821", nextState: "turningOff"
+				attributeState "off", label: '${name}', action: "switch.on", icon: "st.lights.multi-light-bulb-off", backgroundColor: "#ffffff", nextState: "turningOn"
+				attributeState "turningOn", label: '${name}', action: "switch.off", icon: "st.lights.multi-light-bulb-on", backgroundColor: "#79b821", nextState: "turningOff"
+				attributeState "turningOff", label: '${name}', action: "switch.on", icon: "st.lights.multi-light-bulb-off", backgroundColor: "#ffffff", nextState: "turningOn"
+                attributeState "half", label: '${name}', action: "switch.on", icon: "st.lights.multi-light-bulb-on", backgroundColor: "#a3d164", nextState: "turningOn"
+                attributeState "mostlyOn", label: 'Onish', action: "switch.on", icon: "st.lights.multi-light-bulb-on", backgroundColor: "#79b821", nextState: "turningOn"
+                attributeState "mostlyOff", label: 'Offish', action: "switch.off", icon: "st.lights.multi-light-bulb-off", backgroundColor: "#d1e5b5", nextState: "turninOff"
+			}
+            
+            tileAttribute ("device.color", key: "COLOR_CONTROL") {
+            	attributeState "color", action: "color control.setColor"
+            }
+            
+			tileAttribute ("device.onPercentage", key: "SECONDARY_CONTROL") {
+				attributeState "onPercentage", label:'${currentValue}% On'
+                attributeState "100", label:'All On'
+                attributeState "0", label:'All Off'
+			}
+            
+            tileAttribute("device.level", key: "SLIDER_CONTROL") {
+              attributeState "default", label: '', action: "switch level.setLevel"
+    		}
+		}
+        
+        standardTile("levelLabel", "levelLable", height:1, width:1, decoration: "flat", inactiveLabel: true) {
+            state "default", label:"Level", unit:"", icon: "st.illuminance.illuminance.light"
+        }
+        
+        controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 3, inactiveLabel: false) {
+            state "level", action:"switch level.setLevel"
+        }
+        
+        valueTile("levelValue", "device.level", inactiveLabel: true, height:1, width:1, decoration: "flat") {
+            state "default", label:'${currentValue}%', unit:""
+        }
+        
+        valueTile("levelSync", "device.levelSync", height:1, width:1) {
+            state "default", label:' Sync ', unit:"", action: "adjustLevel", backgroundColor: "#ff9900"
+            state "ok", label:'', unit:"", backgroundColor: "#00b509"
+        }
+        
+        standardTile("saturationLabel", "saturationLabel", height:1, width:1, decoration: "flat", inactiveLabel: true) {
+            state "default", label:"Sat", unit:"", icon: "st.Kids.kids2"
+        }
+        
+        controlTile("saturationSliderControl", "device.saturation", "slider", height: 1, width: 3, inactiveLabel: false) {
+            state "saturation", action:"color control.setSaturation"
+        }
+        
+        valueTile("saturationValue", "device.saturation", inactiveLabel: true, height:1, width:1, decoration: "flat") {
+            state "default", label:'${currentValue}%', unit:""
+        }
+        
+        valueTile("saturationSync", "device.saturationSync", height:1, width:1) {
+            state "default", label:' Sync ', unit:"", action: "adjustSaturation", backgroundColor: "#ff9900"
+            state "ok", label:'', unit:"", backgroundColor: "#00b509"
+        }
+        
+        standardTile("hueLabel", "hueLabel", height:1, width:1, decoration: "flat", inactiveLabel: true) {
+            state "default", label:"Hue", unit:"", icon: "st.Kids.kids2"
+        }
+        
+        controlTile("hueSliderControl", "device.hue", "slider", height: 1, width: 3, inactiveLabel: false) {
+            state "hue", action:"color control.setHue"
+        }
+        
+        valueTile("hueValue", "device.hue", inactiveLabel: true, height:1, width:1, decoration: "flat") {
+            state "default", label:'${currentValue}%', unit:""
+        }
+        
+        valueTile("hueSync", "device.hueSync", height:1, width:1) {
+            state "default", label:' Sync ', unit:"", action: "adjustHue", backgroundColor: "#ff9900"
+            state "ok", label:'', unit:"", backgroundColor: "#00b509"
+        }
+	}
+    
+    main "switch"
+    details([
+    	"switch", 
+        "levelLabel", 
+        "levelSliderControl", 
+        "levelValue", 
+        "levelSync", 
+        "saturationLabel", 
+        "saturationSliderControl", 
+        "saturationValue", 
+        "saturationSync",
+        "hueLabel",
+        "hueSliderControl",
+        "hueValue",
+        "hueSync"])
+}
+
+def parse(String description) {
+}
+
+def groupSync(name, values) {
+	try {
+    	"sync${name.capitalize()}"(values)	
+    } catch(ex) {
+    	log.error "Error executing 'sync${name.capitalize()}' method: $ex"
+    }
+}
+
+// SWITCH
+def on() {
+	on(true)
+}
+
+def on(triggerGroup) {
+	sendEvent(name: "switch", value: "on")
+    sendEvent(name: "onPercentage", value: 100, displayed: false)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("on")
+}
+
+def off() {
+	off(true)
+}
+
+def off(triggerGroup) {
+	sendEvent(name: "switch", value: "off")
+    sendEvent(name: "onPercentage", value: 0, displayed: false)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("off")
+}
+
+def syncSwitch(values) {
+	log.debug "syncSwitch(): $values"
+    
+    def onCount = values?.count { it == "on" }
+    def percentOn = (int)Math.floor((onCount / values?.size()) * 100)
+    
+    log.debug "Percent On: $percentOn"
+    
+    if (percentOn == 0 || percentOn == 100) {
+    	if (percentOn == 0)
+        	off(false)
+        else
+        	on(false)            
+        return
+    }
+    
+    def value = null
+    
+    if (percentOn == 50)
+    	value = "half"
+    else if (percentOn > 0 && percentOn < 50)
+		value = "mostlyOff"
+    else if (percentOn > 50 && percentOn < 100)
+		value = "mostlyOn"
+        
+	sendEvent(name: "switch", value: value)
+	sendEvent(name: "onPercentage", value: percentOn, displayed: false)
+}
+
+// LEVEL
+def setLevel(val) {
+	setLevel(val, true)
+}
+
+def setLevel(val, triggerGroup) {
+	log.debug "Setting level to $val"
+
+    if (val < 0)
+    	val = 0
+    
+    if( val > 100)
+    	val = 100
+    
+    if (triggerGroup) {
+       if (val == 0)
+    	   off()
+       else
+    	   on()
+    }
+        
+    sendEvent(name: "level", value: val, isStateChange: true)
+    sendEvent(name: "switch.setLevel", value: val, isStateChange: true)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("setLevel", [val])
+}
+
+def syncLevel(values) {
+	log.debug "syncLevel(): $values"
+    
+    def valueCount = values?.size()
+    def valueCountBy = values?.countBy { it }
+    def matchValue = "bad"
+    def level = device.currentValue("level")
+    
+    valueCountBy.each { value, count -> 
+    	if (count == valueCount) {
+        	level = value
+            matchValue = "ok"
+        	return true
+        }
+    }
+    
+    if (matchValue == "bad")
+    	level = getAdjustmentLevel(values)
+    
+    setLevel(level, false)
+    sendEvent(name: "levelSync", value: matchValue, displayed: false)
+}
+
+def adjustLevel() {
+	def values = parent.getGroupCurrentValues("level")
+    
+    if (!values)
+    	return
+
+    def level = getAdjustmentLevel(values)    
+    setLevel(level)
+}
+
+def getAdjustmentLevel(values) {
+    if (!values)
+    	return
+        
+    def valueCountBy = values?.countBy { it }
+    valueCountBy = valueCountBy?.sort { a, b -> b.value <=> a.value }
+    
+    def level = device.currentValue("level")
+    
+    if (valueCountBy.size() > 1) {        
+        if (valueCountBy.size() == values.size()) {
+        	log.debug "Values are all different - making average"
+            level = Math.round(values.sum() / values.size())
+        } else {
+			log.debug "Some values are the same, choosing most popular"
+            def firstItem = valueCountBy.find { true }
+            level = firstItem.key
+        }
+    }
+    
+    return level
+}
+
+// COLOR
+def setColor(value) {
+	setColor(value, true)
+}
+
+def setColor(value, triggerGroup) {
+	value.level = null
+    
+    def hex = value.hex
+    
+    if (!hex && value.hue && value.saturation)
+		hex = colorUtil.hslToHex(value.hue, value.saturation)
+        
+	sendEvent(name: "color", value: value.hex, displayed:false)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("setColor", [value])
+
+	if (value.saturation)
+		setSaturation(value.saturation, triggerGroup, false)
+        
+    if (value.hue)
+    	setHue(value.hue, triggerGroup, false)
+}
+
+def syncColor(values) {
+	log.debug "syncColor(): $values"
+}
+
+// SATURATION
+def setSaturation(value) {
+	setSaturation(value, true, true)
+}
+
+def setSaturation(value, triggerGroup, sendColor) {
+	on(triggerGroup)
+
+	sendEvent(name: "saturation", value: (int)value, displayed:false)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("setSaturation", [value])
+    
+    if (sendColor) {
+    	def hex = colorUtil.hslToHex((int)device.currentValue("hue"), value)
+    	sendEvent(name: "color", value: hex, displayed:false)	
+    }
+}
+
+def syncSaturation(values) {
+	log.debug "syncSaturation(): $values"
+    
+    def valueCount = values?.size()
+    def valueCountBy = values?.countBy { it }
+    def matchValue = "bad"
+    
+    valueCountBy.each { value, count -> 
+    	if (count == valueCount) {
+            matchValue = "ok"
+        	return true
+        }
+    }
+    
+    sendEvent(name: "saturationSync", value: matchValue, displayed: false)
+}
+
+def adjustSaturation() {
+    def saturation = (int)device.currentValue("saturation")    
+	log.debug "adjustSaturation $saturation"
+    setSaturation(saturation)
+}
+
+// HUE
+def setHue(value) {
+	setHue(value, true, true)
+}
+
+def setHue(value, triggerGroup, sendColor) {
+	on(triggerGroup)
+	sendEvent(name: "hue", value: (int)value, displayed: false)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("setHue", [value])
+    
+    if (sendColor) {
+    	def hex = colorUtil.hslToHex(value, (int)device.currentValue("saturation"))
+    	sendEvent(name: "color", value: hex, displayed:false)	
+    }
+}
+
+def syncHue(values) {
+	log.debug "syncHue(): $values"
+    
+    def valueCount = values?.size()
+    def valueCountBy = values?.countBy { it }
+    def matchValue = "bad"
+    
+    valueCountBy.each { value, count -> 
+    	if (count == valueCount) {
+            matchValue = "ok"
+        	return true
+        }
+    }
+    
+    sendEvent(name: "hueSync", value: matchValue, displayed: false)
+}
+
+def adjustHue() {
+    def hue = (int)device.currentValue("hue")    
+	log.debug "adjustHue: $hue"
+    setHue(hue)
+}

devicetypes/kriskit-trendsetter/dimmer-group-device.src/dimmer-group-device.groovy

@@ -0,0 +1,229 @@
+/**
+ *  Trend Setter - Dimmer Group Device
+ *
+ *  Copyright 2015 Chris Kitch
+ *
+ *  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: "Dimmer Group Device", namespace: "kriskit.trendSetter", author: "Chris Kitch") {
+		capability "Actuator"
+		capability "Sensor"
+		capability "Switch"
+		capability "Switch Level"
+        
+        command "adjustLevel"
+        
+        attribute "onPercentage", "number"
+        attribute "levelSync", "string"
+	}
+
+	simulator {
+		// TODO: define status and reply messages here
+	}
+
+	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.multi-light-bulb-on", backgroundColor: "#79b821", nextState: "turningOff"
+				attributeState "off", label: '${name}', action: "switch.on", icon: "st.lights.multi-light-bulb-off", backgroundColor: "#ffffff", nextState: "turningOn"
+				attributeState "turningOn", label: '${name}', action: "switch.off", icon: "st.lights.multi-light-bulb-on", backgroundColor: "#79b821", nextState: "turningOff"
+				attributeState "turningOff", label: '${name}', action: "switch.on", icon: "st.lights.multi-light-bulb-off", backgroundColor: "#ffffff", nextState: "turningOn"
+                attributeState "half", label: '${name}', action: "switch.on", icon: "st.lights.multi-light-bulb-on", backgroundColor: "#a3d164", nextState: "turningOn"
+                attributeState "mostlyOn", label: 'Onish', action: "switch.on", icon: "st.lights.multi-light-bulb-on", backgroundColor: "#79b821", nextState: "turningOn"
+                attributeState "mostlyOff", label: 'Offish', action: "switch.off", icon: "st.lights.multi-light-bulb-off", backgroundColor: "#d1e5b5", nextState: "turninOff"
+			}
+            
+			tileAttribute ("device.onPercentage", key: "SECONDARY_CONTROL") {
+				attributeState "onPercentage", label:'${currentValue}% On'
+                attributeState "100", label:'All On'
+                attributeState "0", label:'All Off'
+			}
+            
+            tileAttribute("device.level", key: "SLIDER_CONTROL") {
+              attributeState "default", label: '', action: "switch level.setLevel"
+    		}
+		}
+        
+        standardTile("levelLabel", "levelLable", height:1, width:1, decoration: "flat", inactiveLabel: true) {
+            state "default", label:"Level", unit:"", icon: "st.illuminance.illuminance.bright"
+        }
+        
+        controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 3, inactiveLabel: false) {
+            state "level", action:"switch level.setLevel"
+        }
+        
+        valueTile("levelValue", "device.level", inactiveLabel: true, height:1, width:1, decoration: "flat") {
+            state "default", label:'${currentValue}%', unit:""
+        }
+        
+        valueTile("levelSync", "device.levelSync", height:1, width:1) {
+            state "default", label:' Sync ', unit:"", action: "adjustLevel", backgroundColor: "#ff9900"
+            state "ok", label:'', unit:"", backgroundColor: "#00b509"
+        }
+	}
+    
+    main "switch"
+    details(["switch", "levelLabel", "levelSliderControl", "levelValue", "levelSync"])
+}
+
+def parse(String description) {
+}
+
+def groupSync(name, values) {
+	try {
+    	"sync${name.capitalize()}"(values)	
+    } catch(ex) {
+    	log.error "Error executing 'sync${name.capitalize()}' method: $ex"
+    }
+}
+
+// SWITCH
+def on() {
+	on(true)
+}
+
+def on(triggerGroup) {
+	sendEvent(name: "switch", value: "on")
+    sendEvent(name: "onPercentage", value: 100, displayed: false)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("on")
+}
+
+def off() {
+	off(true)
+}
+
+def off(triggerGroup) {
+	sendEvent(name: "switch", value: "off")
+    sendEvent(name: "onPercentage", value: 0, displayed: false)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("off")
+}
+
+def syncSwitch(values) {
+	log.debug "syncSwitch(): $values"
+    
+    def onCount = values?.count { it == "on" }
+    def percentOn = (int)Math.floor((onCount / values?.size()) * 100)
+    
+    log.debug "Percent On: $percentOn"
+    
+    if (percentOn == 0 || percentOn == 100) {
+    	if (percentOn == 0)
+        	off(false)
+        else
+        	on(false)            
+        return
+    }
+    
+    def value = null
+    
+    if (percentOn == 50)
+    	value = "half"
+    else if (percentOn > 0 && percentOn < 50)
+		value = "mostlyOff"
+    else if (percentOn > 50 && percentOn < 100)
+		value = "mostlyOn"
+        
+	sendEvent(name: "switch", value: value)
+	sendEvent(name: "onPercentage", value: percentOn, displayed: false)
+}
+
+// LEVEL
+def setLevel(val){
+	setLevel(val, true)
+}
+
+def setLevel(val, triggerGroup) {
+	log.debug "Setting level to $val"
+
+    if (val < 0)
+    	val = 0
+    
+    if( val > 100)
+    	val = 100
+    
+    if (triggerGroup) {
+       if (val == 0)
+    	   off()
+       else
+    	   on()
+    }
+        
+    sendEvent(name: "level", value: val, isStateChange: true)
+    sendEvent(name: "switch.setLevel", value: val, isStateChange: true)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("setLevel", [val])
+}
+
+def syncLevel(values) {
+	log.debug "syncLevel(): $values"
+    
+    def valueCount = values?.size()
+    def valueCountBy = values?.countBy { it }
+    def matchValue = "bad"
+    def level = device.currentValue("level")
+    
+    valueCountBy.each { value, count -> 
+    	if (count == valueCount) {
+        	level = value
+            matchValue = "ok"
+        	return true
+        }
+    }
+    
+    if (matchValue == "bad")
+    	level = getAdjustmentLevel(values)
+    
+    setLevel(level, false)
+    sendEvent(name: "levelSync", value: matchValue, displayed: false)
+}
+
+def adjustLevel() {
+	def values = parent.getGroupCurrentValues("level")
+    
+    if (!values)
+    	return
+        
+    def valueCountBy = values?.countBy { it }
+    valueCountBy = valueCountBy?.sort { a, b -> b.value <=> a.value }
+    
+    def level = getAdjustmentLevel(values)
+    
+    setLevel(level)
+}
+
+def getAdjustmentLevel(values) {
+    if (!values)
+    	return
+        
+    def valueCountBy = values?.countBy { it }
+    valueCountBy = valueCountBy?.sort { a, b -> b.value <=> a.value }
+    
+    def level = device.currentValue("level")
+    
+    if (valueCountBy.size() > 1) {        
+        if (valueCountBy.size() == values.size()) {
+        	log.debug "Values are all different - making average"
+            level = Math.round(values.sum() / values.size())
+        } else {
+			log.debug "Some values are the same, choosing most popular"
+            def firstItem = valueCountBy.find { true }
+            level = firstItem.key
+        }
+    }
+    
+    return level
+}

devicetypes/kriskit-trendsetter/power-meter-group-device.src/power-meter-group-device.groovy

@@ -0,0 +1,162 @@
+/**
+ *  Power Meter Group Device
+ *
+ *  Copyright 2015 Chris Kitch
+ *
+ *  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: "Power Meter Group Device", namespace: "kriskit.trendsetter", author: "Chris Kitch") {
+		capability "Power Meter"
+		capability "Sensor"
+        capability "Refresh"
+        
+        attribute "powerUsage", "string"
+	}
+
+	simulator {
+		// TODO: define status and reply messages here
+	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name:"main", type: "lighting", width: 6, height: 4) {
+			tileAttribute ("device.powerUsage", key: "PRIMARY_CONTROL") {
+				attributeState "off", label: '${name}', backgroundColor: "#ffffff", icon: "st.Appliances.appliances17"
+                attributeState "low", label: '${name}', backgroundColor: "#5CB85C", icon: "st.Appliances.appliances17"
+                attributeState "medium", label: '${name}', backgroundColor: "#ff7b00", icon: "st.Appliances.appliances17"
+                attributeState "high", label: '${name}', backgroundColor: "#c90000", icon: "st.Appliances.appliances17"
+                attributeState "veryHigh", label: '${name}', backgroundColor: "#ff0000", icon: "st.Appliances.appliances17"
+			}
+        
+			tileAttribute ("device.power", key: "SECONDARY_CONTROL") {
+				attributeState "default", label: '${currentValue} W'
+			}
+        }
+        
+        standardTile("refresh", "refresh", height:2, width:6, inactiveLabel: false, decoration: "flat") {
+        	state "default", action: "refresh.refresh", icon:"st.secondary.refresh"
+        }
+        
+        main("main")
+        details(["main", "refresh"])
+	}
+}
+
+// parse events into attributes
+def parse(String description) {
+}
+
+def groupSync(name, values) {
+	try {
+    	"sync${name.capitalize()}"(values)	
+    } catch(ex) {
+    	log.error "Error executing 'sync${name.capitalize()}' method: $ex"
+    }
+}
+
+def refresh() {
+	def powerValues = parent.getGroupCurrentValues("power")
+    syncPower(powerValues)
+}
+
+// POWER
+def syncPower(values) {   
+    log.debug "syncPower(): $values"
+	def total = values?.sum()
+        
+    if (total == 0) {
+    	sendEvent(name: "power", value: 0)
+        sendEvent(name: "powerUsage", value: "off")
+        return
+    }
+    
+	def aggregate = state.powerAggregate ?: []
+	state.powerSyncCount = state.powerSyncCount + 1
+    
+    if (state.powerSyncCount != null && state.powerSyncCount % 5 != 0) {
+        aggregate.push(total)
+        state.powerAggregate = aggregate
+        return
+    }
+
+    def aggregatedAverage = getAverage(aggregate)
+    log.debug "Aggregated Average Power: $aggregatedAverage"
+    sendEvent(name: "power", value: aggregatedAverage)
+
+    def level = getPowerUsageLevel(aggregatedAverage)
+    log.debug "Power usage level: $level"
+    sendEvent(name: "powerUsage", value: level)
+    
+    state.powerAggregate = []
+}
+
+def getPowerUsageLevel(value) {    
+    if (value == 0)
+    	return "off"
+        
+    def boundaries = getPowerUsageBoundaries()
+    
+    if (!boundaries)    
+    	return "low"
+        
+    log.debug "Determining power usage level with boundaries: $boundaries for value $value"
+        
+   	if (value > 0 && value <= boundaries.bottom)
+    	return "low"
+     
+    if (value > boundaries.bottom && value < boundaries.top)
+    	return "medium"
+        
+    if (value >= boundaries.top && value <= boundaries.max)
+    	return "high"
+        
+    if (value > boundaries.max) {
+    	state.powerUsageBoundaries = null
+    	return "veryHigh"
+	}
+}
+
+def getPowerUsageBoundaries() {
+	if (state.powerUsageBoundaries && state.powerSyncCount < 100)
+    	return state.powerUsageBoundaries
+        
+	def events = device.events([max: 500])
+    def powerEvents = events?.findAll {
+    	it.name == "power" && it.doubleValue > 0
+    }
+    
+    def powerValues = powerEvents*.doubleValue
+    powerValues.sort()
+    
+    def eventCount = powerValues?.size()
+    def eventChunkSize = (int)Math.round(eventCount / 2)
+    def chunkedEvents = powerValues.collate(eventChunkSize)
+   
+   if (chunkedEvents.size() < 2)
+   		return null
+
+	def boundaries = [
+    	top: getAverage(chunkedEvents[1]),
+    	bottom: getAverage(chunkedEvents[0]),
+        max: powerValues.max()
+	]        
+    
+   	state.powerSyncCount = 0
+    state.powerUsageBoundaries = boundaries
+    
+    log.debug "New boundaries: $boundaries"
+    
+    return boundaries
+}
+
+def getAverage(values) {
+	return Math.round((values.sum() / values.size()) * 100) / 100
+}

devicetypes/kriskit-trendsetter/switch-group-device.src/switch-group-device.groovy

@@ -0,0 +1,116 @@
+/**
+ *  Trend Setter - Switch Group Device
+ *
+ *  Copyright 2015 Chris Kitch
+ *
+ *  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 Group Device", namespace: "kriskit.trendSetter", author: "Chris Kitch") {
+		capability "Actuator"
+		capability "Sensor"
+		capability "Switch"
+        
+        attribute "onPercentage", "number"
+	}
+
+	simulator {
+		// TODO: define status and reply messages here
+	}
+
+	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 "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 "turningOff", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "turningOn"
+                attributeState "half", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#a3d164", nextState: "turningOn"
+                attributeState "mostlyOn", label: 'Onish', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#79b821", nextState: "turningOn"
+                attributeState "mostlyOff", label: 'Offish', action: "switch.off", icon: "st.switches.switch.off", backgroundColor: "#d1e5b5", nextState: "turninOff"
+			}
+            
+			tileAttribute ("device.onPercentage", key: "SECONDARY_CONTROL") {
+				attributeState "onPercentage", label:'${currentValue}% On'
+                attributeState "100", label:'All On'
+                attributeState "0", label:'All Off'
+			}
+		}
+	}
+    
+    main "switch"
+    details(["switch"])
+}
+
+def parse(String description) {
+}
+
+def groupSync(name, values) {
+	try {
+    	"sync${name.capitalize()}"(values)	
+    } catch(ex) {
+    	log.error "Error executing 'sync${name.capitalize()}' method: $ex"
+    }
+}
+
+// SWITCH
+def on() {
+	on(true)
+}
+
+def on(triggerGroup) {
+	sendEvent(name: "switch", value: "on")
+    sendEvent(name: "onPercentage", value: 100, displayed: false)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("on")
+}
+
+def off() {
+	off(true)
+}
+
+def off(triggerGroup) {
+	sendEvent(name: "switch", value: "off")
+    sendEvent(name: "onPercentage", value: 0, displayed: false)
+    
+    if (triggerGroup)
+    	parent.performGroupCommand("off")
+}
+
+def syncSwitch(values) {
+	log.debug "syncSwitch(): $values"
+    
+    def onCount = values?.count { it == "on" }
+    def percentOn = (int)Math.floor((onCount / values?.size()) * 100)
+    
+    log.debug "Percent On: $percentOn"
+    
+    if (percentOn == 0 || percentOn == 100) {
+    	if (percentOn == 0)
+        	off(false)
+        else
+        	on(false)            
+        return
+    }
+    
+    def value = null
+    
+    if (percentOn == 50)
+    	value = "half"
+    else if (percentOn > 0 && percentOn < 50)
+		value = "mostlyOff"
+    else if (percentOn > 50 && percentOn < 100)
+		value = "mostlyOn"
+        
+	sendEvent(name: "switch", value: value)
+	sendEvent(name: "onPercentage", value: percentOn, displayed: false)
+}

devicetypes/smartthings/arrival-sensor.src/arrival-sensor.groovy

@@ -87,16 +87,27 @@ def beep() {
 	up to this long from the time you send the message to the time you hear a sound.
 	*/
 
+	// Used source endpoint of 0x02 because we are using smartthings manufacturer specific cluster.
 	[
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
+		"delay 200",
+		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
+		"delay 200",
+		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
+		"delay 200",
+		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
+		"delay 200",
+		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
-		"raw 0xFC05 {15 0A 11 00 00 15 01}"
+		"raw 0xFC05 {15 0A 11 00 00 15 01}",
+		"delay 200",
+		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 	]
 }
 

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

@@ -105,11 +105,21 @@ def parseDescriptionAsMap(description) {
 
 // Commands to device
 def on() {
-	'zcl on-off on'
+	[
+			'zcl on-off on',
+			'delay 200',
+			"send 0x${zigbee.deviceNetworkId} 0x01 0x${zigbee.endpointId}",
+			'delay 500'
+	]
 }
 
 def off() {
-	'zcl on-off off'
+	[
+			'zcl on-off off',
+			'delay 200',
+			"send 0x${zigbee.deviceNetworkId} 0x01 0x${zigbee.endpointId}",
+			'delay 500'
+	]
 }
 
 def setLevel(value) {

devicetypes/smartthings/cree-bulb.src/README.md

@@ -23,10 +23,8 @@ Works with:
 
 ## Device Health
 
-A Category C6 Connected Cree LED Bulb with maxReportTime of 10 min.
-Check-in interval is double the value of maxReportTime for Zigbee device. 
-This gives the device twice the amount of time to respond before it is marked as offline.
-Check-in interval = 2*10 = 20 min
+A Category C6 Connected Cree LED Bulb with maxReportTime of 5 mins.
+Check-in interval = 12 mins
 
 ## Troubleshooting
 

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

@@ -59,6 +59,15 @@ metadata {
     }
 }
 
+def installed() {
+    log.debug "${device} installed"
+}
+
+def updated() {
+    log.debug "${device} updated"
+    configureHealthCheck()
+}
+
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
@@ -93,20 +102,23 @@ def ping() {
 }
 
 def refresh() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig() + zigbee.levelConfig()
+    zigbee.onOffRefresh() + zigbee.levelRefresh()
+}
+
+def configureHealthCheck() {
+    log.debug "configureHealthCheck"
+    unschedule("healthPoll")
+    runEvery5Minutes("healthPoll")
+    // Device-Watch allows 2 check-in misses from device
+    sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 }
 
 def healthPoll() {
+    log.debug "healthPoll()"
     def cmds = zigbee.onOffRefresh() + zigbee.levelRefresh()
     cmds.each{ sendHubCommand(new physicalgraph.device.HubAction(it))}
 }
 
 def configure() {
-    unschedule()
-    schedule("0 0/5 * * * ? *", "healthPoll")
-    log.debug "Configuring Reporting and Bindings."
-    // Device-Watch allows 2 check-in misses from device
-    sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee"])
-    // minReportTime 0 seconds, maxReportTime 5 min. Reporting interval if no activity
-    zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
+    refresh()
 }

devicetypes/smartthings/dimmer-switch.src/.st-ignore

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

devicetypes/smartthings/dimmer-switch.src/README.md

@@ -0,0 +1,45 @@
+# Z-wave Dimmer Switch
+
+
+
+Works with:
+
+* [GE Z-Wave In-Wall Smart Dimmer (GE 12724)](http://products.z-wavealliance.org/products/1197)
+* [GE Z-Wave In-Wall Smart Dimmer (Toggle) (GE 12729)](http://products.z-wavealliance.org/products/1201)
+* [GE Z-Wave Plug-in Smart Dimmer (GE 12718)](http://products.z-wavealliance.org/products/1191)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#Troubleshooting)
+
+## Capabilities
+
+* **Switch Level** - it's defined to accept two parameters, the level and the rate of dimming
+* **Actuator** - represents that a Device has commands
+* **Indicator** - gives you the ability to set the indicator LED light on a Z-Wave switch
+* **Switch** - can detect state (possible values: on/off)
+* **Polling** - represents that poll() can be implemented for the device
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - detects sensor events
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+Z-Wave Smart Dimmers (In-Wall, In-Wall(Toggle), Plug-In) are 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.
+Check-in interval = 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.
+
+## 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:
+* [General Z-Wave Dimmer/Switch Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/200955890-Troubleshooting-GE-in-wall-switch-or-dimmer-won-t-respond-to-commands-or-automations-Z-Wave-)
+* [GE Z-Wave In-Wall Smart Dimmer (GE 12724) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/200902600-GE-In-Wall-Paddle-Dimmer-Switch-GE-12724-Z-Wave-)
+* [GE Z-Wave In-Wall Smart Dimmer (Toggle) (GE 12729) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/207568463-GE-In-Wall-Smart-Toggle-Dimmer-GE-12729-Z-Wave-)
+* [GE Z-Wave Plug-in Smart Dimmer (GE 12718) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/202088474-GE-Plug-In-Smart-Dimmer-GE-12718-Z-Wave-)

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

@@ -20,6 +20,7 @@ metadata {
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
+		capability "Health Check"
 
 		fingerprint mfr:"0063", prod:"4457", deviceJoinName: "Z-Wave Wall Dimmer"
 		fingerprint mfr:"0063", prod:"4944", deviceJoinName: "Z-Wave Wall Dimmer"
@@ -82,6 +83,8 @@ metadata {
 }
 
 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])
   switch (ledIndicator) {
         case "on":
             indicatorWhenOn()
@@ -215,6 +218,13 @@ def poll() {
 	zwave.switchMultilevelV1.switchMultilevelGet().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 = []

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

@@ -31,13 +31,13 @@ metadata {
 		command "switchMode"
 		command "switchFanMode"
 
-		attribute "thermostatSetpoint","number"
-		attribute "thermostatStatus","string"
+		attribute "thermostatSetpoint", "number"
+		attribute "thermostatStatus", "string"
 		attribute "maxHeatingSetpoint", "number"
 		attribute "minHeatingSetpoint", "number"
 		attribute "maxCoolingSetpoint", "number"
 		attribute "minCoolingSetpoint", "number"
-		attribute "deviceTemperatureUnit", "number"
+		attribute "deviceTemperatureUnit", "string"
 	}
 
 	tiles {
@@ -148,14 +148,12 @@ def generateEvent(Map results) {
 						 handlerName: name]
 
 			if (name=="temperature" || name=="heatingSetpoint" || name=="coolingSetpoint" ) {
-				def sendValue = convertTemperatureIfNeeded(value.toDouble(), "F", 1) //API return temperature value in F
-				sendValue =  location.temperatureScale == "C"? roundC(sendValue) : sendValue
+				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]
 			}  else if (name=="maxCoolingSetpoint" || name=="minCoolingSetpoint" || name=="maxHeatingSetpoint" || name=="minHeatingSetpoint") {
-				def sendValue = convertTemperatureIfNeeded(value.toDouble(), "F", 1) //API return temperature value in F
-				sendValue =  location.temperatureScale == "C"? roundC(sendValue) : sendValue
+				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())
@@ -253,7 +251,6 @@ void setCoolingSetpoint(setpoint) {
 	def maxCoolingSetpoint = device.currentValue("maxCoolingSetpoint")
 	def minCoolingSetpoint = device.currentValue("minCoolingSetpoint")
 
-
 	if (coolingSetpoint > maxCoolingSetpoint) {
 		coolingSetpoint = maxCoolingSetpoint
 	} else if (coolingSetpoint < minCoolingSetpoint) {
@@ -283,7 +280,6 @@ void setCoolingSetpoint(setpoint) {
 }
 
 void resumeProgram() {
-
 	log.debug "resumeProgram() is called"
 	sendEvent("name":"thermostatStatus", "value":"resuming schedule", "description":statusText, displayed: false)
 	def deviceId = device.deviceNetworkId.split(/\./).last()
@@ -354,7 +350,6 @@ def switchFanMode() {
 }
 
 def switchToFanMode(nextMode) {
-
 	log.debug "switching to fan mode: $nextMode"
 	def returnCommand
 
@@ -520,63 +515,56 @@ def fanAuto() {
 }
 
 def generateSetpointEvent() {
-
 	log.debug "Generate SetPoint Event"
 
 	def mode = device.currentValue("thermostatMode")
-	log.debug "Current Mode = ${mode}"
 
 	def heatingSetpoint = device.currentValue("heatingSetpoint")
-	log.debug "Heating Setpoint = ${heatingSetpoint}"
-
 	def coolingSetpoint = device.currentValue("coolingSetpoint")
-	log.debug "Cooling Setpoint = ${coolingSetpoint}"
-
 	def maxHeatingSetpoint = device.currentValue("maxHeatingSetpoint")
 	def maxCoolingSetpoint = device.currentValue("maxCoolingSetpoint")
 	def minHeatingSetpoint = device.currentValue("minHeatingSetpoint")
 	def minCoolingSetpoint = device.currentValue("minCoolingSetpoint")
 
-	if(location.temperatureScale == "C")
-	{
-		maxHeatingSetpoint = roundC(maxHeatingSetpoint)
-		maxCoolingSetpoint = roundC(maxCoolingSetpoint)
-		minHeatingSetpoint = roundC(minHeatingSetpoint)
-		minCoolingSetpoint = roundC(minCoolingSetpoint)
-		heatingSetpoint = roundC(heatingSetpoint)
-		coolingSetpoint = roundC(coolingSetpoint)
+	if(location.temperatureScale == "C") {
+		maxHeatingSetpoint = maxHeatingSetpoint > 40 ? roundC(convertFtoC(maxHeatingSetpoint)) : roundC(maxHeatingSetpoint)
+		maxCoolingSetpoint = maxCoolingSetpoint > 40 ? roundC(convertFtoC(maxCoolingSetpoint)) : roundC(maxCoolingSetpoint)
+		minHeatingSetpoint = minHeatingSetpoint > 40 ? roundC(convertFtoC(minHeatingSetpoint)) : roundC(minHeatingSetpoint)
+		minCoolingSetpoint = minCoolingSetpoint > 40 ? roundC(convertFtoC(minCoolingSetpoint)) : roundC(minCoolingSetpoint)
+		heatingSetpoint = heatingSetpoint > 40 ? roundC(convertFtoC(heatingSetpoint)) : roundC(heatingSetpoint)
+		coolingSetpoint = coolingSetpoint > 40 ? roundC(convertFtoC(coolingSetpoint)) : roundC(coolingSetpoint)
+	} else {
+		maxHeatingSetpoint = maxHeatingSetpoint < 40 ? roundC(convertCtoF(maxHeatingSetpoint)) : maxHeatingSetpoint
+		maxCoolingSetpoint = maxCoolingSetpoint < 40 ? roundC(convertCtoF(maxCoolingSetpoint)) : maxCoolingSetpoint
+		minHeatingSetpoint = minHeatingSetpoint < 40 ? roundC(convertCtoF(minHeatingSetpoint)) : minHeatingSetpoint
+		minCoolingSetpoint = minCoolingSetpoint < 40 ? roundC(convertCtoF(minCoolingSetpoint)) : minCoolingSetpoint
+		heatingSetpoint = heatingSetpoint < 40 ? roundC(convertCtoF(heatingSetpoint)) : heatingSetpoint
+		coolingSetpoint = coolingSetpoint < 40 ? roundC(convertCtoF(coolingSetpoint)) : coolingSetpoint
 	}
 
+	log.debug "Current Mode = ${mode}"
+	log.debug "Heating Setpoint = ${heatingSetpoint}"
+	log.debug "Cooling Setpoint = ${coolingSetpoint}"
 
 	sendEvent("name":"maxHeatingSetpoint", "value":maxHeatingSetpoint, "unit":location.temperatureScale)
 	sendEvent("name":"maxCoolingSetpoint", "value":maxCoolingSetpoint, "unit":location.temperatureScale)
 	sendEvent("name":"minHeatingSetpoint", "value":minHeatingSetpoint, "unit":location.temperatureScale)
 	sendEvent("name":"minCoolingSetpoint", "value":minCoolingSetpoint, "unit":location.temperatureScale)
-
+	sendEvent("name":"heatingSetpoint", "value":heatingSetpoint, "unit":location.temperatureScale)
+	sendEvent("name":"coolingSetpoint", "value":coolingSetpoint, "unit":location.temperatureScale)
 
 	if (mode == "heat") {
-
 		sendEvent("name":"thermostatSetpoint", "value":heatingSetpoint, "unit":location.temperatureScale)
-
 	}
 	else if (mode == "cool") {
-
 		sendEvent("name":"thermostatSetpoint", "value":coolingSetpoint, "unit":location.temperatureScale)
-
 	} else if (mode == "auto") {
-
 		sendEvent("name":"thermostatSetpoint", "value":"Auto")
-
 	} else if (mode == "off") {
-
 		sendEvent("name":"thermostatSetpoint", "value":"Off")
-
 	} else if (mode == "auxHeatOnly") {
-
 		sendEvent("name":"thermostatSetpoint", "value":heatingSetpoint, "unit":location.temperatureScale)
-
 	}
-
 }
 
 void raiseSetpoint() {
@@ -585,21 +573,31 @@ void raiseSetpoint() {
 	def maxHeatingSetpoint = device.currentValue("maxHeatingSetpoint")
 	def maxCoolingSetpoint = device.currentValue("maxCoolingSetpoint")
 
-
 	if (mode == "off" || mode == "auto") {
 		log.warn "this mode: $mode does not allow raiseSetpoint"
 	} else {
+
 		def heatingSetpoint = device.currentValue("heatingSetpoint")
 		def coolingSetpoint = device.currentValue("coolingSetpoint")
 		def thermostatSetpoint = device.currentValue("thermostatSetpoint")
+
+		if (location.temperatureScale == "C") {
+			maxHeatingSetpoint = maxHeatingSetpoint > 40 ? convertFtoC(maxHeatingSetpoint) : maxHeatingSetpoint
+			maxCoolingSetpoint = maxCoolingSetpoint > 40 ? convertFtoC(maxCoolingSetpoint) : maxCoolingSetpoint
+			heatingSetpoint = heatingSetpoint > 40 ? convertFtoC(heatingSetpoint) : heatingSetpoint
+			coolingSetpoint = coolingSetpoint > 40 ? convertFtoC(coolingSetpoint) : coolingSetpoint
+			thermostatSetpoint = thermostatSetpoint > 40 ? convertFtoC(thermostatSetpoint) : thermostatSetpoint
+		} else {
+			maxHeatingSetpoint = maxHeatingSetpoint < 40 ? convertCtoF(maxHeatingSetpoint) : maxHeatingSetpoint
+			maxCoolingSetpoint = maxCoolingSetpoint < 40 ? convertCtoF(maxCoolingSetpoint) : maxCoolingSetpoint
+			heatingSetpoint = heatingSetpoint < 40 ? convertCtoF(heatingSetpoint) : heatingSetpoint
+			coolingSetpoint = coolingSetpoint < 40 ? convertCtoF(coolingSetpoint) : coolingSetpoint
+			thermostatSetpoint = thermostatSetpoint < 40 ? convertCtoF(thermostatSetpoint) : thermostatSetpoint
+		}
+
 		log.debug "raiseSetpoint() mode = ${mode}, heatingSetpoint: ${heatingSetpoint}, coolingSetpoint:${coolingSetpoint}, thermostatSetpoint:${thermostatSetpoint}"
 
-		if (device.latestState('thermostatSetpoint')) {
-			targetvalue = device.latestState('thermostatSetpoint').value
-			targetvalue = location.temperatureScale == "F"? targetvalue.toInteger() : targetvalue.toDouble()
-		} else {
-			targetvalue = 0
-		}
+		targetvalue = thermostatSetpoint ? thermostatSetpoint : 0
 		targetvalue = location.temperatureScale == "F"? targetvalue + 1 : targetvalue + 0.5
 
 		if ((mode == "heat" || mode == "auxHeatOnly") && targetvalue > maxHeatingSetpoint) {
@@ -622,20 +620,29 @@ void lowerSetpoint() {
 	def minHeatingSetpoint = device.currentValue("minHeatingSetpoint")
 	def minCoolingSetpoint = device.currentValue("minCoolingSetpoint")
 
-
 	if (mode == "off" || mode == "auto") {
 		log.warn "this mode: $mode does not allow lowerSetpoint"
 	} else {
 		def heatingSetpoint = device.currentValue("heatingSetpoint")
 		def coolingSetpoint = device.currentValue("coolingSetpoint")
 		def thermostatSetpoint = device.currentValue("thermostatSetpoint")
-		log.debug "lowerSetpoint() mode = ${mode}, heatingSetpoint: ${heatingSetpoint}, coolingSetpoint:${coolingSetpoint}, thermostatSetpoint:${thermostatSetpoint}"
-		if (device.latestState('thermostatSetpoint')) {
-			targetvalue = device.latestState('thermostatSetpoint').value
-			targetvalue = location.temperatureScale == "F"? targetvalue.toInteger() : targetvalue.toDouble()
+
+		if (location.temperatureScale == "C") {
+			minHeatingSetpoint = minHeatingSetpoint > 40 ? convertFtoC(minHeatingSetpoint) : minHeatingSetpoint
+			minCoolingSetpoint = minCoolingSetpoint > 40 ? convertFtoC(minCoolingSetpoint) : minCoolingSetpoint
+			heatingSetpoint = heatingSetpoint > 40 ? convertFtoC(heatingSetpoint) : heatingSetpoint
+			coolingSetpoint = coolingSetpoint > 40 ? convertFtoC(coolingSetpoint) : coolingSetpoint
+			thermostatSetpoint = thermostatSetpoint > 40 ? convertFtoC(thermostatSetpoint) : thermostatSetpoint
 		} else {
-			targetvalue = 0
+			minHeatingSetpoint = minHeatingSetpoint < 40 ? convertCtoF(minHeatingSetpoint) : minHeatingSetpoint
+			minCoolingSetpoint = minCoolingSetpoint < 40 ? convertCtoF(minCoolingSetpoint) : minCoolingSetpoint
+			heatingSetpoint = heatingSetpoint < 40 ? convertCtoF(heatingSetpoint) : heatingSetpoint
+			coolingSetpoint = coolingSetpoint < 40 ? convertCtoF(coolingSetpoint) : coolingSetpoint
+			thermostatSetpoint = thermostatSetpoint < 40 ? convertCtoF(thermostatSetpoint) : thermostatSetpoint
 		}
+		log.debug "lowerSetpoint() mode = ${mode}, heatingSetpoint: ${heatingSetpoint}, coolingSetpoint:${coolingSetpoint}, thermostatSetpoint:${thermostatSetpoint}"
+
+		targetvalue = thermostatSetpoint ? thermostatSetpoint : 0
 		targetvalue = location.temperatureScale == "F"? targetvalue - 1 : targetvalue - 0.5
 
 		if ((mode == "heat" || mode == "auxHeatOnly") && targetvalue < minHeatingSetpoint) {
@@ -653,66 +660,83 @@ void lowerSetpoint() {
 
 //called by raiseSetpoint() and lowerSetpoint()
 void alterSetpoint(temp) {
-
 	def mode = device.currentValue("thermostatMode")
-	def heatingSetpoint = device.currentValue("heatingSetpoint")
-	def coolingSetpoint = device.currentValue("coolingSetpoint")
-	def deviceId = device.deviceNetworkId.split(/\./).last()
 
-	def targetHeatingSetpoint
-	def targetCoolingSetpoint
-
-	//step1: check thermostatMode, enforce limits before sending request to cloud
-	if (mode == "heat" || mode == "auxHeatOnly"){
-		if (temp.value > coolingSetpoint){
-			targetHeatingSetpoint = temp.value
-			targetCoolingSetpoint = temp.value
-		} else {
-			targetHeatingSetpoint = temp.value
-			targetCoolingSetpoint = coolingSetpoint
-		}
-	} else if (mode == "cool") {
-		//enforce limits before sending request to cloud
-		if (temp.value < heatingSetpoint){
-			targetHeatingSetpoint = temp.value
-			targetCoolingSetpoint = temp.value
-		} else {
-			targetHeatingSetpoint = heatingSetpoint
-			targetCoolingSetpoint = temp.value
-		}
-	}
-
-	log.debug "alterSetpoint >> in mode ${mode} trying to change heatingSetpoint to $targetHeatingSetpoint " +
-			"coolingSetpoint to $targetCoolingSetpoint with holdType : ${holdType}"
-
-	def sendHoldType = holdType ? (holdType=="Temporary")? "nextTransition" : (holdType=="Permanent")? "indefinite" : "indefinite" : "indefinite"
-
-	def coolingValue = location.temperatureScale == "C"? convertCtoF(targetCoolingSetpoint) : targetCoolingSetpoint
-	def heatingValue = location.temperatureScale == "C"? convertCtoF(targetHeatingSetpoint) : targetHeatingSetpoint
-
-	if (parent.setHold(heatingValue, coolingValue, deviceId, sendHoldType)) {
-		sendEvent("name": "thermostatSetpoint", "value": temp.value, displayed: false)
-		sendEvent("name": "heatingSetpoint", "value": targetHeatingSetpoint, "unit": location.temperatureScale)
-		sendEvent("name": "coolingSetpoint", "value": targetCoolingSetpoint, "unit": location.temperatureScale)
-		log.debug "alterSetpoint in mode $mode succeed change setpoint to= ${temp.value}"
+	if (mode == "off" || mode == "auto") {
+		log.warn "this mode: $mode does not allow alterSetpoint"
 	} else {
-		log.error "Error alterSetpoint()"
-		if (mode == "heat" || mode == "auxHeatOnly"){
-			sendEvent("name": "thermostatSetpoint", "value": heatingSetpoint.toString(), displayed: false)
-		} else if (mode == "cool") {
-			sendEvent("name": "thermostatSetpoint", "value": coolingSetpoint.toString(), displayed: false)
+		def heatingSetpoint = device.currentValue("heatingSetpoint")
+		def coolingSetpoint = device.currentValue("coolingSetpoint")
+		def deviceId = device.deviceNetworkId.split(/\./).last()
+
+		def targetHeatingSetpoint
+		def targetCoolingSetpoint
+
+		def temperatureScaleHasChanged = false
+
+		if (location.temperatureScale == "C") {
+			if ( heatingSetpoint > 40.0 || coolingSetpoint > 40.0 ) {
+				temperatureScaleHasChanged = true
+			}
+		} else {
+			if ( heatingSetpoint < 40.0 || coolingSetpoint < 40.0 ) {
+				temperatureScaleHasChanged = true
+			}
 		}
+
+		//step1: check thermostatMode, enforce limits before sending request to cloud
+		if (mode == "heat" || mode == "auxHeatOnly"){
+			if (temp.value > coolingSetpoint){
+				targetHeatingSetpoint = temp.value
+				targetCoolingSetpoint = temp.value
+			} else {
+				targetHeatingSetpoint = temp.value
+				targetCoolingSetpoint = coolingSetpoint
+			}
+		} else if (mode == "cool") {
+			//enforce limits before sending request to cloud
+			if (temp.value < heatingSetpoint){
+				targetHeatingSetpoint = temp.value
+				targetCoolingSetpoint = temp.value
+			} else {
+				targetHeatingSetpoint = heatingSetpoint
+				targetCoolingSetpoint = temp.value
+			}
+		}
+
+		log.debug "alterSetpoint >> in mode ${mode} trying to change heatingSetpoint to $targetHeatingSetpoint " +
+				"coolingSetpoint to $targetCoolingSetpoint with holdType : ${holdType}"
+
+		def sendHoldType = holdType ? (holdType=="Temporary")? "nextTransition" : (holdType=="Permanent")? "indefinite" : "indefinite" : "indefinite"
+
+		def coolingValue = location.temperatureScale == "C"? convertCtoF(targetCoolingSetpoint) : targetCoolingSetpoint
+		def heatingValue = location.temperatureScale == "C"? convertCtoF(targetHeatingSetpoint) : targetHeatingSetpoint
+
+		if (parent.setHold(heatingValue, coolingValue, deviceId, sendHoldType)) {
+			sendEvent("name": "thermostatSetpoint", "value": temp.value, displayed: false)
+			sendEvent("name": "heatingSetpoint", "value": targetHeatingSetpoint, "unit": location.temperatureScale)
+			sendEvent("name": "coolingSetpoint", "value": targetCoolingSetpoint, "unit": location.temperatureScale)
+			log.debug "alterSetpoint in mode $mode succeed change setpoint to= ${temp.value}"
+		} else {
+			log.error "Error alterSetpoint()"
+			if (mode == "heat" || mode == "auxHeatOnly"){
+				sendEvent("name": "thermostatSetpoint", "value": heatingSetpoint.toString(), displayed: false)
+			} else if (mode == "cool") {
+				sendEvent("name": "thermostatSetpoint", "value": coolingSetpoint.toString(), displayed: false)
+			}
+		}
+
+		if ( temperatureScaleHasChanged )
+			generateSetpointEvent()
+		generateStatusEvent()
 	}
-	generateStatusEvent()
 }
 
 def generateStatusEvent() {
-
 	def mode = device.currentValue("thermostatMode")
 	def heatingSetpoint = device.currentValue("heatingSetpoint")
 	def coolingSetpoint = device.currentValue("coolingSetpoint")
 	def temperature = device.currentValue("temperature")
-
 	def statusText
 
 	log.debug "Generate Status Event for Mode = ${mode}"
@@ -722,36 +746,25 @@ def generateStatusEvent() {
 	log.debug "HVAC Mode = ${mode}"
 
 	if (mode == "heat") {
-
 		if (temperature >= heatingSetpoint)
 			statusText = "Right Now: Idle"
 		else
 			statusText = "Heating to ${heatingSetpoint} ${location.temperatureScale}"
-
 	} else if (mode == "cool") {
-
 		if (temperature <= coolingSetpoint)
 			statusText = "Right Now: Idle"
 		else
 			statusText = "Cooling to ${coolingSetpoint} ${location.temperatureScale}"
-
 	} else if (mode == "auto") {
-
 		statusText = "Right Now: Auto"
-
 	} else if (mode == "off") {
-
 		statusText = "Right Now: Off"
-
 	} else if (mode == "auxHeatOnly") {
-
 		statusText = "Emergency Heat"
-
 	} else {
-
 		statusText = "?"
-
 	}
+
 	log.debug "Generate Status Event = ${statusText}"
 	sendEvent("name":"thermostatStatus", "value":statusText, "description":statusText, displayed: true)
 }
@@ -765,7 +778,7 @@ def roundC (tempC) {
 }
 
 def convertFtoC (tempF) {
-	return String.format("%.1f", (Math.round(((tempF - 32)*(5/9)) * 2))/2)
+	return ((Math.round(((tempF - 32)*(5/9)) * 2))/2).toDouble()
 }
 
 def convertCtoF (tempC) {

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

@@ -57,7 +57,7 @@ metadata {
 }
 
 void installed() {
-	sendEvent(name: "checkInterval", value: 60 * 12, data: [protocol: "lan"], displayed: false)
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}")
 }
 
 // parse events into attributes
@@ -172,6 +172,3 @@ def verifyPercent(percent) {
     }
 }
 
-def ping() {
-    log.debug "${parent.ping(this)}"
-}

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

@@ -7,9 +7,11 @@
 metadata {
 	// Automatically generated. Make future change here.
 	definition (name: "Hue Bridge", namespace: "smartthings", author: "SmartThings") {
+		capability "Health Check"
+
 		attribute "networkAddress", "string"
-        // Used to indicate if bridge is reachable or not, i.e. is the bridge connected to the network
-        // Possible values "Online" or "Offline"
+		// Used to indicate if bridge is reachable or not, i.e. is the bridge connected to the network
+		// Possible values "Online" or "Offline"
 		attribute "status", "string"
 		// Id is the number on the back of the hub, Hue uses last six digits of Mac address
 		// This is also used in the Hue application as ID
@@ -42,6 +44,10 @@ metadata {
 	}
 }
 
+void installed() {
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}")
+}
+
 // parse events into attributes
 def parse(description) {
 	log.debug "Parsing '${description}'"
@@ -70,13 +76,8 @@ def parse(description) {
 					def bulbs = new groovy.json.JsonSlurper().parseText(msg.body)
 					if (bulbs.state) {
 						log.info "Bridge response: $msg.body"
-					} else {
-						// Sending Bulbs List to parent"
-						if (parent.isInBulbDiscovery())
-							log.info parent.bulbListHandler(device.hub.id, msg.body)
 					}
-				}
-				else if (contentType?.contains("xml")) {
+				} else if (contentType?.contains("xml")) {
 					log.debug "HUE BRIDGE ALREADY PRESENT"
 					parent.hubVerification(device.hub.id, msg.body)
 				}
@@ -85,3 +86,4 @@ def parse(description) {
 	}
 	results
 }
+

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

@@ -66,7 +66,7 @@ metadata {
 }
 
 void installed() {
-	sendEvent(name: "checkInterval", value: 60 * 12, data: [protocol: "lan"], displayed: false)
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}")
 }
 
 // parse events into attributes
@@ -174,7 +174,7 @@ void setColorTemperature(value) {
 
 void refresh() {
     log.debug "Executing 'refresh'"
-    parent.manualRefresh()
+    parent?.manualRefresh()
 }
 
 def verifyPercent(percent) {
@@ -188,6 +188,3 @@ def verifyPercent(percent) {
     }
 }
 
-def ping() {
-    log.trace "${parent.ping(this)}"
-}

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

@@ -50,7 +50,7 @@ metadata {
 }
 
 void installed() {
-	sendEvent(name: "checkInterval", value: 60 * 12, data: [protocol: "lan"], displayed: false)
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}")
 }
 
 // parse events into attributes
@@ -93,6 +93,3 @@ void refresh() {
 	parent.manualRefresh()
 }
 
-def ping() {
-    log.debug "${parent.ping(this)}"
-}

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

@@ -55,7 +55,7 @@ metadata {
 }
 
 void installed() {
-	sendEvent(name: "checkInterval", value: 60 * 12, data: [protocol: "lan"], displayed: false)
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}")
 }
 
 // parse events into attributes
@@ -107,6 +107,3 @@ void refresh() {
     parent.manualRefresh()
 }
 
-def ping() {
-    log.debug "${parent.ping(this)}"
-}

devicetypes/smartthings/lifx-color-bulb.src/lifx-color-bulb.groovy

@@ -11,9 +11,9 @@ metadata {
 		capability "Color Temperature"
 		capability "Switch"
 		capability "Switch Level" // brightness
-		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
+		capability "Health Check"
 	}
 
 	simulator {
@@ -23,7 +23,6 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "unreachable", label: "?", action:"refresh.refresh", icon:"http://hosted.lifx.co/smartthings/v1/196xUnreachable.png", backgroundColor:"#666666"
 				attributeState "on", label:'${name}', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#79b821", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"http://hosted.lifx.co/smartthings/v1/196xOff.png", backgroundColor:"#ffffff", nextState:"turningOn"
 				attributeState "turningOn", label:'Turning on', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#79b821", nextState:"turningOff"
@@ -64,12 +63,8 @@ metadata {
 	}
 }
 
-// parse events into attributes
-def parse(String description) {
-	if (description == 'updated') {
-		return // don't poll when config settings is being updated as it may time out
-	}
-	poll()
+void installed() {
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"cloud\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device?.hub?.hardwareID}\"}")
 }
 
 // handle commands
@@ -141,7 +136,6 @@ def setLevel(percentage) {
 		percentage = 1 // clamp to 1%
 	}
 	if (percentage == 0) {
-		sendEvent(name: "level", value: 0) // Otherwise the level value tile does not update
 		return off() // if the brightness is set to 0, just turn it off
 	}
 	parent.logErrors(logObject:log) {
@@ -193,14 +187,17 @@ def off() {
 	return []
 }
 
-def poll() {
-	log.debug "Executing 'poll' for ${device} ${this} ${device.deviceNetworkId}"
+def refresh() {
+	log.debug "Executing 'refresh'"
+	
 	def resp = parent.apiGET("/lights/${selector()}")
 	if (resp.status == 404) {
-		sendEvent(name: "switch", value: "unreachable")
+		state.online = false
+		sendEvent(name: "DeviceWatch-DeviceStatusUpdate", value: "offline", displayed: false)
+ 		log.warn "$device is Offline"
 		return []
 	} else if (resp.status != 200) {
-		log.error("Unexpected result in poll(): [${resp.status}] ${resp.data}")
+		log.error("Unexpected result in refresh(): [${resp.status}] ${resp.data}")
 		return []
 	}
 	def data = resp.data[0]
@@ -209,19 +206,20 @@ def poll() {
 	sendEvent(name: "label", value: data.label)
 	sendEvent(name: "level", value: Math.round((data.brightness ?: 1) * 100))
 	sendEvent(name: "switch.setLevel", value: Math.round((data.brightness ?: 1) * 100))
-	sendEvent(name: "switch", value: data.connected ? data.power : "unreachable")
+	sendEvent(name: "switch", value: data.power)
 	sendEvent(name: "color", value: colorUtil.hslToHex((data.color.hue / 3.6) as int, (data.color.saturation * 100) as int))
 	sendEvent(name: "hue", value: data.color.hue / 3.6)
 	sendEvent(name: "saturation", value: data.color.saturation * 100)
 	sendEvent(name: "colorTemperature", value: data.color.kelvin)
-	sendEvent(name: "model", value: "${data.product.company} ${data.product.name}")
+	sendEvent(name: "model", value: data.product.name)
 
-	return []
+	if (data.connected) {
+		sendEvent(name: "DeviceWatch-DeviceStatus", value: "online", displayed: false)
+		log.debug "$device is Online"
+	} else {
+		sendEvent(name: "DeviceWatch-DeviceStatus", value: "offline", displayed: false)
+		log.warn "$device is Offline"
 }
-
-def refresh() {
-	log.debug "Executing 'refresh'"
-	poll()
 }
 
 def selector() {

devicetypes/smartthings/lifx-white-bulb.src/lifx-white-bulb.groovy

@@ -10,9 +10,9 @@ metadata {
 		capability "Color Temperature"
 		capability "Switch"
 		capability "Switch Level" // brightness
-		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
+		capability "Health Check"
 	}
 
 	simulator {
@@ -22,13 +22,12 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "unreachable", label: "?", action:"refresh.refresh", icon:"http://hosted.lifx.co/smartthings/v1/196xUnreachable.png", backgroundColor:"#666666"
 				attributeState "on", label:'${name}', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#79b821", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"http://hosted.lifx.co/smartthings/v1/196xOff.png", backgroundColor:"#ffffff", nextState:"turningOn"
 				attributeState "turningOn", label:'Turning on', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#79b821", nextState:"turningOff"
 				attributeState "turningOff", label:'Turning off', action:"switch.on", icon:"http://hosted.lifx.co/smartthings/v1/196xOff.png", backgroundColor:"#ffffff", nextState:"turningOn"
-
 			}
+
 			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
 				attributeState "level", action:"switch level.setLevel"
 			}
@@ -53,15 +52,10 @@ metadata {
 		main "switch"
 		details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
 	}
-
 }
 
-// parse events into attributes
-def parse(String description) {
-	if (description == 'updated') {
-		return // don't poll when config settings is being updated as it may time out
-	}
-	poll()
+void installed() {
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"cloud\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device?.hub?.hardwareID}\"}")
 }
 
 // handle commands
@@ -71,7 +65,6 @@ def setLevel(percentage) {
 		percentage = 1 // clamp to 1%
 	}
 	if (percentage == 0) {
-		sendEvent(name: "level", value: 0) // Otherwise the level value tile does not update
 		return off() // if the brightness is set to 0, just turn it off
 	}
 	parent.logErrors(logObject:log) {
@@ -123,14 +116,17 @@ def off() {
 	return []
 }
 
-def poll() {
-	log.debug "Executing 'poll' for ${device} ${this} ${device.deviceNetworkId}"
+def refresh() {
+	log.debug "Executing 'refresh'"
+	
 	def resp = parent.apiGET("/lights/${selector()}")
 	if (resp.status == 404) {
-		sendEvent(name: "switch", value: "unreachable")
+		state.online = false
+		sendEvent(name: "DeviceWatch-DeviceStatusUpdate", value: "offline", displayed: false)
+		log.warn "$device is Offline"
 		return []
 	} else if (resp.status != 200) {
-		log.error("Unexpected result in poll(): [${resp.status}] ${resp.data}")
+		log.error("Unexpected result in refresh(): [${resp.status}] ${resp.data}")
 		return []
 	}
 	def data = resp.data[0]
@@ -138,16 +134,17 @@ def poll() {
 	sendEvent(name: "label", value: data.label)
 	sendEvent(name: "level", value: Math.round((data.brightness ?: 1) * 100))
 	sendEvent(name: "switch.setLevel", value: Math.round((data.brightness ?: 1) * 100))
-	sendEvent(name: "switch", value: data.connected ? data.power : "unreachable")
+	sendEvent(name: "switch", value: data.power)
 	sendEvent(name: "colorTemperature", value: data.color.kelvin)
 	sendEvent(name: "model", value: data.product.name)
 
-	return []
-}
-
-def refresh() {
-	log.debug "Executing 'refresh'"
-	poll()
+	if (data.connected) {
+		sendEvent(name: "DeviceWatch-DeviceStatus", value: "online", displayed: false)
+		log.debug "$device is Online"
+	} else {
+		sendEvent(name: "DeviceWatch-DeviceStatus", value: "offline", displayed: false)
+		log.warn "$device is Offline"
+	}
 }
 
 def selector() {

devicetypes/smartthings/nyce-open-closed-sensor.src/.st-ignore

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

devicetypes/smartthings/nyce-open-closed-sensor.src/README.md

@@ -0,0 +1,37 @@
+# Nyce Door/Window Sensor (Open/Close Sensor)
+
+
+
+Works with:
+
+* [NYCE Door/Window Sensor NCZ-3011](https://support.smartthings.com/hc/en-us/articles/204576764-NYCE-Door-Window-Sensor)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Battery](#battery-specification)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Contact Sensor** - can detect contact (with possible values - open/closed)
+* **Battery** - defines device uses a battery
+* **Refresh** - _refresh()_ command for status updates
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+A Category C2 Nyce Door/Window sensor that has 12min check-in interval
+
+## Battery Specification
+
+One 3V CR2032 battery required.
+
+## 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 sensor from SmartThings can be found in the following link:
+* [Nyce Door/Window Sensor](https://support.smartthings.com/hc/en-us/articles/204576764-NYCE-Door-Window-Sensor)

devicetypes/smartthings/nyce-open-closed-sensor.src/nyce-open-closed-sensor.groovy

@@ -19,25 +19,26 @@ import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
 
 metadata {
 	definition (name: "NYCE Open/Closed Sensor", namespace: "smartthings", author: "NYCE") {
-    	capability "Battery"
+		capability "Battery"
 		capability "Configuration"
-        capability "Contact Sensor"
+		capability "Contact Sensor"
 		capability "Refresh"
-        
-        command "enrollResponse"
- 
- 
- 		fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3010", deviceJoinName: "NYCE Door Hinge Sensor"
+		capability "Health Check"
+
+		command "enrollResponse"
+
+
+		fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3010", deviceJoinName: "NYCE Door Hinge Sensor"
 		fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3011", deviceJoinName: "NYCE Door/Window Sensor"
-        fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3011", deviceJoinName: "NYCE Door/Window Sensor"
-        fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3014", deviceJoinName: "NYCE Tilt Sensor"
-        fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3014", deviceJoinName: "NYCE Tilt Sensor"
+		fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3011", deviceJoinName: "NYCE Door/Window Sensor"
+		fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3014", deviceJoinName: "NYCE Tilt Sensor"
+		fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3014", deviceJoinName: "NYCE Tilt Sensor"
 	}
- 
+
 	simulator {
- 
+
 	}
- 
+
 	tiles {
 		standardTile("contact", "device.contact", width: 2, height: 2) {
 			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
@@ -273,23 +274,28 @@ private List parseIasMessage(String description) {
 	return resultListMap
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	return zigbee.readAttribute(0x001, 0x0020) // Read the Battery Level
+}
+
 def configure() {
+	// Device-Watch allows 2 check-in misses from device
+	sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+
 	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 
-	def configCmds = [
-			//battery reporting and heartbeat
-			"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 1 {${device.zigbeeId}} {}", "delay 200",
-			"zcl global send-me-a-report 1 0x20 0x20 600 3600 {01}", "delay 200",
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500",
-
-
+	def enrollCmds = [
 			// Writes CIE attribute on end device to direct reports to the hub's EUID
 			"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
 			"send 0x${device.deviceNetworkId} 1 1", "delay 500",
 	]
 
 	log.debug "configure: Write IAS CIE"
-	return configCmds
+	// battery minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
+	return enrollCmds + zigbee.batteryConfig(30, 300) + refresh() // send refresh cmds as part of config
 }
 
 def enrollResponse() {
@@ -334,7 +340,8 @@ Integer convertHexToInt(hex) {
 
 def refresh() {
 	log.debug "Refreshing Battery"
-	[
+	def refreshCmds = [
 			"st rattr 0x${device.deviceNetworkId} ${endpointId} 1 0x20", "delay 200"
 	]
+	return refreshCmds + enrollResponse()
 }

devicetypes/smartthings/osram-lightify-gardenspot-mini-rgb.src/osram-lightify-gardenspot-mini-rgb.groovy

@@ -21,9 +21,6 @@ metadata {
         attribute "colorName", "string"
 
         command "setAdjustedColor"
-
-        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Gardenspot RGB"
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY Gardenspot RGB"
     }
 
     // simulator metadata

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

@@ -133,7 +133,7 @@ def refresh() {
 }
 
 def configure() {
-	onOffConfig() + levelConfig() + powerConfig() + refresh()
+	refresh() + onOffConfig() + levelConfig() + powerConfig()
 }
 
 

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

@@ -47,9 +47,21 @@ def parse(String description) {
 
 // Commands to device
 def on() {
-	'zcl on-off on'
+	[
+			'zcl on-off on',
+			'delay 200',
+			"send 0x${zigbee.deviceNetworkId} 0x01 0x${zigbee.endpointId}",
+			'delay 500'
+
+	]
+
 }
 
 def off() {
-	'zcl on-off off'
+	[
+			'zcl on-off off',
+			'delay 200',
+			"send 0x${zigbee.deviceNetworkId} 0x01 0x${zigbee.endpointId}",
+			'delay 500'
+	]
 }

devicetypes/smartthings/smartpower-outlet.src/README.md

@@ -23,10 +23,10 @@ Works with:
 
 ## Device Health
 
-A Category C1 smart power outlet with maxReportTime of 10 min.
-Check-in interval is double the value of maxReportTime for Zigbee device. 
+A Category C1 smart power outlet with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime. 
 This gives the device twice the amount of time to respond before it is marked as offline.
-Check-in interval = 2*10 = 20 min
+Check-in interval = 12 mins
 
 ## Troubleshooting
 

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

@@ -16,7 +16,7 @@
 
 metadata {
 	// Automatically generated. Make future change here.
-	definition (name: "SmartPower Outlet", namespace: "smartthings", author: "SmartThings", category: "C1") {
+	definition (name: "SmartPower Outlet", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
 		capability "Switch"
 		capability "Power Meter"
@@ -74,6 +74,15 @@ metadata {
 	}
 }
 
+def installed() {
+	log.debug "${device} installed"
+}
+
+def updated() {
+	log.debug "${device} updated"
+	configureHealthCheck()
+}
+
 // Parse incoming device messages to generate events
 def parse(String description) {
 	log.debug "description is $description"
@@ -104,8 +113,21 @@ def parse(String description) {
 		}
 	}
 	else {
-		log.warn "DID NOT PARSE MESSAGE for description : $description"
-		log.debug zigbee.parseDescriptionAsMap(description)
+		def cluster = zigbee.parse(description)
+
+		if (cluster && cluster.clusterId == 0x0006 && cluster.command == 0x07){
+			if (cluster.data[0] == 0x00) {
+				log.debug "ON/OFF REPORTING CONFIG RESPONSE: " + cluster
+				sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+			}
+			else {
+				log.warn "ON/OFF REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+			}
+		}
+		else {
+			log.warn "DID NOT PARSE MESSAGE for description : $description"
+			log.debug "${cluster}"
+		}
 	}
 }
 
@@ -127,11 +149,17 @@ def refresh() {
 	zigbee.onOffRefresh() + zigbee.electricMeasurementPowerRefresh()
 }
 
+def configureHealthCheck() {
+	// Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+	// enrolls with default periodic reporting until newer 5 min interval is confirmed
+	sendEvent(name: "checkInterval", value: 3 * 10 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+}
+
 def configure() {
-	// Device-Watch allows 2 check-in misses from device
-	sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee"])
+
+
 	// OnOff minReportTime 0 seconds, maxReportTime 5 min. Reporting interval if no activity
-	zigbee.onOffConfig(0, 300) + powerConfig() + refresh()
+	refresh() + zigbee.onOffConfig(0, 300) + powerConfig()
 }
 
 //power config for devices with min reporting interval as 1 seconds and reporting interval if no activity as 10min (600s)

devicetypes/smartthings/smartsense-moisture-sensor.src/README.md

@@ -23,10 +23,10 @@ Works with:
 
 ## Device Health
 
-A Category C2 moisture sensor with maxReportTime of 1 hr.
-Check-in interval is double the value of maxReportTime for Zigbee device. 
+A Category C2 moisture sensor with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime. 
 This gives the device twice the amount of time to respond before it is marked as offline.
-Check-in interval = 2*60 = 120 min
+Check-in interval = 12 mins
 
 ## Battery Specification
 

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

@@ -17,7 +17,7 @@ import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
 
 
 metadata {
-	definition (name: "SmartSense Moisture Sensor",namespace: "smartthings", author: "SmartThings", category: "C2") {
+	definition (name: "SmartSense Moisture Sensor",namespace: "smartthings", author: "SmartThings") {
 		capability "Configuration"
 		capability "Battery"
 		capability "Refresh"
@@ -84,6 +84,15 @@ metadata {
 	}
 }
 
+def installed() {
+	log.debug "${device} installed"
+}
+
+def updated() {
+	log.debug "${device} updated"
+	configureHealthCheck()
+}
+
 def parse(String description) {
 	log.debug "description: $description"
 
@@ -118,14 +127,28 @@ private Map parseCatchAllMessage(String description) {
 	if (shouldProcessMessage(cluster)) {
 		switch(cluster.clusterId) {
 			case 0x0001:
-				resultMap = getBatteryResult(cluster.data.last())
+				// 0x07 - configure reporting
+				if (cluster.command != 0x07) {
+					resultMap = getBatteryResult(cluster.data.last())
+				}
 				break
 
             case 0x0402:
-                // temp is last 2 data values. reverse to swap endian
-                String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
-                def value = getTemperature(temp)
-                resultMap = getTemperatureResult(value)
+				if (cluster.command == 0x07) {
+					if (cluster.data[0] == 0x00){
+						log.debug "TEMP REPORTING CONFIG RESPONSE" + cluster
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+					}
+					else {
+						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+					}
+				}
+				else {
+					// temp is last 2 data values. reverse to swap endian
+					String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+					def value = getTemperature(temp)
+					resultMap = getTemperatureResult(value)
+				}
                 break
         }
     }
@@ -135,10 +158,8 @@ private Map parseCatchAllMessage(String description) {
 
 private boolean shouldProcessMessage(cluster) {
 	// 0x0B is default response indicating message got through
-	// 0x07 is bind message
 	boolean ignoredMessage = cluster.profileId != 0x0104 ||
 		cluster.command == 0x0B ||
-		cluster.command == 0x07 ||
 		(cluster.data.size() > 0 && cluster.data.first() == 0x3e)
 	return !ignoredMessage
 }
@@ -180,9 +201,9 @@ private Map parseIasMessage(String description) {
 def getTemperature(value) {
 	def celsius = Integer.parseInt(value, 16).shortValue() / 100
 	if(getTemperatureScale() == "C"){
-		return celsius
+		return Math.round(celsius)
 	} else {
-		return celsiusToFahrenheit(celsius) as Integer
+		return Math.round(celsiusToFahrenheit(celsius))
 	}
 }
 
@@ -291,20 +312,16 @@ def refresh() {
 	return refreshCmds + enrollResponse()
 }
 
+def configureHealthCheck() {
+	// Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+	// enrolls with default periodic reporting until newer 5 min interval is confirmed
+	sendEvent(name: "checkInterval", value: 3 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+}
+
 def configure() {
-	// Device-Watch allows 2 check-in misses from device
-	sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee"])
-
-	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
-	log.debug "Configuring Reporting, IAS CIE, and Bindings."
-	def enrollCmds = [
-		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
-		"send 0x${device.deviceNetworkId} 1 1", "delay 500",
-	]
-
 	// temperature minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
 	// battery minReport 30 seconds, maxReportTime 6 hrs by default
-	return enrollCmds + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) + refresh() // send refresh cmds as part of config
+	return refresh() + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) // send refresh cmds as part of config
 }
 
 def enrollResponse() {

devicetypes/smartthings/smartsense-motion-sensor.src/README.md

@@ -22,10 +22,10 @@ Works with:
 
 ## Device Health
 
-A Category C2 motion sensor with maxReportTime of 1 hr.
-Check-in interval is double the value of maxReportTime for Zigbee device. 
+A Category C2 motion sensor with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime.
 This gives the device twice the amount of time to respond before it is marked as offline.
-Check-in interval = 2*60 = 120 min
+Check-in interval = 12 mins
 
 ## Battery Specification
 

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

@@ -17,7 +17,7 @@ import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
 
 
 metadata {
-	definition (name: "SmartSense Motion Sensor", namespace: "smartthings", author: "SmartThings", category: "C2") {
+	definition (name: "SmartSense Motion Sensor", namespace: "smartthings", author: "SmartThings") {
 		capability "Motion Sensor"
 		capability "Configuration"
 		capability "Battery"
@@ -88,6 +88,15 @@ metadata {
 	}
 }
 
+def installed() {
+	log.debug "${device} installed"
+}
+
+def updated() {
+	log.debug "${device} updated"
+	configureHealthCheck()
+}
+
 def parse(String description) {
 	log.debug "description: $description"
 
@@ -122,19 +131,37 @@ private Map parseCatchAllMessage(String description) {
 	if (shouldProcessMessage(cluster)) {
 		switch(cluster.clusterId) {
 			case 0x0001:
-				resultMap = getBatteryResult(cluster.data.last())
+				// 0x07 - configure reporting
+				if (cluster.command != 0x07) {
+					resultMap = getBatteryResult(cluster.data.last())
+				}
 				break
 
 			case 0x0402:
-				// temp is last 2 data values. reverse to swap endian
-				String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
-				def value = getTemperature(temp)
-				resultMap = getTemperatureResult(value)
+				if (cluster.command == 0x07) {
+					if (cluster.data[0] == 0x00) {
+						log.debug "TEMP REPORTING CONFIG RESPONSE" + cluster
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+					}
+					else {
+						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+					}
+
+				}
+				else {
+					// temp is last 2 data values. reverse to swap endian
+					String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+					def value = getTemperature(temp)
+					resultMap = getTemperatureResult(value)
+				}
 				break
 
 			case 0x0406:
-				log.debug 'motion'
-				resultMap.name = 'motion'
+				// 0x07 - configure reporting
+				if (cluster.command != 0x07) {
+					log.debug 'motion'
+					resultMap.name = 'motion'
+				}
 				break
 		}
 	}
@@ -144,10 +171,8 @@ private Map parseCatchAllMessage(String description) {
 
 private boolean shouldProcessMessage(cluster) {
 	// 0x0B is default response indicating message got through
-	// 0x07 is bind message
 	boolean ignoredMessage = cluster.profileId != 0x0104 ||
 		cluster.command == 0x0B ||
-		cluster.command == 0x07 ||
 		(cluster.data.size() > 0 && cluster.data.first() == 0x3e)
 	return !ignoredMessage
 }
@@ -194,9 +219,9 @@ private Map parseIasMessage(String description) {
 def getTemperature(value) {
 	def celsius = Integer.parseInt(value, 16).shortValue() / 100
 	if(getTemperatureScale() == "C"){
-		return celsius
+		return Math.round(celsius)
 	} else {
-		return celsiusToFahrenheit(celsius) as Integer
+		return Math.round(celsiusToFahrenheit(celsius))
 	}
 }
 
@@ -302,20 +327,16 @@ def refresh() {
 	return refreshCmds + enrollResponse()
 }
 
+def configureHealthCheck() {
+	// Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+	// enrolls with default periodic reporting until newer 5 min interval is confirmed
+	sendEvent(name: "checkInterval", value: 3 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+}
+
 def configure() {
-	// Device-Watch allows 2 check-in misses from device
-	sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee"])
-
-	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
-	log.debug "Configuring Reporting, IAS CIE, and Bindings."
-
-	def enrollCmds = [
-		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
-		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
-	]
 	// temperature minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
 	// battery minReport 30 seconds, maxReportTime 6 hrs by default
-	return enrollCmds + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) + refresh() // send refresh cmds as part of config
+	return refresh() + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) // send refresh cmds as part of config
 }
 
 def enrollResponse() {

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

@@ -255,13 +255,9 @@ def refresh() {
 }
 
 def configure() {
-	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting, IAS CIE, and Bindings."
 
 	def configCmds = [
-		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
-		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
-
 		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 1 {${device.zigbeeId}} {}", "delay 200",
 		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}",		//checkin time 6 hrs
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
@@ -270,7 +266,7 @@ def configure() {
 		"zcl global send-me-a-report 0x402 0 0x29 30 3600 {6400}",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
 	]
-    return configCmds + refresh() // send refresh cmds as part of config
+    return refresh() + configCmds  // send refresh cmds as part of config
 }
 
 def enrollResponse() {

devicetypes/smartthings/smartsense-multi-sensor.src/README.md

@@ -26,10 +26,10 @@ Works with:
 
 ## Device Health
 
-A Category C2 multi sensor with maxReportTime of 1 hr.
-Check-in interval is double the value of maxReportTime for Zigbee device. 
+A Category C2 multi sensor with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime. 
 This gives the device twice the amount of time to respond before it is marked as offline.
-Check-in interval = 2*60 = 120 min
+Check-in interval = 12 mins
 
 ## Battery Specification
 

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

@@ -16,7 +16,7 @@
 import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
 
 metadata {
-	definition (name: "SmartSense Multi Sensor", namespace: "smartthings", author: "SmartThings", category: "C2") {
+	definition (name: "SmartSense Multi Sensor", namespace: "smartthings", author: "SmartThings") {
 
 		capability "Three Axis"
 		capability "Battery"
@@ -115,6 +115,34 @@ metadata {
 	}
  }
 
+def installed() {
+	log.debug "${device} installed"
+}
+
+def updated() {
+	log.debug "updated called"
+	log.info "garage value : $garageSensor"
+	if (garageSensor == "Yes") {
+		def descriptionText = "Updating device to garage sensor"
+		if (device.latestValue("status") == "open") {
+			sendEvent(name: 'status', value: 'garage-open', descriptionText: descriptionText, translatable: true)
+		}
+		else if (device.latestValue("status") == "closed") {
+			sendEvent(name: 'status', value: 'garage-closed', descriptionText: descriptionText, translatable: true)
+		}
+	}
+	else {
+		def descriptionText = "Updating device to open/close sensor"
+		if (device.latestValue("status") == "garage-open") {
+			sendEvent(name: 'status', value: 'open', descriptionText: descriptionText, translatable: true)
+		}
+		else if (device.latestValue("status") == "garage-closed") {
+			sendEvent(name: 'status', value: 'closed', descriptionText: descriptionText, translatable: true)
+		}
+	}
+	configureHealthCheck()
+}
+
 def parse(String description) {
 	Map map = [:]
 	if (description?.startsWith('catchall:')) {
@@ -147,20 +175,33 @@ private Map parseCatchAllMessage(String description) {
 	if (shouldProcessMessage(cluster)) {
 		switch(cluster.clusterId) {
 			case 0x0001:
-			resultMap = getBatteryResult(cluster.data.last())
+				// 0x07 - configure reporting
+				if (cluster.command != 0x07) {
+					resultMap = getBatteryResult(cluster.data.last())
+				}
 			break
 
 			case 0xFC02:
-			log.debug 'ACCELERATION'
+				log.debug 'ACCELERATION'
 			break
 
 			case 0x0402:
-			log.debug 'TEMP'
-				// temp is last 2 data values. reverse to swap endian
-				String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
-				def value = getTemperature(temp)
-				resultMap = getTemperatureResult(value)
-				break
+				if (cluster.command == 0x07) {
+					if(cluster.data[0] == 0x00) {
+						log.debug "TEMP REPORTING CONFIG RESPONSE" + cluster
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+					}
+					else {
+						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+					}
+				}
+				else {
+					// temp is last 2 data values. reverse to swap endian
+					String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+					def value = getTemperature(temp)
+					resultMap = getTemperatureResult(value)
+				}
+			break
 		}
 	}
 
@@ -169,10 +210,8 @@ private Map parseCatchAllMessage(String description) {
 
 private boolean shouldProcessMessage(cluster) {
 	// 0x0B is default response indicating message got through
-	// 0x07 is bind message
 	boolean ignoredMessage = cluster.profileId != 0x0104 ||
 	cluster.command == 0x0B ||
-	cluster.command == 0x07 ||
 	(cluster.data.size() > 0 && cluster.data.first() == 0x3e)
 	return !ignoredMessage
 }
@@ -235,35 +274,12 @@ private Map parseIasMessage(String description) {
 	return resultMap
 }
 
-def updated() {
-	log.debug "updated called"
-	log.info "garage value : $garageSensor"
-	if (garageSensor == "Yes") {
-		def descriptionText = "Updating device to garage sensor"
-		if (device.latestValue("status") == "open") {
-			sendEvent(name: 'status', value: 'garage-open', descriptionText: descriptionText, translatable: true)
-		}
-		else if (device.latestValue("status") == "closed") {
-			sendEvent(name: 'status', value: 'garage-closed', descriptionText: descriptionText, translatable: true)
-		}
-	}
-	else {
-		def descriptionText = "Updating device to open/close sensor"
-		if (device.latestValue("status") == "garage-open") {
-			sendEvent(name: 'status', value: 'open', descriptionText: descriptionText, translatable: true)
-		}
-		else if (device.latestValue("status") == "garage-closed") {
-			sendEvent(name: 'status', value: 'closed', descriptionText: descriptionText, translatable: true)
-		}
-	}
-}
-
 def getTemperature(value) {
 	def celsius = Integer.parseInt(value, 16).shortValue() / 100
 	if(getTemperatureScale() == "C"){
-		return celsius
+		return Math.round(celsius)
 		} else {
-			return celsiusToFahrenheit(celsius) as Integer
+			return Math.round(celsiusToFahrenheit(celsius))
 		}
 	}
 
@@ -400,23 +416,25 @@ def refresh() {
 	return refreshCmds + enrollResponse()
 }
 
-def configure() {
-	// Device-Watch allows 2 check-in misses from device
-	sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee"])
+def configureHealthCheck(){
+	// Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+	// enrolls with default periodic reporting until newer 5 min interval is confirmed
+	sendEvent(name: "checkInterval", value: 3 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+}
 
+def configure() {
 	log.debug "Configuring Reporting"
 
 	// temperature minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
 	// battery minReport 30 seconds, maxReportTime 6 hrs by default
-	def configCmds = enrollResponse() +
-			zigbee.batteryConfig() +
+	def configCmds = zigbee.batteryConfig() +
 			zigbee.temperatureConfig(30, 300) +
 			zigbee.configureReporting(0xFC02, 0x0010, 0x18, 10, 3600, 0x01, [mfgCode: manufacturerCode]) +
 			zigbee.configureReporting(0xFC02, 0x0012, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode]) +
 			zigbee.configureReporting(0xFC02, 0x0013, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode]) +
 			zigbee.configureReporting(0xFC02, 0x0014, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode])
 
-	return configCmds + refresh()
+	return refresh() + configCmds
 }
 
 private getEndpointId() {

devicetypes/smartthings/smartsense-open-closed-accelerometer-sensor.src/smartsense-open-closed-accelerometer-sensor.groovy

@@ -277,12 +277,8 @@ def getTemperature(value) {
 def configure() {
 	sendEvent(name: "checkInterval", value: 7200, displayed: false)
 
-	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting, IAS CIE, and Bindings."
 	def configCmds = [
-		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
-		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
-
 		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 1 {${device.zigbeeId}} {}", "delay 200",
 		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}",		//checkin time 6 hrs
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
@@ -295,7 +291,7 @@ def configure() {
 		"zcl global send-me-a-report 0xFC02 2 0x18 30 3600 {01}",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
 	]
-	return configCmds + refresh() // send refresh cmds as part of config
+	return refresh() + configCmds // send refresh cmds as part of config
 }
 
 def enrollResponse() {

devicetypes/smartthings/smartsense-open-closed-sensor.src/README.md

@@ -24,10 +24,10 @@ Works with:
 
 ## Device Health
 
-A Category C2 open/closed sensor with maxReportTime of 1 hr.
-Check-in interval is double the value of maxReportTime for Zigbee device. 
+A Category C2 open/closed sensor with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime. 
 This gives the device twice the amount of time to respond before it is marked as offline.
-Check-in interval = 2*60 = 120 min
+Check-in interval = 12 mins
 
 ## Battery Specification
 

devicetypes/smartthings/smartsense-open-closed-sensor.src/smartsense-open-closed-sensor.groovy

@@ -16,7 +16,7 @@
 import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
 
 metadata {
-	definition (name: "SmartSense Open/Closed Sensor", namespace: "smartthings", author: "SmartThings", category: "C2") {
+	definition (name: "SmartSense Open/Closed Sensor", namespace: "smartthings", author: "SmartThings") {
 		capability "Battery"
 		capability "Configuration"
 		capability "Contact Sensor"
@@ -75,6 +75,15 @@ metadata {
 	}
 }
 
+def installed() {
+	log.debug "${device} installed"
+}
+
+def updated() {
+	log.debug "${device} updated"
+	configureHealthCheck()
+}
+
 def parse(String description) {
 	log.debug "description: $description"
 
@@ -109,15 +118,28 @@ private Map parseCatchAllMessage(String description) {
     if (shouldProcessMessage(cluster)) {
         switch(cluster.clusterId) {
             case 0x0001:
-            	resultMap = getBatteryResult(cluster.data.last())
+				// 0x07 - configure reporting
+				if (cluster.command != 0x07) {
+					resultMap = getBatteryResult(cluster.data.last())
+				}
                 break
 
             case 0x0402:
-                log.debug 'TEMP'
-                // temp is last 2 data values. reverse to swap endian
-                String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
-                def value = getTemperature(temp)
-                resultMap = getTemperatureResult(value)
+				if (cluster.command == 0x07){
+					if (cluster.data[0] == 0x00) {
+						log.debug "TEMP REPORTING CONFIG RESPONSE" + cluster
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+					}
+					else {
+						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+					}
+				}
+				else {
+					// temp is last 2 data values. reverse to swap endian
+					String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+					def value = getTemperature(temp)
+					resultMap = getTemperatureResult(value)
+				}
                 break
         }
     }
@@ -127,10 +149,8 @@ private Map parseCatchAllMessage(String description) {
 
 private boolean shouldProcessMessage(cluster) {
     // 0x0B is default response indicating message got through
-    // 0x07 is bind message
     boolean ignoredMessage = cluster.profileId != 0x0104 ||
         cluster.command == 0x0B ||
-        cluster.command == 0x07 ||
         (cluster.data.size() > 0 && cluster.data.first() == 0x3e)
     return !ignoredMessage
 }
@@ -254,20 +274,17 @@ def refresh() {
 	return refreshCmds + enrollResponse()
 }
 
+def configureHealthCheck() {
+	// Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+	// enrolls with default periodic reporting until newer 5 min interval is confirmed
+	sendEvent(name: "checkInterval", value: 3 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+}
 def configure() {
-	// Device-Watch allows 2 check-in misses from device
-	sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee"])
-
-	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting, IAS CIE, and Bindings."
-	def enrollCmds = [
-		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
-		"send 0x${device.deviceNetworkId} 1 1", "delay 500",
-	]
 
 	// temperature minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
 	// battery minReport 30 seconds, maxReportTime 6 hrs by default
-    return enrollCmds + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) + refresh() // send refresh cmds as part of config
+    return refresh() + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) // send refresh cmds as part of config
 }
 
 def enrollResponse() {

devicetypes/smartthings/smartsense-temp-humidity-sensor.src/README.md

@@ -24,10 +24,10 @@ Works with:
 
 ## Device Health
 
-A Category C2 SmartSense Temp/Humidity Sensor with maxReportTime of 1 hr.
-Check-in interval is double the value of maxReportTime for Zigbee device. 
+A Category C2 SmartSense Temp/Humidity Sensor with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime. 
 This gives the device twice the amount of time to respond before it is marked as offline.
-Check-in interval = 2*60 = 120 min
+Check-in interval = 12 mins
 
 ## Battery Specification
 

devicetypes/smartthings/smartsense-temp-humidity-sensor.src/smartsense-temp-humidity-sensor.groovy

@@ -14,7 +14,7 @@
  *
  */
 metadata {
-	definition (name: "SmartSense Temp/Humidity Sensor",namespace: "smartthings", author: "SmartThings", category: "C2") {
+	definition (name: "SmartSense Temp/Humidity Sensor",namespace: "smartthings", author: "SmartThings") {
 		capability "Configuration"
 		capability "Battery"
 		capability "Refresh"
@@ -69,6 +69,15 @@ metadata {
 	}
 }
 
+def installed() {
+	log.debug "${device} installed"
+}
+
+def updated() {
+	log.debug "${device} updated"
+	configureHealthCheck()
+}
+
 def parse(String description) {
 	log.debug "description: $description"
 
@@ -93,20 +102,37 @@ private Map parseCatchAllMessage(String description) {
     if (shouldProcessMessage(cluster)) {
         switch(cluster.clusterId) {
             case 0x0001:
-            	resultMap = getBatteryResult(cluster.data.last())
+				// 0x07 - configure reporting
+				if (cluster.command != 0x07) {
+					resultMap = getBatteryResult(cluster.data.last())
+				}
                 break
 
             case 0x0402:
-                // temp is last 2 data values. reverse to swap endian
-                String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
-                def value = getTemperature(temp)
-                resultMap = getTemperatureResult(value)
-                break
+				if (cluster.command == 0x07) {
+					if (cluster.data[0] == 0x00){
+						log.debug "TEMP REPORTING CONFIG RESPONSE" + cluster
+						sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+					}
+					else {
+						log.warn "TEMP REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+					}
+				}
+				else {
+					// temp is last 2 data values. reverse to swap endian
+					String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+					def value = getTemperature(temp)
+					resultMap = getTemperatureResult(value)
+				}
+				break
 
 			case 0xFC45:
-                String pctStr = cluster.data[-1, -2].collect { Integer.toHexString(it) }.join('')
-                String display = Math.round(Integer.valueOf(pctStr, 16) / 100)
-                resultMap = getHumidityResult(display)
+				// 0x07 - configure reporting
+				if (cluster.command != 0x07) {
+					String pctStr = cluster.data[-1, -2].collect { Integer.toHexString(it) }.join('')
+					String display = Math.round(Integer.valueOf(pctStr, 16) / 100)
+					resultMap = getHumidityResult(display)
+				}
                 break
         }
     }
@@ -116,10 +142,8 @@ private Map parseCatchAllMessage(String description) {
 
 private boolean shouldProcessMessage(cluster) {
     // 0x0B is default response indicating message got through
-    // 0x07 is bind message
     boolean ignoredMessage = cluster.profileId != 0x0104 ||
         cluster.command == 0x0B ||
-        cluster.command == 0x07 ||
         (cluster.data.size() > 0 && cluster.data.first() == 0x3e)
     return !ignoredMessage
 }
@@ -235,11 +259,7 @@ private Map getTemperatureResult(value) {
 
 private Map getHumidityResult(value) {
 	log.debug 'Humidity'
-	return [
-		name: 'humidity',
-		value: value,
-		unit: '%'
-	]
+	return value ? [name: 'humidity', value: value, unit: '%'] : [:]
 }
 
 /**
@@ -252,21 +272,18 @@ def ping() {
 def refresh()
 {
 	log.debug "refresh temperature, humidity, and battery"
-	[
+	return zigbee.readAttribute(0xFC45, 0x0000, ["mfgCode": 0xC2DF]) +   // Original firmware
+			zigbee.readAttribute(0x0402, 0x0000) +
+			zigbee.readAttribute(0x0001, 0x0020)
+}
 
-		"zcl mfg-code 0xC2DF", "delay 1000",
-		"zcl global read 0xFC45 0", "delay 1000",
-		"send 0x${device.deviceNetworkId} 1 1", "delay 1000",
-        "st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
-        "st rattr 0x${device.deviceNetworkId} 1 1 0x20"
-
-	]
+def configureHealthCheck() {
+	// Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+	// enrolls with default periodic reporting until newer 5 min interval is confirmed
+	sendEvent(name: "checkInterval", value: 3 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 }
 
 def configure() {
-	// Device-Watch allows 2 check-in misses from device
-	sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee"])
-
 	log.debug "Configuring Reporting and Bindings."
 	def humidityConfigCmds = [
 		"zdo bind 0x${device.deviceNetworkId} 1 1 0xFC45 {${device.zigbeeId}} {}", "delay 500",
@@ -276,7 +293,7 @@ def configure() {
 
 	// temperature minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
 	// battery minReport 30 seconds, maxReportTime 6 hrs by default
-	return humidityConfigCmds + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) +  refresh() // send refresh cmds as part of config
+	return refresh() + humidityConfigCmds + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300)  // send refresh cmds as part of config
 }
 
 private hex(value) {

devicetypes/smartthings/tyco-door-window-sensor.src/.st-ignore

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

devicetypes/smartthings/tyco-door-window-sensor.src/README.md

@@ -0,0 +1,42 @@
+# Tyco Door Window Sensor
+
+
+
+Works with: 
+
+* [Tyco Door Window Sensor](https://support.smartthings.com/hc/en-us/articles/204834100-Tyco-Door-Window-Sensor)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Battery](#battery-specification)
+
+## Capabilities
+
+* **Battery** - defines device uses a battery
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Contact Sensor** - can detect contact (open/close)
+* **Refresh** - _refresh()_ command for status updates
+* **Temperature Measurement** - can measure the device temperature
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+Contact sensor with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime for Zigbee device. 
+This gives the device twice the amount of time to respond before it is marked as offline.
+Check-in interval = 12 min
+
+## Battery Specification
+
+3V CR2032 battery is required.
+
+## Troubleshooting
+
+If the device doesn't pair when trying from the SmartThings mobile app, it is possible that either the sensor needs to be reseted or the sensor is out of range.
+Reset needs to be done by inserting the battery in the sensor and then quickly pressing the adjacent black button 10 times. Pairing should be tried again now.
+It may happen that sensor is out of range, then pairing needs to be tried again by placing the sensor closer to the hub.
+Instructions related to pairing, resetting and removing the different motion sensors from SmartThings can be found in the following links
+for the different models:
+* [Tyco Door Window Sensor (MCT-340)](https://support.smartthings.com/hc/en-us/articles/204834100-Tyco-Door-Window-Sensor)

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

@@ -22,6 +22,7 @@ metadata {
 		capability "Contact Sensor"
 		capability "Refresh"
 		capability "Temperature Measurement"
+		capability "Health Check"
 
 		command "enrollResponse"
 
@@ -229,44 +230,42 @@ private Map getContactResult(value) {
 	]
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	return zigbee.readAttribute(0x0402, 0x0000) // Read the Temperature Cluster
+}
+
 def refresh()
 {
 	log.debug "Refreshing Temperature and Battery"
-	[
+	def refreshCmds = [
 
         "st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
 		"st rattr 0x${device.deviceNetworkId} 1 1 0x20"
 
 	]
+
+	return refreshCmds + enrollResponse()
 }
 
 def configure() {
+	// Device-Watch allows 2 check-in misses from device
+	sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 
 	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 		log.debug "Configuring Reporting, IAS CIE, and Bindings."
-	def configCmds = [
+	def enrollCmds = [
     	"delay 1000",
 
 		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
 
-        "zcl global send-me-a-report 1 0x20 0x20 600 3600 {01}", "delay 200",
-        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-
-        "zcl global send-me-a-report 0x402 0 0x29 300 3600 {6400}", "delay 200",
-        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-
-
         //"raw 0x500 {01 23 00 00 00}", "delay 200",
         //"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-
-
-		"zdo bind 0x${device.deviceNetworkId} 1 1 0x402 {${device.zigbeeId}} {}", "delay 500",
-		"zdo bind 0x${device.deviceNetworkId} 1 1 1 {${device.zigbeeId}} {}",
-
-        "delay 500"
 	]
-    return configCmds + enrollResponse() + refresh() // send refresh cmds as part of config
+    return enrollCmds + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) + refresh() // send refresh cmds as part of config
 }
 
 def enrollResponse() {

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

@@ -89,14 +89,8 @@ def parse(String description) {
 }
 
 private Map parseIasButtonMessage(String description) {
-    int zoneInt = Integer.parseInt((description - "zone status 0x"), 16)
-    if (zoneInt & 0x02) {
-        resultMap = getButtonResult('press')
-    } else {
-        resultMap = getButtonResult('release')
-    }
-
-    return resultMap
+    def zs = zigbee.parseZoneStatus(description)
+    return zs.isAlarm2Set() ? getButtonResult("press") : getButtonResult("release")
 }
 
 private Map getBatteryResult(rawValue) {

devicetypes/smartthings/zigbee-dimmer-power.src/.st-ignore

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

devicetypes/smartthings/zigbee-dimmer-power.src/README.md

@@ -0,0 +1,41 @@
+# GE Plug-In/In-Wall Smart Dimmer (ZigBee)
+
+
+
+Works with:
+
+* [GE In-Wall Smart Dimmer (ZigBee)](https://shop.smartthings.com/#!/products/ge-in-wall-smart-dimmer-switch)
+* [GE Plug-In Smart Dimmer (ZigBee)](https://www.smartthings.com/works-with-smartthings/ge/ge-plug-in-smart-dimmer-zigbee)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#Troubleshooting)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Refresh** - _refresh()_ command for status updates
+* **Power Meter** - ability to check the power meter(energy consumption) of device
+* **Sensor** - represents the device sensor capability
+* **Switch** - can detect state (possible values: on/off)
+* **Switch Level** - represents current light level, usually 0-100 in percent
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+A Zigbee dimmer with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime.
+This gives the device twice the amount of time to respond before it is marked as offline.
+Enrolls with default periodic reporting until newer 5 min interval is confirmed
+It then enrolls the device with updated checkInterval i.e. 12 mins
+
+## 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:
+* [GE Z-Wave In-Wall Smart Dimmer (GE 45857) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/204988564-GE-In-Wall-Smart-Dimmer-45857GE-ZigBee-)
+* [GE Zigbee Plug-in Smart Dimmer (GE 45852) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/205239280-GE-Plug-In-Smart-Dimmer-45852GE-ZigBee-)

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

@@ -21,6 +21,7 @@ metadata {
         capability "Sensor"
         capability "Switch"
         capability "Switch Level"
+        capability "Health Check"
 
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B04"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0702"
@@ -70,8 +71,20 @@ def parse(String description) {
         }
     }
     else {
-        log.warn "DID NOT PARSE MESSAGE for description : $description"
-        log.debug zigbee.parseDescriptionAsMap(description)
+        def cluster = zigbee.parse(description)
+        if (cluster && cluster.clusterId == 0x0006 && cluster.command == 0x07) {
+            if (cluster.data[0] == 0x00){
+                log.debug "ON/OFF REPORTING CONFIG RESPONSE: " + cluster
+                sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+            }
+            else {
+                log.warn "ON/OFF REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+            }
+        }
+        else {
+            log.warn "DID NOT PARSE MESSAGE for description : $description"
+            log.debug zigbee.parseDescriptionAsMap(description)
+        }
     }
 }
 
@@ -87,11 +100,22 @@ def setLevel(value) {
     zigbee.setLevel(value)
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+    return zigbee.onOffRefresh()
+}
+
 def refresh() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.simpleMeteringPowerRefresh() + zigbee.electricMeasurementPowerRefresh() + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.simpleMeteringPowerConfig() + zigbee.electricMeasurementPowerConfig()
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.simpleMeteringPowerRefresh() + zigbee.electricMeasurementPowerRefresh() + zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.simpleMeteringPowerConfig() + zigbee.electricMeasurementPowerConfig()
 }
 
 def configure() {
     log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.simpleMeteringPowerConfig() + zigbee.electricMeasurementPowerConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.simpleMeteringPowerRefresh() + zigbee.electricMeasurementPowerRefresh()
+
+    // Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+    // enrolls with default periodic reporting until newer 5 min interval is confirmed
+    sendEvent(name: "checkInterval", value: 3 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+    refresh()
 }

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

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

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

@@ -0,0 +1,36 @@
+# OSRAM Lightify LED On/Off/Dim
+
+
+
+Works with: 
+
+* [OSRAM Lightify LED On/Off/Dim](https://shop.smartthings.com/#!/products/osram-led-smart-bulb-on-off-dim)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Battery](#battery-specification)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Refresh** - _refresh()_ command for status updates
+* **Switch** - can detect state (possible values: on/off)
+* **Switch Level** - represents current light level, usually 0-100 in percent
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+A Category C1 Zigbee dimmer with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime. 
+This gives the device twice the amount of time to respond before it is marked as offline.
+Check-in interval = 12 mins
+
+## 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.
+Other troubleshooting tips are listed as follows:
+* [Troubleshooting:](https://support.smartthings.com/hc/en-us/articles/207191763-OSRAM-LIGHTIFY-LED-Smart-Connected-Light-A19-On-Off-Dim)

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

@@ -48,6 +48,15 @@ metadata {
     }
 }
 
+def installed() {
+    log.debug "${device} installed"
+}
+
+def updated() {
+    log.debug "${device} updated"
+    configureHealthCheck()
+}
+
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
@@ -60,8 +69,21 @@ def parse(String description) {
         }
     }
     else {
-        log.warn "DID NOT PARSE MESSAGE for description : $description"
-        log.debug zigbee.parseDescriptionAsMap(description)
+        def cluster = zigbee.parse(description)
+
+        if (cluster && cluster.clusterId == 0x0006 && cluster.command == 0x07) {
+            if (cluster.data[0] == 0x00) {
+                log.debug "ON/OFF REPORTING CONFIG RESPONSE: " + cluster
+                sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+            }
+            else {
+                log.warn "ON/OFF REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+            }
+        }
+        else {
+            log.warn "DID NOT PARSE MESSAGE for description : $description"
+            log.debug "${cluster}"
+        }
     }
 }
 
@@ -84,13 +106,16 @@ def ping() {
 }
 
 def refresh() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig() + zigbee.levelConfig()
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig(0, 300) + zigbee.levelConfig()
+}
+
+def configureHealthCheck() {
+    // Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+    // enrolls with default periodic reporting until newer 5 min interval is confirmed
+    sendEvent(name: "checkInterval", value: 3 * 10 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 }
 
 def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    // Device-Watch allows 2 check-in misses from device
-    sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee"])
     // OnOff minReportTime 0 seconds, maxReportTime 5 min. Reporting interval if no activity
-    zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig(0, 300) + zigbee.levelConfig()
 }

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

@@ -31,7 +31,8 @@
         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"
+	}
 
     tiles(scale: 2) {
 		multiAttributeTile(name:"toggle", type:"generic", width:6, height:4){
@@ -89,7 +90,7 @@ def configure() {
         zigbee.configureReporting(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING,
                                   TYPE_U8, 600, 21600, 0x01)
     log.info "configure() --- cmds: $cmds"
-    return cmds + refresh() // send refresh cmds as part of config
+    return refresh() + cmds // send refresh cmds as part of config
 }
 
 def refresh() {

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

@@ -0,0 +1,154 @@
+/**
+ *  Copyright 2016 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.
+ *
+ *  Author: SmartThings
+ *  Date: 2016-01-19
+ *
+ *  This DTH should serve as the generic DTH to handle RGB ZigBee HA devices (For color bulbs with no color temperature)
+ */
+
+metadata {
+	definition (name: "ZigBee RGB Bulb", namespace: "smartthings", author: "SmartThings") {
+
+		capability "Actuator"
+		capability "Color Control"
+		capability "Configuration"
+		capability "Polling"
+		capability "Refresh"
+		capability "Switch"
+		capability "Switch Level"
+		capability "Health Check"
+
+		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Gardenspot RGB", deviceJoinName: "OSRAM LIGHTIFY Gardenspot mini RGB"
+		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY Gardenspot RGB", deviceJoinName: "OSRAM LIGHTIFY Gardenspot mini RGB"
+	}
+
+	// UI tile definitions
+	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 "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 "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+				attributeState "level", action:"switch level.setLevel"
+			}
+			tileAttribute ("device.color", key: "COLOR_CONTROL") {
+				attributeState "color", action:"color control.setColor"
+			}
+		}
+		standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+
+		main(["switch"])
+		details(["switch", "refresh"])
+	}
+}
+
+//Globals
+private getATTRIBUTE_HUE() { 0x0000 }
+private getATTRIBUTE_SATURATION() { 0x0001 }
+private getHUE_COMMAND() { 0x00 }
+private getSATURATION_COMMAND() { 0x03 }
+private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
+
+// Parse incoming device messages to generate events
+def parse(String description) {
+	log.debug "description is $description"
+
+	def event = zigbee.getEvent(description)
+	if (event) {
+		log.debug event
+		if (event.name=="level" && event.value==0) {}
+		else {
+			sendEvent(event)
+		}
+	}
+	else {
+		def zigbeeMap = zigbee.parseDescriptionAsMap(description)
+		def cluster = zigbee.parse(description)
+
+		if (zigbeeMap?.clusterInt == COLOR_CONTROL_CLUSTER) {
+			if(zigbeeMap.attrInt == ATTRIBUTE_HUE){  //Hue Attribute
+				def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
+				sendEvent(name: "hue", value: hueValue, descriptionText: "Color has changed")
+			}
+			else if(zigbeeMap.attrInt == ATTRIBUTE_SATURATION){ //Saturation Attribute
+				def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
+				sendEvent(name: "saturation", value: saturationValue, descriptionText: "Color has changed", displayed: false)
+			}
+		}
+		else if (cluster && cluster.clusterId == 0x0006 && cluster.command == 0x07) {
+			if (cluster.data[0] == 0x00){
+				log.debug "ON/OFF REPORTING CONFIG RESPONSE: $cluster"
+				sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+			}
+			else {
+				log.warn "ON/OFF REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+			}
+		}
+		else {
+			log.info "DID NOT PARSE MESSAGE for description : $description"
+			log.debug zigbeeMap
+		}
+	}
+}
+
+def on() {
+	zigbee.on()
+}
+
+def off() {
+	zigbee.off()
+}
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	return zigbee.onOffRefresh()
+}
+
+def refresh() {
+	zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION) + zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, 0x20, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, 0x20, 1, 3600, 0x01)
+}
+
+def configure() {
+	log.debug "Configuring Reporting and Bindings."
+	// Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+	// enrolls with default periodic reporting until newer 5 min interval is confirmed
+	sendEvent(name: "checkInterval", value: 3 * 10 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+
+	// OnOff minReportTime 0 seconds, maxReportTime 5 min. Reporting interval if no activity
+	zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, 0x20, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, 0x20, 1, 3600, 0x01) + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+}
+
+def setLevel(value) {
+	zigbee.setLevel(value)
+}
+
+def setColor(value){
+	log.trace "setColor($value)"
+	zigbee.on() + setHue(value.hue) + "delay 500" + setSaturation(value.saturation)
+}
+
+def setHue(value) {
+	def scaledHueValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+	zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, scaledHueValue, "00", "0500")       //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second) (0500 in U16 reads 5)
+}
+
+def setSaturation(value) {
+	def scaledSatValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+	zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500") + "delay 1000" + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+}

devicetypes/smartthings/zigbee-rgbw-bulb.src/.st-ignore

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

devicetypes/smartthings/zigbee-rgbw-bulb.src/README.md

@@ -0,0 +1,42 @@
+# OSRAM LIGHTIFY LED RGBW Bulb
+
+
+
+Works with: 
+
+* [OSRAM LIGHTIFY LED RGBW Bulb](https://support.smartthings.com/hc/en-us/articles/207728173-OSRAM-LIGHTIFY-LED-Smart-Connected-Light-A19-RGBW)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Battery](#battery-specification)
+
+## Capabilities
+
+* **Actuator** - It represents that a device has commands.
+* **Color Control** - It represents that the color attributes of a device can be controlled (hue, saturation, color value).
+* **Color Temperature** - It represents color temperature capability measured in degree Kelvin.
+* **Polling** - It represents that a device can be polled.
+* **Switch** - can detect state (possible values: on/off)
+* **Switch Level** - can detect current light level (0-100 in percent)
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Refresh** - _refresh()_ command for status updates
+* **Health Check** - indicates ability to get device health notifications
+
+
+## Device Health
+
+A Category C6 OSRAM LIGHTIFY LED RGBW Bulb with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime. 
+This gives the device twice the amount of time to respond before it is marked as offline.
+Check-in interval = 12 mins
+
+
+## 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:
+* [Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/207728173-OSRAM-LIGHTIFY-LED-Smart-Connected-Light-A19-RGBW)

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

@@ -70,6 +70,16 @@ metadata {
     }
 }
 
+
+def installed() {
+    log.debug "${device} installed"
+}
+
+def updated() {
+    log.debug "${device} updated"
+    configureHealthCheck()
+}
+
 //Globals
 private getATTRIBUTE_HUE() { 0x0000 }
 private getATTRIBUTE_SATURATION() { 0x0001 }
@@ -95,7 +105,7 @@ def parse(String description) {
     }
     else {
         def zigbeeMap = zigbee.parseDescriptionAsMap(description)
-        log.trace "zigbeeMap : $zigbeeMap"
+        def cluster = zigbee.parse(description)
 
         if (zigbeeMap?.clusterInt == COLOR_CONTROL_CLUSTER) {
             if(zigbeeMap.attrInt == ATTRIBUTE_HUE){  //Hue Attribute
@@ -107,8 +117,18 @@ def parse(String description) {
                 sendEvent(name: "saturation", value: saturationValue, descriptionText: "Color has changed", displayed: false)
             }
         }
+        else if (cluster && cluster.clusterId == 0x0006 && cluster.command == 0x07) {
+            if (cluster.data[0] == 0x00){
+                log.debug "ON/OFF REPORTING CONFIG RESPONSE: " + cluster
+                sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+            }
+            else {
+                log.warn "ON/OFF REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+            }
+        }
         else {
             log.info "DID NOT PARSE MESSAGE for description : $description"
+            log.debug zigbeeMap
         }
     }
 }
@@ -128,15 +148,18 @@ def ping() {
 }
 
 def refresh() {
-    zigbee.onOffRefresh() + zigbee.readAttribute(0x0008, 0x00) + zigbee.readAttribute(0x0300, 0x00) + zigbee.readAttribute(0x0300, ATTRIBUTE_COLOR_TEMPERATURE) + zigbee.readAttribute(0x0300, ATTRIBUTE_HUE) + zigbee.readAttribute(0x0300, ATTRIBUTE_SATURATION) + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, 0x20, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, 0x20, 1, 3600, 0x01)
+    // OnOff minReportTime 0 seconds, maxReportTime 5 min. Reporting interval if no activity
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION) + zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, 0x20, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, 0x20, 1, 3600, 0x01)
+}
+
+def configureHealthCheck() {
+    // Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+    // enrolls with default periodic reporting until newer 5 min interval is confirmed
+    sendEvent(name: "checkInterval", value: 3 * 10 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 }
 
 def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    // Device-Watch allows 2 check-in misses from device
-    sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee"])
-    // OnOff minReportTime 0 seconds, maxReportTime 5 min. Reporting interval if no activity
-    zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, 0x20, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, 0x20, 1, 3600, 0x01) + zigbee.readAttribute(0x0006, 0x00) + zigbee.readAttribute(0x0008, 0x00) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, 0x00) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+    refresh()
 }
 
 def setColorTemperature(value) {
@@ -177,5 +200,5 @@ def setHue(value) {
 
 def setSaturation(value) {
     def scaledSatValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-    zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500")      //payload-> sat value, transition time
+    zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500") + "delay 1000" + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
 }

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

@@ -82,5 +82,5 @@ def refresh() {
 
 def configure() {
     log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() + zigbee.simpleMeteringPowerConfig() + zigbee.electricMeasurementPowerConfig() + zigbee.onOffRefresh() + zigbee.simpleMeteringPowerRefresh() + zigbee.electricMeasurementPowerRefresh()
+    refresh()
 }

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

@@ -21,6 +21,7 @@ metadata {
 
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006"
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0006", outClusters: "0003, 0006, 0019, 0406", manufacturer: "Leviton", model: "ZSS-10", deviceJoinName: "Leviton Switch"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0006", outClusters: "000A", manufacturer: "HAI", model: "65A21-1", deviceJoinName: "Leviton Wireless Load Control Module-30amp"
     }
 
     // simulator metadata
@@ -78,5 +79,5 @@ def refresh() {
 
 def configure() {
     log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() + zigbee.onOffRefresh()
+    zigbee.onOffRefresh() + zigbee.onOffConfig()
 }

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

@@ -134,10 +134,5 @@ def refresh() {
 
 def configure() {
     log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() +
-    zigbee.configureReporting(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING, TYPE_U8, 600, 21600, 1) +
-    zigbee.configureReporting(CLUSTER_BASIC, BASIC_ATTR_POWER_SOURCE, TYPE_ENUM8, 5, 21600, 1) +
-    zigbee.onOffRefresh() +
-    zigbee.readAttribute(CLUSTER_BASIC, BASIC_ATTR_POWER_SOURCE) +
-    zigbee.readAttribute(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING)
+    refresh()
 }

devicetypes/smartthings/zigbee-white-color-temperature-bulb.src/.st-ignore

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

devicetypes/smartthings/zigbee-white-color-temperature-bulb.src/README.md

@@ -0,0 +1,37 @@
+# OSRAM Lightify Tunable 60 White
+
+
+
+Works with: 
+
+* [OSRAM Lightify Tunable 60 White](http://www.osram.com/osram_com/tools-and-services/tools/lightify---smart-connected-light/lightify-for-home---what-is-light-to-you/lightify-products/lightify-classic-a60-tunable-white/index.jsp)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Battery](#battery-specification)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Color Temperature** - represents color temperature, measured in degrees Kelvin.
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated.
+* **Refresh** - _refresh()_ command for status updates
+* **Switch** - can detect state (possible values: on/off)
+* **Switch Level** - represents current light level, usually 0-100 in percent
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+A Category C1 OSRAM Lightify Tunable 60 White with maxReportTime of 5 mins.
+Check-in interval is double the value of maxReportTime. 
+This gives the device twice the amount of time to respond before it is marked as offline.
+Check-in interval = 12 mins
+
+## 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.
+Other troubleshooting tips are listed as follows:
+* [Troubleshooting:](https://support.smartthings.com/hc/en-us/articles/204576454-OSRAM-LIGHTIFY-Tunable-White-60-Bulb)

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

@@ -69,6 +69,15 @@ metadata {
     }
 }
 
+def installed() {
+    log.debug "${device} installed"
+}
+
+def updated() {
+    log.debug "${device} updated"
+    configureHealthCheck()
+}
+
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
@@ -83,8 +92,21 @@ def parse(String description) {
         }
     }
     else {
-        log.warn "DID NOT PARSE MESSAGE for description : $description"
-        log.debug zigbee.parseDescriptionAsMap(description)
+        def cluster = zigbee.parse(description)
+
+        if (cluster && cluster.clusterId == 0x0006 && cluster.command == 0x07) {
+            if (cluster.data[0] == 0x00) {
+                log.debug "ON/OFF REPORTING CONFIG RESPONSE: " + cluster
+                sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+            }
+            else {
+                log.warn "ON/OFF REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
+            }
+        }
+        else {
+            log.warn "DID NOT PARSE MESSAGE for description : $description"
+            log.debug "${cluster}"
+        }
     }
 }
 
@@ -108,15 +130,18 @@ def ping() {
 }
 
 def refresh() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh() + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig()
+    // OnOff minReportTime 0 seconds, maxReportTime 5 min. Reporting interval if no activity
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh() + zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.colorTemperatureConfig()
+}
+
+def configureHealthCheck() {
+    // Device-Watch allows 3 check-in misses from device (plus 1 min lag time)
+    // enrolls with default periodic reporting until newer 5 min interval is confirmed
+    sendEvent(name: "checkInterval", value: 3 * 10 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 }
 
 def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    // Device-Watch allows 2 check-in misses from device
-    sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee"])
-    // OnOff minReportTime 0 seconds, maxReportTime 5 min. Reporting interval if no activity
-    zigbee.onOffConfig(0, 300) + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
+    refresh()
 }
 
 def setColorTemperature(value) {

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

@@ -11,6 +11,9 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
+import groovy.transform.Field
+
+@Field Boolean hasConfiguredHealthCheck = false
 
 metadata {
     definition (name: "ZLL Dimmer Bulb", namespace: "smartthings", author: "SmartThings") {
@@ -21,6 +24,7 @@ metadata {
         capability "Refresh"
         capability "Switch"
         capability "Switch Level"
+        capability "Health Check"
 
         //fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 1000", outClusters: "0000,0019"
         fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 1000", outClusters: "0019"
@@ -96,7 +100,38 @@ def poll() {
     refresh()
 }
 
-def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+    return zigbee.levelRefresh()
+}
+
+def healthPoll() {
+    log.debug "healthPoll()"
+    def cmds = refresh()
+    cmds.each{ sendHubCommand(new physicalgraph.device.HubAction(it))}
+}
+
+def configureHealthCheck() {
+    Integer hcIntervalMinutes = 12
+    if (!hasConfiguredHealthCheck) {
+        log.debug "Configuring Health Check, Reporting"
+        unschedule("healthPoll")
+        runEvery5Minutes("healthPoll")
+        // Device-Watch allows 2 check-in misses from device
+        sendEvent(name: "checkInterval", value: hcIntervalMinutes * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+        hasConfiguredHealthCheck = true
+    }
+}
+
+def configure() {
+    log.debug "configure()"
+    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
+    configureHealthCheck()
+}
+
+def updated() {
+    log.debug "updated()"
+    configureHealthCheck()
 }

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

@@ -0,0 +1,134 @@
+/**
+ *  Copyright 2016 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: "ZLL RGB Bulb", namespace: "smartthings", author: "SmartThings") {
+
+		capability "Actuator"
+		capability "Color Control"
+		capability "Configuration"
+		capability "Polling"
+		capability "Refresh"
+		capability "Switch"
+		capability "Switch Level"
+	}
+
+	// UI tile definitions
+	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 "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 "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+				attributeState "level", action:"switch level.setLevel"
+			}
+			tileAttribute ("device.color", key: "COLOR_CONTROL") {
+				attributeState "color", action:"color control.setColor"
+			}
+		}
+		standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+
+		main(["switch"])
+		details(["switch", "refresh"])
+	}
+}
+
+//Globals
+private getATTRIBUTE_HUE() { 0x0000 }
+private getATTRIBUTE_SATURATION() { 0x0001 }
+private getHUE_COMMAND() { 0x00 }
+private getSATURATION_COMMAND() { 0x03 }
+private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
+
+// Parse incoming device messages to generate events
+def parse(String description) {
+	log.debug "description is $description"
+
+	def finalResult = zigbee.getEvent(description)
+	if (finalResult) {
+		log.debug finalResult
+		sendEvent(finalResult)
+	}
+	else {
+		def zigbeeMap = zigbee.parseDescriptionAsMap(description)
+		log.trace "zigbeeMap : $zigbeeMap"
+
+		if (zigbeeMap?.clusterInt == COLOR_CONTROL_CLUSTER) {
+			if(zigbeeMap.attrInt == ATTRIBUTE_HUE){  //Hue Attribute
+				def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 360)
+				sendEvent(name: "hue", value: hueValue, displayed:false)
+			}
+			else if(zigbeeMap.attrInt == ATTRIBUTE_SATURATION){ //Saturation Attribute
+				def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
+				sendEvent(name: "saturation", value: saturationValue, displayed:false)
+			}
+		}
+		else {
+			log.info "DID NOT PARSE MESSAGE for description : $description"
+		}
+	}
+}
+
+def on() {
+	zigbee.on() + ["delay 1500"] + zigbee.onOffRefresh()
+}
+
+def off() {
+	zigbee.off() + ["delay 1500"] + zigbee.onOffRefresh()
+}
+
+def refresh() {
+	refreshAttributes() + configureAttributes()
+}
+
+def poll() {
+	refreshAttributes()
+}
+
+def configure() {
+	log.debug "Configuring Reporting and Bindings."
+	configureAttributes() + refreshAttributes()
+}
+
+def configureAttributes() {
+	zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, 0x20, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, 0x20, 1, 3600, 0x01)
+}
+
+def refreshAttributes() {
+	zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+}
+
+def setLevel(value) {
+	zigbee.setLevel(value) + ["delay 1500"] + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
+}
+
+def setColor(value){
+	log.trace "setColor($value)"
+	zigbee.on() + setHue(value.hue) + ["delay 300"] + setSaturation(value.saturation) + ["delay 2000"] + refreshAttributes()
+}
+
+def setHue(value) {
+	def scaledHueValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+	zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, scaledHueValue, "00", "0500") + ["delay 1500"] + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE)      //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second) (0500 in U16 reads 5)
+}
+
+def setSaturation(value) {
+	def scaledSatValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+	zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500") + ["delay 1500"] + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)      //payload-> sat value, transition time
+}

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

@@ -123,7 +123,7 @@ def configureAttributes() {
 }
 
 def refreshAttributes() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh() + zigbee.readAttribute(0x0300, 0x00) + zigbee.readAttribute(0x0300, ATTRIBUTE_HUE) + zigbee.readAttribute(0x0300, ATTRIBUTE_SATURATION)
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh() + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
 }
 
 def setColorTemperature(value) {
@@ -141,10 +141,10 @@ def setColor(value){
 
 def setHue(value) {
     def scaledHueValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-    zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, scaledHueValue, "00", "0500")       //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second) (0500 in U16 reads 5)
+    zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, scaledHueValue, "00", "0500") + ["delay 1500"] + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE)       //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second) (0500 in U16 reads 5)
 }
 
 def setSaturation(value) {
     def scaledSatValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-    zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500")      //payload-> sat value, transition time
+    zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500") + ["delay 1500"] + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)      //payload-> sat value, transition time
 }

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

@@ -11,6 +11,9 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
+import groovy.transform.Field
+
+@Field Boolean hasConfiguredHealthCheck = false
 
 metadata {
     definition (name: "ZLL White Color Temperature Bulb", namespace: "smartthings", author: "SmartThings") {
@@ -22,6 +25,7 @@ metadata {
         capability "Refresh"
         capability "Switch"
         capability "Switch Level"
+        capability "Health Check"
 
         attribute "colorName", "string"
         command "setGenericName"
@@ -96,9 +100,41 @@ def poll() {
     zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+    return zigbee.levelRefresh()
+}
+
+def healthPoll() {
+    log.debug "healthPoll()"
+    def cmds = zigbee.onOffRefresh() + zigbee.levelRefresh()
+    cmds.each{ sendHubCommand(new physicalgraph.device.HubAction(it))}
+}
+
+def configureHealthCheck() {
+    Integer hcIntervalMinutes = 12
+    if (!hasConfiguredHealthCheck) {
+        log.debug "Configuring Health Check, Reporting"
+        unschedule("healthPoll")
+        runEvery5Minutes("healthPoll")
+        // Device-Watch allows 2 check-in misses from device
+        sendEvent(name: "checkInterval", value: hcIntervalMinutes * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+        hasConfiguredHealthCheck = true
+    }
+}
+
 def configure() {
-    log.debug "Configuring Reporting and Bindings."
+    log.debug "configure()"
+    configureHealthCheck()
     zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
+
+}
+
+def updated() {
+    log.debug "updated()"
+    configureHealthCheck()
 }
 
 def setColorTemperature(value) {

devicetypes/smartthings/zwave-dimmer-switch-generic.src/.st-ignore

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

devicetypes/smartthings/zwave-dimmer-switch-generic.src/README.md

@@ -0,0 +1,39 @@
+# Z-wave Dimmer
+
+
+
+Works with: 
+
+* [Leviton Plug-in Lamp Dimmer Module (DZPD3-1LW)](http://www.leviton.com/OA_HTML/ProductDetail.jsp?partnumber=DZPD3-1LW)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Switch Level** - it's defined to accept two parameters, the level and the rate of dimming
+* **Actuator** - represents that a Device has commands
+* **Health Check** - indicates ability to get device health notifications
+* **Switch** - can detect state (possible values: on/off)
+* **Polling** - represents that poll() can be implemented for the device
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - detects sensor events
+
+## Device Health
+
+A Category C5 Leviton Plug-in Lamp Dimmer Module (DZPA1-1LW) (Z-Wave) 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.
+
+## 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:
+* [Leviton Plug-in Lamp Dimmer Module (DZPD3-1LW) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/206171053-How-to-connect-Leviton-Z-Wave-devices)

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

@@ -15,12 +15,14 @@ metadata {
 	definition (name: "Z-Wave Dimmer Switch Generic", namespace: "smartthings", author: "SmartThings") {
 		capability "Switch Level"
 		capability "Actuator"
+		capability "Health Check"
 		capability "Switch"
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
 
 		fingerprint inClusters: "0x26", deviceJoinName: "Z-Wave Dimmer"
+		fingerprint mfr:"001D", prod:"1902", deviceJoinName: "Z-Wave Dimmer"
 	}
 
 	simulator {
@@ -68,6 +70,11 @@ metadata {
 	}
 }
 
+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])
+}
+
 def parse(String description) {
 	def result = null
 	if (description != "updated") {
@@ -185,6 +192,13 @@ def poll() {
 	zwave.switchMultilevelV1.switchMultilevelGet().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 = []

devicetypes/smartthings/zwave-switch-generic.src/.st-ignore

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

devicetypes/smartthings/zwave-switch-generic.src/README.md

@@ -0,0 +1,39 @@
+# Z-wave Switch
+
+
+
+Works with: 
+
+* [Leviton Appliance Module (DZPA1-1LW)](https://support.smartthings.com/hc/en-us/articles/205881176-Leviton-Appliance-Module-DZPA1-1LW-)
+* [GE Plug-In Outdoor Smart Switch (GE 12720) (Z-Wave)](https://support.smartthings.com/hc/en-us/articles/200903080-GE-Plug-In-Outdoor-Smart-Switch-GE-12720-Z-Wave-)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Health Check** - indicates ability to get device health notifications
+* **Switch** - can detect state (possible values: on/off)
+* **Polling** - represents that poll() can be implemented for the device
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - detects sensor events
+
+## Device Health
+
+A Category C5 Leviton Appliance Module (DZPA1-1LW) and GE Plug-In Outdoor Smart Switch (GE 12720) (Z-Wave) 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.
+
+## 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:
+* [Leviton Appliance Module (DZPA1-1LW) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/205881176-Leviton-Appliance-Module-DZPA1-1LW-)
+* [GE Plug-In Outdoor Smart Switch (GE 12720) (Z-Wave) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/200903080-GE-Plug-In-Outdoor-Smart-Switch-GE-12720-Z-Wave-)

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

@@ -14,12 +14,15 @@
 metadata {
 	definition (name: "Z-Wave Switch Generic", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
+		capability "Health Check"
  		capability "Switch"
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
 
 		fingerprint inClusters: "0x25", deviceJoinName: "Z-Wave Switch"
+		fingerprint mfr:"001D", prod:"1A02", deviceJoinName: "Z-Wave Switch"
+		fingerprint mfr:"0063", prod:"4F50", deviceJoinName: "Z-Wave Switch"
 	}
 
 	// simulator metadata
@@ -50,6 +53,11 @@ metadata {
 	}
 }
 
+def updated(){
+// Device-Watch simply pings if no device events received for checkInterval duration of 32min = 2 * 15min + 2min lag time
+	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+}
+
 def parse(String description) {
 	def result = null
 	def cmd = zwave.parse(description, [0x20: 1, 0x70: 1])
@@ -126,6 +134,13 @@ def poll() {
 	])
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	refresh()
+}
+
 def refresh() {
 	delayBetween([
 		zwave.switchBinaryV1.switchBinaryGet().format(),

devicetypes/smartthings/zwave-switch.src/.st-ignore

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

devicetypes/smartthings/zwave-switch.src/README.md

@@ -0,0 +1,49 @@
+# Z-Wave Switch
+
+
+Works with: 
+
+* [GE Z-Wave Plug-In Smart Switch (12719)](http://products.z-wavealliance.org/products/1193)
+* [GE Z-Wave In-Wall Smart Outlet (12721)](http://products.z-wavealliance.org/products/1195)
+* [GE Z-Wave In-Wall Smart Switch (12722)](http://products.z-wavealliance.org/products/1196)
+* [GE Z-Wave In-Wall Smart Toggle Switch (12727)](http://products.z-wavealliance.org/products/1200)
+
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#Troubleshooting)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Indicator** - gives you the ability to set the indicator LED light on a Z-Wave switch
+* **Switch** - can detect state (possible values: on/off)
+* **Polling** - represents that poll() can be implemented for the device
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - detects sensor events
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+Z-Wave Switches (Plug-In, In-Wall(Toggle Switch, Switch, Outlet)) are 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.
+
+
+## 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:
+* [General Z-Wave Dimmer/Switch Troubleshooting](https://support.smartthings.com/hc/en-us/articles/200955890-Troubleshooting-GE-in-wall-switch-or-dimmer-won-t-respond-to-commands-or-automations-Z-Wave-)
+* [GE Z-Wave Plug-In Smart Switch (12719) Troubleshooting](https://support.smartthings.com/hc/en-us/articles/200903070-GE-Plug-In-Smart-Switch-GE-12719-Z-Wave)
+* [GE Z-Wave In-Wall Smart Outlet (12721) Troubleshooting](https://support.smartthings.com/hc/en-us/articles/200903020-GE-In-Wall-Smart-Outlet-GE-12721-Z-Wave)
+* [GE Z-Wave In-Wall Smart Switch (12722) Troubleshooting](https://support.smartthings.com/hc/en-us/articles/200902540-GE-In-Wall-Smart-Switch-GE-12722-Z-Wave)
+* [GE Z-Wave In-Wall Smart Toggle Switch (12727) Troubleshooting](https://support.smartthings.com/hc/en-us/articles/207568933-GE-In-Wall-Smart-Toggle-Switch-GE-12727-Z-Wave)
+
+

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

@@ -19,6 +19,7 @@ metadata {
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
+		capability "Health Check"
 
 		fingerprint mfr:"0063", prod:"4952", deviceJoinName: "Z-Wave Wall Switch"
 		fingerprint mfr:"0063", prod:"5257", deviceJoinName: "Z-Wave Wall Switch"
@@ -64,6 +65,8 @@ metadata {
 }
 
 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])
   switch (ledIndicator) {
         case "on":
             indicatorWhenOn()
@@ -156,6 +159,13 @@ def poll() {
 	])
 }
 
+/**
+  * PING is used by Device-Watch in attempt to reach the Device
+**/
+def ping() {
+		refresh()
+}
+
 def refresh() {
 	delayBetween([
 		zwave.switchBinaryV1.switchBinaryGet().format(),

smartapps/egid/smart-windows.src/smart-windows.groovy

@@ -1,7 +1,7 @@
 /**
  *  Smart Windows
  *	Compares two temperatures – indoor vs outdoor, for example – then sends an alert if windows are open (or closed!).
- * 
+ *
  *  Copyright 2014 Eric Gideon
  *
  * 	Based in part on the "When it's going to rain" SmartApp by the SmartThings team,
@@ -21,13 +21,18 @@ definition(
 	name: "Smart Windows",
 	namespace: "egid",
 	author: "Eric Gideon",
-	description: "Compares two temperatures – indoor vs outdoor, for example – then sends an alert if windows are open (or closed!). If you don't use an external temperature device, your zipcode will be used instead.",
+	description: "Compares two temperatures – indoor vs outdoor, for example – then sends an alert if windows are open (or closed!). If you don't use an external temperature device, your location will be used instead.",
 	iconUrl: "https://s3.amazonaws.com/smartthings-device-icons/Home/home9-icn.png",
 	iconX2Url: "https://s3.amazonaws.com/smartthings-device-icons/Home/home9-icn@2x.png"
 )
 
 
 preferences {
+
+  if (!(location.zipCode || ( location.latitude && location.longitude )) && location.channelName == 'samsungtv') {
+		section { paragraph title: "Note:", "Location is required for this SmartApp. Go to 'Location Name' settings to setup your correct location." }
+	}
+
 	section( "Set the temperature range for your comfort zone..." ) {
 		input "minTemp", "number", title: "Minimum temperature"
 		input "maxTemp", "number", title: "Maximum temperature"
@@ -39,9 +44,11 @@ preferences {
 		input "inTemp", "capability.temperatureMeasurement", title: "Indoor"
 		input "outTemp", "capability.temperatureMeasurement", title: "Outdoor (optional)", required: false
 	}
-	section( "Set your location" ) {
-		input "zipCode", "text", title: "Zip code"
-	}
+
+	if (location.channelName != 'samsungtv') {
+		section( "Set your location" ) { input "zipCode", "text", title: "Zip code" }
+  }
+
 	section( "Notifications" ) {
 		input "sendPushMessage", "enum", title: "Send a push notification?", metadata:[values:["Yes","No"]], required:false
 		input "retryPeriod", "number", title: "Minutes between notifications:"
@@ -72,7 +79,7 @@ def temperatureHandler(evt) {
 
 	def currentInTemp = evt.doubleValue
 	def openWindows = sensors.findAll { it?.latestValue("contact") == 'open' }
-	
+
 	log.trace "Temp event: $evt"
 	log.info "In: $currentInTemp; Out: $currentOutTemp"
 
@@ -98,7 +105,7 @@ def temperatureHandler(evt) {
 			if ( currentOutTemp < maxTemp && !openWindows ) {
 				send( "Open some windows to cool down the house! Currently ${currentInTemp}°F inside and ${currentOutTemp}°F outside." )
 			} else if ( currentOutTemp > maxTemp && openWindows ) {
-				send( "It's gotten warmer outside! You should close these windows: ${openWindows.join(', ')}. Currently ${currentInTemp}°F inside and ${currentOutTemp}°F outside." )				
+				send( "It's gotten warmer outside! You should close these windows: ${openWindows.join(', ')}. Currently ${currentInTemp}°F inside and ${currentOutTemp}°F outside." )
 			} else {
 				log.debug "No notifications sent. Everything is in the right place."
 			}
@@ -125,7 +132,11 @@ def temperatureHandler(evt) {
 }
 
 def weatherCheck() {
-	def json = getWeatherFeature("conditions", zipCode)
+	def json 
+	if (location.channelName != 'samsungtv')
+		json = getWeatherFeature("conditions", zipCode)
+	else
+		json = getWeatherFeature("conditions")
 	def currentTemp = json?.current_observation?.temp_f
 
 	if ( currentTemp ) {
@@ -150,4 +161,4 @@ private send(msg) {
 	}
 
 	log.info msg
-}
+}

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

@@ -0,0 +1,253 @@
+/**
+ *  Gideon
+ *
+ *  Copyright 2016 Nicola Russo
+ *
+ *  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: "Gideon",
+    namespace: "gideon.api",
+    author: "Braindrain Solutions",
+    description: "Gideon AI Smart app allows you to connect and control all of your SmartThings devices through the Gideon AI app, making your SmartThings devices even smarter.",
+    category: "Family",
+    iconUrl: "http://s33.postimg.org/t77u7y7v3/logo.png",
+    iconX2Url: "http://s33.postimg.org/t77u7y7v3/logo.png",
+    iconX3Url: "http://s33.postimg.org/t77u7y7v3/logo.png",
+    oauth: [displayName: "Gideon AI API", displayLink: "gideon.ai"])
+
+
+preferences {
+	section("Control these switches...") {
+        input "switches", "capability.switch", multiple:true
+    }
+    section("Control these motion sensors...") {
+        input "motions", "capability.motionSensor", multiple:true
+    }
+    section("Control these presence sensors...") {
+    	input "presence_sensors", "capability.presenceSensor", multiple:true
+    }
+    section("Control these outlets...") {
+    	input "outlets", "capability.switch", multiple:true
+    }
+    section("Control these locks...") {
+    	input "locks", "capability.lock", multiple:true
+    }
+    section("Control these locks...") {
+	    input "temperature_sensors", "capability.temperatureMeasurement"
+    }
+}
+
+def installed() {
+	log.debug "Installed with settings: ${settings}"
+
+	initialize()
+}
+
+def updated() {
+	log.debug "Updated with settings: ${settings}"
+
+	unsubscribe()
+	initialize()
+}
+
+def initialize() {
+	// TODO: subscribe to attributes, devices, locations, etc.
+    subscribe(outlet, "energy", outletHandler)
+  	subscribe(outlet, "switch", outletHandler)
+}
+
+// TODO: implement event handlers
+def outletHandler(evt) {
+	log.debug "$outlet.currentEnergy"
+	//TODO call G API  
+}
+
+
+private device(it, type) {
+	it ? [id: it.id, label: it.label, type: type] : null
+}
+
+//API Mapping
+mappings {
+	path("/getalldevices") {
+    action: [
+      			GET: "getAllDevices"
+    		]
+  	}
+	path("/doorlocks/:id/:command") {
+    action: [
+      GET: "updateDoorLock"
+    ]
+  }
+  	path("/doorlocks/:id") {
+    action: [
+      			GET: "getDoorLockStatus"
+    		]
+  	}
+  	path("/tempsensors/:id") {
+    action: [
+      GET: "getTempSensorsStatus"
+    ]
+  }
+  	path("/presences/:id") {
+    action: [
+      GET: "getPresenceStatus"
+    ]
+  }
+  	path("/motions/:id") {
+    action: [
+      GET: "getMotionStatus"
+    ]
+  }
+  	path("/outlets/:id") {
+    action: [
+      GET: "getOutletStatus"
+    ]
+  }
+  	path("/outlets/:id/:command") {
+    action: [
+      GET: "updateOutlet"
+    ]
+  }
+  	path("/switches/:command") {
+    action: [
+      PUT: "updateSwitch"
+    ]
+  }
+}
+
+//API Methods
+def getAllDevices() {
+	def locks_list = locks.collect{device(it,"Lock")}
+    def presences_list = presence_sensors.collect{device(it,"Presence")}
+    def motions_list = motions.collect{device(it,"Motion")}
+    def outlets_list = outlets.collect{device(it,"Outlet")}
+    def switches_list = switches.collect{device(it,"Switch")}
+    def temp_list = temperature_sensors.collect{device(it,"Temperature")}
+    return [Locks: locks_list, Presences: presences_list, Motions: motions_list, Outlets: outlets_list, Switches: switches_list, Temperatures: temp_list]
+}
+
+//LOCKS
+def getDoorLockStatus() {
+	def device = locks.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	return [Device_state: device.currentValue('lock')]
+        }
+}
+
+def updateDoorLock() {
+	def command = params.command
+    def device = locks.find { it.id == params.id }
+    if (command){
+        if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            if(command == "toggle")
+            {
+                if(device.currentValue('lock') == "locked")
+                  device.unlock();
+                else
+                  device.lock();
+                  
+                return [Device_id: params.id, result_action: "200"]
+            }
+        }
+    }
+}
+
+//PRESENCE
+def getPresenceStatus() {
+
+	def device = presence_sensors.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	return [Device_state: device.currentValue('presence')]
+   }
+}
+
+//MOTION
+def getMotionStatus() {
+
+	def device = motions.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	return [Device_state: device.currentValue('motion')]
+   }
+}
+
+//OUTLET
+def getOutletStatus() {
+	
+    def device = outlets.find { it.id == params.id }
+   	if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	return [Device_state: device.currentSwitch, Current_watt: device.currentValue("energy")]
+  }
+}
+
+def updateOutlet() {
+	
+    def command = params.command
+    def device = outlets.find { it.id == params.id }
+    if (command){
+        if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            if(command == "toggle")
+            {
+                if(device.currentSwitch == "on")
+                  device.off();
+                else
+                  device.on();
+                  
+                return [Device_id: params.id, result_action: "200"]
+            }
+        }
+    }
+}                
+
+//SWITCH
+def updateSwitch() {
+    def command = params.command
+    def device = switches.find { it.id == params.id }
+    if (command){
+        if (!device) {
+            httpError(404, "Device not found")
+        } else {
+            if(command == "toggle")
+            {
+                if(device.currentSwitch == "on")
+                  device.off();
+                else
+                  device.on();
+                  
+                return [Device_id: params.id, result_action: "200"]
+            }
+        }
+    }
+}
+
+//TEMPERATURE
+def getTempSensorsStatus() {
+	
+    def device = temperature_sensors.find { it.id == params.id }
+    if (!device) {
+            httpError(404, "Device not found")
+        } else {
+        	return [Device_state: device.currentValue('temperature')]
+   }
+}

smartapps/imbrianj/ready-for-rain.src/ready-for-rain.groovy

@@ -18,8 +18,13 @@ definition(
 )
 
 preferences {
-  section("Zip code?") {
-    input "zipcode", "text", title: "Zipcode?"
+
+  if (!(location.zipCode || ( location.latitude && location.longitude )) && location.channelName == 'samsungtv') {
+		section { paragraph title: "Note:", "Location is required for this SmartApp. Go to 'Location Name' settings to setup your correct location." }
+	}
+
+  if (location.channelName != 'samsungtv') {
+		section( "Set your location" ) { input "zipCode", "text", title: "Zip code" }
   }
 
   section("Things to check?") {
@@ -60,7 +65,11 @@ def scheduleCheck(evt) {
   // Only need to poll if we haven't checked in a while - and if something is left open.
   if((now() - (30 * 60 * 1000) > state.lastCheck["time"]) && open) {
     log.info("Something's open - let's check the weather.")
-    def response = getWeatherFeature("forecast", zipcode)
+    def response
+    if (location.channelName != 'samsungtv')
+      response = getWeatherFeature("forecast", zipCode)
+    else
+      response = getWeatherFeature("forecast")
     def weather  = isStormy(response)
 
     if(weather) {

smartapps/imbrianj/safe-watch.src/safe-watch.groovy

@@ -26,9 +26,9 @@ preferences {
   }
 
   section("Temperature monitor?") {
-    input "temp",    "capability.temperatureMeasurement", title: "Temp Sensor", required: false
-    input "maxTemp", "number",                            title: "Max Temp?",   required: false
-    input "minTemp", "number",                            title: "Min Temp?",   required: false
+    input "temp",    "capability.temperatureMeasurement", title: "Temperature Sensor", required: false
+    input "maxTemp", "number",                            title: "Max Temperature (°${location.temperatureScale})",   required: false
+    input "minTemp", "number",                            title: "Min Temperature (°${location.temperatureScale})",   required: false
   }
 
   section("When which people are away?") {

smartapps/juano2310/jawbone-up-connect.src/jawbone-up-connect.groovy

@@ -4,6 +4,9 @@
  *  Author: Juan Risso
  *  Date: 2013-12-19
  */
+
+include 'asynchttp_v1'
+
 definition(
 	name: "Jawbone UP (Connect)",
 	namespace: "juano2310",
@@ -303,7 +306,8 @@ def setup() {
 			  	def childDevice = addChildDevice('juano2310', "Jawbone User", "${app.id}.${member.xid}",null,[name:"Jawbone UP - " + member.first, completedSetup: true])
 			    if (childDevice) {
 			       	log.debug "Child Device Successfully Created"
-			        generateInitialEvent (member, childDevice)
+			        childDevice?.generateSleepingEvent(false)
+                    pollChild(childDevice)
 			    }
 			}
 		}
@@ -349,67 +353,67 @@ def uninstalled() {
 }
 
 def pollChild(childDevice) {
-    def member = state.member
-    generatePollingEvents (member, childDevice)
+		def childMap = [ value: "$childDevice.device.deviceNetworkId}"]
+
+		def params = [
+				uri: 'https://jawbone.com',
+				path: '/nudge/api/users/@me/goals',
+				headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ],
+				contentType: 'application/json'
+		]
+
+		asynchttp_v1.get('responseGoals', params, childMap)
+
+		def params2 = [
+				uri: 'https://jawbone.com',
+				path: '/nudge/api/users/@me/moves',
+				headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ],
+				contentType: 'application/json'
+		]
+
+		asynchttp_v1.get('responseMoves', params2, childMap)
 }
 
-def generatePollingEvents (member, childDevice) {
-    // lets figure out if the member is currently "home" (At the place)
-    def urlgoals = "https://jawbone.com/nudge/api/users/@me/goals"
-    def urlmoves = "https://jawbone.com/nudge/api/users/@me/moves"
-    def urlsleeps = "https://jawbone.com/nudge/api/users/@me/sleeps"
-    def goals = null
-    def moves = null
- 	def sleeps = null
-    httpGet(uri: urlgoals, headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ]) {response ->
-        goals = response.data.data
-    }
-    httpGet(uri: urlmoves, headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ]) {response ->
-        moves = response.data.data.items[0]
-    }
-
-    try { // we are going to just ignore any errors
-        log.debug "Member = ${member.first}"
-        log.debug "Moves Goal = ${goals.move_steps} Steps"
-        log.debug "Moves = ${moves.details.steps} Steps"
-
-        childDevice?.sendEvent(name:"steps", value: moves.details.steps)
-        childDevice?.sendEvent(name:"goal", value: goals.move_steps)
-    	//setColor(moves.details.steps,goals.move_steps,childDevice)
-    }
-    catch (e) {
-            // eat it
-    }
+def responseGoals(response, dni) {
+	if (response.hasError()) {
+			log.error "response has error: $response.errorMessage"
+	} else {
+			def goals
+			try {
+					// json response already parsed into JSONElement object
+					goals = response.json.data
+			} catch (e) {
+					log.error "error parsing json from response: $e"
+			}
+			if (goals) {
+				def childDevice = getChildDevice(dni.value)
+				log.debug "Goal = ${goals.move_steps} Steps"
+				childDevice?.sendEvent(name:"goal", value: goals.move_steps)
+			} else {
+					log.debug "did not get json results from response body: $response.data"
+			}
+	}
 }
 
-def generateInitialEvent (member, childDevice) {
-    // lets figure out if the member is currently "home" (At the place)
-    def urlgoals = "https://jawbone.com/nudge/api/users/@me/goals"
-    def urlmoves = "https://jawbone.com/nudge/api/users/@me/moves"
-    def urlsleeps = "https://jawbone.com/nudge/api/users/@me/sleeps"
-    def goals = null
-    def moves = null
- 	def sleeps = null
-    httpGet(uri: urlgoals, headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ]) {response ->
-        goals = response.data.data
-    }
-    httpGet(uri: urlmoves, headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ]) {response ->
-        moves = response.data.data.items[0]
-    }
-
-    try { // we are going to just ignore any errors
-        log.debug "Member = ${member.first}"
-        log.debug "Moves Goal = ${goals.move_steps} Steps"
-        log.debug "Moves = ${moves.details.steps} Steps"
-        log.debug "Sleeping state = false"
-        childDevice?.generateSleepingEvent(false)
-        childDevice?.sendEvent(name:"steps", value: moves.details.steps)
-        childDevice?.sendEvent(name:"goal", value: goals.move_steps)
-    	//setColor(moves.details.steps,goals.move_steps,childDevice)
-    }
-    catch (e) {
-            // eat it
-    }
+def responseMoves(response, dni) {
+	if (response.hasError()) {
+			log.error "response has error: $response.errorMessage"
+	} else {
+			def moves
+			try {
+					// json response already parsed into JSONElement object
+					moves = response.json.data.items[0]
+			} catch (e) {
+					log.error "error parsing json from response: $e"
+			}
+			if (moves) {
+				def childDevice = getChildDevice(dni.value)
+				log.debug "Moves = ${moves.details.steps} Steps"
+				childDevice?.sendEvent(name:"steps", value: moves.details.steps)
+			} else {
+					log.debug "did not get json results from response body: $response.data"
+			}
+	}
 }
 
 def setColor (steps,goal,childDevice) {
@@ -433,7 +437,7 @@ def hookEventHandler() {
     // get some stuff we need
     def userId = json.events.user_xid[0]
     def	json_type = json.events.type[0]
-	def json_action = json.events.action[0]
+	  def json_action = json.events.action[0]
 
     //log.debug json
     log.debug "Userid = ${userId}"

smartapps/kriskit-trendsetter/group.src/group.groovy

@@ -0,0 +1,317 @@
+/**
+ *  Trend Setter - Group
+ *
+ *  Copyright 2015 Chris Kitch
+ *
+ *  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: "Group",
+    namespace: "kriskit.trendSetter",
+    author: "Chris Kitch",
+    description: "A child SmartApp for Trend Setter for handling a group of devices.",
+    category: "My Apps",
+    iconUrl: "https://cdn.rawgit.com/Kriskit/SmartThingsPublic/master/smartapps/kriskit/trendsetter/icon.png",
+    iconX2Url: "https://cdn.rawgit.com/Kriskit/SmartThingsPublic/master/smartapps/kriskit/trendsetter/icon@2x.png",
+    iconX3Url: "https://cdn.rawgit.com/Kriskit/SmartThingsPublic/master/smartapps/kriskit/trendsetter/icon@3x.png",
+    parent: "kriskit.trendsetter:Trend Setter")
+    
+def version() {
+	return "1.0"
+}
+
+def typeDefinitions() {
+	return [
+        [
+        	type: "switch", 
+            singular: "Switch", 
+            plural: "Switches", 
+            deviceType: "Switch Group Device",
+            attributes: [
+            		[name: "switch"]
+            	]
+        ],
+        [
+        	type: "switchLevel", 
+            singular: "Dimmer", 
+            plural: "Dimmers", 
+            deviceType: "Dimmer Group Device",
+            inherits: "switch",
+            attributes: [
+            	[name: "level"]
+            ]
+        ],
+        [
+        	type: "colorControl",
+            singular: "Colorful Light",
+            plural: "Colorful Lights",
+            deviceType: "Colorful Light Group Device",
+            inherits: "switchLevel",
+            attributes: [
+            	[name: "hue"],
+                [name: "saturation"],
+                [name: "color"]
+            ]
+        ],
+        [
+        	type: "powerMeter",
+            singular: "Power Meter",
+            plural: "Power Meters",
+            deviceType: "Power Meter Group Device",
+            attributes: [
+            	[name: "power"]
+            ]
+        ]
+    ]
+}
+
+// Setup
+preferences {
+	page(name: "configure")
+}
+
+def configure() {
+	atomicState.typeDefinitions = null
+	def controller = getControllerDevice();
+
+	dynamicPage(name: "configure", uninstall: controller != null, install: true) {   
+        if (!controller) {
+           section {              
+				input "deviceType", "enum", title: "Device Type", required: true, submitOnChange: true, options: getDeviceTypeOptions()
+                paragraph "This cannot be changed once the group is created.", color: "#ffcc00"
+            }
+        }
+        
+        if (deviceType) {
+           	def definition = getTypeDefinition(deviceType)
+        
+            section(title: controller == null ? "Grouping" : null) {
+        		label title: "Group Name", required: true
+            
+                input "devices", "capability.${deviceType}", title: "${definition.plural}", multiple: true, required: true, submitOnChange: controller != null
+
+                if (selectedDevicesContainsController()) {
+                    paragraph "WARNING: You have selected the controller ${definition.singular.toLowerCase()} for this group. This will likely cause unexpected behaviour.\n\nPlease uncheck the '${controller.displayName}' from the selected ${definition.plural.toLowerCase()}.", 
+                        image: "https://cdn2.iconfinder.com/data/icons/freecns-cumulus/32/519791-101_Warning-512.png"
+                }
+            }
+            
+			if (controller == null) {
+                section(title: "Controller") {                        
+                    input "deviceName", "text", title: "${definition.singular} Name", required: true, description: "For the controlling virtual ${definition.singular.toLowerCase()} to be created"
+                }
+            }
+            
+            if (definition.advanced) {
+            	section(title: "Advanced", hidden: true, hideable: true) {
+                }
+            }
+        }
+	}
+}
+
+def installed() {
+	log.debug "Installed with settings: ${settings}"
+    
+	installControllerDevice()
+	initialize()
+}
+
+def uninstalled() {
+	log.debug "Uninstalled"
+}
+
+def installControllerDevice() {
+	def definition = getTypeDefinition()
+
+	log.debug "Installing switch group controller device..."
+	addChildDevice("kriskit.trendSetter", definition.deviceType, UUID.randomUUID().toString(), null, ["name": deviceName, "label": deviceName, completedSetup: true])
+}
+
+def updated() {
+	log.debug "Updated with settings: ${settings}"
+
+	unsubscribe()
+	initialize()
+}
+
+def initialize() {
+	def definition = getTypeDefinition()
+	addSubscriptions(definition)
+    def namesToCheck = definition.attributes?.collect { it.name }
+    updateControllerState(namesToCheck)
+}
+
+def addSubscriptions(definition) {
+	def controller = getControllerDevice()
+
+    definition.attributes?.each {
+    	log.debug "Subscribing to ${it.name}..."
+    	subscribe(devices, it.name, onDeviceAttributeChange)
+    }
+}
+
+// Subscription Handlers
+def onDeviceAttributeChange(evt) {
+	def namesToCheck = atomicState.namesToCheck  ?: []
+
+	log.debug "Device state change: ${evt.device.displayName} -> ${evt.name} = ${evt.value}"
+
+    if (!namesToCheck.any { it == evt.name })
+    	namesToCheck.push(evt.name)
+        
+	atomicState.namesToCheck = namesToCheck
+    runIn(1, "updateControllerState")
+}
+
+def updateControllerState() {
+	def namesToCheck = atomicState.namesToCheck
+    updateControllerState(namesToCheck)
+    atomicState.namesToCheck = null
+}
+
+def updateControllerState(namesToCheck) {
+	if (!namesToCheck)
+    	return
+
+	def controller = getControllerDevice()
+    namesToCheck?.each { name ->
+    	def values = devices?.currentValue(name)
+        values?.removeAll([null])
+        log.debug "Updating Controller State: $name -> $values"
+        controller.groupSync(name, values)
+    }
+}
+
+def performGroupCommand(command, arguments = null) {
+	runCommand(devices, command, arguments ?: []) 
+}
+
+def runCommand(target, command, args) {
+    log.debug "Running command '${command}' with arguments ${args} on ${target}..."
+    $performCommand(target, command, args)
+}
+
+def getGroupCurrentValues(name) {
+	return devices?.currentValue(name)
+}
+
+// Utilities
+def getTypeDefinitions() {
+	if (atomicState.version != version()) {
+    	atomicState.typeDefinitions = null
+        atomicState.version = version()
+	}
+
+	if (atomicState.typeDefinitions)
+    	return atomicState.typeDefinitions
+
+	log.debug "Building type definitions..."
+
+	def result = []
+	def definitions = typeDefinitions()
+    
+    definitions?.each { definition ->
+    	if (definition.inherits)
+        	definition = mergeAttributes(definition, definitions.find { it.type == definition.inherits })
+    
+    	result.push(definition)
+    }
+    
+    atomicState.typeDefinitions = result
+    
+    return result
+}
+
+def mergeAttributes(definition, inheritedDefinition) {
+    inheritedDefinition.attributes?.each { attr ->
+    	if (!definition.attributes?.any { it.name == attr.name })
+        	definition.attributes.push(attr)
+    }
+    
+    if (inheritedDefinition.inherits) {
+    	def definitions = typeDefinitions()
+    	definition = mergeAttributes(definition, definitions.find { it.type == inheritedDefinition.inherits })
+	}
+    
+    return definition
+}
+
+def getControllerDevice() {
+	return getChildDevices()?.find { true }
+}
+
+def getTypeDefinition() {
+	return getTypeDefinition(deviceType)
+}
+
+def getTypeDefinition(type) {
+	return getTypeDefinitions().find {
+    	it.type == type
+    }
+}
+
+def getDeviceTypeOptions() {
+	return getTypeDefinitions().collect {
+    	["${it.type}": it.singular]
+    }
+}
+
+def selectedDevicesContainsController() {
+	def controller = getControllerDevice()
+	return devices?.any { 
+    	it?.deviceNetworkId == controller?.deviceNetworkId 
+    }
+}
+
+private $performCommand(target, command, args) {
+    switch(args?.size()) {
+    	default: 
+        	target?."$command"()
+        break
+    
+    	case 1: 
+        	target?."$command"(args[0])
+        break
+        
+		case 2: 
+        	target?."$command"(args[0], args[1])
+        break
+        
+		case 3: 
+        	target?."$command"(args[0], args[1], args[2])
+        break
+        
+		case 4: 
+        	target?."$command"(args[0], args[1], args[2], args[3])
+        break
+        
+		case 5: 
+        	target?."$command"(args[0], args[1], args[2], args[3], args[4], args[5])
+        break
+        
+		case 6: 
+        	target?."$command"(args[0], args[1], args[2], args[3], args[4], args[5], args[6])
+        break
+        
+        case 7: 
+        	target?."$command"(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7])
+        break
+        
+        case 8: 
+        	target?."$command"(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8])
+        break
+        
+        case 9: 
+        	target?."$command"(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9])
+        break
+    }
+}

smartapps/kriskit-trendsetter/trend-setter.src/trend-setter.groovy

@@ -0,0 +1,58 @@
+/**
+ *  Trend Setter
+ *
+ *  Copyright 2015 Chris Kitch
+ *
+ *  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: "Trend Setter",
+    namespace: "kriskit.trendSetter",
+    author: "Chris Kitch",
+    description: "Uses virtual child devices to group other devices together and perform commands and aggregate data from the group.",
+    category: "My Apps",
+    iconUrl: "https://cdn.rawgit.com/Kriskit/SmartThingsPublic/master/smartapps/kriskit/trendsetter/icon.png",
+    iconX2Url: "https://cdn.rawgit.com/Kriskit/SmartThingsPublic/master/smartapps/kriskit/trendsetter/icon@2x.png",
+    iconX3Url: "https://cdn.rawgit.com/Kriskit/SmartThingsPublic/master/smartapps/kriskit/trendsetter/icon@3x.png",
+    singleInstance: true)
+
+
+preferences {
+    page(name: "mainPage")
+}
+
+def mainPage() {
+	dynamicPage(name: "mainPage", title: "Your Groups", install: true, uninstall: true, submitOnChange: true) {
+        section {
+        	app(name: "groups", appName: "Group", namespace: "kriskit.trendSetter", title: "Create Group...", multiple: true)
+        }
+    }
+}
+
+def installed() {
+	log.debug "Installed with settings: ${settings}"
+
+	initialize()
+}
+
+def updated() {
+	log.debug "Updated with settings: ${settings}"
+
+	unsubscribe()
+	initialize()
+}
+
+def initialize() {
+	// TODO: subscribe to attributes, devices, locations, etc.
+}
+
+def childUninstalled() {
+}

smartapps/smartthings/gentle-wake-up.src/gentle-wake-up.groovy

@@ -454,17 +454,23 @@ def sendStopEvent(source) {
 		eventData.value += "cancelled"
 	}
 
+	// send 100% completion event
+	sendTimeRemainingEvent(100)
+
+	// send a non-displayed 0% completion to reset tiles
+	sendTimeRemainingEvent(0, false)
+
+	// send sessionStatus event last so the event feed is ordered properly
 	sendControllerEvent(eventData)
-	sendTimeRemainingEvent(0)
 }
 
-def sendTimeRemainingEvent(percentComplete) {
+def sendTimeRemainingEvent(percentComplete, displayed = true) {
 	log.trace "sendTimeRemainingEvent(${percentComplete})"
 
 	def percentCompleteEventData = [
 			name: "percentComplete",
 			value: percentComplete as int,
-			displayed: true,
+			displayed: displayed,
 			isStateChange: true
 	]
 	sendControllerEvent(percentCompleteEventData)
@@ -474,7 +480,7 @@ def sendTimeRemainingEvent(percentComplete) {
 	def timeRemainingEventData = [
 			name: "timeRemaining",
 			value: displayableTime(timeRemaining),
-			displayed: true,
+			displayed: displayed,
 			isStateChange: true
 	]
 	sendControllerEvent(timeRemainingEventData)
@@ -608,8 +614,6 @@ private completion() {
 	handleCompletionMessaging()
 
 	handleCompletionModesAndPhrases()
-
-	sendTimeRemainingEvent(100)
 }
 
 private handleCompletionSwitches() {

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

@@ -242,8 +242,6 @@ def installed() {
 	} else {
 		initialize()
 	}
-	// Check for new devices and remove old ones every 3 hours
-	runEvery3Hours('updateDevices')
 }
 
 // called after settings are changed
@@ -271,9 +269,19 @@ private removeChildDevices(devices) {
 def initialize() {
 	log.debug "initialize"
 	updateDevices()
+	// Check for new devices and remove old ones every 3 hours
+	runEvery5Minutes('updateDevices')
+	setupDeviceWatch()
 }
 
 // Misc
+private setupDeviceWatch() {
+	def hub = location.hubs[0]
+	// Make sure that all child devices are enrolled in device watch
+	getChildDevices().each {
+		it.sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${hub?.hub?.hardwareID}\"}")
+	}
+}
 
 Map apiRequestHeaders() {
 	return ["Authorization": "Bearer ${state.lifxAccessToken}",
@@ -376,7 +384,7 @@ def updateDevices() {
 			def data = [
 					label: device.label,
 					level: Math.round((device.brightness ?: 1) * 100),
-					switch: device.connected ? device.power : "unreachable",
+					switch: device.power,
 					colorTemperature: device.color.kelvin
 			]
 			if (device.product.capabilities.has_color) {
@@ -387,18 +395,42 @@ def updateDevices() {
 			} else {
 				childDevice = addChildDevice(app.namespace, "LIFX White Bulb", device.id, null, data)
 			}
+			childDevice?.completedSetup = true
+		} else {
+			if (device.product.capabilities.has_color) {
+				sendEvent(name: "color", value: colorUtil.hslToHex((device.color.hue / 3.6) as int, (device.color.saturation * 100) as int))
+				sendEvent(name: "hue", value: device.color.hue / 3.6)
+				sendEvent(name: "saturation", value: device.color.saturation * 100)
+			}
+			childDevice.sendEvent(name: "label", value: device.label)
+			childDevice.sendEvent(name: "level", value: Math.round((device.brightness ?: 1) * 100))
+			childDevice.sendEvent(name: "switch.setLevel", value: Math.round((device.brightness ?: 1) * 100))
+			childDevice.sendEvent(name: "switch", value: device.power)
+			childDevice.sendEvent(name: "colorTemperature", value: device.color.kelvin)
+			childDevice.sendEvent(name: "model", value: device.product.name)
 		}
+
+		if (state.devices[device.id] == null) {
+			// State missing, add it and set it to opposite status as current status to provoke event below
+			state.devices[device.id] = [online : !device.connected]
+		}
+
+		if (!state.devices[device.id]?.online && device.connected) {
+			// Device came online after being offline
+			childDevice?.sendEvent(name: "DeviceWatch-DeviceStatus", value: "online", displayed: false)
+			log.debug "$device is back Online"
+		} else if (state.devices[device.id]?.online && !device.connected) {
+			// Device went offline after being online
+			childDevice?.sendEvent(name: "DeviceWatch-DeviceStatus", value: "offline", displayed: false)
+			log.debug "$device went Offline"
+		}
+		state.devices[device.id] = [online: device.connected]
 	}
 	getChildDevices().findAll { !selectors.contains("${it.deviceNetworkId}") }.each {
 		log.info("Deleting ${it.deviceNetworkId}")
+		state.devices[it.deviceNetworkId] = null
 		deleteChildDevice(it.deviceNetworkId)
 	}
-	runIn(1, 'refreshDevices') // Asynchronously refresh devices so we don't block
 }
 
-def refreshDevices() {
-	log.info("Refreshing all devices...")
-	getChildDevices().each { device ->
-		device.refresh()
-	}
-}
+

smartapps/smartthings/logitech-harmony-connect.src/logitech-harmony-connect.groovy

@@ -34,6 +34,7 @@
  *  locks                | lock              | lock, unlock                | locked, unlocked
  *  ---------------------+-------------------+-----------------------------+------------------------------------
  */
+include 'asynchttp_v1'
 
 definition(
     name: "Logitech Harmony (Connect)",
@@ -96,7 +97,7 @@ def authPage() {
     def description = null
     if (!state.HarmonyAccessToken) {
 		if (!state.accessToken) {
-			log.debug "About to create access token"
+			log.debug "Harmony - About to create access token"
 			createAccessToken()
 		}
         description = "Click to enter Harmony Credentials"
@@ -109,26 +110,28 @@ def authPage() {
 		//device discovery request every 5 //25 seconds
 		int deviceRefreshCount = !state.deviceRefreshCount ? 0 : state.deviceRefreshCount as int
 		state.deviceRefreshCount = deviceRefreshCount + 1
-		def refreshInterval = 3
+		def refreshInterval = 5
 
 		def huboptions = state.HarmonyHubs ?: []
 		def actoptions = state.HarmonyActivities ?: []
 
 		def numFoundHub = huboptions.size() ?: 0
-        def numFoundAct = actoptions.size() ?: 0
+    def numFoundAct = actoptions.size() ?: 0
+
 		if((deviceRefreshCount % 5) == 0) {
 			discoverDevices()
 		}
+
 		return dynamicPage(name:"Credentials", title:"Discovery Started!", nextPage:"", refreshInterval:refreshInterval, install:true, uninstall: true) {
 			section("Please wait while we discover your Harmony Hubs and Activities. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
-				input "selectedhubs", "enum", required:false, title:"Select Harmony Hubs (${numFoundHub} found)", multiple:true, options:huboptions
+				input "selectedhubs", "enum", required:false, title:"Select Harmony Hubs (${numFoundHub} found)", multiple:true, submitOnChange: true, options:huboptions
 			}
-            // Virtual activity flag
-            if (numFoundHub > 0 && numFoundAct > 0 && true)
+      // Virtual activity flag
+      if (numFoundHub > 0 && numFoundAct > 0 && true)
 			section("You can also add activities as virtual switches for other convenient integrations") {
-				input "selectedactivities", "enum", required:false, title:"Select Harmony Activities (${numFoundAct} found)", multiple:true, options:actoptions
+				input "selectedactivities", "enum", required:false, title:"Select Harmony Activities (${numFoundAct} found)", multiple:true, submitOnChange: true, options:actoptions
 			}
-            if (state.resethub)
+    if (state.resethub)
 			section("Connection to the hub timed out. Please restart the hub and try again.") {}
 		}
     }
@@ -138,13 +141,13 @@ def callback() {
 	def redirectUrl = null
 	if (params.authQueryString) {
 		redirectUrl = URLDecoder.decode(params.authQueryString.replaceAll(".+&redirect_url=", ""))
-		log.debug "redirectUrl: ${redirectUrl}"
+		log.debug "Harmony - redirectUrl: ${redirectUrl}"
 	} else {
-		log.warn "No authQueryString"
+		log.warn "Harmony - No authQueryString"
 	}
 
 	if (state.HarmonyAccessToken) {
-		log.debug "Access token already exists"
+		log.debug "Harmony - Access token already exists"
 		discovery()
 		success()
 	} else {
@@ -152,27 +155,27 @@ def callback() {
 		if (code) {
 			if (code.size() > 6) {
 				// Harmony code
-				log.debug "Exchanging code for access token"
+				log.debug "Harmony - Exchanging code for access token"
 				receiveToken(redirectUrl)
 			} else {
 				// Initiate the Harmony OAuth flow.
 				init()
 			}
 		} else {
-			log.debug "This code should be unreachable"
+			log.debug "Harmony - This code should be unreachable"
 			success()
 		}
 	}
 }
 
 def init() {
-	log.debug "Requesting Code"
+	log.debug "Harmony - Requesting Code"
 	def oauthParams = [client_id: "${appSettings.clientId}", scope: "remote", response_type: "code", redirect_uri: "${servercallbackUrl}" ]
 	redirect(location: "https://home.myharmony.com/oauth2/authorize?${toQueryString(oauthParams)}")
 }
 
 def receiveToken(redirectUrl = null) {
-	log.debug "receiveToken"
+	log.debug "Harmony - receiveToken"
     def oauthParams = [ client_id: "${appSettings.clientId}", client_secret: "${appSettings.clientSecret}", grant_type: "authorization_code", code: params.code ]
     def params = [
       uri: "https://home.myharmony.com/oauth2/token?${toQueryString(oauthParams)}",
@@ -183,7 +186,7 @@ def receiveToken(redirectUrl = null) {
         }
 	} catch (java.util.concurrent.TimeoutException e) {
     	fail(e)
-		log.warn "Connection timed out, please try again later."
+		log.warn "Harmony - Connection timed out, please try again later."
 	}
     discovery()
 	if (state.HarmonyAccessToken) {
@@ -307,7 +310,7 @@ def buildRedirectUrl(page) {
 
 def installed() {
 	if (!state.accessToken) {
-		log.debug "About to create access token"
+		log.debug "Harmony - About to create access token"
 		createAccessToken()
 	} else {
 		initialize()
@@ -316,7 +319,7 @@ def installed() {
 
 def updated() {
 	if (!state.accessToken) {
-		log.debug "About to create access token"
+		log.debug "Harmony - About to create access token"
 		createAccessToken()
 	} else {
 		initialize()
@@ -327,9 +330,9 @@ def uninstalled() {
 	if (state.HarmonyAccessToken) {
 		try {
         	state.HarmonyAccessToken = ""
-        	log.debug "Success disconnecting Harmony from SmartThings"
+        	log.debug "Harmony - Success disconnecting Harmony from SmartThings"
 		} catch (groovyx.net.http.HttpResponseException e) {
-			log.error "Error disconnecting Harmony from SmartThings: ${e.statusCode}"
+			log.error "Harmony - Error disconnecting Harmony from SmartThings: ${e.statusCode}"
 		}
 	}
 }
@@ -338,7 +341,8 @@ def initialize() {
 	state.aux = 0
 	if (selectedhubs || selectedactivities) {
 		addDevice()
-        runEvery5Minutes("poll")
+    runEvery5Minutes("poll")
+    getActivityList()
 	}
 }
 
@@ -347,7 +351,7 @@ def getHarmonydevices() {
 }
 
 Map discoverDevices() {
-    log.trace "Discovering devices..."
+    log.trace "Harmony - Discovering devices..."
     discovery()
     if (getHarmonydevices() != []) {
         def devices = state.Harmonydevices.hubs
@@ -359,7 +363,7 @@ Map discoverDevices() {
             def hubname = getHubName(it.key)
             def hubvalue = "${hubname}"
             hubs["harmony-${hubkey}"] = hubvalue
-        	it.value.response.data.activities.each {
+        	  it.value.response.data.activities.each {
                 def value = "${it.value.name}"
                 def key = "harmony-${hubkey}-${it.key}"
                 activities["${key}"] = value
@@ -377,164 +381,177 @@ def discovery() {
 	try {
 		httpGet(uri: url, headers: ["Accept": "application/json"]) {response ->
 	    	if (response.status == 200) {
-            	log.debug "valid Token"
+            	log.debug "Harmony - valid Token"
                 state.Harmonydevices = response.data
                 state.resethub = false
-                getActivityList()
-                poll()
 	        } else {
-            	log.debug "Error: $response.status"
+            	log.debug "Harmony - Error: $response.status"
             }
 	    }
 	} catch (groovyx.net.http.HttpResponseException e) {
         if (e.statusCode == 401) { // token is expired
             state.remove("HarmonyAccessToken")
-            log.warn "Harmony Access token has expired"
+            log.warn "Harmony - Harmony Access token has expired"
         }
 	} catch (java.net.SocketTimeoutException e) {
-		log.warn "Connection to the hub timed out. Please restart the hub and try again."
+		log.warn "Harmony - Connection to the hub timed out. Please restart the hub and try again."
     state.resethub = true
  	} catch (e) {
-    log.info "Logitech Harmony - Error: $e"
+    log.info "Harmony - Error: $e"
 	}
     return null
 }
 
 def addDevice() {
-    log.trace "Adding Hubs"
+    log.trace "Harmony - Adding Hubs"
     selectedhubs.each { dni ->
         def d = getChildDevice(dni)
         if(!d) {
             def newAction = state.HarmonyHubs.find { it.key == dni }
             d = addChildDevice("smartthings", "Logitech Harmony Hub C2C", dni, null, [label:"${newAction.value}"])
-            log.trace "created ${d.displayName} with id $dni"
+            log.trace "Harmony - Created ${d.displayName} with id $dni"
             poll()
         } else {
-            log.trace "found ${d.displayName} with id $dni already exists"
+            log.trace "Harmony - Found ${d.displayName} with id $dni already exists"
         }
     }
-    log.trace "Adding Activities"
+    log.trace "Harmony - Adding Activities"
     selectedactivities.each { dni ->
         def d = getChildDevice(dni)
         if(!d) {
             def newAction = state.HarmonyActivities.find { it.key == dni }
             if (newAction) {
 	            d = addChildDevice("smartthings", "Harmony Activity", dni, null, [label:"${newAction.value} [Harmony Activity]"])
-	            log.trace "created ${d.displayName} with id $dni"
+	            log.trace "Harmony - Created ${d.displayName} with id $dni"
 	            poll()
             }
         } else {
-            log.trace "found ${d.displayName} with id $dni already exists"
+            log.trace "Harmony - Found ${d.displayName} with id $dni already exists"
         }
     }
 }
 
 def activity(dni,mode) {
-    def Params = [auth: state.HarmonyAccessToken]
-    def msg = "Command failed"
-    def url = ''
+    def tokenParam = [auth: state.HarmonyAccessToken]
+    def url
     if (dni == "all") {
-        url = "https://home.myharmony.com/cloudapi/activity/off?${toQueryString(Params)}"
+        url = "https://home.myharmony.com/cloudapi/activity/off?${toQueryString(tokenParam)}"
     } else {
         def aux = dni.split('-')
         def hubId = aux[1]
         if (mode == "hub" || (aux.size() <= 2) || (aux[2] == "off")){
-        	url = "https://home.myharmony.com/cloudapi/hub/${hubId}/activity/off?${toQueryString(Params)}"
+        	url = "https://home.myharmony.com/cloudapi/hub/${hubId}/activity/off?${toQueryString(tokenParam)}"
         } else {
-            def activityId = aux[2]
-        	url = "https://home.myharmony.com/cloudapi/hub/${hubId}/activity/${activityId}/${mode}?${toQueryString(Params)}"
+          def activityId = aux[2]
+        	url = "https://home.myharmony.com/cloudapi/hub/${hubId}/activity/${activityId}/${mode}?${toQueryString(tokenParam)}"
         }
 	}
-	try {
-    	httpPostJson(uri: url) { response ->
-        	if (response.data.code == 200 || dni == "all") {
-            	msg = "Command sent succesfully"
-            	state.aux = 0
-            } else {
-            	msg = "Command failed. Error: $response.data.code"
-            }
-		}
-    } catch (groovyx.net.http.HttpResponseException ex) {
-        log.error ex
-        if (state.aux == 0) {
-        	state.aux = 1
-        	activity(dni,mode)
-        } else {
-        	msg = ex
-            state.aux = 0
-        }
-    } catch(Exception ex) {
-    	msg = ex
+  def params = [
+      uri: url,
+      contentType: 'application/json'
+  ]
+  asynchttp_v1.post('activityResponse', params)
+  return "Command Sent"
+}
+
+def activityResponse(response, data) {
+  if (response.hasError()) {
+    log.error "Harmony - response has error: $response.errorMessage"
+    if (response.status == 401) { // token is expired
+      state.remove("HarmonyAccessToken")
+      log.warn "Harmony - Access token has expired"
     }
-    runIn(10, "poll", [overwrite: true])
-    return msg
+  } else {
+    if (response.status == 200) {
+      log.trace "Harmony - Command sent succesfully"
+      poll()
+    } else {
+      log.trace "Harmony - Command failed. Error: $response.status"
+    }
+  }
 }
 
 def poll() {
 	// GET THE LIST OF ACTIVITIES
     if (state.HarmonyAccessToken) {
-    	  getActivityList()
-        def Params = [auth: state.HarmonyAccessToken]
-        def url = "https://home.myharmony.com/cloudapi/state?${toQueryString(Params)}"
-        try {
-            httpGet(uri: url, headers: ["Accept": "application/json"]) {response ->
-                def map = [:]
-                response.data.hubs.each {
-		            if (it.value.message == "OK") {
-	                    map["${it.key}"] = "${it.value.response.data.currentAvActivity},${it.value.response.data.activityStatus}"
-	                    def hub = getChildDevice("harmony-${it.key}")
-	                    if (hub) {
-	                        if (it.value.response.data.currentAvActivity == "-1") {
-	                            hub.sendEvent(name: "currentActivity", value: "--", descriptionText: "There isn't any activity running", display: false)
-	                        } else {
-	                            def currentActivity = getActivityName(it.value.response.data.currentAvActivity,it.key)
-	                            hub.sendEvent(name: "currentActivity", value: currentActivity, descriptionText: "Current activity is ${currentActivity}", display: false)
-	                        }
-	                    }
-	                } else {
-		                log.trace it.value.message
-	                }
-                }
-                def activities = getChildDevices()
-                def activitynotrunning = true
-                activities.each { activity ->
-                    def act = activity.deviceNetworkId.split('-')
-                    if (act.size() > 2) {
-                        def aux = map.find { it.key == act[1] }
-                        if (aux) {
-                            def aux2 = aux.value.split(',')
-                            def childDevice = getChildDevice(activity.deviceNetworkId)
-                            if ((act[2] == aux2[0]) && (aux2[1] == "1" || aux2[1] == "2")) {
-                                childDevice?.sendEvent(name: "switch", value: "on")
-                                if (aux2[1] == "1")
-                                    runIn(5, "poll", [overwrite: true])
-                            } else {
-                                childDevice?.sendEvent(name: "switch", value: "off")
-                                if (aux2[1] == "3")
-                                    runIn(5, "poll", [overwrite: true])
-                            }
-                        }
-                    }
-                }
-                return "Poll completed $map - $state.hubs"
-            }
-        } catch (groovyx.net.http.HttpResponseException e) {
-              if (e.statusCode == 401) { // token is expired
-                  state.remove("HarmonyAccessToken")
-                  log.warn "Harmony Access token has expired"
-              }
-        } catch (java.net.SocketTimeoutException e) {
-        	log.warn "Connection to the hub timed out. Please restart the hub and try again."
-              state.resethub = true
-        } catch (e) {
-        	log.info "Logitech Harmony - Error: $e"
-        }
-    }
+        def tokenParam = [auth: state.HarmonyAccessToken]
+        def params = [
+            uri: "https://home.myharmony.com/cloudapi/state?${toQueryString(tokenParam)}",
+            headers: ["Accept": "application/json"],
+            contentType: 'application/json'
+        ]
+        asynchttp_v1.get('pollResponse', params)
+      } else {
+        log.warn "Harmony - Access token has expired"
+      }
 }
 
+def pollResponse(response, data) {
+	if (response.hasError()) {
+    log.error "Harmony - response has error: $response.errorMessage"
+    if (response.status == 401) { // token is expired
+      state.remove("HarmonyAccessToken")
+      log.warn "Harmony - Access token has expired"
+    }
+	} else {
+			def ResponseValues
+			try {
+					// json response already parsed into JSONElement object
+					ResponseValues = response.json
+			} catch (e) {
+					log.error "Harmony - error parsing json from response: $e"
+			}
+			if (ResponseValues) {
+        def map = [:]
+        ResponseValues.hubs.each {
+        if (it.value.message == "OK") {
+              map["${it.key}"] = "${it.value.response.data.currentAvActivity},${it.value.response.data.activityStatus}"
+              def hub = getChildDevice("harmony-${it.key}")
+              if (hub) {
+                  if (it.value.response.data.currentAvActivity == "-1") {
+                      hub.sendEvent(name: "currentActivity", value: "--", descriptionText: "There isn't any activity running", display: false)
+                  } else {
+                      def currentActivity
+                      def activityDTH = getChildDevice("harmony-${it.key}-${it.value.response.data.currentAvActivity}")
+                      if (activityDTH)
+                        currentActivity = activityDTH.device.displayName
+                      else
+                        currentActivity = getActivityName(it.value.response.data.currentAvActivity,it.key)
+                      hub.sendEvent(name: "currentActivity", value: currentActivity, descriptionText: "Current activity is ${currentActivity}", display: false)
+                  }
+              }
+          } else {
+            log.trace "Harmony - error response: $it.value.message"
+          }
+        }
+        def activities = getChildDevices()
+        def activitynotrunning = true
+        activities.each { activity ->
+            def act = activity.deviceNetworkId.split('-')
+            if (act.size() > 2) {
+                def aux = map.find { it.key == act[1] }
+                if (aux) {
+                    def aux2 = aux.value.split(',')
+                    def childDevice = getChildDevice(activity.deviceNetworkId)
+                    if ((act[2] == aux2[0]) && (aux2[1] == "1" || aux2[1] == "2")) {
+                        childDevice?.sendEvent(name: "switch", value: "on")
+                        if (aux2[1] == "1")
+                            runIn(5, "poll", [overwrite: true])
+                    } else {
+                        childDevice?.sendEvent(name: "switch", value: "off")
+                        if (aux2[1] == "3")
+                            runIn(5, "poll", [overwrite: true])
+                    }
+                }
+            }
+        }
+			} else {
+					log.debug "Harmony - did not get json results from response body: $response.data"
+			}
+	}
+}
 
 def getActivityList() {
-	// GET ACTIVITY'S NAME
     if (state.HarmonyAccessToken) {
         def Params = [auth: state.HarmonyAccessToken]
         def url = "https://home.myharmony.com/cloudapi/activity/all?${toQueryString(Params)}"
@@ -551,21 +568,19 @@ def getActivityList() {
                                 [id: it.key, name: it.value['name'], type: it.value['type']]
                             }
                             activities += [id: "off", name: "Activity OFF", type: "0"]
-                            log.trace activities
                         }
                         hub.sendEvent(name: "activities", value: new groovy.json.JsonBuilder(activities).toString(), descriptionText: "Activities are ${activities.collect { it.name }?.join(', ')}", display: false)
-					}
+					          }
                 }
             }
         } catch (groovyx.net.http.HttpResponseException e) {
         	log.trace e
         } catch (java.net.SocketTimeoutException e) {
         	log.trace e
-		} catch(Exception e) {
+		    } catch(Exception e) {
         	log.trace e
-		}
+		    }
     }
-	return activity
 }
 
 def getActivityName(activity,hubId) {
@@ -628,7 +643,7 @@ def sendNotification(msg) {
 
 def hookEventHandler() {
     // log.debug "In hookEventHandler method."
-    log.debug "request = ${request}"
+    log.debug "Harmony - request = ${request}"
 
     def json = request.JSON
 
@@ -637,14 +652,14 @@ def hookEventHandler() {
 }
 
 def listDevices() {
-	log.debug "getDevices, params: ${params}"
+	log.debug "Harmony - getDevices(), params: ${params}"
 	allDevices.collect {
 		deviceItem(it)
 	}
 }
 
 def getDevice() {
-	log.debug "getDevice, params: ${params}"
+	log.debug "Harmony - getDevice(), params: ${params}"
 	def device = allDevices.find { it.id == params.id }
 	if (!device) {
 		render status: 404, data: '{"msg": "Device not found"}'
@@ -657,7 +672,7 @@ def updateDevice() {
 	def data = request.JSON
 	def command = data.command
 	def arguments = data.arguments
-	log.debug "updateDevice, params: ${params}, request: ${data}"
+	log.debug "Harmony - updateDevice(), params: ${params}, request: ${data}"
 	if (!command) {
 		render status: 400, data: '{"msg": "command is required"}'
 	} else {
@@ -725,7 +740,7 @@ def getDeviceCapabilityCommands(deviceCapabilities) {
 }
 
 def listSubscriptions() {
-	log.debug "listSubscriptions()"
+	log.debug "Harmony - listSubscriptions()"
 	app.subscriptions?.findAll { it.device?.device && it.device.id }?.collect {
 		def deviceInfo = state[it.device.id]
 		def response = [
@@ -746,17 +761,17 @@ def addSubscription() {
 	def attribute = data.attributeName
 	def callbackUrl = data.callbackUrl
 
-	log.debug "addSubscription, params: ${params}, request: ${data}"
+	log.debug "Harmony - addSubscription, params: ${params}, request: ${data}"
 	if (!attribute) {
 		render status: 400, data: '{"msg": "attributeName is required"}'
 	} else {
 		def device = allDevices.find { it.id == data.deviceId }
 		if (device) {
 			if (!state.harmonyHubs) {
-				log.debug "Adding callbackUrl: $callbackUrl"
+				log.debug "Harmony - Adding callbackUrl: $callbackUrl"
 				state[device.id] = [callbackUrl: callbackUrl]
 			}
-			log.debug "Adding subscription"
+			log.debug "Harmony - Adding subscription"
 			def subscription = subscribe(device, attribute, deviceHandler)
 			if (!subscription || !subscription.eventSubscription) {
 				subscription = app.subscriptions?.find { it.device?.device && it.device.id == data.deviceId && it.data == attribute && it.handler == 'deviceHandler' }
@@ -784,7 +799,7 @@ def removeSubscription() {
 
 	log.debug "removeSubscription, params: ${params}, subscription: ${subscription}, device: ${device}"
 	if (device) {
-		log.debug "Removing subscription for device: ${device.id}"
+		log.debug "Harmony - Removing subscription for device: ${device.id}"
 		state.remove(device.id)
 		unsubscribe(device)
 	}
@@ -808,16 +823,17 @@ def deviceHandler(evt) {
 	def deviceInfo = state[evt.deviceId]
 	if (state.harmonyHubs) {
 		state.harmonyHubs.each { harmonyHub ->
+      log.trace "Harmony - Sending data to $harmonyHub.name"
 			sendToHarmony(evt, harmonyHub.callbackUrl)
 		}
 	} else if (deviceInfo) {
 		if (deviceInfo.callbackUrl) {
 			sendToHarmony(evt, deviceInfo.callbackUrl)
 		} else {
-			log.warn "No callbackUrl set for device: ${evt.deviceId}"
+			log.warn "Harmony - No callbackUrl set for device: ${evt.deviceId}"
 		}
 	} else {
-		log.warn "No subscribed device found for device: ${evt.deviceId}"
+		log.warn "Harmony - No subscribed device found for device: ${evt.deviceId}"
 	}
 }
 
@@ -841,12 +857,12 @@ def sendToHarmony(evt, String callbackUrl) {
       body: [evt: [deviceId: evt.deviceId, name: evt.name, value: evt.value]]
     ]
     try {
-        log.debug "Sending data to Harmony Cloud: $params"
+        log.debug "Harmony - Sending data to Harmony Cloud: $params"
         httpPostJson(params) { resp ->
-            log.debug "Harmony Cloud - Response: ${resp.status}"
+            log.debug "Harmony - Cloud Response: ${resp.status}"
         }
     } catch (e) {
-        log.error "Harmony Cloud - Something went wrong: $e"
+        log.error "Harmony - Cloud Something went wrong: $e"
     }
   }
 }
@@ -871,10 +887,10 @@ def activityCallback() {
 		if (data.errorCode == "200") {
 			device.setCurrentActivity(data.currentActivityId)
 		} else {
-			log.warn "Activity callback error: ${data}"
+			log.warn "Harmony - Activity callback error: ${data}"
 		}
 	} else {
-		log.warn "Activity callback sent to non-existant dni: ${params.dni}"
+		log.warn "Harmony - Activity callback sent to non-existant dni: ${params.dni}"
 	}
 	render status: 200, data: '{"msg": "Successfully received callbackUrl"}'
 }
@@ -908,13 +924,13 @@ def harmony() {
 }
 
 def deleteHarmony() {
-	log.debug "Trying to delete Harmony hub with mac: ${params.mac}"
+	log.debug "Harmony - Trying to delete Harmony hub with mac: ${params.mac}"
 	def harmonyHub = state.harmonyHubs?.find { it.mac == params.mac }
 	if (harmonyHub) {
-		log.debug "Deleting Harmony hub with mac: ${params.mac}"
+		log.debug "Harmony - Deleting Harmony hub with mac: ${params.mac}"
 		state.harmonyHubs.remove(harmonyHub)
 	} else {
-		log.debug "Couldn't find Harmony hub with mac: ${params.mac}"
+		log.debug "Harmony - Couldn't find Harmony hub with mac: ${params.mac}"
 	}
 	render status: 204, data: "{}"
 }

smartapps/smartthings/severe-weather-alert.src/severe-weather-alert.groovy

@@ -26,17 +26,22 @@ definition(
 )
 
 preferences {
-	section ("In addition to push notifications, send text alerts to...") {
-        input("recipients", "contact", title: "Send notifications to") {
-            input "phone1", "phone", title: "Phone Number 1", required: false
-            input "phone2", "phone", title: "Phone Number 2", required: false
-            input "phone3", "phone", title: "Phone Number 3", required: false
-        }
+
+  if (!(location.zipCode || ( location.latitude && location.longitude )) && location.channelName == 'samsungtv') {
+		section { paragraph title: "Note:", "Location is required for this SmartApp. Go to 'Location Name' settings to setup your correct location." }
 	}
 
-	section ("Zip code (optional, defaults to location coordinates)...") {
-		input "zipcode", "text", title: "Zip Code", required: false
-	}
+  if (location.channelName != 'samsungtv') {
+		section( "Set your location" ) { input "zipCode", "text", title: "Zip code" }
+  }
+
+	section ("In addition to push notifications, send text alerts to...") {
+      input("recipients", "contact", title: "Send notifications to") {
+          input "phone1", "phone", title: "Phone Number 1", required: false
+          input "phone2", "phone", title: "Phone Number 2", required: false
+          input "phone3", "phone", title: "Phone Number 3", required: false
+      }
+	 }
 }
 
 def installed() {
@@ -61,7 +66,7 @@ def checkForSevereWeather() {
 	def alerts
 	if(locationIsDefined()) {
 		if(zipcodeIsValid()) {
-			alerts = getWeatherFeature("alerts", zipcode)?.alerts
+			alerts = getWeatherFeature("alerts", zipCode)?.alerts
 		} else {
 			log.warn "Severe Weather Alert: Invalid zipcode entered, defaulting to location's zipcode"
 			alerts = getWeatherFeature("alerts")?.alerts