Merge pull request #1842 from SmartThingsCommunity/staging

Rolling up staging to production

README.md

@@ -1,10 +1,10 @@
-# SmartThings Public Github Repo
+# SmartThings Public GitHub Repo
 
 An official list of SmartApps and Device Types from SmartThings.
 
 Here are some links to help you get started coding right away:
 
-* [Github-specific Documentation](http://docs.smartthings.com/en/latest/tools-and-ide/github-integration.html)
+* [GitHub-specific Documentation](http://docs.smartthings.com/en/latest/tools-and-ide/github-integration.html)
 * [Full Documentation](http://docs.smartthings.com)
 * [IDE & Simulator](http://ide.smartthings.com)
 * [Community Forums](http://community.smartthings.com)

build.gradle

@@ -1,13 +1,15 @@
 import java.nio.charset.StandardCharsets
 import java.nio.file.Paths
+import com.smartthings.deployment.slack.FileUpload
+import com.smartthings.deployment.slack.Message
 
 apply plugin: 'groovy'
 apply plugin: 'smartthings-executable-deployment'
-apply plugin: 'smartthings-hipchat'
+apply plugin: 'smartthings-slack'
 
 buildscript {
     dependencies {
-        classpath "com.smartthings.deployment:executable-deployment-scripts:1.0.6"
+        classpath "com.smartthings.deployment:executable-deployment-scripts:1.0.11"
     }
     repositories {
         mavenLocal()
@@ -17,7 +19,7 @@ buildscript {
                 username smartThingsArtifactoryUserName
                 password smartThingsArtifactoryPassword
             }
-            url "http://artifactory.smartthings.com/libs-release-local"
+            url "https://artifactory.smartthings.com/libs-release-local"
         }
     }
 }
@@ -25,12 +27,76 @@ buildscript {
 repositories {
     mavenLocal()
     jcenter()
+    maven {
+        credentials {
+            username smartThingsArtifactoryUserName
+            password smartThingsArtifactoryPassword
+        }
+        url "https://artifactory.smartthings.com/libs-release-local"
+    }
+}
+
+sourceSets {
+    devicetypes {
+        groovy {
+            srcDirs = ['devicetypes']
+        }
+    }
+    smartapps {
+        groovy {
+            srcDirs = ['smartapps']
+        }
+    }
 }
 
 dependencies {
+    devicetypesCompile 'org.codehaus.groovy:groovy-all:2.4.7'
+    devicetypesCompile 'smartthings:appengine-z-wave:0.1.2'
+    devicetypesCompile 'smartthings:appengine-zigbee:0.1.11'
+    smartappsCompile 'org.codehaus.groovy:groovy-all:2.4.7'
+    smartappsCompile 'smartthings:appengine-common:0.1.8'
+    smartappsCompile 'org.codehaus.groovy.modules.http-builder:http-builder:0.7.1'
+    smartappsCompile 'org.grails:grails-web:2.3.11'
+    smartappsCompile 'org.json:json:20140107'
 }
 
-hipchatShareFile {
+slackSendMessage {
+    String branch = project.hasProperty('branch') ? project.property('branch') : 'unknown'
+    String token = project.hasProperty('slackToken') ? project.property('slackToken') : null
+    String webhookUrl = project.hasProperty('slackWebhookUrl') ? project.property('slackWebhookUrl') : null
+    String channel = project.hasProperty('slackChannel') ? project.property('slackChannel') : null
+    String drinks = 'https://dl.dropboxusercontent.com/s/m1z5mpd3c83lwev/minion_beer.jpeg?dl=0'
+    String wolverine = 'https://dl.dropboxusercontent.com/s/4lbjqzvm2v033u9/minion_wolverine.jpg?dl=0'
+    String beach = 'https://dl.dropboxusercontent.com/s/rqrfgxk53gfng69/minion_beach.png?dl=0'
+    String iconUrl
+    String color
+    String messageText
+    String username
+    switch (branch) {
+        case 'master':
+            username = 'Hickory'
+            iconUrl = wolverine
+            color = '#35D0F2'
+            messageText = 'Began deployment of _SmartThingsPublic[master]_ branch to the _Dev_ environments.'
+            break
+        case 'staging':
+            username = 'Dickory'
+            iconUrl = beach
+            color = '#FFDE20'
+            messageText = 'Began deployment of _SmartThingsPublic[staging]_ branch to the _Staging_ environments.'
+            break
+        case 'production':
+            username = 'Dock'
+            iconUrl = drinks
+            color = '#FF1D23'
+            messageText = 'Began deployment of _SmartThingsPublic[production]_ branch to the _Prod_ environments.'
+            break
+        default:
+            username = 'Hickory'
+            iconUrl = wolverine
+            color = '#35D0F2'
+            messageText = "Began deployment of an _SmartThingsPublic[${branch}]_ branch.  Have no idea what's going on."
+    }
     List<String> archives = []
     File rootDir = new File("${project.buildDir}/archives")
     if (rootDir.exists()) {
@@ -43,19 +109,25 @@ hipchatShareFile {
             }
         }
     }
+    Date date = new Date()
+    String fileDate = date.format('yyyy-MM-dd_HH-mm-ss', TimeZone.getTimeZone('GMT'))
 
-    // Set task properties
-    data = archives.join('\n').getBytes(StandardCharsets.UTF_8)
-    fileName = 'deployment-notes.txt'
-    contentType = 'text/html'
-}
-
-hipchatSendNotification {
-    String branch = project.hasProperty('branch') ? project.property('branch') : 'unknown'
-    message = "Began executable deploy of SmartThingsPublic(${branch})."
-    if (branch == 'master') {
-      message += ' (dev shards)'
-    }
-    color = branch == 'master' ? 'yellow' : 'red'
-    notify = true
+    // Required Task Arguments.
+    file = new FileUpload(
+        data: archives.join('\n').getBytes(StandardCharsets.UTF_8),
+        filename: "deployment-notes-${fileDate}.txt",
+        title: 'Deployment Notes',
+        channels: channel,
+        token: token,
+        color: color
+    )
+    message = new Message(
+        webhookUrl: webhookUrl,
+        username: username,
+        asUser: true,
+        iconUrl: iconUrl,
+        channel: channel,
+        fallback: 'Deployment Notification',
+        text: messageText
+    )
 }

circle.yml

@@ -5,7 +5,9 @@ machine:
 
 dependencies:
   override:
-    - echo "Nothing to do."
+    - ./gradlew dependencies -PsmartThingsArtifactoryUserName="$ARTIFACTORY_USERNAME" -PsmartThingsArtifactoryPassword="$ARTIFACTORY_PASSWORD"
+  post:
+    - ./gradlew compileSmartappsGroovy compileDevicetypesGroovy -PsmartThingsArtifactoryUserName="$ARTIFACTORY_USERNAME" -PsmartThingsArtifactoryPassword="$ARTIFACTORY_PASSWORD"
 
 test:
   override:
@@ -15,13 +17,11 @@ deployment:
   develop:
     branch: master
     commands:
-      - ./gradlew deployArchives -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD -Ps3Buckets="$S3_BUCKETS_DEV"
-      - ./gradlew hipchatSendNotification -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD -Pbranch=$CIRCLE_BRANCH
-      - ./gradlew hipchatShareFile -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD
+      - ./gradlew deployArchives -PsmartThingsArtifactoryUserName="$ARTIFACTORY_USERNAME" -PsmartThingsArtifactoryPassword="$ARTIFACTORY_PASSWORD" -Ps3Buckets="$S3_BUCKETS_DEV"
+      - ./gradlew slackSendMessage -PsmartThingsArtifactoryUserName="$ARTIFACTORY_USERNAME" -PsmartThingsArtifactoryPassword="$ARTIFACTORY_PASSWORD" -Pbranch="$CIRCLE_BRANCH" -PslackToken="$SLACK_TOKEN" -PslackWebhookUrl="$SLACK_WEBHOOK_URL" -PslackChannel="$SLACK_CHANNEL" --stacktrace
 
   stage:
     branch: staging
     commands:
-      - ./gradlew deployArchives -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD -Ps3Buckets="$S3_BUCKETS_STAGE"
-      - ./gradlew hipchatSendNotification -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD -Pbranch=$CIRCLE_BRANCH
-      - ./gradlew hipchatShareFile -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD
+      - ./gradlew deployArchives -PsmartThingsArtifactoryUserName="$ARTIFACTORY_USERNAME" -PsmartThingsArtifactoryPassword="$ARTIFACTORY_PASSWORD" -Ps3Buckets="$S3_BUCKETS_STAGE"
+      - ./gradlew slackSendMessage -PsmartThingsArtifactoryUserName="$ARTIFACTORY_USERNAME" -PsmartThingsArtifactoryPassword="$ARTIFACTORY_PASSWORD" -Pbranch="$CIRCLE_BRANCH" -PslackToken="$SLACK_TOKEN" -PslackWebhookUrl="$SLACK_WEBHOOK_URL" -PslackChannel="$SLACK_CHANNEL" --stacktrace

devicetypes/capabilities/acceleration-sensor-capability.src/acceleration-sensor-capability.groovy

@@ -23,8 +23,8 @@ metadata {
 
 	tiles {
 		standardTile("acceleration", "device.acceleration", width: 2, height: 2) {
-			state("inactive", label:'${name}', icon:"st.motion.acceleration.inactive", backgroundColor:"#ffffff")
-			state("active", label:'${name}', icon:"st.motion.acceleration.active", backgroundColor:"#53a7c0")
+			state("inactive", label:'${name}', icon:"st.motion.acceleration.inactive", backgroundColor:"#cccccc")
+			state("active", label:'${name}', icon:"st.motion.acceleration.active", backgroundColor:"#00A0DC")
 		}
 
 		main "acceleration"

devicetypes/capabilities/contact-sensor-capability.src/contact-sensor-capability.groovy

@@ -23,8 +23,8 @@ metadata {
 
 	tiles {
 		standardTile("contact", "device.contact", width: 2, height: 2) {
-			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
-			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
+			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#00A0DC")
+			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#e86d13")
 		}
 		main "contact"
 		details "contact"

devicetypes/capabilities/lock-capability.src/lock-capability.groovy

@@ -27,7 +27,7 @@ metadata {
 	tiles {
 		standardTile("toggle", "device.lock", width: 2, height: 2) {
 			state "unlocked", label:'unlocked', action:"lock.lock", icon:"st.locks.lock.unlocked", backgroundColor:"#ffffff"
-			state "locked", label:'locked', action:"lock.unlock", icon:"st.locks.lock.locked", backgroundColor:"#79b821"
+			state "locked", label:'locked', action:"lock.unlock", icon:"st.locks.lock.locked", backgroundColor:"#00A0DC"
 		}
 		standardTile("lock", "device.lock", inactiveLabel: false, decoration: "flat") {
 			state "default", label:'lock', action:"lock.lock", icon:"st.locks.lock.locked"

devicetypes/capabilities/momentary-capability.src/momentary-capability.groovy

@@ -29,7 +29,7 @@ metadata {
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
 			state "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "on"
-			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00A0DC"
 		}
 		main "switch"
 		details "switch"

devicetypes/capabilities/motion-sensor-capability.src/motion-sensor-capability.groovy

@@ -24,7 +24,7 @@ metadata {
 	tiles {
 		standardTile("motion", "device.motion", width: 2, height: 2) {
 			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff")
-			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0")
+			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC")
 		}
 		main "motion"
 		details "motion"

devicetypes/capabilities/presence-sensor-capability.src/presence-sensor-capability.groovy

@@ -24,7 +24,7 @@ metadata {
 	tiles {
 		standardTile("presence", "device.presence", width: 2, height: 2) {
 			state("not present", label:'not present', icon:"st.presence.tile.not-present", backgroundColor:"#ffffff")
-			state("present", label:'present', icon:"st.presence.tile.present", backgroundColor:"#53a7c0")
+			state("present", label:'present', icon:"st.presence.tile.present", backgroundColor:"#00A0DC")
 		}
 		main "presence"
 		details "presence"

devicetypes/capabilities/switch-capability.src/switch-capability.groovy

@@ -31,7 +31,7 @@ metadata {
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
 			state "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
-			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00A0DC"
 		}
 		main "switch"
 		details "switch"

devicetypes/capabilities/switch-level-capability.src/switch-level-capability.groovy

@@ -35,8 +35,8 @@ metadata {
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2) {
 			state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-			state "turningOn", label:'${name}', icon:"st.switches.switch.on", backgroundColor:"#79b821"
+			state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
+			state "turningOn", label:'${name}', icon:"st.switches.switch.on", backgroundColor:"#00A0DC"
 			state "turningOff", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ffffff"
 		}
 		controlTile("levelSliderControl", "device.level", "slider", height: 2, width: 1, inactiveLabel: false) {

devicetypes/capabilities/thermostat-capability.src/thermostat-capability.groovy

@@ -79,8 +79,8 @@ metadata {
 		standardTile("mode", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
 			state "off", label:'${name}', action:"thermostat.emergencyHeat", backgroundColor:"#ffffff"
 			state "emergencyHeat", label:'${name}', action:"thermostat.heat", backgroundColor:"#e86d13"
-			state "heat", label:'${name}', action:"thermostat.cool", backgroundColor:"#ffc000"
-			state "cool", label:'${name}', action:"thermostat.off", backgroundColor:"#269bd2"
+			state "heat", label:'${name}', action:"thermostat.cool", backgroundColor:"#e86d13"
+			state "cool", label:'${name}', action:"thermostat.off", backgroundColor:"#00A0DC"
 		}
 		standardTile("fanMode", "device.thermostatFanMode", inactiveLabel: false, decoration: "flat") {
 			state "fanAuto", label:'${name}', action:"thermostat.fanOn", backgroundColor:"#ffffff"

devicetypes/capabilities/water-sensor-capability.src/water-sensor-capability.groovy

@@ -24,7 +24,7 @@ metadata {
 	tiles {
 		standardTile("water", "device.water", width: 2, height: 2) {
 			state "dry", icon:"st.alarm.water.dry", backgroundColor:"#ffffff"
-			state "wet", icon:"st.alarm.water.wet", backgroundColor:"#53a7c0"
+			state "wet", icon:"st.alarm.water.wet", backgroundColor:"#00A0DC"
 		}
 
 		main "water"

devicetypes/com-obycode/beaconthing.src/beaconthing.groovy

@@ -37,7 +37,7 @@ metadata {
 
 	tiles {
 		standardTile("presence", "device.presence", width: 2, height: 2, canChangeBackground: true) {
-			state("present", labelIcon:"st.presence.tile.present", backgroundColor:"#53a7c0")
+			state("present", labelIcon:"st.presence.tile.present", backgroundColor:"#00A0DC")
 			state("not present", labelIcon:"st.presence.tile.not-present", backgroundColor:"#ffffff")
 		}
 		valueTile("inRange", "device.inRangeFriendly", inactiveLabel: true, height:1, width:3, decoration: "flat") {

devicetypes/com-obycode/obything-music.src/obything-music.groovy

@@ -38,7 +38,7 @@ metadata {
 		// Main
 		standardTile("main", "device.status", width: 1, height: 1, canChangeIcon: true) {
 			state "paused", label:'Paused', action:"music Player.play", icon:"st.Electronics.electronics19", nextState:"playing", backgroundColor:"#ffffff"
-			state "playing", label:'Playing', action:"music Player.pause", icon:"st.Electronics.electronics19", nextState:"paused", backgroundColor:"#79b821"
+			state "playing", label:'Playing', action:"music Player.pause", icon:"st.Electronics.electronics19", nextState:"paused", backgroundColor:"#00A0DC"
 		}
 
 		// Row 1

devicetypes/dianoga/netatmo-additional-module.src/netatmo-additional-module.groovy

@@ -15,6 +15,7 @@
  */
 metadata {
 	definition (name: "Netatmo Additional Module", namespace: "dianoga", author: "Brian Steere") {
+		capability "Sensor"
 		capability "Relative Humidity Measurement"
 		capability "Temperature Measurement"
 

devicetypes/dianoga/netatmo-basestation.src/netatmo-basestation.groovy

@@ -15,6 +15,7 @@
  */
 metadata {
 	definition (name: "Netatmo Basestation", namespace: "dianoga", author: "Brian Steere") {
+		capability "Sensor"
 		capability "Relative Humidity Measurement"
 		capability "Temperature Measurement"
 

devicetypes/dianoga/netatmo-outdoor-module.src/netatmo-outdoor-module.groovy

@@ -15,6 +15,7 @@
  */
 metadata {
 	definition (name: "Netatmo Outdoor Module", namespace: "dianoga", author: "Brian Steere") {
+		capability "Sensor"
 		capability "Relative Humidity Measurement"
 		capability "Temperature Measurement"
 	}

devicetypes/dianoga/netatmo-rain.src/netatmo-rain.groovy

@@ -15,6 +15,8 @@
  */
 metadata {
 	definition (name: "Netatmo Rain", namespace: "dianoga", author: "Brian Steere") {
+		capability "Sensor"
+	
 		attribute "rain", "number"
         attribute "rainSumHour", "number"
         attribute "rainSumDay", "number"

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

@@ -0,0 +1,272 @@
+/**
+ *  Fibaro Door/Window Sensor ZW5
+ *
+ *  Copyright 2016 Fibar Group S.A.
+ *
+ *  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: "Fibaro Door/Window Sensor ZW5 with Temperature", namespace: "fibargroup", author: "Fibar Group S.A.") {
+		capability "Battery"
+		capability "Contact Sensor"
+		capability "Sensor"
+        capability "Configuration"
+        capability "Tamper Alert"
+        
+        capability "Temperature Measurement"
+
+		fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x85, 0x59, 0x22, 0x20, 0x80, 0x70, 0x56, 0x5A, 0x7A, 0x72, 0x8E, 0x71, 0x73, 0x98, 0x2B, 0x9C, 0x30, 0x31, 0x86", outClusters: ""
+        fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x85, 0x59, 0x22, 0x20, 0x80, 0x70, 0x56, 0x5A, 0x7A, 0x72, 0x8E, 0x71, 0x73, 0x98, 0x2B, 0x9C, 0x30, 0x31, 0x86, 0x84", outClusters: ""//actual NIF
+	}
+
+	simulator {
+		
+	}
+    
+    tiles(scale: 2) {
+    	multiAttributeTile(name:"FGK", type:"lighting", width:6, height:4) {//with generic type secondary control text is not displayed in Android app
+        	tileAttribute("device.contact", key:"PRIMARY_CONTROL") {
+            	attributeState("open", icon:"st.contact.contact.open", backgroundColor:"#e86d13")
+                attributeState("closed", icon:"st.contact.contact.closed", backgroundColor:"#00a0dc")
+            }
+            
+            tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
+				attributeState("active", label:'tamper active', backgroundColor:"#53a7c0")
+				attributeState("inactive", label:'tamper inactive', backgroundColor:"#ffffff")
+			}  
+        }
+                
+        valueTile("battery", "device.battery", inactiveLabel: false, width: 2, height: 2, decoration: "flat") {
+            state "battery", label:'${currentValue}% battery', unit:""
+        }
+        
+        valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {
+			state "temperature", label:'${currentValue}°',
+			backgroundColors:[
+				[value: 31, color: "#153591"],
+				[value: 44, color: "#1e9cbb"],
+				[value: 59, color: "#90d2a7"],
+				[value: 74, color: "#44b621"],
+				[value: 84, color: "#f1d801"],
+				[value: 95, color: "#d04e00"],
+				[value: 96, color: "#bc2323"]
+			]
+		}
+        
+        main "FGK"
+        details(["FGK","battery", "temperature"])
+    }
+}
+
+// parse events into attributes
+def parse(String description) {
+	log.debug "Parsing '${description}'"   
+    def result = []
+    
+    if (description.startsWith("Err 106")) {
+		if (state.sec) {
+			result = createEvent(descriptionText:description, displayed:false)
+		} else {
+			result = createEvent(
+				descriptionText: "FGK failed to complete the network security key exchange. If you are unable to receive data from it, you must remove it from your network and add it again.",
+				eventType: "ALERT",
+				name: "secureInclusion",
+				value: "failed",
+				displayed: true,
+			)
+		}
+	} else if (description == "updated") {
+		return null
+	} else {
+    	def cmd = zwave.parse(description, [0x31: 5, 0x56: 1, 0x71: 3, 0x72: 2, 0x80: 1, 0x84: 2, 0x85: 2, 0x86: 1, 0x98: 1])
+    
+    	if (cmd) {
+    		log.debug "Parsed '${cmd}'"
+        	zwaveEvent(cmd)
+    	}
+    }
+}
+
+//security
+def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
+	def encapsulatedCommand = cmd.encapsulatedCommand([0x71: 3, 0x84: 2, 0x85: 2, 0x98: 1])
+	if (encapsulatedCommand) {
+		return zwaveEvent(encapsulatedCommand)
+	} else {
+		log.warn "Unable to extract encapsulated cmd from $cmd"
+		createEvent(descriptionText: cmd.toString())
+	}
+}
+
+//crc16
+def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd)
+{
+    def versions = [0x31: 5, 0x72: 2, 0x80: 1, 0x86: 1]
+	def version = versions[cmd.commandClass as Integer]
+	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
+	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
+	if (!encapsulatedCommand) {
+		log.debug "Could not extract command from $cmd"
+	} else {
+		zwaveEvent(encapsulatedCommand)
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
+	//it is assumed that default notification events are used
+    //(parameter 20 was not changed before device's re-inclusion)
+    def map = [:]
+    if (cmd.notificationType == 6) {
+    	switch (cmd.event) {                
+        	case 22:
+            	map.name = "contact"
+                map.value = "open"
+                map.descriptionText = "${device.displayName}: is open"
+            	break
+                
+            case 23:
+            	map.name = "contact"
+                map.value = "closed"
+                map.descriptionText = "${device.displayName}: is closed"
+            	break
+        }
+    } else if (cmd.notificationType == 7) {
+    	switch (cmd.event) {
+        	case 0:
+            	map.name = "tamper"
+                map.value = "inactive"
+                map.descriptionText = "${device.displayName}: tamper alarm has been deactivated"
+				break
+                
+        	case 3:
+            	map.name = "tamper"
+                map.value = "active"
+                map.descriptionText = "${device.displayName}: tamper alarm activated"
+            	break
+        }
+    }
+    
+    createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
+	def map = [:]
+	map.name = "battery"
+	map.value = cmd.batteryLevel == 255 ? 1 : cmd.batteryLevel.toString()
+	map.unit = "%"
+	map.displayed = true
+	createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd) {    
+    def event = createEvent(descriptionText: "${device.displayName} woke up", displayed: false)
+    def cmds = []
+    cmds << encap(zwave.batteryV1.batteryGet())
+    cmds << "delay 500"
+    cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0))
+    cmds << "delay 1200"
+    cmds << encap(zwave.wakeUpV1.wakeUpNoMoreInformation())
+    [event, response(cmds)]
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) { 
+	log.debug "manufacturerId:   ${cmd.manufacturerId}"
+    log.debug "manufacturerName: ${cmd.manufacturerName}"
+    log.debug "productId:        ${cmd.productId}"
+    log.debug "productTypeId:    ${cmd.productTypeId}"
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.DeviceSpecificReport cmd) { 
+	log.debug "deviceIdData:                ${cmd.deviceIdData}"
+    log.debug "deviceIdDataFormat:          ${cmd.deviceIdDataFormat}"
+    log.debug "deviceIdDataLengthIndicator: ${cmd.deviceIdDataLengthIndicator}"
+    log.debug "deviceIdType:                ${cmd.deviceIdType}"
+    
+    if (cmd.deviceIdType == 1 && cmd.deviceIdDataFormat == 1) {//serial number in binary format
+		String serialNumber = "h'"
+        
+        cmd.deviceIdData.each{ data ->
+        	serialNumber += "${String.format("%02X", data)}"
+        }
+        
+        updateDataValue("serialNumber", serialNumber)
+        log.debug "${device.displayName} - serial number: ${serialNumber}"
+    }
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {	
+    updateDataValue("version", "${cmd.applicationVersion}.${cmd.applicationSubVersion}")
+    log.debug "applicationVersion:      ${cmd.applicationVersion}"
+    log.debug "applicationSubVersion:   ${cmd.applicationSubVersion}"
+    log.debug "zWaveLibraryType:        ${cmd.zWaveLibraryType}"
+    log.debug "zWaveProtocolVersion:    ${cmd.zWaveProtocolVersion}"
+    log.debug "zWaveProtocolSubVersion: ${cmd.zWaveProtocolSubVersion}"
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd) {
+	def map = [:]
+	if (cmd.sensorType == 1) {
+        // temperature
+        def cmdScale = cmd.scale == 1 ? "F" : "C"
+        map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmdScale, cmd.precision)
+        map.unit = getTemperatureScale()
+        map.name = "temperature"
+        map.displayed = true
+	}
+	
+    createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLocallyNotification cmd) {
+	log.info "${device.displayName}: received command: $cmd - device has reset itself"
+}
+
+def configure() {
+	log.debug "Executing 'configure'"
+    
+    def cmds = []
+        
+    cmds += zwave.wakeUpV2.wakeUpIntervalSet(seconds:21600, nodeid: zwaveHubNodeId)//FGK's default wake up interval
+    cmds += zwave.manufacturerSpecificV2.manufacturerSpecificGet()
+    cmds += zwave.manufacturerSpecificV2.deviceSpecificGet()
+    cmds += zwave.versionV1.versionGet()
+    cmds += zwave.batteryV1.batteryGet()
+    cmds += zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0)
+    cmds += zwave.associationV2.associationSet(groupingIdentifier:1, nodeId: [zwaveHubNodeId])
+    cmds += zwave.wakeUpV2.wakeUpNoMoreInformation()
+    
+    encapSequence(cmds, 500)
+}
+
+private secure(physicalgraph.zwave.Command cmd) {
+	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
+}
+
+private crc16(physicalgraph.zwave.Command cmd) {
+	//zwave.crc16EncapV1.crc16Encap().encapsulate(cmd).format()
+    "5601${cmd.format()}0000"
+}
+
+private encapSequence(commands, delay=200) {
+	delayBetween(commands.collect{ encap(it) }, delay)
+}
+
+private encap(physicalgraph.zwave.Command cmd) {
+    def secureClasses = [0x20, 0x2B, 0x30, 0x5A, 0x70, 0x71, 0x84, 0x85, 0x8E, 0x9C]
+    
+    //todo: check if secure inclusion was successful
+    //if not do not send security-encapsulated command
+	if (secureClasses.find{ it == cmd.commandClassId }) {
+    	secure(cmd)
+    } else {
+    	crc16(cmd)
+    }
+}

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

@@ -0,0 +1,239 @@
+/**
+ *  Fibaro Door/Window Sensor ZW5
+ *
+ *  Copyright 2016 Fibar Group S.A.
+ *
+ *  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: "Fibaro Door/Window Sensor ZW5", namespace: "fibargroup", author: "Fibar Group S.A.") {
+		capability "Battery"
+		capability "Contact Sensor"
+		capability "Sensor"
+        capability "Configuration"
+        capability "Tamper Alert"
+
+        fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x85, 0x59, 0x22, 0x20, 0x80, 0x70, 0x56, 0x5A, 0x7A, 0x72, 0x8E, 0x71, 0x73, 0x98, 0x2B, 0x9C, 0x30, 0x86, 0x84", outClusters: ""
+	}
+
+	simulator {
+		
+	}
+        
+    tiles(scale: 2) {
+    	multiAttributeTile(name:"FGK", type:"lighting", width:6, height:4) {//with generic type secondary control text is not displayed in Android app
+        	tileAttribute("device.contact", key:"PRIMARY_CONTROL") {
+            	attributeState("open", icon:"st.contact.contact.open", backgroundColor:"#e86d13")
+                attributeState("closed", icon:"st.contact.contact.closed", backgroundColor:"#00a0dc")
+            }
+            
+            tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
+				attributeState("active", label:'tamper active', backgroundColor:"#53a7c0")
+				attributeState("inactive", label:'tamper inactive', backgroundColor:"#ffffff")
+			}  
+        }
+                
+        valueTile("battery", "device.battery", inactiveLabel: false, width: 2, height: 2, decoration: "flat") {
+            state "battery", label:'${currentValue}% battery', unit:""
+        }
+        
+        main "FGK"
+        details(["FGK","battery"])
+    }
+}
+
+// parse events into attributes
+def parse(String description) {
+	log.debug "Parsing '${description}'"   
+    def result = []
+    
+    if (description.startsWith("Err 106")) {
+		if (state.sec) {
+			result = createEvent(descriptionText:description, displayed:false)
+		} else {
+			result = createEvent(
+				descriptionText: "FGK failed to complete the network security key exchange. If you are unable to receive data from it, you must remove it from your network and add it again.",
+				eventType: "ALERT",
+				name: "secureInclusion",
+				value: "failed",
+				displayed: true,
+			)
+		}
+	} else if (description == "updated") {
+		return null
+	} else {
+    	def cmd = zwave.parse(description, [0x56: 1, 0x71: 3, 0x72: 2, 0x80: 1, 0x84: 2, 0x85: 2, 0x86: 1, 0x98: 1])
+    
+    	if (cmd) {
+    		log.debug "Parsed '${cmd}'"
+        	zwaveEvent(cmd)
+    	}
+    }
+}
+
+//security
+def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
+	def encapsulatedCommand = cmd.encapsulatedCommand([0x71: 3, 0x84: 2, 0x85: 2, 0x98: 1])
+	if (encapsulatedCommand) {
+		return zwaveEvent(encapsulatedCommand)
+	} else {
+		log.warn "Unable to extract encapsulated cmd from $cmd"
+		createEvent(descriptionText: cmd.toString())
+	}
+}
+
+//crc16
+def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd)
+{
+    def versions = [0x72: 2, 0x80: 1, 0x86: 1]
+	def version = versions[cmd.commandClass as Integer]
+	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
+	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
+	if (!encapsulatedCommand) {
+		log.debug "Could not extract command from $cmd"
+	} else {
+		zwaveEvent(encapsulatedCommand)
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
+	//it is assumed that default notification events are used
+    //(parameter 20 was not changed before device's re-inclusion)
+    def map = [:]
+    if (cmd.notificationType == 6) {
+    	switch (cmd.event) {                
+        	case 22:
+            	map.name = "contact"
+                map.value = "open"
+                map.descriptionText = "${device.displayName}: is open"
+            	break
+                
+            case 23:
+            	map.name = "contact"
+                map.value = "closed"
+                map.descriptionText = "${device.displayName}: is closed"
+            	break
+        }
+    } else if (cmd.notificationType == 7) {
+    	switch (cmd.event) {
+        	case 0:
+            	map.name = "tamper"
+                map.value = "inactive"
+                map.descriptionText = "${device.displayName}: tamper alarm has been deactivated"
+				break
+                
+        	case 3:
+            	map.name = "tamper"
+                map.value = "active"
+                map.descriptionText = "${device.displayName}: tamper alarm activated"
+            	break
+        }
+    }
+    
+    createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
+	def map = [:]
+	map.name = "battery"
+	map.value = cmd.batteryLevel == 255 ? 1 : cmd.batteryLevel.toString()
+	map.unit = "%"
+	map.displayed = true
+	createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd) {    
+    def event = createEvent(descriptionText: "${device.displayName} woke up", displayed: false)
+    def cmds = []
+    cmds << encap(zwave.batteryV1.batteryGet())
+    cmds << "delay 1200"
+    cmds << encap(zwave.wakeUpV1.wakeUpNoMoreInformation())
+    [event, response(cmds)]
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) { 
+	log.debug "manufacturerId:   ${cmd.manufacturerId}"
+    log.debug "manufacturerName: ${cmd.manufacturerName}"
+    log.debug "productId:        ${cmd.productId}"
+    log.debug "productTypeId:    ${cmd.productTypeId}"
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.DeviceSpecificReport cmd) { 
+	log.debug "deviceIdData:                ${cmd.deviceIdData}"
+    log.debug "deviceIdDataFormat:          ${cmd.deviceIdDataFormat}"
+    log.debug "deviceIdDataLengthIndicator: ${cmd.deviceIdDataLengthIndicator}"
+    log.debug "deviceIdType:                ${cmd.deviceIdType}"
+    
+    if (cmd.deviceIdType == 1 && cmd.deviceIdDataFormat == 1) {//serial number in binary format
+		String serialNumber = "h'"
+        
+        cmd.deviceIdData.each{ data ->
+        	serialNumber += "${String.format("%02X", data)}"
+        }
+        
+        updateDataValue("serialNumber", serialNumber)
+        log.debug "${device.displayName} - serial number: ${serialNumber}"
+    }
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {	
+    updateDataValue("version", "${cmd.applicationVersion}.${cmd.applicationSubVersion}")
+    log.debug "applicationVersion:      ${cmd.applicationVersion}"
+    log.debug "applicationSubVersion:   ${cmd.applicationSubVersion}"
+    log.debug "zWaveLibraryType:        ${cmd.zWaveLibraryType}"
+    log.debug "zWaveProtocolVersion:    ${cmd.zWaveProtocolVersion}"
+    log.debug "zWaveProtocolSubVersion: ${cmd.zWaveProtocolSubVersion}"
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLocallyNotification cmd) {
+	log.info "${device.displayName}: received command: $cmd - device has reset itself"
+}
+
+def configure() {
+	log.debug "Executing 'configure'"
+    
+    def cmds = []
+    
+    cmds += zwave.wakeUpV2.wakeUpIntervalSet(seconds:21600, nodeid: zwaveHubNodeId)//FGK's default wake up interval
+    cmds += zwave.manufacturerSpecificV2.manufacturerSpecificGet()
+    cmds += zwave.manufacturerSpecificV2.deviceSpecificGet()
+    cmds += zwave.versionV1.versionGet()
+    cmds += zwave.batteryV1.batteryGet()
+    cmds += zwave.associationV2.associationSet(groupingIdentifier:1, nodeId: [zwaveHubNodeId])
+    cmds += zwave.wakeUpV2.wakeUpNoMoreInformation()
+    
+    encapSequence(cmds, 500)
+}
+
+private secure(physicalgraph.zwave.Command cmd) {
+	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
+}
+
+private crc16(physicalgraph.zwave.Command cmd) {
+	//zwave.crc16EncapV1.crc16Encap().encapsulate(cmd).format()
+    "5601${cmd.format()}0000"
+}
+
+private encapSequence(commands, delay=200) {
+	delayBetween(commands.collect{ encap(it) }, delay)
+}
+
+private encap(physicalgraph.zwave.Command cmd) {
+    def secureClasses = [0x20, 0x2B, 0x30, 0x5A, 0x70, 0x71, 0x84, 0x85, 0x8E, 0x9C]
+    
+    //todo: check if secure inclusion was successful
+    //if not do not send security-encapsulated command
+	if (secureClasses.find{ it == cmd.commandClassId }) {
+    	secure(cmd)
+    } else {
+    	crc16(cmd)
+    }
+}

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

@@ -0,0 +1,286 @@
+/**
+ *  Fibaro Flood Sensor ZW5
+ *
+ *  Copyright 2016 Fibar Group S.A.
+ *
+ *  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: "Fibaro Flood Sensor ZW5", namespace: "fibargroup", author: "Fibar Group S.A.") {
+		capability "Battery"
+		capability "Configuration"
+		capability "Sensor"
+		capability "Tamper Alert"
+		capability "Temperature Measurement"
+		capability "Water Sensor"
+		capability "Health Check"
+
+		fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x22, 0x85, 0x59, 0x20, 0x80, 0x70, 0x56, 0x5A, 0x7A, 0x72, 0x8E, 0x71, 0x73, 0x98, 0x9C, 0x31, 0x86", outClusters: ""
+		fingerprint mfr:"010F", prod:"0B01", model:"2002"
+		fingerprint mfr:"010F", prod:"0B01", model:"1002"
+	}
+
+	simulator {
+	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name:"FGFS", type:"lighting", width:6, height:4) {//with generic type secondary control text is not displayed in Android app
+			tileAttribute("device.water", key:"PRIMARY_CONTROL") {
+				attributeState("dry", icon:"st.alarm.water.dry", backgroundColor:"#00a0dc")
+				attributeState("wet", icon:"st.alarm.water.wet", backgroundColor:"#e86d13")
+			}
+			
+			tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
+				attributeState("active", label:'tamper active', backgroundColor:"#00a0dc")
+				attributeState("inactive", label:'tamper inactive', backgroundColor:"#cccccc")
+			}
+		}
+		
+		valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {
+			state "temperature", label:'${currentValue}°',
+			backgroundColors:[
+				[value: 31, color: "#153591"],
+				[value: 44, color: "#1e9cbb"],
+				[value: 59, color: "#90d2a7"],
+				[value: 74, color: "#44b621"],
+				[value: 84, color: "#f1d801"],
+				[value: 95, color: "#d04e00"],
+				[value: 96, color: "#bc2323"]
+			]
+		}
+
+		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "battery", label:'${currentValue}% battery', unit:""
+		}
+
+		main "FGFS"
+		details(["FGFS","battery", "temperature"])
+	}
+}
+
+// parse events into attributes
+def parse(String description) {
+	log.debug "Parsing '${description}'"
+	def result = []
+
+	if (description.startsWith("Err 106")) {
+		if (state.sec) {
+			result = createEvent(descriptionText:description, displayed:false)
+		} else {
+			result = createEvent(
+				descriptionText: "FGFS failed to complete the network security key exchange. If you are unable to receive data from it, you must remove it from your network and add it again.",
+				eventType: "ALERT",
+				name: "secureInclusion",
+				value: "failed",
+				displayed: true,
+			)
+		}
+	} else if (description == "updated") {
+		return null
+	} else {
+		def cmd = zwave.parse(description, [0x31: 5, 0x56: 1, 0x71: 3, 0x72:2, 0x80: 1, 0x84: 2, 0x85: 2, 0x86: 1, 0x98: 1])
+
+		if (cmd) {
+			log.debug "Parsed '${cmd}'"
+			zwaveEvent(cmd)
+		}
+	}
+}
+
+//security
+def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
+	def encapsulatedCommand = cmd.encapsulatedCommand([0x71: 3, 0x84: 2, 0x85: 2, 0x86: 1, 0x98: 1])
+	if (encapsulatedCommand) {
+		return zwaveEvent(encapsulatedCommand)
+	} else {
+		log.warn "Unable to extract encapsulated cmd from $cmd"
+		createEvent(descriptionText: cmd.toString())
+	}
+}
+
+//crc16
+def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd)
+{
+	def versions = [0x31: 5, 0x72: 2, 0x80: 1]
+	def version = versions[cmd.commandClass as Integer]
+	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
+	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
+	if (!encapsulatedCommand) {
+		log.debug "Could not extract command from $cmd"
+	} else {
+		zwaveEvent(encapsulatedCommand)
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd)
+{
+	def event = createEvent(descriptionText: "${device.displayName} woke up", displayed: false)
+	def cmds = []
+	// cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0))
+	// cmds << "delay 500"
+	cmds << encap(zwave.batteryV1.batteryGet())
+	[event, response(cmds)]
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) { 
+	log.debug "manufacturerId:   ${cmd.manufacturerId}"
+	log.debug "manufacturerName: ${cmd.manufacturerName}"
+	log.debug "productId:        ${cmd.productId}"
+	log.debug "productTypeId:    ${cmd.productTypeId}"
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.DeviceSpecificReport cmd) { 
+	log.debug "deviceIdData:                ${cmd.deviceIdData}"
+	log.debug "deviceIdDataFormat:          ${cmd.deviceIdDataFormat}"
+	log.debug "deviceIdDataLengthIndicator: ${cmd.deviceIdDataLengthIndicator}"
+	log.debug "deviceIdType:                ${cmd.deviceIdType}"
+
+	if (cmd.deviceIdType == 1 && cmd.deviceIdDataFormat == 1) { //serial number in binary format
+		String serialNumber = "h'"
+
+		cmd.deviceIdData.each{ data ->
+			serialNumber += "${String.format("%02X", data)}"
+		}
+
+		updateDataValue("serialNumber", serialNumber)
+		log.debug "${device.displayName} - serial number: ${serialNumber}"
+	}
+
+	def response_cmds = []
+	if (!device.currentState("temperature")) {
+		response_cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0))
+	}
+	if (!getDataValue("version") && !zwaveInfo.ver) {
+		log.debug "Requesting Version Report"
+		response_cmds << "delay 500"
+		response_cmds << encap(zwave.versionV1.versionGet())
+	}
+	response_cmds << "delay 1000"
+	response_cmds << encap(zwave.wakeUpV2.wakeUpNoMoreInformation())
+	[[:], response(response_cmds)]
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {
+	updateDataValue("version", "${cmd.applicationVersion}.${cmd.applicationSubVersion}")
+	log.debug "applicationVersion:      ${cmd.applicationVersion}"
+	log.debug "applicationSubVersion:   ${cmd.applicationSubVersion}"
+	log.debug "zWaveLibraryType:        ${cmd.zWaveLibraryType}"
+	log.debug "zWaveProtocolVersion:    ${cmd.zWaveProtocolVersion}"
+	log.debug "zWaveProtocolSubVersion: ${cmd.zWaveProtocolSubVersion}"
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
+	def result = []
+	def map = [:]
+	map.name = "battery"
+	map.value = cmd.batteryLevel == 255 ? 1 : cmd.batteryLevel.toString()
+	map.unit = "%"
+
+	result << createEvent(map)
+
+	if (!getDataValue("serialNumber")) {
+		result << response(encap(zwave.manufacturerSpecificV2.deviceSpecificGet()))
+	} else {
+		result << response(encap(zwave.wakeUpV2.wakeUpNoMoreInformation()))
+	}
+	result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
+	def map = [:]
+	if (cmd.notificationType == 5) {
+		switch (cmd.event) {
+			case 2:
+				map.name = "water"
+				map.value = "wet"
+				map.descriptionText = "${device.displayName} is ${map.value}"
+				break
+
+			case 0:
+				map.name = "water"
+				map.value = "dry"
+				map.descriptionText = "${device.displayName} is ${map.value}"
+				break
+		}
+	} else if (cmd.notificationType == 7) {
+		switch (cmd.event) {
+			case 0:
+				map.name = "tamper"
+				map.value = "inactive"
+				map.descriptionText = "${device.displayName}: tamper alarm has been deactivated"
+				break
+
+			case 3:
+				map.name = "tamper"
+				map.value = "active"
+				map.descriptionText = "${device.displayName}: tamper alarm activated"
+				break
+		}
+	}
+
+	createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd) {
+	def map = [:]
+	if (cmd.sensorType == 1) {
+		// temperature
+		def cmdScale = cmd.scale == 1 ? "F" : "C"
+		map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmdScale, cmd.precision)
+		map.unit = getTemperatureScale()
+		map.name = "temperature"
+		map.displayed = true
+	}
+
+	createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLocallyNotification cmd) {
+	log.info "${device.displayName}: received command: $cmd - device has reset itself"
+}
+
+def configure() {
+	log.debug "Executing 'configure'"
+	// Device wakes up every 4 hours, this interval of 8h 2m allows us to miss one wakeup notification before marking offline
+	sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+
+	// default initial state
+	sendEvent(name: "water", value: "dry")
+
+	def cmds = []
+
+	cmds << zwave.associationV2.associationSet(groupingIdentifier:1, nodeId: [zwaveHubNodeId])
+	cmds << zwave.batteryV1.batteryGet()  // other queries sent as response to BatteryReport
+
+	encapSequence(cmds, 200)
+}
+
+private secure(physicalgraph.zwave.Command cmd) {
+	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
+}
+
+private crc16(physicalgraph.zwave.Command cmd) {
+	//zwave.crc16EncapV1.crc16Encap().encapsulate(cmd).format()
+	"5601${cmd.format()}0000"
+}
+
+private encapSequence(commands, delay=200) {
+	delayBetween(commands.collect{ encap(it) }, delay)
+}
+
+private encap(physicalgraph.zwave.Command cmd) {
+	if (zwaveInfo.zw && !zwaveInfo.zw.contains("s")) {
+		// Secure inclusion failed
+		crc16(cmd)
+	} else {
+		secure(cmd)
+	}
+}

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

@@ -0,0 +1,285 @@
+/**
+ *  Fibaro Motion Sensor ZW5
+ *
+ *  Copyright 2016 Fibar Group S.A.
+ *
+ *  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: "Fibaro Motion Sensor ZW5", namespace: "fibargroup", author: "Fibar Group S.A.") {
+		capability "Battery"
+		capability "Configuration"
+		capability "Illuminance Measurement"
+		capability "Motion Sensor"
+		capability "Sensor"
+		capability "Tamper Alert"
+		capability "Temperature Measurement"
+		capability "Health Check"
+        
+        fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x20, 0x86, 0x72, 0x5A, 0x59, 0x85, 0x73, 0x84, 0x80, 0x71, 0x56, 0x70, 0x31, 0x8E, 0x22, 0x30, 0x9C, 0x98, 0x7A", outClusters: ""
+	}
+    
+	simulator {
+		
+    }
+    
+    tiles(scale: 2) {
+    	multiAttributeTile(name:"FGMS", type:"lighting", width:6, height:4) {//with generic type secondary control text is not displayed in Android app
+        	tileAttribute("device.motion", key:"PRIMARY_CONTROL") {
+            	attributeState("inactive", label:"no motion", icon:"st.motion.motion.inactive", backgroundColor:"#79b821")
+            	attributeState("active", label:"motion", icon:"st.motion.motion.active", backgroundColor:"#ffa81e")   
+            }
+            
+            tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
+				attributeState("active", label:'tamper active', backgroundColor:"#00a0dc")
+				attributeState("inactive", label:'tamper inactive', backgroundColor:"#cccccc")
+			}  
+        }
+        
+        valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {
+			state "temperature", label:'${currentValue}°',
+			backgroundColors:[
+				[value: 31, color: "#153591"],
+				[value: 44, color: "#1e9cbb"],
+				[value: 59, color: "#90d2a7"],
+				[value: 74, color: "#44b621"],
+				[value: 84, color: "#f1d801"],
+				[value: 95, color: "#d04e00"],
+				[value: 96, color: "#bc2323"]
+			]
+		}
+        
+        valueTile("illuminance", "device.illuminance", inactiveLabel: false, width: 2, height: 2) {
+			state "luminosity", label:'${currentValue} ${unit}', unit:"lux"
+		}
+        
+        valueTile("battery", "device.battery", inactiveLabel: false, width: 2, height: 2, decoration: "flat") {
+            state "battery", label:'${currentValue}% battery', unit:""
+        }
+        
+        main "FGMS"
+        details(["FGMS","battery","temperature","illuminance"])
+    }
+}
+
+// parse events into attributes
+def parse(String description) {
+	log.debug "Parsing '${description}'"        
+    def result = []
+    
+    if (description.startsWith("Err 106")) {
+		if (state.sec) {
+			result = createEvent(descriptionText:description, displayed:false)
+		} else {
+			result = createEvent(
+				descriptionText: "FGK failed to complete the network security key exchange. If you are unable to receive data from it, you must remove it from your network and add it again.",
+				eventType: "ALERT",
+				name: "secureInclusion",
+				value: "failed",
+				displayed: true,
+			)
+		}
+	} else if (description == "updated") {
+		return null
+	} else {
+    	def cmd = zwave.parse(description, [0x31: 5, 0x56: 1, 0x71: 3, 0x72: 2, 0x80: 1, 0x84: 2, 0x85: 2, 0x86: 1, 0x98: 1])
+    
+    	if (cmd) {
+    		log.debug "Parsed '${cmd}'"
+        	zwaveEvent(cmd)
+    	}
+    }
+}
+
+//security
+def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
+	def encapsulatedCommand = cmd.encapsulatedCommand([0x71: 3, 0x84: 2, 0x85: 2, 0x86: 1, 0x98: 1])
+	if (encapsulatedCommand) {
+		return zwaveEvent(encapsulatedCommand)
+	} else {
+		log.warn "Unable to extract encapsulated cmd from $cmd"
+		createEvent(descriptionText: cmd.toString())
+	}
+}
+
+//crc16
+def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd)
+{
+    def versions = [0x31: 5, 0x71: 3, 0x72: 2, 0x80: 1, 0x84: 2, 0x85: 2, 0x86: 1]
+	def version = versions[cmd.commandClass as Integer]
+	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
+	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
+	if (!encapsulatedCommand) {
+		log.debug "Could not extract command from $cmd"
+	} else {
+		zwaveEvent(encapsulatedCommand)
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd) {
+	def map = [ displayed: true ]
+    switch (cmd.sensorType) {
+    	case 1:
+			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"
+            map.value = cmd.scaledSensorValue.toInteger().toString()
+            map.unit = "lux"
+            break
+    }
+
+	createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
+	def map = [:]
+    if (cmd.notificationType == 7) {
+    	switch (cmd.event) {
+        	case 0:
+            	if (cmd.eventParameter[0] == 3) {
+            		map.name = "tamper"
+                    map.value = "inactive"
+                    map.descriptionText = "${device.displayName}: tamper alarm has been deactivated"
+            	}
+            	if (cmd.eventParameter[0] == 8) {
+                	map.name = "motion"
+                    map.value = "inactive"
+                    map.descriptionText = "${device.displayName}: motion has stopped"
+                }
+        		break
+                
+        	case 3:
+            	map.name = "tamper"
+                map.value = "active"
+                map.descriptionText = "${device.displayName}: tamper alarm activated"
+            	break
+                
+            case 8:
+                map.name = "motion"
+                map.value = "active"
+                map.descriptionText = "${device.displayName}: motion detected"
+                break
+        }
+    }
+    
+    createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
+	def map = [:]
+	map.name = "battery"
+	map.value = cmd.batteryLevel == 255 ? 1 : cmd.batteryLevel.toString()
+	map.unit = "%"
+	map.displayed = true
+	createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd)
+{
+	def event = createEvent(descriptionText: "${device.displayName} woke up", displayed: false)
+    def cmds = []
+    cmds << encap(zwave.batteryV1.batteryGet())
+    cmds << "delay 500"
+    cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0))
+    cmds << "delay 500"
+    cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 3, scale: 1))     
+    cmds << "delay 1200"
+    cmds << encap(zwave.wakeUpV1.wakeUpNoMoreInformation())
+    [event, response(cmds)]
+    
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) { 
+	log.debug "manufacturerId:   ${cmd.manufacturerId}"
+    log.debug "manufacturerName: ${cmd.manufacturerName}"
+    log.debug "productId:        ${cmd.productId}"
+    log.debug "productTypeId:    ${cmd.productTypeId}"
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.DeviceSpecificReport cmd) { 
+	log.debug "deviceIdData:                ${cmd.deviceIdData}"
+    log.debug "deviceIdDataFormat:          ${cmd.deviceIdDataFormat}"
+    log.debug "deviceIdDataLengthIndicator: ${cmd.deviceIdDataLengthIndicator}"
+    log.debug "deviceIdType:                ${cmd.deviceIdType}"
+    
+    if (cmd.deviceIdType == 1 && cmd.deviceIdDataFormat == 1) {//serial number in binary format
+		String serialNumber = "h'"
+        
+        cmd.deviceIdData.each{ data ->
+        	serialNumber += "${String.format("%02X", data)}"
+        }
+        
+        updateDataValue("serialNumber", serialNumber)
+        log.debug "${device.displayName} - serial number: ${serialNumber}"
+    }
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {	
+    updateDataValue("version", "${cmd.applicationVersion}.${cmd.applicationSubVersion}")
+    log.debug "applicationVersion:      ${cmd.applicationVersion}"
+    log.debug "applicationSubVersion:   ${cmd.applicationSubVersion}"
+    log.debug "zWaveLibraryType:        ${cmd.zWaveLibraryType}"
+    log.debug "zWaveProtocolVersion:    ${cmd.zWaveProtocolVersion}"
+    log.debug "zWaveProtocolSubVersion: ${cmd.zWaveProtocolSubVersion}"
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLocallyNotification cmd) {
+	log.info "${device.displayName}: received command: $cmd - device has reset itself"
+}
+
+def configure() {
+	log.debug "Executing 'configure'"
+	// Device-Watch simply pings if no device events received for 8 hrs & 2 minutes
+	sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+
+    def cmds = []
+    
+    cmds += zwave.wakeUpV2.wakeUpIntervalSet(seconds: 7200, nodeid: zwaveHubNodeId)//FGMS' default wake up interval
+    cmds += zwave.manufacturerSpecificV2.manufacturerSpecificGet()
+    cmds += zwave.manufacturerSpecificV2.deviceSpecificGet()
+    cmds += zwave.versionV1.versionGet()
+    cmds += zwave.associationV2.associationSet(groupingIdentifier:1, nodeId:[zwaveHubNodeId])
+    cmds += zwave.batteryV1.batteryGet()
+    cmds += zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0)
+    cmds += zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 3, scale: 1)
+    cmds += zwave.wakeUpV2.wakeUpNoMoreInformation()
+    
+    encapSequence(cmds, 500)
+}
+
+private secure(physicalgraph.zwave.Command cmd) {
+	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
+}
+
+private crc16(physicalgraph.zwave.Command cmd) {
+	//zwave.crc16encapV1.crc16Encap().encapsulate(cmd).format()
+    "5601${cmd.format()}0000"
+}
+
+private encapSequence(commands, delay=200) {
+	delayBetween(commands.collect{ encap(it) }, delay)
+}
+
+private encap(physicalgraph.zwave.Command cmd) {
+	def secureClasses = [0x20, 0x30, 0x5A, 0x70, 0x71, 0x84, 0x85, 0x8E, 0x9C]
+
+	//todo: check if secure inclusion was successful
+    //if not do not send security-encapsulated command
+	if (secureClasses.find{ it == cmd.commandClassId }) {
+    	secure(cmd)
+    } else {
+    	crc16(cmd)
+    }
+}

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

@@ -0,0 +1,795 @@
+/**
+ *  CoopBoss H3Vx
+ *	02/29/16	Fixed app crash with Android by changing the syntax of default state in tile definition. 
+ *				Fixed null value errors during join process.  Added 3 new commands to refresh data.
+ *
+ *	01/18/16	Masked invalid temperature reporting when TempProbe1 is below 0C
+ *				Added setBaseCurrentNE, readBaseCurrentNE, commands as well as baseCurrentNE attribute.  
+ *
+ *  Copyright 2016 John Rucker
+ *
+ *  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.
+ *  Icon location = http://scripts.3dgo.net/smartthings/icons/
+ */
+metadata {
+	definition (name: "CoopBoss H3Vx", namespace: "JohnRucker", author: "John.Rucker@Solar-Current.com") {
+        capability "Refresh"
+        capability "Polling"
+        capability "Sensor"
+        capability "Actuator"
+        capability "Configuration"
+		capability "Temperature Measurement"   
+        capability "Door Control"
+  		capability "Switch"
+        
+        command "closeDoor"
+        command "closeDoorHiI"
+        command "openDoor"
+        command "autoCloseOn"
+        command "autoCloseOff"
+        command "autoOpenOn"
+        command "autoOpenOff"
+        command "setCloseLevelTo"
+        command "setOpenLevelTo" 
+        command "setSensitivityLevel"
+        command "Aux1On"
+        command "Aux1Off"        
+        command "Aux2On"
+        command "Aux2Off" 
+        command "updateTemp1"
+        command "updateTemp2"
+        command "updateSun"
+        command "setNewBaseCurrent"
+        command "setNewPhotoCalibration"
+        command "readNewPhotoCalibration"
+        command "readBaseCurrentNE"
+        command "setBaseCurrentNE"
+        command "updateSensitivity"
+        command "updateCloseLightLevel"
+        command "updateOpenLightLevel"
+
+        attribute "doorState","string"
+        attribute "currentLightLevel","number"
+        attribute "closeLightLevel","number"
+        attribute "openLightLevel","number"
+        attribute "autoCloseEnable","string" 
+        attribute "autoOpenEnable","string"
+        attribute "TempProb1","number"
+        attribute "TempProb2","number"   
+        attribute "dayOrNight","string"
+        attribute "doorSensitivity","number"
+        attribute "doorCurrent","number"  
+        attribute "doorVoltage","number"
+        attribute "Aux1","string"
+        attribute "Aux2","string"
+        attribute "coopStatus","string"
+        attribute "baseDoorCurrent","number"
+        attribute "photoCalibration","number"
+        attribute "baseCurrentNE","string"
+        
+    	fingerprint profileId: "0104", inClusters: "0000,0101,0402", manufacturer: "Solar-Current", model: "Coop Boss"
+    
+	}
+
+	// simulator metadata
+	simulator {
+    }
+    
+    
+	preferences {
+		input description: "This feature allows you to correct any temperature variations by selecting an offset. Ex: If your sensor consistently reports a temp that's 5 degrees too warm, you'd enter \"-5\". If 3 degrees too cold, enter \"+3\".", displayDuringSetup: false, type: "paragraph", element: "paragraph"
+		input "tempOffsetCoop", "number", title: "Coop Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+		input "tempOffsetOutside", "number", title: "Outside Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false        
+	}    
+       
+
+	// UI tile definitions
+	tiles(scale: 2){        
+		multiAttributeTile(name:"doorCtrl", type:"generic", width:6, height:4) {tileAttribute("device.doorState", key: "PRIMARY_CONTROL") 
+        	{  
+			attributeState "unknown", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", nextState:"Sent"          
+			attributeState "open", label: '${name}', action:"closeDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#0000ff" , nextState:"Sent" 
+			attributeState "opening", label: '${name}', action:"closeDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ffa81e"            
+			attributeState "closed", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#79b821", nextState:"Sent" 
+			attributeState "closing", label: '${name}', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ffa81e" 
+			attributeState "jammed", label: '${name}', action:"closeDoorHiI", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff0000", nextState:"Sent" 
+			attributeState "forced close", label: 'forced\rclose', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff8000", nextState:"Sent"   
+			attributeState "fault", label: 'FAULT', action:"openDoor", icon: "st.Outdoor.outdoor20", backgroundColor: "#ff0000", nextState:"Sent"              
+			attributeState "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"              
+			} 
+            tileAttribute ("device.coopStatus", key: "SECONDARY_CONTROL") {
+				attributeState "device.coopStatus", label:'${currentValue}'
+			}
+        }
+                     
+		multiAttributeTile(name:"dtlsDoorCtrl", type:"generic", width:6, height:4) {tileAttribute("device.doorState", key: "PRIMARY_CONTROL") 
+        	{
+      		attributeState "unknown", label: '${name}', action:"openDoor", icon: "st.secondary.tools", nextState:"Sent"
+      		attributeState "open", label: '${name}', action:"closeDoor", icon: "st.doors.garage.garage-open", backgroundColor: "#00A0DC", nextState:"Sent"
+            attributeState "opening", label: '${name}', action:"closeDoor", icon: "st.doors.garage.garage-opening", backgroundColor: "#00A0DC"
+            attributeState "closed", label: '${name}', action:"openDoor", icon: "st.doors.garage.garage-closed", backgroundColor: "#ffffff", nextState:"Sent"
+            attributeState "closing", label: '${name}', action:"openDoor", icon: "st.doors.garage.garage-closing", backgroundColor: "#ffffff"
+            attributeState "jammed", label: '${name}', action:"closeDoorHiI", icon: "st.doors.garage.garage-open", backgroundColor: "#ff0000", nextState:"Sent"
+            attributeState "forced close", label: "forced", action:"openDoor", icon: "st.doors.garage.garage-closed", backgroundColor: "#ff8000", nextState:"Sent"
+            attributeState "fault", label: 'FAULT', action:"openDoor", icon: "st.secondary.tools", backgroundColor: "#ff0000", nextState:"Sent"  
+            attributeState "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"
+            } 
+            tileAttribute ("device.doorState", key: "SECONDARY_CONTROL") {
+				attributeState "unknown", label: 'Door is in unknown state. Push to open.'
+                attributeState "open", label: 'Coop door is open. Push to close.'
+                attributeState "opening", label: 'Caution, door is opening!'
+                attributeState "closed", label: 'Coop door is closed. Push to open.'
+                attributeState "closing", label: 'Caution, door is closing!'
+                attributeState "jammed", label: 'Door open! Push for high-force close'
+                attributeState "forced close", label: "Door is closed. Push to open."
+                attributeState "fault", label: 'Door fault check electrical connection.'
+                attributeState "Sent", label: 'Command sent to CoopBoss...'
+			}                 
+    	}        
+        
+		standardTile("autoClose", "device.autoCloseEnable", width: 2, height: 2){
+			state "on", label: 'Auto', action:"autoCloseOff", icon: "st.doors.garage.garage-closing", backgroundColor: "#79b821", nextState:"Sent"
+			state "off", label: 'Auto', action:"autoCloseOn", icon: "st.doors.garage.garage-closing", nextState:"Sent"
+			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"              
+		}    
+        
+		standardTile("autoOpen", "device.autoOpenEnable", width: 2, height: 2){
+			state "on", label: 'Auto', action:"autoOpenOff", icon: "st.doors.garage.garage-opening", backgroundColor: "#79b821", nextState:"Sent"
+			state "off", label: 'Auto', action:"autoOpenOn", icon: "st.doors.garage.garage-opening", nextState:"Sent"
+			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"              
+		}            
+        
+		valueTile("TempProb1", "device.TempProb1", width: 2, height: 2, decoration: "flat"){
+        state "default", label:'Coop\r${currentValue}°', unit:"F", action:"updateTemp1"}         
+        
+		valueTile("TempProb2", "device.TempProb2", width: 2, height: 2, decoration: "flat"){
+        state "default", label:'Outside\r${currentValue}°', unit:"F", action:"updateTemp2"}        
+
+		valueTile("currentLevel", "device.currentLightLevel", width: 2, height: 2, decoration: "flat") {
+        state "default", label:'Sun\r${currentValue}', action:"updateSun"}    
+                
+        valueTile("dayOrNight", "device.dayOrNight", decoration: "flat",  inactiveLabel: false, width: 2, height: 2) {
+        state "default", label:'${currentValue}.'
+        }             
+                
+        controlTile("SetClSlider", "device.closeLightLevel", "slider", height: 2, width: 4, inactiveLabel: false, range:"(1..100)") {
+        state "closeLightLevel", action:"setCloseLevelTo", backgroundColor:"#d04e00"
+        }
+        
+        valueTile("SetClValue", "device.closeLightLevel", decoration: "flat",  inactiveLabel: false, width: 2, height: 2) {
+        state "default", label:'Close\nSunlight\n${currentValue}', action:'updateCloseLightLevel'
+        }        
+        
+        controlTile("SetOpSlider", "device.openLightLevel", "slider", height: 2, width: 4, inactiveLabel: false, range:"(1..100)") {
+        state "openLightLevel", action:"setOpenLevelTo", backgroundColor:"#d04e00"
+        }
+        
+        valueTile("SetOpValue", "device.openLightLevel", decoration: "flat",  inactiveLabel: false, width: 2, height: 2) {
+        state "default", label:'Open\nSunlight\n${currentValue}', action:'updateOpenLightLevel'
+        } 
+        
+        controlTile("SetSensitivitySlider", "device.doorSensitivity", "slider", height: 2, width: 4, inactiveLabel: false, range:"(1..100)") {
+        state "openLightLevel", action:"setSensitivityLevel", backgroundColor:"#d04e00"
+        }        
+        
+        valueTile("SetSensitivityValue", "device.doorSensitivity", decoration: "flat",  inactiveLabel: false, width: 2, height: 2) {
+        state "default", label:'Door\nSensitivity\n${currentValue}', action:'updateSensitivity'
+        }          
+        
+        standardTile("refresh", "device.refresh", width: 2, height: 2, decoration: "flat", inactiveLabel: false) {
+		state "default", label:'All', action:"refresh.refresh", icon:"st.secondary.refresh-icon"
+		}   
+        
+		standardTile("aux1", "device.Aux1", width: 2, height: 2, canChangeIcon: true) {
+			state "off", label:'Aux 1', action:"Aux1On", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"Sent"        
+			state "on", label:'Aux 1', action:"Aux1Off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"Sent"
+			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"            
+		}        
+        
+		standardTile("aux2", "device.Aux2", width: 2, height: 2, canChangeIcon: true) {
+			state "off", label:'Aux 2', action:"Aux2On", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"Sent"        
+			state "on", label:'Aux 2', action:"Aux2Off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"Sent"
+			state "Sent", label: 'wait', icon: "st.motion.motion.active", backgroundColor: "#ffa81e"   
+		}            
+        
+		main "doorCtrl"
+		details (["dtlsDoorCtrl", "TempProb1", "TempProb2", "currentLevel", "autoClose", "autoOpen", "dayOrNight",
+        "SetClSlider", "SetClValue", "SetOpSlider", "SetOpValue", "SetSensitivitySlider", "SetSensitivityValue",
+        "aux1", "aux2", "refresh"])
+	}
+}
+
+// Parse incoming device messages to generate events  def parse(String description) {
+def parse(String description) {
+	log.debug "description: $description"
+	Map map = [:]
+	if (description?.startsWith('catchall:')) {
+		map = parseCatchAllMessage(description)
+	}
+	else if (description?.startsWith('read attr -')) {
+		map = parseReportAttributeMessage(description)
+	}
+	else if (description?.startsWith('temperature: ') || description?.startsWith('humidity: ')) {
+		map = parseCustomMessage(description)
+	}
+    log.debug map
+	//return map ? createEvent(map) : null
+    sendEvent(map)
+    callUpdateStatusTxt() 
+}
+
+private Map parseCatchAllMessage(String description) {
+    Map resultMap = [:]    
+    def cluster = zigbee.parse(description)
+    log.debug cluster
+    if (cluster.clusterId == 0x0402) {
+        switch(cluster.sourceEndpoint) {
+
+            case 0x39:		// Endpoint 0x39 is the temperature of probe 1
+            String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+            resultMap.name = "TempProb1"
+            def celsius = Integer.valueOf(temp,16).shortValue()    
+            if (celsius ==  -32768){									// This number is used to indicate an error in the temperature reading
+                resultMap.value = "---"
+            }else{
+                celsius = celsius / 100									// Temperature value is sent X 100.
+                resultMap.value = celsiusToFahrenheit(celsius)		
+                if (tempOffsetOutside) {
+                    def offset = tempOffsetOutside as int
+					resultMap.value = resultMap.value + offset
+                }                      
+            }
+            sendEvent(name: "temperature", value: resultMap.value, displayed: false)		// set the temperatureMeasurment capability to temperature
+            break
+
+            case 0x40:													// Endpoint 0x40 is the temperature of probe 2
+            String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+            resultMap.name = "TempProb2"
+            def celsius = Integer.valueOf(temp,16).shortValue() 									
+            //resultMap.descriptionText = "Prob2 celsius value = ${celsius}"
+            if (celsius ==  -32768){									// This number is used to indicate an error in the temperature reading
+                resultMap.value = "---"
+            }else{
+            	celsius = celsius / 100									// Temperature value is sent X 100.
+                resultMap.value = celsiusToFahrenheit(celsius)			
+                if (tempOffsetCoop) {
+                    def offset = tempOffsetCoop as int
+					resultMap.value = resultMap.value + offset
+                }                                                
+            }                           
+            break
+    	}                        
+	}
+    
+    if (cluster.clusterId == 0x0101 && cluster.command == 0x0b) {		// This is a default response to a command sent to cluster 0x0101 door control
+    	//log.debug "Default Response Data = $cluster.data"
+        switch(cluster.data) {
+        
+        case "[10, 0]":		// 0x0a turn auto close on command verified          
+        resultMap.name = "autoCloseEnable"
+        resultMap.value = "on"        
+        break                 
+        
+        case "[11, 0]":		// 0x0b turn auto close off command verified          
+        resultMap.name = "autoCloseEnable"
+        resultMap.value = "off"        
+        break            
+        
+        case "[12, 0]":		// 0x0C turn auto open on command verified           
+        resultMap.name = "autoOpenEnable"
+        resultMap.value = "on"        
+        break    
+        
+        case "[13, 0]":		// 0x0d turn auto open off command verified           
+        resultMap.name = "autoOpenEnable"
+        resultMap.value = "off"        
+        break               
+        
+        
+        case "[20, 0]":		// 0x14 Aux1 On command verified 
+        log.info "verified Aux1 On"
+    	sendEvent(name: "switch", value: "on", displayed: false)   
+        resultMap.name = "Aux1"
+        resultMap.value = "on"        
+        break
+
+        case "[21, 0]":		// 0x15 Aux1 Off command verified 
+        log.info "verified Aux1 Off"
+    	sendEvent(name: "switch", value: "off", displayed: false)
+        resultMap.name = "Aux1"
+        resultMap.value = "off"
+        break
+        
+        case "[22, 0]":		// 0x16 Aux2 On command verified 
+        log.info "verified Aux2 On"    
+        resultMap.name = "Aux2"
+        resultMap.value = "on"        
+        break
+
+        case "[23, 0]":		// 0x17 Aux2 Off command verified 
+        log.info "verified Aux2 Off"
+        resultMap.name = "Aux2"
+        resultMap.value = "off"        
+        break        
+        
+        }
+    }
+    return resultMap
+}
+
+private Map parseReportAttributeMessage(String description) {
+    Map resultMap = [:]
+    def descMap = parseDescriptionAsMap(description)
+    //log.debug "read attr descMap --> $descMap"
+    if (descMap.cluster == "0101" && descMap.attrId == "0003") {
+        resultMap.name = "doorState"
+        if (descMap.value == "00"){
+            resultMap.value = "unknown"
+            sendEvent(name: "door", value: "unknown", displayed: false)
+        }else if(descMap.value == "01"){
+            resultMap.value = "closed"
+            sendEvent(name: "door", value: "closed", displayed: false)            
+        }else if(descMap.value == "02"){
+            resultMap.value = "open"    
+            sendEvent(name: "door", value: "open", displayed: false)              
+        }else if(descMap.value == "03"){
+            resultMap.value = "jammed"     
+        }else if(descMap.value == "04"){
+            resultMap.value = "forced close"   
+        }else if(descMap.value == "05"){
+            resultMap.value = "forced close"   
+        }else if(descMap.value == "06"){
+            resultMap.value = "closing"  
+            sendEvent(name: "door", value: "closing", displayed: false)              
+        }else if(descMap.value == "07"){
+            resultMap.value = "opening"
+            sendEvent(name: "door", value: "opening", displayed: false)                 
+        }else if(descMap.value == "08"){
+            resultMap.value = "fault"            
+        }else {            
+            resultMap.value = "unknown"
+        }   
+        resultMap.descriptionText = "Door State Changed to ${resultMap.value}"
+        
+    } else if (descMap.cluster == "0101" && descMap.attrId == "0400") { 
+        resultMap.name = "currentLightLevel"
+        resultMap.value = (Integer.parseInt(descMap.value, 16))      
+        resultMap.displayed = false
+        
+    } else if (descMap.cluster == "0101" && descMap.attrId == "0401") { 
+        resultMap.name = "closeLightLevel"
+        resultMap.value = (Integer.parseInt(descMap.value, 16))
+
+    } else if (descMap.cluster == "0101" && descMap.attrId == "0402") { 
+        resultMap.name = "openLightLevel"
+        resultMap.value = (Integer.parseInt(descMap.value, 16))
+
+    } else if (descMap.cluster == "0101" && descMap.attrId == "0403") { 
+        resultMap.name = "autoCloseEnable"
+        if (descMap.value == "01"){resultMap.value = "on"}
+        else{resultMap.value = "off"}       
+
+    } else if (descMap.cluster == "0101" && descMap.attrId == "0404") { 
+        resultMap.name = "autoOpenEnable"
+        if (descMap.value == "01"){resultMap.value = "on"}
+        else{resultMap.value = "off"}  
+
+    } else if (descMap.cluster == "0101" && descMap.attrId == "0405") { 
+        resultMap.name = "doorCurrent"
+        resultMap.value = (Integer.parseInt(descMap.value, 16)) 
+        resultMap.value = resultMap.value * 0.001        
+
+     } else if (descMap.cluster == "0101" && descMap.attrId == "0408") { 
+        resultMap.name = "doorSensitivity"
+        resultMap.value = (100 - Integer.parseInt(descMap.value, 16))
+        
+    } else if (descMap.cluster == "0101" && descMap.attrId == "0409") { 
+        resultMap.name = "baseDoorCurrent"
+        resultMap.value = (Integer.parseInt(descMap.value, 16)) 
+        resultMap.value = resultMap.value * 0.001                
+        
+    } else if (descMap.cluster == "0101" && descMap.attrId == "040a") { 
+        resultMap.name = "doorVoltage"
+        resultMap.value = (Integer.parseInt(descMap.value, 16))  
+        resultMap.value = resultMap.value * 0.001
+        
+    } else if (descMap.cluster == "0101" && descMap.attrId == "040b") { 
+        resultMap.name = "Aux1"
+        if(descMap.value == "01"){
+        resultMap.value = "on"
+    	sendEvent(name: "switch", value: "on", displayed: false)        
+        }else{
+        resultMap.value = "off"        
+    	sendEvent(name: "switch", value: "off", displayed: false)        
+        }
+     
+    } else if (descMap.cluster == "0101" && descMap.attrId == "040c") { 
+        resultMap.name = "Aux2"
+        if(descMap.value == "01"){
+        resultMap.value = "on"
+        }else{
+        resultMap.value = "off"        
+        }   
+    } else if (descMap.cluster == "0101" && descMap.attrId == "040d") { 
+        resultMap.name = "photoCalibration"
+        resultMap.value = (Integer.parseInt(descMap.value, 16))           
+    } else if (descMap.cluster == "0101" && descMap.attrId == "040e") { 
+        resultMap.name = "baseCurrentNE"
+        resultMap.value = (Integer.parseInt(descMap.value, 16))           
+    }    
+    return resultMap
+}
+
+private Map parseCustomMessage(String description) {
+    //log.info "ParseCustomMessage called with ${description}"
+	Map resultMap = [:]
+    if (description?.startsWith('temperature: ')) {
+        resultMap.name = "temperature"
+    	def rawT = (description - "temperature: ").trim()
+        resultMap.descriptionText = "Temperature celsius value = ${rawT}"
+        def rawTint = Float.parseFloat(rawT)
+        if (rawTint > 65){
+        	resultMap.name = null
+            resultMap.value = null
+            resultMap.descriptionText = "Temperature celsius value = ${rawT} is invalid not updating"
+            log.warn "Invalid temperature value detected! rawT = ${rawT}, description = ${description}"
+        }else if (rawT ==  -32768){											// This number is used to indicate an error in the temperature reading
+            resultMap.value = "ERR"
+        }else{
+            resultMap.value = celsiusToFahrenheit(rawT.toFloat()) as Float
+            sendEvent(name: "TempProb1", value: resultMap.value, displayed: false)		// Workaround for lack of access to endpoint information for Temperature report  
+        }        
+	}
+    resultMap.displayed = false
+    log.info "Temperature reported = ${resultMap.value}"
+    return resultMap    
+}
+
+def parseDescriptionAsMap(description) {
+    (description - "read attr - ").split(",").inject([:]) { map, param ->
+        def nameAndValue = param.split(":")
+        map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
+    }
+}
+
+// Added for Temeperature parse
+def getFahrenheit(value) {
+	def celsius = Integer.parseInt(value, 16)
+	return celsiusToFahrenheit(celsius) as Integer
+}
+
+// Private methods
+def callUpdateStatusTxt(){	
+	def cTemp = device.currentState("TempProb1")?.value
+    def cLight = 0
+    def testNull = device.currentState("currentLightLevel")?.value
+    if (testNull != null){
+    cLight = device.currentState("currentLightLevel")?.value as int
+    }   
+	updateStatusTxt(cTemp, cLight)
+}
+
+def updateStatusTxt(currentTemp, currentLight){
+	//log.info "called updateStatusTxt with ${currentTemp}, ${currentLight}"
+    def cTmp = currentTemp
+    def cLL = 10
+    def oLL = 10
+    
+    def testNull = device.currentState("closeLightLevel")?.value
+    if (testNull != null){
+    	cLL = device.currentState("closeLightLevel")?.value as int
+	}
+
+    testNull = device.currentState("openLightLevel")?.value
+    if (testNull != null){
+    	oLL = device.currentState("openLightLevel")?.value as int
+    }   
+    
+    def aOpnEn = device.currentState("autoOpenEnable")?.value
+    def aClsEn = device.currentState("autoCloseEnable")?.value
+    
+        if (currentLight < cLL){  
+        	if (aOpnEn == "on"){
+           		sendEvent(name: "dayOrNight", value: "Sun must be > ${oLL} to auto open", displayed: false)
+            	sendEvent(name: "coopStatus", value: "Sunlight ${currentLight} open at ${oLL}. Coop ${cTmp}°", displayed: false)
+                }else{
+           		sendEvent(name: "dayOrNight", value: "Auto Open is turned off.", displayed: false)
+            	sendEvent(name: "coopStatus", value: "Sunlight ${currentLight} auto open off. Coop ${cTmp}°", displayed: false)                
+                }
+        }else { 
+        	if (aClsEn == "on"){        
+            	sendEvent(name: "dayOrNight", value: "Sun must be < ${cLL} to auto close", displayed: false)
+            	sendEvent(name: "coopStatus", value: "Sunlight ${currentLight} close at ${cLL}. Coop ${cTmp}°", displayed: false)
+                }else{
+           		sendEvent(name: "dayOrNight", value: "Auto Close is turned off.", displayed: false)
+            	sendEvent(name: "coopStatus", value: "Sunlight ${currentLight} auto close off. Coop ${cTmp}°", displayed: false)                   
+                }
+        }
+}
+
+// Commands to device
+def on() {
+	log.debug "on calling Aux1On"
+    Aux1On()
+}
+
+def off() {
+	log.debug "off calling Aux1Off"
+    Aux1Off()
+}
+
+def close() {
+	log.debug "close calling closeDoor"
+	closeDoor()
+}
+
+def open() {
+	log.debug "open calling openDoor"
+	openDoor()
+}
+
+def Aux1On(){
+	log.debug "Sending Aux1 = on command"
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x14 {}"             
+}
+
+def Aux1Off(){     
+	log.debug "Sending Aux1 = off command"
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x15 {}"             
+}
+
+def Aux2On(){
+	log.debug "Sending Aux2 = on command"
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x16 {}"             
+}
+
+def Aux2Off(){
+	log.debug "Sending Aux2 = off command"
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x17 {}"             
+}
+
+def openDoor() {
+	log.debug "Sending Open command"
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x1 {}"
+}
+
+def closeDoor() {
+	log.debug "Sending Close command"
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x0 {}"
+}
+
+def closeDoorHiI() {
+	log.debug "Sending High Current Close command"
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x4 {}"
+}
+
+def autoOpenOn() {
+	log.debug "Setting Auto Open On"   
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x0C {}"
+}
+
+def autoOpenOff() {
+	log.debug "Setting Auto Open Off"   
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x0D {}"
+}
+
+def autoCloseOn() {
+	log.debug "Setting Auto Close On"
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x0A {}"
+}
+
+def autoCloseOff() {
+	log.debug "Setting Auto Close Off"
+	"st cmd 0x${device.deviceNetworkId} 0x38 0x0101 0x0B {}"
+}
+
+def setOpenLevelTo(cValue) {
+	def cX = cValue
+	log.debug "Setting Open Light Level to ${cX} Hex = 0x${Integer.toHexString(cX)}"
+    
+    def cmd = []
+    cmd << "st wattr 0x${device.deviceNetworkId} 0x38 0x0101 0x402 0x23 {${Integer.toHexString(cX)}}"	
+    cmd << "delay 150"
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x402"											// Read light value   
+    cmd    
+}
+
+def setCloseLevelTo(cValue) {
+	def cX = cValue
+	log.debug "Setting Close Light Level to ${cX} Hex = 0x${Integer.toHexString(cX)}"
+    
+    def cmd = []
+    cmd << "st wattr 0x${device.deviceNetworkId} 0x38 0x0101 0x401 0x23 {${Integer.toHexString(cX)}}"	
+    cmd << "delay 150"
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x401"											// Read light value   
+    cmd 
+    
+}
+
+def setSensitivityLevel(cValue) {
+	def cX = 100 - cValue
+	log.debug "Setting Door sensitivity level to ${cX} Hex = 0x${Integer.toHexString(cX)}"
+    
+    def cmd = []
+    cmd << "st wattr 0x${device.deviceNetworkId} 0x38 0x0101 0x408 0x23 {${Integer.toHexString(cX)}}"		// Write attribute.  0x23 is a 32 bit integer value. 
+    cmd << "delay 150"
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x408"											// Read attribute 
+    cmd    
+}
+
+def setNewBaseCurrent(cValue) {
+	def cX = cValue as int
+	log.info "Setting new BaseCurrent to ${cX} Hex = 0x${Integer.toHexString(cX)}"
+    
+    def cmd = []
+    cmd << "st wattr 0x${device.deviceNetworkId} 0x38 0x0101 0x409 0x23 {${Integer.toHexString(cX)}}"		// Write attribute.  0x23 is a 32 bit integer value.
+    cmd << "delay 150"
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x409"											// Read attribute 
+    cmd    
+}
+
+def setNewPhotoCalibration(cValue) {
+	def cX = cValue as int
+	log.info "Setting new Photoresister calibration to ${cX} Hex = 0x${Integer.toHexString(cX)}"
+    
+    def cmd = []
+    cmd << "st wattr 0x${device.deviceNetworkId} 0x38 0x0101 0x40D 0x2B {${Integer.toHexString(cX)}}"		// Write attribute.  0x2B is a 32 bit signed integer value. 
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x40D"											// Read attribute 
+    cmd    
+}
+
+def readNewPhotoCalibration() {
+	log.info "Requesting current Photoresister calibration "
+    
+    def cmd = []
+	cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x40D"											// Read attribute 
+    cmd    
+}
+
+def readBaseCurrentNE() {
+	log.info "Requesting base current never exceed setting "
+    
+    def cmd = []
+	cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x40E"											// Read attribute 
+    cmd    
+}
+
+def setBaseCurrentNE(cValue) {
+	def cX = cValue as int
+	log.info "Setting new base Current Never Exceed to ${cX} Hex = 0x${Integer.toHexString(cX)}"
+    
+    def cmd = []
+    cmd << "st wattr 0x${device.deviceNetworkId} 0x38 0x0101 0x40E 0x23 {${Integer.toHexString(cX)}}"		// Write attribute.  0x23 is a 32 bit unsigned integer value. 
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x40E"											// Read attribute 
+    cmd    
+}
+
+def poll(){
+	log.debug "Polling Device"
+    def cmd = []
+	cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0003"   // Read Door State 
+    cmd << "delay 150"
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0400"	// Read Current Light Level
+    cmd << "delay 150"        
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x39 0x0402 0x0000"    // Read probe 1 Temperature 
+    cmd << "delay 150"       
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x40 0x0402 0x0000"    // Read probe 2 Temperature        
+    
+    cmd
+}
+
+def updateTemp1() {
+	log.debug "Sending attribute read request for Temperature Probe1"   
+    def cmd = []    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x39 0x0402 0x0000"    // Read Current Temperature from Coop Probe 1
+    cmd
+}
+
+def updateTemp2() {
+	log.debug "Sending attribute read request for Temperature Probe2"   
+    def cmd = []    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x40 0x0402 0x0000"    // Read Current Temperature from Coop Probe 2   
+    cmd
+}
+
+
+def updateSun() {
+	log.debug "Sending attribute read request for Sun Light Level"   
+    def cmd = []    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0400"	// Read Current Light Level
+    cmd
+}
+
+def updateSensitivity() {
+	log.debug "Sending attribute read request for door sensitivity"   
+    def cmd = []    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0408"	// Read Door sensitivity
+    cmd
+}
+
+def updateCloseLightLevel() {
+	log.debug "Sending attribute read close light level"   
+    def cmd = []    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0401"	
+    cmd
+}
+
+def updateOpenLightLevel() {
+	log.debug "Sending attribute read open light level"   
+    def cmd = []    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0402"	
+    cmd
+}
+
+def refresh() {
+	log.debug "sending refresh command"   
+    def cmd = []
+	cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0003"   // Read Door State 
+    cmd << "delay 150"
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0400"	// Read Current Light Level
+    cmd << "delay 150"        
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0401"	// Read Door Close Light Level
+    cmd << "delay 150"    
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0402"	// Read Door Open Light Level
+    cmd << "delay 150"
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0403"	// Read Auto Door Close Settings 
+    cmd << "delay 150"    
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0404"	// Read Auto Door Open Settings
+    cmd << "delay 150"  
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x39 0x0402 0x0000"    // Read Current Temperature from Coop Probe 1
+    cmd << "delay 150" 
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0408"    // Object detection sensitivity 
+    cmd << "delay 150"  
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x40 0x0402 0x0000"    // Read Current Temperature from Coop Probe 2    
+    cmd << "delay 150"   
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x0405"    // Current required to close door      
+    cmd << "delay 150"   
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x040B"    // Aux1 Status      
+    cmd << "delay 150"       
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x040C"    // Aux2 Status      
+    cmd << "delay 150"     
+    
+    cmd << "st rattr 0x${device.deviceNetworkId} 0x38 0x0101 0x409"		// Read Base current
+
+    cmd
+}
+
+def configure() {
+    log.debug "Binding SEP 0x38 DEP 0x01 Cluster 0x0101 Lock cluster to hub"  
+    log.debug "Binding SEP 0x39 DEP 0x01 Cluster 0x0402 Temperature cluster to hub"      
+    log.debug "Binding SEP 0x40 DEP 0x01 Cluster 0x0402 Temperature cluster to hub"      
+    
+    def cmd = []
+    cmd << "zdo bind 0x${device.deviceNetworkId} 0x38 0x01 0x0101 {${device.zigbeeId}} {}"			// Bind to end point 0x38 and the lock cluster
+    cmd << "delay 150"
+    cmd << "zdo bind 0x${device.deviceNetworkId} 0x39 0x01 0x0402 {${device.zigbeeId}} {}"    		// Bind to end point 0x39 and the temperature cluster
+    cmd << "delay 150"
+    cmd << "zdo bind 0x${device.deviceNetworkId} 0x40 0x01 0x0402 {${device.zigbeeId}} {}"    		// Bind to end point 0x40 and the temperature cluster
+    cmd << "delay 1500"    
+    
+    log.info "Sending ZigBee Configuration Commands to Coop Control"
+    return cmd + refresh()
+}
+
+

devicetypes/juano2310/jawbone-user.src/jawbone-user.groovy

@@ -24,7 +24,7 @@ metadata {
     tiles {
         standardTile("sleeping", "device.sleeping", width: 1, height: 1, canChangeIcon: false, canChangeBackground: false) {
             state("sleeping", label: "Sleeping", icon:"st.Bedroom.bedroom12", backgroundColor:"#ffffff")
-            state("not sleeping", label: "Awake", icon:"st.Health & Wellness.health12", backgroundColor:"#79b821")
+            state("not sleeping", label: "Awake", icon:"st.Health & Wellness.health12", backgroundColor:"#00A0DC")
         }
         standardTile("steps", "device.steps", width: 2, height: 2, canChangeIcon: false, canChangeBackground: false) {
             state("steps", label: '${currentValue} Steps', icon:"st.Health & Wellness.health11", backgroundColor:"#ffffff")                     

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

@@ -40,10 +40,10 @@ metadata {
     // UI tile definitions
     tiles {
         standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-            state "on", action: "switch.off", icon: "st.vents.vent-open-text", backgroundColor: "#53a7c0"
+            state "on", action: "switch.off", icon: "st.vents.vent-open-text", backgroundColor: "#00a0dc"
             state "off", action: "switch.on", icon: "st.vents.vent-closed", backgroundColor: "#ffffff"
-            state "obstructed", action: "clearObstruction", icon: "st.vents.vent-closed", backgroundColor: "#ff0000"
-            state "clearing", action: "", icon: "st.vents.vent-closed", backgroundColor: "#ffff33"
+            state "obstructed", action: "clearObstruction", icon: "st.vents.vent-closed", backgroundColor: "#e86d13"
+            state "clearing", action: "", icon: "st.vents.vent-closed", backgroundColor: "#ffffff"
         }
         controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false) {
             state "level", action:"switch level.setLevel"
@@ -274,6 +274,7 @@ private Map makeTemperatureResult(value) {
         name: 'temperature',
         value: "" + value,
         descriptionText: "${linkText} is ${value}°${temperatureScale}",
+        unit: temperatureScale
     ]
 }
 

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

@@ -1,6 +1,5 @@
 /**
- *  Spruce Controller - Pre Release V2 10/11/2015
- *
+ *  Spruce Controller V2_4 Big Tiles *
  *  Copyright 2015 Plaid Systems
  *
  *	Author: NC
@@ -21,82 +20,96 @@
  */
 
 metadata {
-	definition (name: "Spruce Controller", namespace: "plaidsystems", author: "NCauffman") {
-		capability "Switch"
-        capability "Configuration"
-        capability "Refresh"
-        capability "Actuator"
-        capability "Valve"        
+	definition (name: 'Spruce Controller', namespace: 'plaidsystems', author: 'Plaid Systems') {
+		capability 'Switch'
+        capability 'Configuration'
+        capability 'Refresh'
+        capability 'Actuator'
+        capability 'Valve'        
 		
-        attribute "switch", "string"
-        attribute "switch1", "string"
-		attribute "switch2", "string"
-		attribute "switch8", "string"
-		attribute "switch5", "string"
-		attribute "switch3", "string"
-		attribute "switch4", "string"
-		attribute "switch6", "string"
-		attribute "switch7", "string"
-        attribute "switch9", "string"
-		attribute "switch10", "string"
-		attribute "switch11", "string"
-		attribute "switch12", "string"
-		attribute "switch13", "string"
-		attribute "switch14", "string"
-		attribute "switch15", "string"
-        attribute "switch16", "string"
-		attribute "status", "string"        
+        attribute 'switch', 'string'
+        attribute 'switch1', 'string'
+		attribute 'switch2', 'string'
+		attribute 'switch8', 'string'
+		attribute 'switch5', 'string'
+		attribute 'switch3', 'string'
+		attribute 'switch4', 'string'
+		attribute 'switch6', 'string'
+		attribute 'switch7', 'string'
+        attribute 'switch9', 'string'
+		attribute 'switch10', 'string'
+		attribute 'switch11', 'string'
+		attribute 'switch12', 'string'
+		attribute 'switch13', 'string'
+		attribute 'switch14', 'string'
+		attribute 'switch15', 'string'
+        attribute 'switch16', 'string'
+		attribute 'rainsensor', 'string'
+        attribute 'status', 'string'
+        attribute 'tileMessage', 'string'
+        attribute 'minutes', 'string'
+        attribute 'VALUE_UP', 'string'
+        attribute 'VALUE_DOWN', 'string'        
         
-        command "programOn"
-        command "programOff"
-        command "on"
-        command "off"
-        command "z1on"
-		command "z1off"
-		command "z2on"
-		command "z2off"        
-		command "z3on"
-		command "z3off"
-		command "z4on"
-		command "z4off"
-		command "z5on"
-		command "z5off"
-		command "z6on"
-		command "z6off"
-		command "z7on"
-		command "z7off"
-		command "z8on"
-		command "z8off"
-        command "z9on"
-        command "z9off"
-		command "z10on"
-		command "z10off"
-		command "z11on"
-		command "z11off"
-		command "z12on"
-		command "z12off"
-		command "z13on"
-		command "z13off"
-		command "z14on"
-		command "z14off"
-		command "z15on"
-		command "z15off"
-		command "z16on"
-		command "z16off"
-        command "offtime"
+        command 'levelUp'
+        command 'levelDown'
+        command 'programOn'
+        command 'programOff'
+        command 'programWait'
+        command 'programEnd'
         
-        command "refresh"        
-        command "rain"
-        command "manual"
-        command "setDisplay"
+        command 'on'
+        command 'off'
+        command 'zon'
+        command 'zoff'
+        command 'z1on'
+		command 'z1off'
+		command 'z2on'
+		command 'z2off'        
+		command 'z3on'
+		command 'z3off'
+		command 'z4on'
+		command 'z4off'
+		command 'z5on'
+		command 'z5off'
+		command 'z6on'
+		command 'z6off'
+		command 'z7on'
+		command 'z7off'
+		command 'z8on'
+		command 'z8off'
+        command 'z9on'
+        command 'z9off'
+		command 'z10on'
+		command 'z10off'
+		command 'z11on'
+		command 'z11off'
+		command 'z12on'
+		command 'z12off'
+		command 'z13on'
+		command 'z13off'
+		command 'z14on'
+		command 'z14off'
+		command 'z15on'
+		command 'z15off'
+		command 'z16on'
+		command 'z16off'
         
-        command "settingsMap"
-        command "writeTime"
-        command "writeType"        
-        command "notify"
-        command "updated"
-
-		fingerprint endpointId: "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18", profileId: "0104", deviceId: "0002", deviceVersion: "00", inClusters: "0000,0003,0004,0005,0006,000F", outClusters: "0003, 0019", manufacturer: "PLAID SYSTEMS", model: "PS-SPRZ16-01"
+        command 'config'
+        command 'refresh'        
+        command 'rain'
+        command 'manual'
+        command 'manualTime'
+        command 'settingsMap'
+        command 'writeTime'
+        command 'writeType'        
+        command 'notify'
+        command 'updated'      
+        
+		//ST release
+		//fingerprint endpointId: '1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18', profileId: '0104', deviceId: '0002', deviceVersion: '00', inClusters: '0000,0003,0004,0005,0006,000F', outClusters: '0003, 0019', manufacturer: 'PLAID SYSTEMS', model: 'PS-SPRZ16-01'
+		//new release
+        fingerprint endpointId: "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18", profileId: "0104", deviceId: "0002", deviceVersion: "00", inClusters: "0000,0003,0004,0005,0006,0009,000A,000F", outClusters: "0003, 0019", manufacturer: "PLAID SYSTEMS", model: "PS-SPRZ16-01"
 		
 	}
 
@@ -104,162 +117,230 @@ metadata {
 	simulator {
 		// status messages
 		
-		// reply messages
-		
+		// reply messages		
 	}
+    
     preferences {
-    input description: "Press Configure button after making changes to these preferences", displayDuringSetup: true, type: "paragraph", element: "paragraph", title: ""
-    input "RainEnable", "bool", title: "Rain Sensor Attached?", required: false, displayDuringSetup: true
-    input "ManualTime", "number", title: "Automatic shutoff time when a zone is turned on manually?", required: false, displayDuringSetup: true
-	}
+    input description: 'If you have a rain sensor wired to the rain sensor input on the Spruce controller, turn it on here.', displayDuringSetup: true, type: 'paragraph', element: 'paragraph', title: 'Rain Sensor'
+    input description: 'The SYNC SETTINGS button must be pressed after making a change to the Rain sensor:', displayDuringSetup: false, type: 'paragraph', element: 'paragraph', title: ''     
+    input 'RainEnable', 'bool', title: 'Rain Sensor Attached?', required: false, displayDuringSetup: true
+    input description: 'Adjust manual water time with arrows on main tile.  The time indicated in the first small tile indicates the time the zone will water when manually switched on.', displayDuringSetup: false, type: 'paragraph', element: 'paragraph', title: ''
+    }
 
 	// UI tile definitions
 	tiles {
     
-    	standardTile("status", "device.status") {            
-            state "schedule", label: 'Schedule Set', icon: "http://www.plaidsystems.com/smartthings/st_spruce_leaf_225_t.png"
-            state "finished", label: 'Spruce Finished', icon: "st.Outdoor.outdoor5", backgroundColor: "#46c2e8"
-            state "raintoday", label: 'Rain Today', icon: "st.custom.wuk.nt_chancerain"
-            state "rainy", label: 'Previous Rain', icon: "st.custom.wuk.nt_chancerain"
-            state "raintom", label: 'Rain Tomorrow', icon: "st.custom.wuk.nt_chancerain"           
-            state "donewweek", label: 'Spruce Finished', icon: "st.Outdoor.outdoor5", backgroundColor: "#52c435"
-            state "skipping", label: 'Skip Today', icon: "st.Outdoor.outdoor20", backgroundColor: "#36cfe3"
-            state "moisture", label: '', icon: "st.Weather.weather2", backgroundColor: "#36cfe3"
-            state "pause", label: 'PAUSE', icon: "st.contact.contact.open", backgroundColor: "#f2a51f"           
-            state "active", label: 'Active', icon: "st.Outdoor.outdoor12", backgroundColor: "#3DC72E"
-            state "season", label: 'Seasonal Adjustment', icon: "st.Outdoor.outdoor17", backgroundColor: "#ffb900"
-            state "disable", label: 'Disabled', icon: "st.secondary.off", backgroundColor: "#888888"
-            state "warning", label: '', icon: "st.categories.damageAndDanger", backgroundColor: "#ffff7f"
-            state "alarm", label: 'Alarm', icon: "st.categories.damageAndDanger", backgroundColor: "#f9240c"
+    	multiAttributeTile(name:"switchall", type:"generic", width:6, height:4) {        
+            tileAttribute('device.status', key: 'PRIMARY_CONTROL') {
+            attributeState 'schedule', label: 'Ready', icon: 'http://www.plaidsystems.com/smartthings/st_spruce_leaf_225_top.png'
+            attributeState 'finished', label: 'Finished', icon: 'st.Outdoor.outdoor5', backgroundColor: '#46c2e8'
+            attributeState 'raintoday', label: 'Rain Today', icon: 'http://www.plaidsystems.com/smartthings/st_rain.png', backgroundColor: '#d65fe3'
+            attributeState 'rainy', label: 'Rain', icon: 'http://www.plaidsystems.com/smartthings/st_rain.png', backgroundColor: '#d65fe3'
+            attributeState 'raintom', label: 'Rain Tomorrow', icon: 'http://www.plaidsystems.com/smartthings/st_rain.png', backgroundColor: '#d65fe3'
+            attributeState 'donewweek', label: 'Finished', icon: 'st.Outdoor.outdoor5', backgroundColor: '#00A0DC'
+            attributeState 'skipping', label: 'Skip', icon: 'st.Outdoor.outdoor20', backgroundColor: '#46c2e8'
+            attributeState 'moisture', label: 'Ready', icon: 'st.Weather.weather2', backgroundColor: '#46c2e8'
+            attributeState 'pause', label: 'PAUSE', icon: 'st.contact.contact.open', backgroundColor: '#e86d13'
+			attributeState 'delayed', label: 'Delayed', icon: 'st.contact.contact.open', backgroundColor: '#e86d13'
+            attributeState 'active', label: 'Active', icon: 'st.Outdoor.outdoor12', backgroundColor: '#3DC72E'
+            attributeState 'season', label: 'Adjust', icon: 'st.Outdoor.outdoor17', backgroundColor: '#ffb900'
+            attributeState 'disable', label: 'Off', icon: 'st.secondary.off', backgroundColor: '#cccccc'
+            attributeState 'warning', label: 'Warning', icon: 'http://www.plaidsystems.com/smartthings/st_spruce_leaf_225_top_yellow.png'
+            attributeState 'alarm', label: 'Alarm', icon: 'http://www.plaidsystems.com/smartthings/st_spruce_leaf_225_s_red.png', backgroundColor: '#e66565'
+            }
+            
+            tileAttribute("device.minutes", key: "VALUE_CONTROL") {
+                attributeState "VALUE_UP", action: "levelUp"
+                attributeState "VALUE_DOWN", action: "levelDown"
+            }
+            
+            tileAttribute("device.tileMessage", key: "SECONDARY_CONTROL") {
+                attributeState "tileMessage", label: '${currentValue}'     
+            }            
+            
         }
-		standardTile("switch", "device.switch") {			
-			//state "programOff", label: 'Start Program', action: "programOn", icon: "st.sonos.play-icon", backgroundColor: "#a9a9a9"
-            state "off", label: 'Start Program', action: "programOn", icon: "st.sonos.play-icon", backgroundColor: "#a9a9a9"
-            state "programOn", label: 'Initialize Program', action: "programOff", icon: "st.contact.contact.open", backgroundColor: "#f6e10e"            
-            state "on", label: 'Program Running', action: "off", icon: "st.Outdoor.outdoor12", backgroundColor: "#3DC72E"
-		}
-        standardTile("rainsensor", "device.rainsensor") {			
-			state "rainSensrooff", label: 'Rain Sensor Clear', icon: "st.Weather.weather14", backgroundColor: "#a9a9a9"
-            state "rainSensoron", label: 'Rain Detected', icon: "st.Weather.weather10", backgroundColor: "#f6e10e"
-		}    	
-        standardTile("switch1", "device.switch1") {			
-			state "z1off", label: '1', action: "z1on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z1on", label: '1', action: "z1off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
-		}
-        standardTile("switch2", "device.switch2") {            
-            state "z2off", label: '2', action: "z2on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z2on", label: '2', action: "z2off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
+        valueTile('minutes', 'device.minutes'){
+        	state 'minutes', label: '${currentValue} min'
+        }
+        valueTile('dummy', 'device.minutes'){
+        	state 'minutes', label: ''
+        }
+		standardTile('switch', 'device.switch', width:2, height:2) {
+            state 'off', label: 'Start', action: 'programOn', icon: 'st.Outdoor.outdoor12', backgroundColor: '#a9a9a9'
+            state 'programOn', label: 'Wait', action: 'programOff', icon: 'st.contact.contact.open', backgroundColor: '#f6e10e'
+            state 'programWait', label: 'Wait', action: 'programEnd', icon: 'st.contact.contact.open', backgroundColor: '#f6e10e'
+            state 'on', label: 'Running', action: 'programEnd', icon: 'st.Outdoor.outdoor12', backgroundColor: '#3DC72E'
 		}        
-        standardTile("switch3", "device.switch3", inactiveLabel: false) {			
-			state "z3off", label: '3', action: "z3on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z3on", label: '3', action: "z3off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
+        standardTile("rainsensor", "device.rainsensor", decoration: 'flat') {			
+			state "rainSensoroff", label: 'sensor', icon: 'http://www.plaidsystems.com/smartthings/st_drop_on.png'
+            state "rainSensoron", label: 'sensor', icon: 'http://www.plaidsystems.com/smartthings/st_drop_on_blue_small.png'
+            state "disable", label: 'sensor', icon: 'http://www.plaidsystems.com/smartthings/st_drop_x_small.png'
+            state "enable", label: 'sensor', icon: 'http://www.plaidsystems.com/smartthings/st_drop_on.png'
 		}
-        standardTile("switch4", "device.switch4", inactiveLabel: false) {            
-            state "z4off", label: '4', action: "z4on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z4on", label: '4', action: "z4off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
+        standardTile('switch1', 'device.switch1', inactiveLabel: false) {			
+			state 'z1off', label: '1', action: 'z1on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z1on', label: '1', action: 'z1off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
 		}
-        standardTile("switch5", "device.switch5", inactiveLabel: false) {            
-            state "z5off", label: '5', action: "z5on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z5on", label: '5', action: "z5off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
-		}
-		standardTile("switch6", "device.switch6", inactiveLabel: false) {            
-            state "z6off", label: '6', action: "z6on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z6on", label: '6', action: "z6off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
-		}
-        standardTile("switch7", "device.switch7", inactiveLabel: false) {            
-            state "z7off", label: '7', action: "z7on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z7on", label: '7', action: "z7off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
-		}
-		standardTile("switch8", "device.switch8", inactiveLabel: false) {            
-            state "z8off", label: '8', action: "z8on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z8on", label: '8', action: "z8off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
-		}
-        standardTile("switch9", "device.switch9", inactiveLabel: false) {			
-			state "z9off", label: '9', action: "z9on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z9on", label: '9', action: "z9off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
-		}
-        standardTile("switch10", "device.switch10", inactiveLabel: false) {            
-            state "z10off", label: '10', action: "z10on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z10on", label: '10', action: "z10off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
+        standardTile('switch2', 'device.switch2', inactiveLabel: false) {            
+            state 'z2off', label: '2', action: 'z2on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z2on', label: '2', action: 'z2off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
 		}        
-        standardTile("switch11", "device.switch11", inactiveLabel: false) {			
-			state "z11off", label: '11', action: "z11on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z11on", label: '11', action: "z11off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
+        standardTile('switch3', 'device.switch3', inactiveLabel: false) {			
+			state 'z3off', label: '3', action: 'z3on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z3on', label: '3', action: 'z3off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
 		}
-        standardTile("switch12", "device.switch12", inactiveLabel: false) {            
-            state "z12off", label: '12', action: "z12on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z12on", label: '12', action: "z12off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
+        standardTile('switch4', 'device.switch4', inactiveLabel: false) {            
+            state 'z4off', label: '4', action: 'z4on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z4on', label: '4', action: 'z4off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
 		}
-        standardTile("switch13", "device.switch13", inactiveLabel: false) {            
-            state "z13off", label: '13', action: "z13on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z13on", label: '13', action: "z13off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
+        standardTile('switch5', 'device.switch5', inactiveLabel: false) {            
+            state 'z5off', label: '5', action: 'z5on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z5on', label: '5', action: 'z5off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
 		}
-		standardTile("switch14", "device.switch14", inactiveLabel: false) {            
-            state "z14off", label: '14', action: "z14on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z14on", label: '14', action: "z14off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
+		standardTile('switch6', 'device.switch6', inactiveLabel: false) {            
+            state 'z6off', label: '6', action: 'z6on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z6on', label: '6', action: 'z6off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
 		}
-        standardTile("switch15", "device.switch15", inactiveLabel: false) {            
-            state "z15off", label: '15', action: "z15on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z15on", label: '15', action: "z15off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
+        standardTile('switch7', 'device.switch7', inactiveLabel: false) {            
+            state 'z7off', label: '7', action: 'z7on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z7on', label: '7', action: 'z7off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
+		}
+		standardTile('switch8', 'device.switch8', inactiveLabel: false) {            
+            state 'z8off', label: '8', action: 'z8on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z8on', label: '8', action: 'z8off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
+		}
+        standardTile('switch9', 'device.switch9', inactiveLabel: false) {			
+			state 'z9off', label: '9', action: 'z9on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z9on', label: '9', action: 'z9off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
+		}
+        standardTile('switch10', 'device.switch10', inactiveLabel: false) {            
+            state 'z10off', label: '10', action: 'z10on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z10on', label: '10', action: 'z10off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
+		}        
+        standardTile('switch11', 'device.switch11', inactiveLabel: false) {			
+			state 'z11off', label: '11', action: 'z11on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z11on', label: '11', action: 'z11off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
+		}
+        standardTile('switch12', 'device.switch12', inactiveLabel: false) {            
+            state 'z12off', label: '12', action: 'z12on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z12on', label: '12', action: 'z12off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
+		}
+        standardTile('switch13', 'device.switch13', inactiveLabel: false) {            
+            state 'z13off', label: '13', action: 'z13on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z13on', label: '13', action: 'z13off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
+		}
+		standardTile('switch14', 'device.switch14', inactiveLabel: false) {            
+            state 'z14off', label: '14', action: 'z14on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z14on', label: '14', action: 'z14off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
+		}
+        standardTile('switch15', 'device.switch15', inactiveLabel: false) {            
+            state 'z15off', label: '15', action: 'z15on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z15on', label: '15', action: 'z15off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
 		}		
-        standardTile("switch16", "device.switch16", inactiveLabel: false) {            
-            state "z16off", label: '16', action: "z16on", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
-            state "z16on", label: '16', action: "z16off", icon: "st.valves.water.open", backgroundColor: "#46c2e8"
+        standardTile('switch16', 'device.switch16', inactiveLabel: false) {            
+            state 'z16off',  label: '16', action: 'z16on', icon: 'st.valves.water.closed', backgroundColor: '#ffffff'
+            state 'z16on',  label: '16', action: 'z16off', icon: 'st.valves.water.open', backgroundColor: '#00A0DC'
 		}        
-        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
-			state "default", action: "refresh", icon:"st.secondary.refresh"            
+        standardTile('refresh', 'device.switch', inactiveLabel: false, decoration: 'flat') {
+			state 'default', action: 'refresh', icon:'st.secondary.refresh'//-icon'            
 		}
-        standardTile("configure", "device.configure", inactiveLabel: false, decoration: "flat") {
-			state "configure", label:'', action:"configuration.configure", icon:"st.secondary.configure"
-		}		
+        standardTile('configure', 'device.configure', inactiveLabel: false, decoration: 'flat') {
+			state 'configure', label:'', action:'configuration.configure', icon:'http://www.plaidsystems.com/smartthings/st_syncsettings.png'//sync_icon_small.png'
+		}        
 		
-        main (["status"])        
-        details(["status","rainsensor","switch","switch1","switch2","switch3","switch4","switch5","switch6","switch7","switch8","switch9","switch10","switch11","switch12","switch13","switch14","switch15","switch16","refresh","configure"])		
-    }    
+        main (['switchall'])        
+        details(['switchall','minutes','rainsensor','switch1','switch2','switch3','switch4','switch','switch5','switch6','switch7','switch8','switch9','switch10','switch11','switch12','refresh','configure','switch13','switch14','switch15','switch16'])		
+    }       
 }
 
+//used for schedule 
 def programOn(){
-    sendEvent(name: "switch", value: "programOn", descriptionText: "Program turned on")    
+    sendEvent(name: 'switch', value: 'programOn', descriptionText: 'Program turned on')    
+    }
+
+def programWait(){    
+    sendEvent(name: 'switch', value: 'programWait', descriptionText: "Initializing Schedule")
+    }
+
+def programEnd(){
+	//sets switch to off and tells schedule switch is off/schedule complete with manaual
+    sendEvent(name: 'switch', value: 'off', descriptionText: 'Program manually turned off')
+    zoff() 
     }
     
 def programOff(){    
-    sendEvent(name: "switch", value: "off", descriptionText: "Program turned off")
+    sendEvent(name: 'switch', value: 'off', descriptionText: 'Program turned off')
     off()
     }
-    
-def updated(){
-	log.debug "updated"    
+
+//set minutes
+def levelUp(){
+	def newvalue = 1
+    if (device.latestValue('minutes') != null) newvalue = device.latestValue('minutes').toInteger()+1
+    if (newvalue >= 60) newvalue = 60
+    def value = newvalue.toString()    
+    log.debug value
+	sendEvent(name: 'minutes', value: "${value}", descriptionText: "Manual Time set to ${value}", display: false)    
+}
+
+def levelDown(){
+	def newvalue = device.latestValue('minutes').toInteger()-1
+    if (newvalue <= 0) newvalue = 1
+    def value = newvalue.toString()    
+    log.debug value
+	sendEvent(name: 'minutes', value: "${value}", descriptionText: "Manual Time set to ${value}", display: false)
 }
 
 // Parse incoming device messages to generate events
 def parse(String description) {	
-	//log.debug "Parse description $description"
+	log.debug "Parse description ${description}"
     def result = null
     def map = [:]
-	if (description?.startsWith("read attr -")) {
+	if (description?.startsWith('read attr -')) {
 		def descMap = parseDescriptionAsMap(description)
 		//log.debug "Desc Map: $descMap"
         //using 000F cluster instead of 0006 (switch) because ST does not differentiate between EPs and processes all as switch
-		if (descMap.cluster == "000F" && descMap.attrId == "0055") {
-			log.debug "Zone"
+		if (descMap.cluster == '000F' && descMap.attrId == '0055') {
+			log.debug 'Zone'
             map = getZone(descMap)            
 		}
-        else if (descMap.cluster == "0009" && descMap.attrId == "0000") {
-			log.debug "Alarm"            
+        else if (descMap.cluster == '0009' && descMap.attrId == '0000') {
+			log.debug 'Alarm'
             map = getAlarm(descMap)
             }
-	}     
-	
-	if (map) {
-		result = createEvent(map)
 	}
-	log.debug "Parse returned $map $result"
+    else if (description?.startsWith('catchall: 0104 0009')){
+    	log.debug 'Sync settings to controller complete'
+        if (device.latestValue('status') != 'alarm'){
+        	def configEvt = createEvent(name: 'status', value: 'schedule', descriptionText: "Sync settings to controller complete")
+            def configMsg = createEvent(name: 'tileMessage', value: 'Sync settings to controller complete', descriptionText: "Sync settings to controller complete", displayed: false)
+        	result = [configEvt, configMsg]
+            }
+        return result
+    }
+  
+    if (map) {
+    	result = createEvent(map)
+    	//configure after reboot
+        if (map.value == 'warning' || map.value == 'alarm'){
+            def cmds = config()       
+            def alarmEvt = createEvent(name: 'tileMessage', value: map.descriptionText, descriptionText: "${map.descriptionText}", displayed: false)
+            result = cmds?.collect { new physicalgraph.device.HubAction(it) } + createEvent(map) + alarmEvt           
+			return result
+		}
+        else if (map.name == 'rainsensor'){
+        	def rainEvt = createEvent(name: 'tileMessage', value: map.descriptionText, descriptionText: "${map.descriptionText}", displayed: false)
+        	result = [createEvent(map), rainEvt]
+            return result
+        }
+	}
+	if (map) log.debug "Parse returned ${map} ${result}"
 	return result
 }
 
 def parseDescriptionAsMap(description) {
-	(description - "read attr - ").split(",").inject([:]) { map, param ->
-		def nameAndValue = param.split(":")
+	(description - 'read attr - ').split(',').inject([:]) { map, param ->
+		def nameAndValue = param.split(':')
 		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
 	}
 }
@@ -270,27 +351,28 @@ def getZone(descMap){
     def EP = Integer.parseInt(descMap.endpoint.trim(), 16)
     
     String onoff
-    if(descMap.value == "00"){
-    	onoff = "off"        
+    if(descMap.value == '00'){
+    	onoff = 'off'        
     }    
-    else onoff = "on"
+    else onoff = 'on'
             
     if (EP == 1){
-    	map.name = "switch"
+    	map.name = 'switch'
         map.value = onoff
-        map.descriptionText = "${device.displayName} turned sprinkler program $onoff"
+        map.descriptionText = "${device.displayName} turned sprinkler program ${onoff}"
         }
         
     else if (EP == 18) {
-        map.name = "rainsensor"
-    	map.value = "rainSensor" + onoff
-        map.descriptionText = "${device.displayName} rain sensor is $onoff"
+        map.name = 'rainsensor'
+    	log.debug "Rain enable: ${RainEnable}, sensor: ${onoff}"
+        map.value = 'rainSensor' + onoff
+        map.descriptionText = "${device.displayName} rain sensor is ${onoff}"
         }
    	else {
         EP -= 1
-        map.name = "switch" + EP
-    	map.value = "z" + EP + onoff
-    	map.descriptionText = "${device.displayName} turned Zone $EP $onoff"
+        map.name = 'switch' + EP
+    	map.value = 'z' + EP + onoff
+    	map.descriptionText = "${device.displayName} turned Zone $EP ${onoff}"
     	}
         
     map.isStateChange = true 
@@ -300,37 +382,59 @@ def getZone(descMap){
 
 def getAlarm(descMap){
 	def map = [:]
-    map.name = "status"
+    map.name = 'status'
     def alarmID = Integer.parseInt(descMap.value.trim(), 16)
     log.debug "${alarmID}"
-    if(alarmID <= 0) map.descriptionText = "${device.displayName} has rebooted, no other alarms"
-    else map.descriptionText = "${device.displayName} rebooted, reported error on zone ${alarmID - 1}, please check zone is working correctly"    
-	map.value = "alarm"
-    map.isStateChange = true
+    map.value = 'alarm'
     map.displayed = true
+    map.isStateChange = true
+    if(alarmID <= 0){
+    	map.descriptionText = "${device.displayName} reboot, no other alarms"
+        map.value = 'warning'
+        //map.isStateChange = false
+        }
+    else map.descriptionText = "${device.displayName} reboot, reported zone ${alarmID - 1} error, please check zone is working correctly, press SYNC SETTINGS button to clear"
+       
     return map        
 }
 
 //status notify and change status
-def notify(value, text){	
-	sendEvent(name:"status", value:"$value", descriptionText:"$text", isStateChange: true, display: false)
+def notify(String val, String txt){
+	sendEvent(name: 'status', value: val, descriptionText: txt, isStateChange: true, display: false)
+    
+    //String txtShort = txt.take(100)
+    sendEvent(name: 'tileMessage', value: txt, descriptionText: "", isStateChange: true, display: false)
+}
 
+def updated(){
+	log.debug "updated"
+    
 }
 
 //prefrences - rain sensor, manual time
 def rain() {
-    log.debug "Rain $RainEnable"
+    log.debug "Rain sensor: ${RainEnable}"
+    if (RainEnable) sendEvent(name: 'rainsensor', value: 'enable', descriptionText: "${device.displayName} rain sensor is enabled", isStateChange: true)
+    else sendEvent(name: 'rainsensor', value: 'disable', descriptionText: "${device.displayName} rain sensor is disabled", isStateChange: true)
+    
     if (RainEnable) "st wattr 0x${device.deviceNetworkId} 18 0x0F 0x51 0x10 {01}"
     else "st wattr 0x${device.deviceNetworkId} 18 0x0F 0x51 0x10 {00}"
 }
-def manual(){
-	log.debug "Time $ManualTime"
-    def mTime = 10
-    if (ManualTime) mTime = ManualTime
-    def manualTime = hex(mTime)
-    "st wattr 0x${device.deviceNetworkId} 1 6 0x4002 0x21 {00${manualTime}}"
+
+def manualTime(value){	
+	sendEvent(name: 'minutes', value: "${value}", descriptionText: "Manual Time set to ${value}", display: false)
+}
+
+def manual(){    
+    def newManaul = 10    
+    if (device.latestValue('minutes')) newManaul = device.latestValue('minutes').toInteger()    
+    log.debug "Manual Zone runtime ${newManaul} mins"    
+    def manualTime = hex(newManaul)  
     
-    }
+    def sendCmds = []
+    sendCmds.push("st wattr 0x${device.deviceNetworkId} 1 6 0x4002 0x21 {00${manualTime}}")
+    return sendCmds
+}
 
 //write switch time settings map
 def settingsMap(WriteTimes, attrType){
@@ -366,13 +470,20 @@ def writeTime(wEP, runTime){
 
 //set reporting and binding
 def configure() {
+	
+    sendEvent(name: 'status', value: 'schedule', descriptionText: "Syncing settings to controller")
+    sendEvent(name: 'minutes', value: "10", descriptionText: "Manual Time set to 10 mins", display: false)
+    sendEvent(name: 'tileMessage', value: 'Syncing settings to controller', descriptionText: 'Syncing settings to controller')
+    config()    
+}
+
+def config(){
 
 	String zigbeeId = swapEndianHex(device.hub.zigbeeId)
-	log.debug "Confuguring Reporting and Bindings ${device.deviceNetworkId} ${device.zigbeeId}"
-	sendEvent(name: 'configuration',value: 100, descriptionText: "Configuration initialized")
+	log.debug "Configuring Reporting and Bindings ${device.deviceNetworkId} ${device.zigbeeId}"
     
     def configCmds = [	
-        //program on/off
+        //program on/off        
         "zdo bind 0x${device.deviceNetworkId} 1 1 6 {${device.zigbeeId}} {}", "delay 1000",
         "zdo bind 0x${device.deviceNetworkId} 1 1 0x09 {${device.zigbeeId}} {}", "delay 1000",        
         "zdo bind 0x${device.deviceNetworkId} 1 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
@@ -458,38 +569,16 @@ def configure() {
         "zcl global send-me-a-report 0x09 0x00 0x21 1 0 {00}", "delay 500",
         "send 0x${device.deviceNetworkId} 1 1", "delay 500"
 	]
-    return configCmds + rain() + manual()
+    return configCmds + rain()
 }
 
-
-
-private hex(value) {
-	new BigInteger(Math.round(value).toString()).toString(16)
-}
-
-private String swapEndianHex(String hex) {
-    reverseArray(hex.decodeHex()).encodeHex()
-}
-
-private byte[] reverseArray(byte[] array) {
-    int i = 0;
-    int j = array.length - 1;
-    byte tmp;
-    while (j > i) {
-        tmp = array[j];
-        array[j] = array[i];
-        array[i] = tmp;
-        j--;
-        i++;
-    }
-    return array
-}    
-
 def refresh() {
 
-	log.debug "refresh"
-    def refreshCmds = [
-	        
+	log.debug "refresh pressed"
+    sendEvent(name: 'tileMessage', value: 'Refresh', descriptionText: 'Refresh')
+        
+    def refreshCmds = [	    
+        
         "st rattr 0x${device.deviceNetworkId} 1 0x0F 0x55", "delay 500",
         
         "st rattr 0x${device.deviceNetworkId} 2 0x0F 0x55", "delay 500",
@@ -513,64 +602,96 @@ def refresh() {
         "st rattr 0x${device.deviceNetworkId} 18 0x0F 0x51","delay 500",
  	
     ]
-    return refreshCmds + rain() + manual()
+    
+    return refreshCmds
+}
+
+private hex(value) {
+	new BigInteger(Math.round(value).toString()).toString(16)
+}
+
+private String swapEndianHex(String hex) {
+    reverseArray(hex.decodeHex()).encodeHex()
+}
+
+private byte[] reverseArray(byte[] array) {
+    int i = 0;
+    int j = array.length - 1;
+    byte tmp;
+    while (j > i) {
+        tmp = array[j];
+        array[j] = array[i];
+        array[i] = tmp;
+        j--;
+        i++;
+    }
+    return array
+}
+
+//on & off redefined for Alexa to start manual schedule
+def on() {    
+    log.debug 'Alexa on'
+    //schedule subscribes to programOn
+    sendEvent(name: 'switch', value: 'programOn', descriptionText: 'Alexa turned program on')           
+}
+def off() {
+	log.debug 'Alexa off'
+    sendEvent(name: 'switch', value: 'off', descriptionText: 'Alexa turned program off')
+    zoff()        
 }
 
 // Commands to device
 //zones on - 8
-def on() {
-    //sendEvent(name:"status", value:"active", descriptionText:"Program Running", isStateChange: true, display: false)
-    log.debug "on"
-    "st cmd 0x${device.deviceNetworkId} 1 6 1 {}"    
+def zon() {
+	"st cmd 0x${device.deviceNetworkId} 1 6 1 {}"
 }
-def off() {
-    log.debug "off"
-    "st cmd 0x${device.deviceNetworkId} 1 6 0 {}"    
+def zoff() {
+	"st cmd 0x${device.deviceNetworkId} 1 6 0 {}" 
 }
 def z1on() {	
-    "st cmd 0x${device.deviceNetworkId} 2 6 1 {}"
+    return manual() + "st cmd 0x${device.deviceNetworkId} 2 6 1 {}"    
 }
 def z1off() {    
     "st cmd 0x${device.deviceNetworkId} 2 6 0 {}"
 }
 def z2on() {	
-    "st cmd 0x${device.deviceNetworkId} 3 6 1 {}"    
+    return manual() + "st cmd 0x${device.deviceNetworkId} 3 6 1 {}"    
 }
 def z2off() {    
     "st cmd 0x${device.deviceNetworkId} 3 6 0 {}"    
 }
 def z3on() {        
-    "st cmd 0x${device.deviceNetworkId} 4 6 1 {}"    
+    return manual() + "st cmd 0x${device.deviceNetworkId} 4 6 1 {}"    
 }
 def z3off() {	
     "st cmd 0x${device.deviceNetworkId} 4 6 0 {}"    
 }
 def z4on() {	
-    "st cmd 0x${device.deviceNetworkId} 5 6 1 {}"    
+    return manual() + "st cmd 0x${device.deviceNetworkId} 5 6 1 {}"    
 }
 def z4off() {    
     "st cmd 0x${device.deviceNetworkId} 5 6 0 {}"    
 }
 def z5on() {	
-	"st cmd 0x${device.deviceNetworkId} 6 6 1 {}"   
+	return manual() + "st cmd 0x${device.deviceNetworkId} 6 6 1 {}"   
 }
 def z5off() {
 	"st cmd 0x${device.deviceNetworkId} 6 6 0 {}"    
 }
 def z6on() {
-	"st cmd 0x${device.deviceNetworkId} 7 6 1 {}"
+	return manual() + "st cmd 0x${device.deviceNetworkId} 7 6 1 {}"
 }
 def z6off() {
     "st cmd 0x${device.deviceNetworkId} 7 6 0 {}"
 }
 def z7on() {
-	"st cmd 0x${device.deviceNetworkId} 8 6 1 {}"  
+	return manual() + "st cmd 0x${device.deviceNetworkId} 8 6 1 {}"  
 }
 def z7off() {
 	"st cmd 0x${device.deviceNetworkId} 8 6 0 {}"    
 }
 def z8on() {
-	"st cmd 0x${device.deviceNetworkId} 9 6 1 {}"    
+	return manual() + "st cmd 0x${device.deviceNetworkId} 9 6 1 {}"    
 }
 def z8off() {
 	"st cmd 0x${device.deviceNetworkId} 9 6 0 {}"    
@@ -578,50 +699,51 @@ def z8off() {
 
 //zones 9 - 16
 def z9on() {	
-    "st cmd 0x${device.deviceNetworkId} 10 6 1 {}"    
+    return manual() + "st cmd 0x${device.deviceNetworkId} 10 6 1 {}"    
 }
 def z9off() {	    
     "st cmd 0x${device.deviceNetworkId} 10 6 0 {}"   
 }
 def z10on() {	
-    "st cmd 0x${device.deviceNetworkId} 11 6 1 {}"    
+    return manual() + "st cmd 0x${device.deviceNetworkId} 11 6 1 {}"    
 }
 def z10off() {    
     "st cmd 0x${device.deviceNetworkId} 11 6 0 {}"    
 }
 def z11on() {        
-    "st cmd 0x${device.deviceNetworkId} 12 6 1 {}"    
+    return manual() + "st cmd 0x${device.deviceNetworkId} 12 6 1 {}"    
 }
 def z11off() {	
     "st cmd 0x${device.deviceNetworkId} 12 6 0 {}"    
 }
 def z12on() {	
-    "st cmd 0x${device.deviceNetworkId} 13 6 1 {}"    
+    return manual() + "st cmd 0x${device.deviceNetworkId} 13 6 1 {}"    
 }
 def z12off() {    
     "st cmd 0x${device.deviceNetworkId} 13 6 0 {}"    
 }
 def z13on() {	
-	"st cmd 0x${device.deviceNetworkId} 14 6 1 {}"   
+	return manual() + "st cmd 0x${device.deviceNetworkId} 14 6 1 {}"   
 }
 def z13off() {
 	"st cmd 0x${device.deviceNetworkId} 14 6 0 {}"    
 }
 def z14on() {
-	"st cmd 0x${device.deviceNetworkId} 15 6 1 {}"
+	return manual() + "st cmd 0x${device.deviceNetworkId} 15 6 1 {}"
 }
 def z14off() {
     "st cmd 0x${device.deviceNetworkId} 15 6 0 {}"
 }
 def z15on() {
-	"st cmd 0x${device.deviceNetworkId} 16 6 1 {}"  
+	return manual() + "st cmd 0x${device.deviceNetworkId} 16 6 1 {}"  
 }
 def z15off() {
 	"st cmd 0x${device.deviceNetworkId} 16 6 0 {}"    
 }
 def z16on() {
-	"st cmd 0x${device.deviceNetworkId} 17 6 1 {}"    
+	return manual() + "st cmd 0x${device.deviceNetworkId} 17 6 1 {}"    
 }
 def z16off() {
 	"st cmd 0x${device.deviceNetworkId} 17 6 0 {}"    
-}
+}
+

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

@@ -254,7 +254,8 @@ private Map getTemperatureResult(value) {
 	return [
 		name: 'temperature',
 		value: value,
-		descriptionText: descriptionText
+		descriptionText: descriptionText,
+		unit: temperatureScale
 	]
 }
 

devicetypes/roomieremote-agent/simple-sync.src/simple-sync.groovy

@@ -22,7 +22,7 @@ metadata
     {
 		standardTile("mainTile", "device.status", width: 1, height: 1, icon: "st.Entertainment.entertainment11")
         {
-        	state "default", label: "Simple Sync", icon: "st.Home.home2", backgroundColor: "#55A7FF"
+        	state "default", label: "Simple Sync", icon: "st.Home.home2", backgroundColor: "#00a0dc"
 		}
         
     	def detailTiles = ["mainTile"]

devicetypes/smartthings/aeon-illuminator-module.src/aeon-illuminator-module.groovy

@@ -47,9 +47,9 @@ metadata {
 
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+			state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00A0DC", nextState:"turningOff"
 			state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			state "turningOn", label:'${name}', icon:"st.switches.switch.on", backgroundColor:"#79b821"
+			state "turningOn", label:'${name}', icon:"st.switches.switch.on", backgroundColor:"#00A0DC"
 			state "turningOff", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ffffff"
 		}
 		controlTile("levelSliderControl", "device.level", "slider", height: 2, width: 1, inactiveLabel: false) {

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

@@ -15,6 +15,7 @@ metadata {
 	definition (name: "Aeon Key Fob", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
 		capability "Button"
+		capability "Holdable Button"
 		capability "Configuration"
 		capability "Sensor"
 		capability "Battery"
@@ -36,14 +37,14 @@ metadata {
 	tiles {
 		standardTile("button", "device.button", width: 2, height: 2) {
 			state "default", label: "", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#ffffff"
-			state "button 1 pushed", label: "pushed #1", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#79b821"
-			state "button 2 pushed", label: "pushed #2", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#79b821"
-			state "button 3 pushed", label: "pushed #3", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#79b821"
-			state "button 4 pushed", label: "pushed #4", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#79b821"
-			state "button 1 held", label: "held #1", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#ffa81e"
-			state "button 2 held", label: "held #2", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#ffa81e"
-			state "button 3 held", label: "held #3", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#ffa81e"
-			state "button 4 held", label: "held #4", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#ffa81e"
+			state "button 1 pushed", label: "pushed #1", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#00A0DC"
+			state "button 2 pushed", label: "pushed #2", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#00A0DC"
+			state "button 3 pushed", label: "pushed #3", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#00A0DC"
+			state "button 4 pushed", label: "pushed #4", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#00A0DC"
+			state "button 1 held", label: "held #1", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#e86d13"
+			state "button 2 held", label: "held #2", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#e86d13"
+			state "button 3 held", label: "held #3", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#e86d13"
+			state "button 4 held", label: "held #4", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#e86d13"
 		}
 		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat") {
 			state "battery", label:'${currentValue}% battery', unit:""
@@ -118,3 +119,16 @@ def configure() {
 	log.debug("Sending configuration: $cmd")
 	return cmd
 }
+
+
+def installed() {
+	initialize()
+}
+
+def updated() {
+	initialize()
+}
+
+def initialize() {
+	sendEvent(name: "numberOfButtons", value: 4)
+}

devicetypes/smartthings/aeon-led-bulb.src/aeon-led-bulb.groovy

@@ -37,9 +37,9 @@ metadata {
 	}
 
 	standardTile("switch", "device.switch", width: 1, height: 1, canChangeIcon: true) {
-		state "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+		state "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#00a0dc", nextState:"turningOff"
 		state "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-		state "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+		state "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#00a0dc", nextState:"turningOff"
 		state "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
 	}
 	standardTile("reset", "device.reset", inactiveLabel: false, decoration: "flat") {

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

@@ -15,6 +15,7 @@ metadata {
 	definition (name: "Aeon Minimote", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
 		capability "Button"
+		capability "Holdable Button"
 		capability "Configuration"
 		capability "Sensor"
 
@@ -107,3 +108,16 @@ def configure() {
 	log.debug("Sending configuration: $cmds")
 	return cmds
 }
+
+
+def installed() {
+	initialize()
+}
+
+def updated() {
+	initialize()
+}
+
+def initialize() {
+	sendEvent(name: "numberOfButtons", value: 4)
+}

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

@@ -28,6 +28,7 @@ metadata {
 		attribute "powerSupply", "enum", ["USB Cable", "Battery"]
 
 		fingerprint deviceId: "0x2101", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x7A", outClusters: "0x5A"
+		fingerprint deviceId: "0x2101", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x7A,0x5A"
 	}
 
 	simulator {
@@ -81,8 +82,8 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name:"motion", type: "generic", width: 6, height: 4){
 			tileAttribute ("device.motion", key: "PRIMARY_CONTROL") {
-				attributeState "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
-				attributeState "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
+				attributeState "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC"
+				attributeState "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#cccccc"
 			}
 		}
 		valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {
@@ -352,7 +353,7 @@ def configure() {
 									motionSensitivity == "minimum" ? 0 : 64)
 
 	//5. report every x minutes (threshold reports don't work on battery power, default 8 mins)
-	request << zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: timeOptionValueMap[reportInterval] ?: 8*60) //association group 1
+	request << zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: timeOptionValueMap[reportInterval] ?: (8*60)) //association group 1
 
 	request << zwave.configurationV1.configurationSet(parameterNumber: 112, size: 4, scaledConfigurationValue: 6*60*60)  //association group 2
 

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

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

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

@@ -0,0 +1,43 @@
+# Aeon Multisensor Gen5
+
+Cloud Execution
+
+Works with: 
+
+* [Aeon Labs MultiSensor (Gen 5)](https://www.smartthings.com/works-with-smartthings/sensors/aeon-labs-multisensor-gen-5)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Motion Sensor** - can detect motion
+* **Temperature Measurement** - defines device measures current temperature
+* **Relative Humidity Measurement** - allow reading the relative humidity from devices that support it
+* **Illuminance Measurement** - gives the illuminance reading from devices that support it
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Sensor** - detects sensor events
+* **Battery** - defines device uses a battery
+* **Health Check** - indicates ability to get device health notifications
+
+
+## Device Health
+
+Aeon Labs MultiSensor (Gen 5) is polled by the hub.
+As of hubCore version 0.14.38 the hub sends up reports every 15 minutes regardless of whether the state changed.
+Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*15 + 2)mins = 32 mins.
+Not to mention after going OFFLINE when the device is plugged back in, it might take a considerable amount of time for
+the device to appear as ONLINE again. This is because if this listening device does not respond to two poll requests in a row,
+it is not polled for 5 minutes by the hub. This can delay up the process of being marked ONLINE by quite some time.
+
+* __32min__ checkInterval
+
+## Troubleshooting
+
+If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the device is out of range.
+Pairing needs to be tried again by placing the device closer to the hub.
+Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following link:
+* [Aeon Labs MultiSensor (Gen 5) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/206157226-Aeon-Labs-MultiSensor-Gen-5-)

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

@@ -20,8 +20,12 @@ metadata {
 		capability "Configuration"
 		capability "Sensor"
 		capability "Battery"
+		capability "Health Check"
+
+		command "configureAfterSecure"
 
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x98,0x7A", outClusters:"0x5A"
+		fingerprint mfr:"0086", prod:"0102", model:"004A", deviceJoinName: "Aeon Labs MultiSensor (Gen 5)"
 	}
 
 	simulator {
@@ -62,8 +66,8 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name:"motion", type: "generic", width: 6, height: 4){
 			tileAttribute ("device.motion", key: "PRIMARY_CONTROL") {
-				attributeState "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
-				attributeState "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
+				attributeState "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00a0dc"
+				attributeState "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#cccccc"
 			}
 		}
 		valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {
@@ -96,6 +100,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
@@ -242,6 +251,13 @@ def configureAfterSecure() {
     secureSequence(request) + ["delay 20000", zwave.wakeUpV1.wakeUpNoMoreInformation().format()]
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	secure(zwave.batteryV1.batteryGet())
+}
+
 def configure() {
 	// log.debug "configure()"
     //["delay 30000"] + secure(zwave.securityV1.securityCommandsSupportedGet())

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

@@ -59,8 +59,8 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name:"motion", type: "generic", width: 6, height: 4){
 			tileAttribute ("device.motion", key: "PRIMARY_CONTROL") {
-				attributeState "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
-				attributeState "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
+				attributeState "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00a0dc"
+				attributeState "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#cccccc"
 			}
 		}
 		valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {

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

@@ -45,7 +45,7 @@ metadata {
 	// tile definitions
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00a0dc"
 			state "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
 		}
 		valueTile("energy", "device.energy", decoration: "flat") {

devicetypes/smartthings/aeon-secure-smart-energy-switch-uk.src/aeon-secure-smart-energy-switch-uk.groovy

@@ -53,7 +53,7 @@ metadata {
 	// tile definitions
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00A0DC"
 			state "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
 		}
 		valueTile("power", "device.power", decoration: "flat") {

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

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

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

@@ -0,0 +1,37 @@
+# Aeon Siren
+
+Cloud Execution
+
+Works with: 
+
+* [Aeon Labs Siren (Gen 5)](https://www.smartthings.com/works-with-smartthings/aeon-labs/aeon-labs-siren-gen-5)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Alarm** - allows for interacting with devices that serve as alarms
+* **Switch** - can detect state (possible values: on/off)
+* **Health Check** - indicates ability to get device health notifications
+
+## Device Health
+
+Aeon Labs Siren (Gen 5) is polled by the hub.
+As of hubCore version 0.14.38 the hub sends up reports every 15 minutes regardless of whether the state changed.
+Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*15 + 2)mins = 32 mins.
+Not to mention after going OFFLINE when the device is plugged back in, it might take a considerable amount of time for
+the device to appear as ONLINE again. This is because if this listening device does not respond to two poll requests in a row,
+it is not polled for 5 minutes by the hub. This can delay up the process of being marked ONLINE by quite some time.
+
+* __32min__ checkInterval
+
+## Troubleshooting
+
+If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the device is out of range.
+Pairing needs to be tried again by placing the device closer to the hub.
+Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following link:
+* [Aeon Labs Siren (Gen 5) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/204555240-Aeon-Labs-Siren-Gen-5-)

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

@@ -20,10 +20,11 @@ metadata {
 	capability "Actuator"
 	capability "Alarm"
 	capability "Switch"
+	capability "Health Check"
 
 	command "test"
 
-	fingerprint deviceId: "0x1005", inClusters: "0x5E,0x98"
+	fingerprint deviceId: "0x1005", inClusters: "0x5E,0x98", deviceJoinName: "Aeon Labs Siren (Gen 5)"
  }
 
  simulator {
@@ -58,6 +59,9 @@ 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])
+
 	if(!state.sound) state.sound = 1
 	if(!state.volume) state.volume = 3
 
@@ -148,3 +152,10 @@ def test() {
 private secure(physicalgraph.zwave.Command cmd) {
 	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
 }
+
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	secure(zwave.basicV1.basicGet())
+}

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

@@ -60,7 +60,7 @@ metadata {
 	// tile definitions
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00a0dc"
 			state "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
 		}
 		valueTile("power", "device.power", decoration: "flat") {
@@ -78,7 +78,7 @@ metadata {
 
 		(1..4).each { n ->
 			standardTile("switch$n", "switch$n", canChangeIcon: true) {
-				state "on", label: '${name}', action: "off$n", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+				state "on", label: '${name}', action: "off$n", icon: "st.switches.switch.on", backgroundColor: "#00a0dc"
 				state "off", label: '${name}', action: "on$n", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
 			}
 			valueTile("power$n", "power$n", decoration: "flat") {

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

@@ -11,17 +11,6 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
- 
- /*
- *  Purpose: Arrival Sensor HA DTH File
- *
- *  Filename: Arrival-Sensor-HA.src/Arrival-Sensor-HA.groovy
- *
- *  Change History:
- *  1. 20160115 TW - Update/Edit to support i18n translations
- *  2. 20160121 TW - Update to V4 battery calcs, added pref's page title translations
- */
- 
 metadata {
     definition (name: "Arrival Sensor HA", namespace: "smartthings", author: "SmartThings") {
         capability "Tone"
@@ -50,7 +39,7 @@ metadata {
 
     tiles {
         standardTile("presence", "device.presence", width: 2, height: 2, canChangeBackground: true) {
-            state "present", labelIcon:"st.presence.tile.present", backgroundColor:"#53a7c0"
+            state "present", labelIcon:"st.presence.tile.present", backgroundColor:"#00a0dc"
             state "not present", labelIcon:"st.presence.tile.not-present", backgroundColor:"#ffffff"
         }
         standardTile("beep", "device.beep", decoration: "flat") {
@@ -70,7 +59,7 @@ def updated() {
 }
 
 def configure() {
-    def cmds = zigbee.configureReporting(0x0001, 0x0020, 0x20, 20, 20, 0x01)
+    def cmds = zigbee.batteryConfig(20, 20, 0x01)
     log.debug "configure -- cmds: ${cmds}"
     return cmds
 }
@@ -162,7 +151,7 @@ private handlePresenceEvent(present) {
 
 private startTimer() {
     log.debug "Scheduling periodic timer"
-    schedule("0 * * * * ?", checkPresenceCallback)
+    runEvery1Minute("checkPresenceCallback")
 }
 
 private stopTimer() {

devicetypes/smartthings/arrival-sensor-ha.src/i18n/messages.properties

@@ -1,35 +1,26 @@
-#==============================================================================
 #  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 
+#  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 
+#  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.
-#==============================================================================
-# Purpose: Arrival Sensor HA i18n Translation File
-#
-# Filename: Arrival-Sensor-HA.src/i18n/messages.properties
-#
-# Change History:
-#	1. 20160115 TW Initial release with informal Korean translation.
-#	2. 20160121 TW Added def preference section titles.
-#==============================================================================
 # Korean (ko)
 # Device Preferences
-'''Give your device a name'''.ko=기기 이름 바꾸기
+'''Give your device a name'''.ko=기기 이름 설정
 '''Set Device Image'''.ko=기기 이미지 설정
-'''Presence timeout (minutes)'''.ko=시간 초과. 스마트폰 위치 정보
+'''Presence timeout (minutes)'''.ko=알람 유예 시간 설정 (분)
 '''Tap to set'''.ko=눌러서 설정
 '''Arrival Sensor'''.ko=도착알림 센서
+'''${currentValue}% battery'''.ko=${currentValue}% 배터리
 # Events / Notifications
-'''{{ linkText }} battery was {{ value }}'''.ko={{ linkText }}남아있는 배터리는 {{ value }}입니다.
-'''{{ linkText }} has arrived'''.ko={{ linkText }}집에 도착했습니다.
-'''{{ linkText }} has left'''.ko={{ linkText }}집을 나갔습니다.
+'''{{ linkText }} battery was {{ value }}'''.ko={{ linkText }}의 남은 배터리 {{ value }}
+'''{{ linkText }} has arrived'''.ko={{ linkText }} 귀가
+'''{{ linkText }} has left'''.ko={{ linkText }} 외출
 #==============================================================================

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

@@ -42,8 +42,8 @@ metadata {
 
 	tiles {
 		standardTile("presence", "device.presence", width: 2, height: 2, canChangeBackground: true) {
-			state "present", labelIcon:"st.presence.tile.present", backgroundColor:"#53a7c0"
-			state "not present", labelIcon:"st.presence.tile.not-present", backgroundColor:"#ebeef2"
+			state "present", labelIcon:"st.presence.tile.present", backgroundColor:"#00a0dc"
+			state "not present", labelIcon:"st.presence.tile.not-present", backgroundColor:"#ffffff"
 		}
 		standardTile("beep", "device.beep", decoration: "flat") {
 			state "beep", label:'', action:"tone.beep", icon:"st.secondary.beep", backgroundColor:"#ffffff"
@@ -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/bose-soundtouch.src/bose-soundtouch.groovy

@@ -27,7 +27,7 @@ metadata {
         capability "Switch"
         capability "Refresh"
         capability "Music Player"
-        capability "Polling"
+        capability "Health Check"
 
         /**
          * Define all commands, ie, if you have a custom action not
@@ -47,6 +47,9 @@ metadata {
 
         command "everywhereJoin"
         command "everywhereLeave"
+
+        command "forceOff"
+        command "forceOn"
     }
 
     /**
@@ -64,8 +67,10 @@ metadata {
     }
 
     standardTile("switch", "device.switch", width: 1, height: 1, canChangeIcon: true) {
-        state "off", label: '${name}', action: "switch.on", icon: "st.Electronics.electronics16", backgroundColor: "#ffffff"
-        state "on", label: '${name}', action: "switch.off", icon: "st.Electronics.electronics16", backgroundColor: "#79b821"
+        state "on", label: '${name}', action: "forceOff", icon: "st.Electronics.electronics16", backgroundColor: "#00a0dc", nextState:"turningOff"
+        state "turningOff", label:'TURNING OFF', icon:"st.Electronics.electronics16", backgroundColor:"#ffffff"
+        state "off", label: '${name}', action: "forceOn", icon: "st.Electronics.electronics16", backgroundColor: "#ffffff", nextState:"turningOn"
+        state "turningOn", label:'TURNING ON', icon:"st.Electronics.electronics16", backgroundColor:"#00a0dc"
     }
     valueTile("1", "device.station1", decoration: "flat", canChangeIcon: false) {
         state "station1", label:'${currentValue}', action:"preset1"
@@ -138,8 +143,22 @@ metadata {
  * one place.
  *
  */
-def off() { onAction("off") }
-def on() { onAction("on") }
+def off() {
+    if (device.currentState("switch")?.value == "on") {
+        onAction("off")
+    }
+}
+def forceOff() {
+    onAction("off")
+}
+def on() {
+    if (device.currentState("switch")?.value == "off") {
+        onAction("on")
+    }
+}
+def forceOn() {
+    onAction("on")
+}
 def volup() { onAction("volup") }
 def voldown() { onAction("voldown") }
 def preset1() { onAction("1") }
@@ -217,7 +236,33 @@ def parse(String event) {
  * @return action(s) to take or null
  */
 def installed() {
-    onAction("refresh")
+    // Notify health check about this device with timeout interval 12 minutes
+    sendEvent(name: "checkInterval", value: 12 * 60, data: [protocol: "lan", hubHardwareId: device.hub.hardwareID], displayed: false)
+    startPoll()
+}
+
+/**
+ * Called by health check if no events been generated in the last 12 minutes
+ * If device doesn't respond it will be marked offline (not available)
+ */
+def ping() {
+    TRACE("ping")
+    boseSendGetNowPlaying()
+}
+
+/**
+ * Schedule a 2 minute poll of the device to refresh the
+ * tiles so the user gets the correct information.
+ */
+def startPoll() {
+    TRACE("startPoll")
+    unschedule()
+    // Schedule 2 minute polling of speaker status (song average length is 3-4 minutes)
+    def sec = Math.round(Math.floor(Math.random() * 60))
+    //def cron = "$sec 0/5 * * * ?" // every 5 min
+    def cron = "$sec 0/2 * * * ?" // every 2 min
+    log.debug "schedule('$cron', boseSendGetNowPlaying)"
+    schedule(cron, boseSendGetNowPlaying)
 }
 
 /**
@@ -238,11 +283,11 @@ def onAction(String user, data=null) {
     def actions = null
     switch (user) {
         case "on":
-            actions = boseSetPowerState(true)
+            boseSetPowerState(true)
             break
         case "off":
             boseSetNowPlaying(null, "STANDBY")
-            actions = boseSetPowerState(false)
+            boseSetPowerState(false)
             break
         case "volume":
             actions = boseSetVolume(data)
@@ -297,14 +342,6 @@ def onAction(String user, data=null) {
     return actions
 }
 
-/**
- * Called every so often (every 5 minutes actually) to refresh the
- * tiles so the user gets the correct information.
- */
-def poll() {
-    return boseRefreshNowPlaying()
-}
-
 /**
  * Joins this speaker into the everywhere zone
  */
@@ -747,8 +784,16 @@ def cb_boseSetInput(xml, input) {
  */
 def boseSetPowerState(boolean enable) {
     log.info "boseSetPowerState(${enable})"
-    queueCallback('nowPlaying', "cb_boseSetPowerState", enable ? "POWERON" : "POWEROFF")
-    return boseRefreshNowPlaying()
+    // Fix to get faster update of power status back from speaker after sending on/off
+    // Instead of queuing the command to be sent after the refresh send it directly via sendHubCommand
+    // Note: This is a temporary hack that should be replaced by a re-design of the
+    // DTH to use sendHubCommand for all commands
+    sendHubCommand(bosePOST("/key", "<key state=\"press\" sender=\"Gabbo\">POWER</key>")) 
+    sendHubCommand(bosePOST("/key", "<key state=\"release\" sender=\"Gabbo\">POWER</key>"))
+    sendHubCommand(boseGET("/now_playing"))
+    if (enable) {
+        queueCallback('nowPlaying', "cb_boseConfirmPowerOn", 5)
+    }
 }
 
 /**
@@ -787,10 +832,11 @@ def cb_boseSetPowerState(xml, state) {
  */
 def cb_boseConfirmPowerOn(xml, tries) {
     def result = []
-    log.warn "boseConfirmPowerOn() attempt #" + tries
-    if (xml.attributes()['source'] == "STANDBY" && tries > 0) {
+    def attempt = tries as Integer
+    log.warn "boseConfirmPowerOn() attempt #$attempt"
+    if (xml.attributes()['source'] == "STANDBY" && attempt > 0) {
         result << boseRefreshNowPlaying()
-        queueCallback('nowPlaying', "cb_boseConfirmPowerOn", tries-1)
+        queueCallback('nowPlaying', "cb_boseConfirmPowerOn", attempt-1)
     }
     return result
 }
@@ -809,6 +855,10 @@ def boseRefreshNowPlaying(delay=0) {
     return boseGET("/now_playing")
 }
 
+def boseSendGetNowPlaying() {
+    sendHubCommand(boseGET("/now_playing"))
+}
+
 /**
  * Requests the list of presets
  *
@@ -986,4 +1036,8 @@ def boseGetDeviceID() {
  */
 def getDeviceIP() {
     return parent.resolveDNI2Address(device.deviceNetworkId)
+}
+
+def TRACE(text) {
+    log.trace "${text}"
 }

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

@@ -1,146 +0,0 @@
-/**
- *  Copyright 2015 SmartThings
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- *	CentraLite Dimmer
- *
- *	Author: SmartThings
- *	Date: 2013-12-04
- */
-//DEPRECATED - Using the generic DTH for this device. Users need to be moved before deleting this DTH
-metadata {
-	definition (name: "CentraLite Dimmer", namespace: "smartthings", author: "SmartThings") {
-		capability "Switch Level"
-		capability "Actuator"
-		capability "Switch"
-		capability "Power Meter"
-		capability "Configuration"
-		capability "Refresh"
-		capability "Sensor"
-
-	}
-
-	// simulator metadata
-	simulator {
-		// status messages
-		status "on": "on/off: 1"
-		status "off": "on/off: 0"
-
-		// reply messages
-		reply "zcl on-off on": "on/off: 1"
-		reply "zcl on-off off": "on/off: 0"
-	}
-
-	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"
-			}
-			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-				attributeState "level", action:"switch level.setLevel"
-			}
-			tileAttribute ("power", key: "SECONDARY_CONTROL") {
-				attributeState "power", label:'${currentValue} W'
-			}
-		}
-		
-		standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-		
-		main "switch"
-		details(["switch","refresh"])
-	}
-}
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-	log.debug "Parse description $description"
-	def name = null
-	def value = null
-	if (description?.startsWith("catchall:")) {
-		def msg = zigbee.parse(description)
-		log.trace msg
-		log.trace "data: $msg.data"
-	} else if (description?.startsWith("read attr -")) {
-		def descMap = parseDescriptionAsMap(description)
-		log.debug "Read attr: $description"
-		if (descMap.cluster == "0006" && descMap.attrId == "0000") {
-			name = "switch"
-			value = descMap.value.endsWith("01") ? "on" : "off"
-		} else {
-			def reportValue = description.split(",").find {it.split(":")[0].trim() == "value"}?.split(":")[1].trim()
-			name = "power"
-			// assume 16 bit signed for encoding and power divisor is 10
-			value = Integer.parseInt(reportValue, 16) / 10
-		}
-	} else if (description?.startsWith("on/off:")) {
-		log.debug "Switch command"
-		name = "switch"
-		value = description?.endsWith(" 1") ? "on" : "off"
-	}
-
-	def result = createEvent(name: name, value: value)
-	log.debug "Parse returned ${result?.descriptionText}"
-	return result
-}
-
-def parseDescriptionAsMap(description) {
-	(description - "read attr - ").split(",").inject([:]) { map, param ->
-		def nameAndValue = param.split(":")
-		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
-	}
-}
-
-// Commands to device
-def on() {
-	'zcl on-off on'
-}
-
-def off() {
-	'zcl on-off off'
-}
-
-def setLevel(value) {
-	log.trace "setLevel($value)"
-	sendEvent(name: "level", value: value)
-    def level = hexString(Math.round(value * 255/100))
-	def cmd = "st cmd 0x${device.deviceNetworkId} 1 8 4 {${level} 2000}"
-	log.debug cmd
-	cmd
-}
-
-def meter() {
-	"st rattr 0x${device.deviceNetworkId} 1 0xB04 0x50B"
-}
-
-def refresh() {
-	"st rattr 0x${device.deviceNetworkId} 1 0xB04 0x50B"
-}
-
-def configure() {
-	[
-		"zdo bind 0x${device.deviceNetworkId} 1 1 8 {${device.zigbeeId}} {}", "delay 200",
-		"zdo bind 0x${device.deviceNetworkId} 1 1 6 {${device.zigbeeId}} {}", "delay 200",
-		"zdo bind 0x${device.deviceNetworkId} 1 1 0xB04 {${device.zigbeeId}} {}"
-	]
-}
-
-private hex(value, width=2) {
-    def s = new BigInteger(Math.round(value).toString()).toString(16)
-    while (s.size() < width) {
-        s = "0" + s
-    }
-    s
-}

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

@@ -55,13 +55,13 @@ metadata {
 			state "fanOn", label:'${name}', action:"thermostat.setThermostatFanMode"
 		}
 		controlTile("heatSliderControl", "device.heatingSetpoint", "slider", height: 1, width: 2, inactiveLabel: false) {
-			state "setHeatingSetpoint", action:"thermostat.setHeatingSetpoint", backgroundColor:"#d04e00"
+			state "setHeatingSetpoint", action:"thermostat.setHeatingSetpoint", backgroundColor:"#e86d13"
 		}
 		valueTile("heatingSetpoint", "device.heatingSetpoint", inactiveLabel: false, decoration: "flat") {
 			state "heat", label:'${currentValue}° heat', unit:"F", backgroundColor:"#ffffff"
 		}
 		controlTile("coolSliderControl", "device.coolingSetpoint", "slider", height: 1, width: 2, inactiveLabel: false) {
-			state "setCoolingSetpoint", action:"thermostat.setCoolingSetpoint", backgroundColor: "#1e9cbb"
+			state "setCoolingSetpoint", action:"thermostat.setCoolingSetpoint", backgroundColor: "#00a0dc"
 		}
 		valueTile("coolingSetpoint", "device.coolingSetpoint", inactiveLabel: false, decoration: "flat") {
 			state "cool", label:'${currentValue}° cool', unit:"F", backgroundColor:"#ffffff"
@@ -81,48 +81,47 @@ metadata {
 // parse events into attributes
 def parse(String description) {
 	log.debug "Parse description $description"
-	def map = [:]
-	if (description?.startsWith("read attr -")) {
-		def descMap = parseDescriptionAsMap(description)
-		log.debug "Desc Map: $descMap"
-		if (descMap.cluster == "0201" && descMap.attrId == "0000") {
+	List result = []
+	def descMap = zigbee.parseDescriptionAsMap(description)
+	log.debug "Desc Map: $descMap"
+	List attrData = [[cluster: descMap.cluster ,attrId: descMap.attrId, value: descMap.value]]
+	descMap.additionalAttrs.each {
+	    attrData << [cluster: descMap.cluster, attrId: it.attrId, value: it.value]
+	}
+	attrData.each {
+		def map = [:]
+		if (it.cluster == "0201" && it.attrId == "0000") {
 			log.debug "TEMP"
 			map.name = "temperature"
-			map.value = getTemperature(descMap.value)
-		} else if (descMap.cluster == "0201" && descMap.attrId == "0011") {
+			map.value = getTemperature(it.value)
+			map.unit = temperatureScale
+		} else if (it.cluster == "0201" && it.attrId == "0011") {
 			log.debug "COOLING SETPOINT"
 			map.name = "coolingSetpoint"
-			map.value = getTemperature(descMap.value)
-		} else if (descMap.cluster == "0201" && descMap.attrId == "0012") {
+			map.value = getTemperature(it.value)
+			map.unit = temperatureScale
+		} else if (it.cluster == "0201" && it.attrId == "0012") {
 			log.debug "HEATING SETPOINT"
 			map.name = "heatingSetpoint"
-			map.value = getTemperature(descMap.value)
-		} else if (descMap.cluster == "0201" && descMap.attrId == "001c") {
+			map.value = getTemperature(it.value)
+			map.unit = temperatureScale
+		} else if (it.cluster == "0201" && it.attrId == "001c") {
 			log.debug "MODE"
 			map.name = "thermostatMode"
-			map.value = getModeMap()[descMap.value]
-		} else if (descMap.cluster == "0202" && descMap.attrId == "0000") {
+			map.value = getModeMap()[it.value]
+		} else if (it.cluster == "0202" && it.attrId == "0000") {
 			log.debug "FAN MODE"
 			map.name = "thermostatFanMode"
-			map.value = getFanModeMap()[descMap.value]
+			map.value = getFanModeMap()[it.value]
 		}
+		if (map) {
+			result << createEvent(map)
+		}
+		log.debug "Parse returned $map"
 	}
-
-	def result = null
-	if (map) {
-		result = createEvent(map)
-	}
-	log.debug "Parse returned $map"
 	return result
 }
 
-def parseDescriptionAsMap(description) {
-	(description - "read attr - ").split(",").inject([:]) { map, param ->
-		def nameAndValue = param.split(":")
-		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
-	}
-}
-
 def getModeMap() { [
 	"00":"off",
 	"03":"cool",
@@ -169,7 +168,7 @@ def setHeatingSetpoint(degrees) {
 
 		def degreesInteger = Math.round(degrees)
 		log.debug "setHeatingSetpoint({$degreesInteger} ${temperatureScale})"
-		sendEvent("name": "heatingSetpoint", "value": degreesInteger)
+		sendEvent("name": "heatingSetpoint", "value": degreesInteger, "unit": temperatureScale)
 
 		def celsius = (getTemperatureScale() == "C") ? degreesInteger : (fahrenheitToCelsius(degreesInteger) as Double).round(2)
 		"st wattr 0x${device.deviceNetworkId} 1 0x201 0x12 0x29 {" + hex(celsius * 100) + "}"
@@ -180,7 +179,7 @@ def setCoolingSetpoint(degrees) {
 	if (degrees != null) {
 		def degreesInteger = Math.round(degrees)
 		log.debug "setCoolingSetpoint({$degreesInteger} ${temperatureScale})"
-		sendEvent("name": "coolingSetpoint", "value": degreesInteger)
+		sendEvent("name": "coolingSetpoint", "value": degreesInteger, "unit": temperatureScale)
 		def celsius = (getTemperatureScale() == "C") ? degreesInteger : (fahrenheitToCelsius(degreesInteger) as Double).round(2)
 		"st wattr 0x${device.deviceNetworkId} 1 0x201 0x11 0x29 {" + hex(celsius * 100) + "}"
 	}

devicetypes/smartthings/cooper-rf9500.src/cooper-rf9500.groovy

@@ -16,7 +16,7 @@ metadata {
 		capability "Switch"
 		capability "Switch Level"
 		capability "Button"
-        capability "Actuator"
+		capability "Actuator"
 
 		//fingerprint deviceId: "0x1200", inClusters: "0x77 0x86 0x75 0x73 0x85 0x72 0xEF", outClusters: "0x26"
 	}
@@ -36,7 +36,7 @@ metadata {
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
 			state "off", label: '${name}', action: "switch.on", icon: "st.Home.home30", backgroundColor: "#ffffff"
-			state "on", label: '${name}', action: "switch.off", icon: "st.Home.home30", backgroundColor: "#79b821"
+			state "on", label: '${name}', action: "switch.off", icon: "st.Home.home30", backgroundColor: "#00a0dc"
 		}
 		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
@@ -74,20 +74,20 @@ def off() {
 }
 
 def levelup() {
-	def curlevel = device.currentValue('level') as Integer 
+	def curlevel = device.currentValue('level') as Integer
 	if (curlevel <= 90)
-    	setLevel(curlevel + 10);     
+    	setLevel(curlevel + 10);
 }
 
 def leveldown() {
-	def curlevel = device.currentValue('level') as Integer 
+	def curlevel = device.currentValue('level') as Integer
 	if (curlevel >= 10)
-    	setLevel(curlevel - 10)    
+    	setLevel(curlevel - 10)
 }
 
 def setLevel(value) {
 	log.trace "setLevel($value)"
-	sendEvent(name: "level", value: value) 
+	sendEvent(name: "level", value: value)
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd) {
@@ -106,11 +106,11 @@ def zwaveEvent(physicalgraph.zwave.commands.switchmultilevelv1.SwitchMultilevelS
 	if (cmd.upDown == true) {
 		Integer buttonid = 2
         leveldown()
-		checkbuttonEvent(buttonid)		
+		checkbuttonEvent(buttonid)
     } else if (cmd.upDown == false) {
 		Integer buttonid = 3
         levelup()
-		checkbuttonEvent(buttonid)       
+		checkbuttonEvent(buttonid)
 	}
 }
 
@@ -140,12 +140,12 @@ def buttonEvent(button) {
     def result = []
 	if (button == 1) {
     	def mystate = device.currentValue('switch');
-        if (mystate == "on") 
+        if (mystate == "on")
             off()
         else
-            on()   
+            on()
     }
-    updateState("currentButton", "$button")   
+    updateState("currentButton", "$button")
         // update the device state, recording the button press
         result << createEvent(name: "button", value: "pushed", data: [buttonNumber: button], descriptionText: "$device.displayName button $button was pushed", isStateChange: true)
     result
@@ -182,3 +182,16 @@ def updateState(String name, String value) {
 	state[name] = value
 	device.updateDataValue(name, value)
 }
+
+
+def installed() {
+	initialize()
+}
+
+def updated() {
+	initialize()
+}
+
+def initialize() {
+	sendEvent(name: "numberOfButtons", value: 3)
+}

devicetypes/smartthings/cree-bulb.src/.st-ignore

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

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

@@ -0,0 +1,36 @@
+# Connected Cree LED Bulb
+
+Cloud Execution
+
+Works with: 
+
+* [Connected Cree LED Bulb](https://support.smartthings.com/hc/en-us/articles/204258280-Cree-Connected-LED-Bulb)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Configuration** - _configure()_ command called when device is installed or device preferences updated
+* **Polling** - represents that poll() can be implemented for the device
+* **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
+
+Connected Cree LED Bulb with cloud polling it every __5min__
+SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
+
+* __12min__ checkInterval
+
+## Troubleshooting
+
+If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the device is out of range.
+Pairing needs to be tried again by placing the device closer to the hub.
+Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following link:
+* [Cree Connected LED Bulb Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/204258280-Cree-Connected-LED-Bulb)

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

@@ -13,7 +13,7 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
- 
+
 metadata {
     definition (name: "Cree Bulb", namespace: "smartthings", author: "SmartThings") {
 
@@ -22,6 +22,8 @@ metadata {
         capability "Refresh"
         capability "Switch"
         capability "Switch Level"
+        capability "Health Check"
+        capability "Light"
 
         fingerprint profileId: "C05E", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0000,0019"
     }
@@ -41,9 +43,9 @@ metadata {
     tiles(scale: 2) {
         multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
             }
             tileAttribute ("device.level", key: "SLIDER_CONTROL") {
@@ -81,14 +83,30 @@ def on() {
 }
 
 def setLevel(value) {
-    zigbee.setLevel(value) + ["delay 500"] + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
+    zigbee.setLevel(value) + zigbee.onOffRefresh() + zigbee.levelRefresh()       //adding refresh because of ZLL bulb not conforming to send-me-a-report
+}
+
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+    return zigbee.levelRefresh()
 }
 
 def refresh() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig() + zigbee.levelConfig()
+    zigbee.onOffRefresh() + zigbee.levelRefresh()
+}
+
+def healthPoll() {
+    log.debug "healthPoll()"
+    def cmds = zigbee.onOffRefresh() + zigbee.levelRefresh()
+    cmds.each{ sendHubCommand(new physicalgraph.device.HubAction(it))}
 }
 
 def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
+    unschedule()
+    runEvery5Minutes("healthPoll")
+    // Device-Watch allows 2 check-in misses from device + ping
+    sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+    zigbee.onOffRefresh() + zigbee.levelRefresh()
 }

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

@@ -81,13 +81,13 @@ metadata {
 			state "fanCirculate", label:'${name}', action:"switchFanMode"
 		}
 		controlTile("heatSliderControl", "device.heatingSetpoint", "slider", height: 1, width: 2, inactiveLabel: false) {
-			state "setHeatingSetpoint", action:"quickSetHeat", backgroundColor:"#d04e00"
+			state "setHeatingSetpoint", action:"quickSetHeat", backgroundColor:"#e86d13"
 		}
 		valueTile("heatingSetpoint", "device.heatingSetpoint", inactiveLabel: false, decoration: "flat") {
 			state "heat", label:'${currentValue}° heat', backgroundColor:"#ffffff"
 		}
 		controlTile("coolSliderControl", "device.coolingSetpoint", "slider", height: 1, width: 2, inactiveLabel: false) {
-			state "setCoolingSetpoint", action:"quickSetCool", backgroundColor: "#1e9cbb"
+			state "setCoolingSetpoint", action:"quickSetCool", backgroundColor: "#00a0dc"
 		}
 		valueTile("coolingSetpoint", "device.coolingSetpoint", inactiveLabel: false, decoration: "flat") {
 			state "cool", label:'${currentValue}° cool', backgroundColor:"#ffffff"

devicetypes/smartthings/danalock.src/danalock.groovy

@@ -33,10 +33,10 @@ metadata {
 
 	tiles {
 		standardTile("toggle", "device.lock", width: 2, height: 2) {
-			state "locked", label:'locked', action:"lock.unlock", icon:"st.locks.lock.locked", backgroundColor:"#79b821", nextState:"unlocking"
+			state "locked", label:'locked', action:"lock.unlock", icon:"st.locks.lock.locked", backgroundColor:"#00a0dc", nextState:"unlocking"
 			state "unlocked", label:'unlocked', action:"lock.lock", icon:"st.locks.lock.unlocked", backgroundColor:"#ffffff", nextState:"locking"
 			state "unknown", label:"unknown", action:"lock.lock", icon:"st.locks.lock.unknown", backgroundColor:"#ffffff", nextState:"locking"
-			state "locking", label:'locking', icon:"st.locks.lock.locked", backgroundColor:"#79b821"
+			state "locking", label:'locking', icon:"st.locks.lock.locked", backgroundColor:"#00a0dc"
 			state "unlocking", label:'unlocking', icon:"st.locks.lock.unlocked", backgroundColor:"#ffffff"
 		}
 		standardTile("lock", "device.lock", inactiveLabel: false, decoration: "flat") {

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,51 @@
+# Z-wave Dimmer Switch
+
+Local Execution on V2 Hubs
+
+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)
+* [GE 1,000-Watt In-Wall Smart Dimmer Switch (GE 12725)](http://products.z-wavealliance.org/products/1198)
+* [GE In-Wall Smart Fan Control (GE 12730)](http://products.z-wavealliance.org/products/1202)
+
+## 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), 1000-watt In-Wall Smart Dimmer Switch and In-Wall Smart Fan Control 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.
+
+* __32min__ checkInterval
+
+## Troubleshooting
+
+If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the device is out of range.
+Pairing needs to be tried again by placing the device closer to the hub.
+Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following link:
+* [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-)
+* [GE 1,000-Watt In-Wall Smart Dimmer Switch (GE 12725) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/200879274)
+* [GE In-Wall Smart Fan Control (GE 12730) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/200879274)

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

@@ -20,8 +20,13 @@ metadata {
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
+		capability "Health Check"
+		capability "Light"
 
-		fingerprint inClusters: "0x26"
+		fingerprint mfr:"0063", prod:"4457", deviceJoinName: "GE In-Wall Smart Dimmer "
+		fingerprint mfr:"0063", prod:"4944", deviceJoinName: "GE In-Wall Smart Dimmer "
+		fingerprint mfr:"0063", prod:"5044", deviceJoinName: "GE Plug-In Smart Dimmer "
+		fingerprint mfr:"0063", prod:"4944", model:"3034", deviceJoinName: "GE In-Wall Smart Fan Control"
 	}
 
 	simulator {
@@ -42,12 +47,16 @@ metadata {
 		reply "200163,delay 5000,2602": "command: 2603, payload: 63"
 	}
 
+	preferences {
+		input "ledIndicator", "enum", title: "LED Indicator", description: "Turn LED indicator... ", required: false, options:["on": "When On", "off": "When Off", "never": "Never"], defaultValue: "off"
+	}
+
 	tiles(scale: 2) {
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00a0dc", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00a0dc", nextState:"turningOff"
 				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
 			}
 			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
@@ -70,11 +79,30 @@ metadata {
 		}
 
 		main(["switch"])
-		details(["switch", "level", "indicator", "refresh"])
+		details(["switch", "level", "refresh"])
 
 	}
 }
 
+def updated(){
+	// Device-Watch simply pings if no device events received for 32min(checkInterval)
+	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+  switch (ledIndicator) {
+        case "on":
+            indicatorWhenOn()
+            break
+        case "off":
+            indicatorWhenOff()
+            break
+        case "never":
+            indicatorNever()
+            break
+        default:
+            indicatorWhenOn()
+            break
+    }
+}
+
 def parse(String description) {
 	def result = null
 	if (description != "updated") {
@@ -138,6 +166,7 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
 	log.debug "productTypeId:    ${cmd.productTypeId}"
 	def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
 	updateDataValue("MSR", msr)
+	updateDataValue("manufacturer", cmd.manufacturerName)
 	createEvent([descriptionText: "$device.displayName MSR: $msr", isStateChange: false])
 }
 
@@ -191,6 +220,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 = []
@@ -201,19 +237,19 @@ def refresh() {
 	delayBetween(commands,100)
 }
 
-def indicatorWhenOn() {
-	sendEvent(name: "indicatorStatus", value: "when on")
-	zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()
+void indicatorWhenOn() {
+	sendEvent(name: "indicatorStatus", value: "when on", displayed: false)
+	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()))
 }
 
-def indicatorWhenOff() {
-	sendEvent(name: "indicatorStatus", value: "when off")
-	zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 3, size: 1).format()
+void indicatorWhenOff() {
+	sendEvent(name: "indicatorStatus", value: "when off", displayed: false)
+	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 3, size: 1).format()))
 }
 
-def indicatorNever() {
-	sendEvent(name: "indicatorStatus", value: "never")
-	zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 3, size: 1).format()
+void indicatorNever() {
+	sendEvent(name: "indicatorStatus", value: "never", displayed: false)
+	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 3, size: 1).format()))
 }
 
 def invertSwitch(invert=true) {
@@ -223,4 +259,4 @@ def invertSwitch(invert=true) {
 	else {
 		zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 4, size: 1).format()
 	}
-}
+}

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

@@ -47,8 +47,8 @@ metadata {
 		}
 
 		standardTile("motion", "device.motion") {
-			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff")
-			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0")
+			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#cccccc")
+			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC")
 		}
 
 		standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat") {

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

@@ -23,6 +23,7 @@ metadata {
 		capability "Sensor"
 		capability "Refresh"
 		capability "Relative Humidity Measurement"
+		capability "Health Check"
 
 		command "generateEvent"
 		command "raiseSetpoint"
@@ -31,13 +32,14 @@ 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"
+		attribute "deviceAlive", "enum", ["true", "false"]
 	}
 
 	tiles {
@@ -120,6 +122,21 @@ metadata {
 
 }
 
+void installed() {
+    // The device refreshes every 5 minutes by default so if we miss 2 refreshes we can consider it offline
+    // Using 12 minutes because in testing, device health team found that there could be "jitter"
+    sendEvent(name: "checkInterval", value: 60 * 12, data: [protocol: "cloud"], displayed: false)
+}
+
+// Device Watch will ping the device to proactively determine if the device has gone offline
+// If the device was online the last time we refreshed, trigger another refresh as part of the ping.
+def ping() {
+    def isAlive = device.currentValue("deviceAlive") == "true" ? true : false
+    if (isAlive) {
+        refresh()
+    }
+}
+
 // parse events into attributes
 def parse(String description) {
 	log.debug "Parsing '${description}'"
@@ -148,15 +165,13 @@ 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, isStateChange: isChange, displayed: isDisplayed]
+				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
-				event << [value: sendValue, displayed: false]
+				def sendValue =  location.temperatureScale == "C"? roundC(convertFtoC(value.toDouble())) : value.toInteger()
+				event << [value: sendValue, unit: temperatureScale, displayed: false]
 			}  else if (name=="heatMode" || name=="coolMode" || name=="autoMode" || name=="auxHeatMode"){
 				isChange = isStateChange(device, name, value.toString())
 				event << [value: value.toString(), isStateChange: isChange, displayed: false]
@@ -166,7 +181,11 @@ def generateEvent(Map results) {
 			}  else if (name=="humidity") {
 				isChange = isStateChange(device, name, value.toString())
 				event << [value: value.toString(), isStateChange: isChange, displayed: false, unit: "%"]
-			}  else {
+			} else if (name == "deviceAlive") {
+				isChange = isStateChange(device, name, value.toString())
+				event['isStateChange'] = isChange
+				event['displayed'] = false
+			} else {
 				isChange = isStateChange(device, name, value.toString())
 				isDisplayed = isChange
 				event << [value: value.toString(), isStateChange: isChange, displayed: isDisplayed]
@@ -234,9 +253,9 @@ void setHeatingSetpoint(setpoint) {
 	def heatingValue = location.temperatureScale == "C"? convertCtoF(heatingSetpoint) : heatingSetpoint
 
 	def sendHoldType = holdType ? (holdType=="Temporary")? "nextTransition" : (holdType=="Permanent")? "indefinite" : "indefinite" : "indefinite"
-	if (parent.setHold(this, heatingValue, coolingValue, deviceId, sendHoldType)) {
-		sendEvent("name":"heatingSetpoint", "value":heatingSetpoint)
-		sendEvent("name":"coolingSetpoint", "value":coolingSetpoint)
+	if (parent.setHold(heatingValue, coolingValue, deviceId, sendHoldType)) {
+		sendEvent("name":"heatingSetpoint", "value":heatingSetpoint, "unit":location.temperatureScale)
+		sendEvent("name":"coolingSetpoint", "value":coolingSetpoint, "unit":location.temperatureScale)
 		log.debug "Done setHeatingSetpoint> coolingSetpoint: ${coolingSetpoint}, heatingSetpoint: ${heatingSetpoint}"
 		generateSetpointEvent()
 		generateStatusEvent()
@@ -253,7 +272,6 @@ void setCoolingSetpoint(setpoint) {
 	def maxCoolingSetpoint = device.currentValue("maxCoolingSetpoint")
 	def minCoolingSetpoint = device.currentValue("minCoolingSetpoint")
 
-
 	if (coolingSetpoint > maxCoolingSetpoint) {
 		coolingSetpoint = maxCoolingSetpoint
 	} else if (coolingSetpoint < minCoolingSetpoint) {
@@ -271,9 +289,9 @@ void setCoolingSetpoint(setpoint) {
 	def heatingValue = location.temperatureScale == "C"? convertCtoF(heatingSetpoint) : heatingSetpoint
 
 	def sendHoldType = holdType ? (holdType=="Temporary")? "nextTransition" : (holdType=="Permanent")? "indefinite" : "indefinite" : "indefinite"
-	if (parent.setHold(this, heatingValue, coolingValue, deviceId, sendHoldType)) {
-		sendEvent("name":"heatingSetpoint", "value":heatingSetpoint)
-		sendEvent("name":"coolingSetpoint", "value":coolingSetpoint)
+	if (parent.setHold(heatingValue, coolingValue, deviceId, sendHoldType)) {
+		sendEvent("name":"heatingSetpoint", "value":heatingSetpoint, "unit":location.temperatureScale)
+		sendEvent("name":"coolingSetpoint", "value":coolingSetpoint, "unit":location.temperatureScale)
 		log.debug "Done setCoolingSetpoint>> coolingSetpoint = ${coolingSetpoint}, heatingSetpoint = ${heatingSetpoint}"
 		generateSetpointEvent()
 		generateStatusEvent()
@@ -283,18 +301,17 @@ 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()
-	if (parent.resumeProgram(this, deviceId)) {
+	if (parent.resumeProgram(deviceId)) {
 		sendEvent("name":"thermostatStatus", "value":"setpoint is updating", "description":statusText, displayed: false)
 		runIn(5, "poll")
 		log.debug "resumeProgram() is done"
 		sendEvent("name":"resumeProgram", "value":"resume", descriptionText: "resumeProgram is done", displayed: false, isStateChange: true)
 	} else {
 		sendEvent("name":"thermostatStatus", "value":"failed resume click refresh", "description":statusText, displayed: false)
-		log.error "Error resumeProgram() check parent.resumeProgram(this, deviceId)"
+		log.error "Error resumeProgram() check parent.resumeProgram(deviceId)"
 	}
 
 }
@@ -354,7 +371,6 @@ def switchFanMode() {
 }
 
 def switchToFanMode(nextMode) {
-
 	log.debug "switching to fan mode: $nextMode"
 	def returnCommand
 
@@ -406,7 +422,7 @@ def generateOperatingStateEvent(operatingState) {
 def off() {
 	log.debug "off"
 	def deviceId = device.deviceNetworkId.split(/\./).last()
-	if (parent.setMode (this,"off", deviceId))
+	if (parent.setMode ("off", deviceId))
 		generateModeEvent("off")
 	else {
 		log.debug "Error setting new mode."
@@ -420,7 +436,7 @@ def off() {
 def heat() {
 	log.debug "heat"
 	def deviceId = device.deviceNetworkId.split(/\./).last()
-	if (parent.setMode (this,"heat", deviceId))
+	if (parent.setMode ("heat", deviceId))
 		generateModeEvent("heat")
 	else {
 		log.debug "Error setting new mode."
@@ -438,7 +454,7 @@ def emergencyHeat() {
 def auxHeatOnly() {
 	log.debug "auxHeatOnly"
 	def deviceId = device.deviceNetworkId.split(/\./).last()
-	if (parent.setMode (this,"auxHeatOnly", deviceId))
+	if (parent.setMode ("auxHeatOnly", deviceId))
 		generateModeEvent("auxHeatOnly")
 	else {
 		log.debug "Error setting new mode."
@@ -452,7 +468,7 @@ def auxHeatOnly() {
 def cool() {
 	log.debug "cool"
 	def deviceId = device.deviceNetworkId.split(/\./).last()
-	if (parent.setMode (this,"cool", deviceId))
+	if (parent.setMode ("cool", deviceId))
 		generateModeEvent("cool")
 	else {
 		log.debug "Error setting new mode."
@@ -466,7 +482,7 @@ def cool() {
 def auto() {
 	log.debug "auto"
 	def deviceId = device.deviceNetworkId.split(/\./).last()
-	if (parent.setMode (this,"auto", deviceId))
+	if (parent.setMode ("auto", deviceId))
 		generateModeEvent("auto")
 	else {
 		log.debug "Error setting new mode."
@@ -489,7 +505,7 @@ def fanOn() {
 	def coolingValue = location.temperatureScale == "C"? convertCtoF(coolingSetpoint) : coolingSetpoint
 	def heatingValue = location.temperatureScale == "C"? convertCtoF(heatingSetpoint) : heatingSetpoint
 
-	if (parent.setFanMode(this, heatingValue, coolingValue, deviceId, sendHoldType, fanMode)) {
+	if (parent.setFanMode(heatingValue, coolingValue, deviceId, sendHoldType, fanMode)) {
 		generateFanModeEvent(fanMode)
 	} else {
 		log.debug "Error setting new mode."
@@ -510,7 +526,7 @@ def fanAuto() {
 	def coolingValue = location.temperatureScale == "C"? convertCtoF(coolingSetpoint) : coolingSetpoint
 	def heatingValue = location.temperatureScale == "C"? convertCtoF(heatingSetpoint) : heatingSetpoint
 
-	if (parent.setFanMode(this, heatingValue, coolingValue, deviceId, sendHoldType, fanMode)) {
+	if (parent.setFanMode(heatingValue, coolingValue, deviceId, sendHoldType, fanMode)) {
 		generateFanModeEvent(fanMode)
 	} else {
 		log.debug "Error setting new mode."
@@ -520,63 +536,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 )
-
+		sendEvent("name":"thermostatSetpoint", "value":heatingSetpoint, "unit":location.temperatureScale)
 	}
 	else if (mode == "cool") {
-
-		sendEvent("name":"thermostatSetpoint", "value":coolingSetpoint)
-
+		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)
-
+		sendEvent("name":"thermostatSetpoint", "value":heatingSetpoint, "unit":location.temperatureScale)
 	}
-
 }
 
 void raiseSetpoint() {
@@ -585,21 +594,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) {
@@ -608,7 +627,7 @@ void raiseSetpoint() {
 			targetvalue = maxCoolingSetpoint
 		}
 
-		sendEvent("name":"thermostatSetpoint", "value":targetvalue, displayed: false)
+		sendEvent("name":"thermostatSetpoint", "value":targetvalue, "unit":location.temperatureScale, displayed: false)
 		log.info "In mode $mode raiseSetpoint() to $targetvalue"
 
 		runIn(3, "alterSetpoint", [data: [value:targetvalue], overwrite: true]) //when user click button this runIn will be overwrite
@@ -622,20 +641,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) {
@@ -644,7 +672,7 @@ void lowerSetpoint() {
 			targetvalue = minCoolingSetpoint
 		}
 
-		sendEvent("name":"thermostatSetpoint", "value":targetvalue, displayed: false)
+		sendEvent("name":"thermostatSetpoint", "value":targetvalue, "unit":location.temperatureScale, displayed: false)
 		log.info "In mode $mode lowerSetpoint() to $targetvalue"
 
 		runIn(3, "alterSetpoint", [data: [value:targetvalue], overwrite: true]) //when user click button this runIn will be overwrite
@@ -653,66 +681,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(this, heatingValue, coolingValue, deviceId, sendHoldType)) {
-		sendEvent("name": "thermostatSetpoint", "value": temp.value, displayed: false)
-		sendEvent("name": "heatingSetpoint", "value": targetHeatingSetpoint)
-		sendEvent("name": "coolingSetpoint", "value": targetCoolingSetpoint)
-		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 +767,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 +799,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/econet-vent.src/econet-vent.groovy

@@ -53,7 +53,7 @@ metadata {
 
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "on", action:"switch.off", icon:"st.vents.vent-open-text", backgroundColor:"#53a7c0"
+			state "on", action:"switch.off", icon:"st.vents.vent-open-text", backgroundColor:"#00a0dc"
 			state "off", action:"switch.on", icon:"st.vents.vent-closed", backgroundColor:"#ffffff"
 		}
         valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat") {

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

@@ -33,7 +33,7 @@ metadata {
 		multiAttributeTile(name:"water", type: "generic", width: 6, height: 4){
 			tileAttribute ("device.water", key: "PRIMARY_CONTROL") {
 				attributeState "dry", icon:"st.alarm.water.dry", backgroundColor:"#ffffff"
-				attributeState "wet", icon:"st.alarm.water.wet", backgroundColor:"#53a7c0"
+				attributeState "wet", icon:"st.alarm.water.wet", backgroundColor:"#00a0dc"
 			}
 		}
 		valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false, width: 2, height: 2) {

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

@@ -56,9 +56,9 @@ metadata {
 
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+			state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00a0dc", nextState:"turningOff"
 			state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			state "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+			state "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00a0dc", nextState:"turningOff"
 			state "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
 		}
 		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {

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

@@ -1,12 +1,12 @@
 /**
  *  Device Type Definition File
  *
- *  Device Type:		Fibaro Flood Sensor
- *  File Name:			fibaro-flood-sensor.groovy
- *	Initial Release:	2014-12-10
- *	@author:			Todd Wackford
- *  Email:				todd@wackford.net
- *  @version:			1.0
+ *  Device Type:        Fibaro Flood Sensor
+ *  File Name:          fibaro-flood-sensor.groovy
+ *  Initial Release:    2014-12-10
+ *  @author:            Todd Wackford
+ *  Email:              todd@wackford.net
+ *  @version:           1.0
  *
  *  Copyright 2014 SmartThings
  *
@@ -26,8 +26,8 @@
  * not displayed to the user. We do this so we can receive events and display on device 
  * activity. If the user wants to display the tamper tile, adjust the tile display lines
  * with the following:
- *		main(["water", "temperature", "tamper"])
- *		details(["water", "temperature", "battery", "tamper"])
+ *      main(["water", "temperature", "tamper"])
+ *      details(["water", "temperature", "battery", "tamper"])
  *
  * @param none
  *
@@ -39,13 +39,18 @@ metadata {
 		capability "Temperature Measurement"
 		capability "Configuration"
 		capability "Battery"
-       
-        command		"resetParams2StDefaults"
-        command		"listCurrentParams"
-        command		"updateZwaveParam"
-        command		"test"
-        
+		capability "Health Check"
+    capability "Sensor"
+    
+		command    "resetParams2StDefaults"
+		command    "listCurrentParams"
+		command    "updateZwaveParam"
+		command    "test"
+
 		fingerprint deviceId: "0xA102", inClusters: "0x30,0x9C,0x60,0x85,0x8E,0x72,0x70,0x86,0x80,0x84"
+		fingerprint mfr:"010F", prod:"0000", model:"2002"
+		fingerprint mfr:"010F", prod:"0000", model:"1002"
+		fingerprint mfr:"010F", prod:"0B00", model:"1001"
 	}
 
 	simulator {
@@ -72,7 +77,7 @@ metadata {
 	tiles {
 		standardTile("water", "device.water", width: 2, height: 2) {
 			state "dry", icon:"st.alarm.water.dry", backgroundColor:"#ffffff"
-			state "wet", icon:"st.alarm.water.wet", backgroundColor:"#53a7c0"
+			state "wet", icon:"st.alarm.water.wet", backgroundColor:"#00a0dc"
 		}
 		valueTile("temperature", "device.temperature", inactiveLabel: false) {
 			state "temperature", label:'${currentValue}°',
@@ -86,9 +91,9 @@ metadata {
 				[value: 96, color: "#bc2323"]
 			]
 		}
-        standardTile("tamper", "device.tamper") {
-			state("secure", 	label:"secure",   	icon:"st.locks.lock.locked",   backgroundColor:"#ffffff")
-			state("tampered", 	label:"tampered", 	icon:"st.locks.lock.unlocked", backgroundColor:"#53a7c0")
+		standardTile("tamper", "device.tamper") {
+			state("secure",         label:"secure",         icon:"st.locks.lock.locked",   backgroundColor:"#ffffff")
+			state("tampered",       label:"tampered",       icon:"st.locks.lock.unlocked", backgroundColor:"#00a0dc")
 		}
 		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat") {
 			state "battery", label:'${currentValue}% battery', unit:""
@@ -106,26 +111,17 @@ metadata {
 def parse(String description)
 {
 	def result = []
-	
-    if (description == "updated") {
-    	if (!state.MSR) {
-			result << response(zwave.wakeUpV1.wakeUpIntervalSet(seconds: 60*60, nodeid:zwaveHubNodeId))
-			result << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
-		} 
-    } else {
-		def cmd = zwave.parse(description, [0x31: 2, 0x30: 1, 0x70: 2, 0x71: 1, 0x84: 1, 0x80: 1, 0x9C: 1, 0x72: 2, 0x56: 2, 0x60: 3])
-    
-		if (cmd) {
-			result += zwaveEvent(cmd) //createEvent(zwaveEvent(cmd))   
-		}
-    }
-    
-    result << response(zwave.batteryV1.batteryGet().format())
-    
-    if ( result[0] != null ) {
+
+	def cmd = zwave.parse(description, [0x31: 2, 0x30: 1, 0x70: 2, 0x71: 1, 0x84: 1, 0x80: 1, 0x9C: 1, 0x72: 2, 0x56: 2, 0x60: 3])
+
+	if (cmd) {
+		result += zwaveEvent(cmd) //createEvent(zwaveEvent(cmd))   
+	}
+
+	if ( result[0] != null ) {
 		log.debug "Parse returned ${result}"
 		result
-    }
+	}
 }
 
 
@@ -142,10 +138,9 @@ def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd) {
 	def result = [createEvent(descriptionText: "${device.displayName} woke up", isStateChange: false)]
 	if (!isConfigured()) {
 		// we're still in the process of configuring a newly joined device
-		result += lateConfigure(true)
+		result << lateConfigure(true)
 	} else {
-		result += response(zwave.wakeUpV1.wakeUpNoMoreInformation())
-        log.debug "We're done with WakeUp!"
+		result << response(zwave.wakeUpV1.wakeUpNoMoreInformation())
 	}
 	result
 }
@@ -153,7 +148,7 @@ def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd) {
 def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv2.SensorMultilevelReport cmd)
 {
 	def map = [:]
-    
+
 	switch (cmd.sensorType) {
 		case 1:
 			// temperature
@@ -184,7 +179,7 @@ def zwaveEvent(physicalgraph.zwave.commands.sensorbinaryv1.SensorBinaryReport cm
 	def map = [:]
 	map.value = cmd.sensorValue ? "active" : "inactive"
 	map.name = "acceleration"
-    
+
 	if (map.value == "active") {
 		map.descriptionText = "$device.displayName detected vibration"
 	}
@@ -199,49 +194,49 @@ def zwaveEvent(physicalgraph.zwave.commands.configurationv2.ConfigurationReport
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
-    log.debug "BasicSet with CMD = ${cmd}"
-    
-    if (!isConfigured()) {
-    	def result = []
-    	def map = [:]
-    
-    	map.name = "water"
+	log.debug "BasicSet with CMD = ${cmd}"
+
+	if (!isConfigured()) {
+		def result = []
+		def map = [:]
+
+		map.name = "water"
 		map.value = cmd.value ? "wet" : "dry"
 		map.descriptionText = "${device.displayName} is ${map.value}"
-    
-    	// If we are getting a BasicSet, and isConfigured == false, then we are likely NOT properly configured.
-    	result += lateConfigure(true)
-    
-    	result << createEvent(map)
-        
-        result
-    }
+
+		// If we are getting a BasicSet, and isConfigured == false, then we are likely NOT properly configured.
+		result += lateConfigure(true)
+
+		result << createEvent(map)
+
+		result
+	}
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.sensoralarmv1.SensorAlarmReport cmd)
 {
 	def map = [:]
-    
+
 	if (cmd.sensorType == 0x05) {
 		map.name = "water"
 		map.value = cmd.sensorState ? "wet" : "dry"
 		map.descriptionText = "${device.displayName} is ${map.value}"
-        
-        log.debug "CMD = SensorAlarmReport: ${cmd}"
-    	setConfigured()
-    } else if ( cmd.sensorType == 0) {
-    	map.name = "tamper"
-        map.isStateChange = true
-        map.value = cmd.sensorState ? "tampered" : "secure"
-        map.descriptionText = "${device.displayName} has been tampered with"
-        runIn(30, "resetTamper") //device does not send alarm cancelation
-        
-    } else if ( cmd.sensorType == 1) {
-    	map.name = "tamper"
-        map.value = cmd.sensorState ? "tampered" : "secure"
-        map.descriptionText = "${device.displayName} has been tampered with"
-        runIn(30, "resetTamper") //device does not send alarm cancelation
-        
+
+		log.debug "CMD = SensorAlarmReport: ${cmd}"
+		setConfigured()
+	} else if ( cmd.sensorType == 0) {
+		map.name = "tamper"
+		map.isStateChange = true
+		map.value = cmd.sensorState ? "tampered" : "secure"
+		map.descriptionText = "${device.displayName} has been tampered with"
+		runIn(30, "resetTamper") //device does not send alarm cancelation
+
+	} else if ( cmd.sensorType == 1) {
+		map.name = "tamper"
+		map.value = cmd.sensorState ? "tampered" : "secure"
+		map.descriptionText = "${device.displayName} has been tampered with"
+		runIn(30, "resetTamper") //device does not send alarm cancelation
+
 	} else {
 		map.descriptionText = "${device.displayName}: ${cmd}"
 	}
@@ -250,10 +245,10 @@ def zwaveEvent(physicalgraph.zwave.commands.sensoralarmv1.SensorAlarmReport cmd)
 
 def resetTamper() {
 	def map = [:]
-    map.name = "tamper"
-    map.value = "secure"
-    map.descriptionText = "$device.displayName is secure"
-    sendEvent(map)
+	map.name = "tamper"
+	map.value = "secure"
+	map.descriptionText = "$device.displayName is secure"
+	sendEvent(map)
 }
 
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
@@ -267,10 +262,10 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
 	def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
 	log.debug "msr: $msr"
 	device.updateDataValue(["MSR", msr])
-    
-    if ( msr == "010F-0B00-2001" ) { //this is the msr and device type for the fibaro flood sensor
-    	result += lateConfigure(true)
-    }
+
+	if ( msr == "010F-0B00-2001" ) { //this is the msr and device type for the fibaro flood sensor
+		result += lateConfigure(true)
+	}
 
 	result << createEvent(descriptionText: "$device.displayName MSR: $msr", isStateChange: false)
 	result
@@ -282,17 +277,17 @@ def setConfigured() {
 
 def isConfigured() {
 	Boolean configured = device.getDataValue(["configured"]) as Boolean
-    
-    return configured
+
+	return configured
 }
 
 def lateConfigure(setConf = False) {
 	def res = response(configure())
-    
-    if (setConf)
-        setConfigured()
-        
-    return res
+
+	if (setConf)
+		setConfigured()
+
+	return res
 }
 
  /**
@@ -304,26 +299,34 @@ def lateConfigure(setConf = False) {
  */
 def configure() {
 	log.debug "Configuring Device..."
-    def cmds = []
-    
-    // send associate to group 2 to get alarm data
-    cmds << zwave.associationV2.associationSet(groupingIdentifier:2, nodeId:[zwaveHubNodeId]).format()
-    
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [255], parameterNumber: 5, size: 1).format()
-    
-    // send associate to group 3 to get sensor data reported only to hub
-    cmds << zwave.associationV2.associationSet(groupingIdentifier:3, nodeId:[zwaveHubNodeId]).format()
+	// Device wakes up every 4 hours, this interval allows us to miss one wakeup notification before marking offline
+	sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 
-	// temp hysteresis set to .5 degrees celcius
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,50], parameterNumber: 12, size: 2).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 12).format()
+	// default initial state
+	sendEvent(name: "water", value: "dry")
+
+	def cmds = []
+
+	// send associate to group 2 to get alarm data
+	cmds << zwave.associationV2.associationSet(groupingIdentifier:2, nodeId:[zwaveHubNodeId]).format()
+
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [255], parameterNumber: 5, size: 1).format()
+
+	// send associate to group 3 to get sensor data reported only to hub
+	cmds << zwave.associationV2.associationSet(groupingIdentifier:3, nodeId:[zwaveHubNodeId]).format()
 
 	// reporting frequency of temps and battery set to one hour
 	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,60*60], parameterNumber: 10, size: 2).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 10).format()
-    
-    cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
-    
+	// cmds << zwave.configurationV1.configurationGet(parameterNumber: 10).format()
+
+	// temp hysteresis set to .5 degrees celcius
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,50], parameterNumber: 12, size: 2).format()
+	// cmds << zwave.configurationV1.configurationGet(parameterNumber: 12).format()
+
+	cmds << zwave.batteryV1.batteryGet().format()
+
+	cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
+
 	delayBetween(cmds, 100)
 }
 
@@ -349,18 +352,18 @@ def test() {
  * @return none
  */
 def updateZwaveParam(params) {
-	if ( params ) {     
-        def pNumber = params.paramNumber
-        def pSize	= params.size
-        def pValue	= [params.value]
-        log.debug "Make sure device is awake and in recieve mode (triple-click?)"
-        log.debug "Updating ${device.displayName} parameter number '${pNumber}' with value '${pValue}' with size of '${pSize}'"
+	if ( params ) {
+		def pNumber = params.paramNumber
+		def pSize	= params.size
+		def pValue	= [params.value]
+		log.debug "Make sure device is awake and in recieve mode (triple-click?)"
+		log.debug "Updating ${device.displayName} parameter number '${pNumber}' with value '${pValue}' with size of '${pSize}'"
 
 		def cmds = []
-        cmds << zwave.configurationV1.configurationSet(configurationValue: pValue, parameterNumber: pNumber, size: pSize).format()
-        cmds << zwave.configurationV1.configurationGet(parameterNumber: pNumber).format()
-        delayBetween(cmds, 1000)        
-    }
+		cmds << zwave.configurationV1.configurationSet(configurationValue: pValue, parameterNumber: pNumber, size: pSize).format()
+		cmds << zwave.configurationV1.configurationGet(parameterNumber: pNumber).format()
+		delayBetween(cmds, 1000)
+	}
 }
 
  /**
@@ -377,26 +380,26 @@ def updateZwaveParam(params) {
 def resetParams2StDefaults() {
 	log.debug "Resetting ${device.displayName} parameters to SmartThings compatible defaults"
 	def cmds = []
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], 			parameterNumber: 1,  size: 2).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [3], 			parameterNumber: 2,  size: 1).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [255], 			parameterNumber: 5,  size: 1).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [255], 			parameterNumber: 7,  size: 1).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [1], 			parameterNumber: 9,  size: 1).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,60*60], 		parameterNumber: 10, size: 2).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,50], 			parameterNumber: 12, size: 2).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [0],				parameterNumber: 13, size: 1).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [5,220], 		parameterNumber: 50, size: 2).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [13,172],		parameterNumber: 51, size: 2).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0,0,225],		parameterNumber: 61, size: 4).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,255,0,0], 	parameterNumber: 62, size: 4).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [2], 			parameterNumber: 63, size: 1).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], 			parameterNumber: 73, size: 2).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [2], 			parameterNumber: 74, size: 1).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], 			parameterNumber: 75, size: 2).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], 			parameterNumber: 76, size: 2).format()
-    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], 			parameterNumber: 77, size: 1).format()
-    
-    delayBetween(cmds, 1200)
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0],			parameterNumber: 1,	 size: 2).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [3],				parameterNumber: 2,	 size: 1).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [255],			parameterNumber: 5,	 size: 1).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [255],			parameterNumber: 7,	 size: 1).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [1],				parameterNumber: 9,	 size: 1).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,60*60],		parameterNumber: 10, size: 2).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,50],			parameterNumber: 12, size: 2).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0],				parameterNumber: 13, size: 1).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [5,220],			parameterNumber: 50, size: 2).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [13,172],		parameterNumber: 51, size: 2).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0,0,225],		parameterNumber: 61, size: 4).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,255,0,0],		parameterNumber: 62, size: 4).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [2],				parameterNumber: 63, size: 1).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0],			parameterNumber: 73, size: 2).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [2],				parameterNumber: 74, size: 1).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0],			parameterNumber: 75, size: 2).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0],			parameterNumber: 76, size: 2).format()
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0],				parameterNumber: 77, size: 1).format()
+
+	delayBetween(cmds, 1200)
 }
 
  /**
@@ -413,25 +416,25 @@ def resetParams2StDefaults() {
 def listCurrentParams() {
 	log.debug "Listing of current parameter settings of ${device.displayName}"
 	def cmds = []
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 1).format() 
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 2).format() 
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 5).format() 
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 7).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 9).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 10).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 12).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 13).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 50).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 51).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 61).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 62).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 63).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 73).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 74).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 75).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 76).format()
-    cmds << zwave.configurationV1.configurationGet(parameterNumber: 77).format()
-    
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 1).format() 
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 2).format() 
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 5).format() 
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 7).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 9).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 10).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 12).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 13).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 50).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 51).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 61).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 62).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 63).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 73).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 74).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 75).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 76).format()
+	cmds << zwave.configurationV1.configurationGet(parameterNumber: 77).format()
+
 	delayBetween(cmds, 1200)
 }
 

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

@@ -46,6 +46,7 @@
 		capability 	"Illuminance Measurement"
 		capability 	"Sensor"
 		capability 	"Battery"
+		capability  "Health Check"
         
         command		"resetParams2StDefaults"
         command		"listCurrentParams"
@@ -81,8 +82,8 @@
 
 	tiles {
 		standardTile("motion", "device.motion", width: 2, height: 2) {
-			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
-			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
+			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00a0dc"
+			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#cccccc"
 		}
 		valueTile("temperature", "device.temperature", inactiveLabel: false) {
 			state "temperature", label:'${currentValue}°',
@@ -125,6 +126,9 @@
  */
 def configure() {
 	log.debug "Configuring Device For SmartThings Use"
+	// Device-Watch simply pings if no device events received for 8 hrs & 2 minutes
+	sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+
     def cmds = []
     
     // send associate to group 3 to get sensor data reported only to hub

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

@@ -29,10 +29,10 @@
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
-		capability "Configuration" 
+		capability "Configuration"
 		capability "Color Control"
         capability "Power Meter"
-       
+
         command "getDeviceData"
         command "softwhite"
         command "daylight"
@@ -54,12 +54,12 @@
         command "setAdjustedColor"
         command "setWhiteLevel"
         command "test"
-        
+
         attribute "whiteLevel", "string"
-      
+
 		fingerprint deviceId: "0x1101", inClusters: "0x27,0x72,0x86,0x26,0x60,0x70,0x32,0x31,0x85,0x33"
 	}
-    
+
     simulator {
     	status "on":  "command: 2003, payload: FF"
     	status "off": "command: 2003, payload: 00"
@@ -84,14 +84,14 @@
 		}
 		controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false) {
 			state "level", action:"switch level.setLevel"
-		}     
+		}
 		controlTile("whiteSliderControl", "device.whiteLevel", "slider", height: 1, width: 3, inactiveLabel: false) {
             state "whiteLevel", action:"setWhiteLevel", label:'White Level'
         }
 		standardTile("switch", "device.switch", width: 1, height: 1, canChangeIcon: true) {
-        	state "on", label:'${name}', action:"switch.off", icon:"st.illuminance.illuminance.bright", backgroundColor:"#79b821", nextState:"turningOff"
+        	state "on", label:'${name}', action:"switch.off", icon:"st.illuminance.illuminance.bright", backgroundColor:"#00A0DC", nextState:"turningOff"
             state "off", label:'${name}', action:"switch.on", icon:"st.illuminance.illuminance.dark", backgroundColor:"#ffffff", nextState:"turningOn"
-            state "turningOn", label:'${name}', icon:"st.illuminance.illuminance.bright", backgroundColor:"#79b821"
+            state "turningOn", label:'${name}', icon:"st.illuminance.illuminance.bright", backgroundColor:"#00A0DC"
             state "turningOff", label:'${name}', icon:"st.illuminance.illuminance.dark", backgroundColor:"#ffffff"
         }
         valueTile("power", "device.power", decoration: "flat") {
@@ -183,24 +183,24 @@
 		valueTile("hue", "device.hue", inactiveLabel: false, decoration: "flat") {
 			state "hue", label: 'Hue ${currentValue}   '
 		}
-        
+
         main(["switch"])
-        details(["switch", 
-                 "levelSliderControl", 
-                 "rgbSelector", 
-                 "whiteSliderControl", 
+        details(["switch",
+                 "levelSliderControl",
+                 "rgbSelector",
+                 "whiteSliderControl",
                  /*"softwhite",
                  "daylight",
                  "warmwhite",
-                 "red", 
-                 "green", 
+                 "red",
+                 "green",
                  "blue",
                  "white",
                  "cyan",
                  "magenta",
                  "orange",
                  "purple",
-                 "yellow",                 
+                 "yellow",
                  "fireplace",
                  "storm",
                  "deepfade",
@@ -214,7 +214,7 @@
 
 def setAdjustedColor(value) {
 	log.debug "setAdjustedColor: ${value}"
-    
+
     toggleTiles("off") //turn off the hard color tiles
 
     def level = device.latestValue("level")
@@ -223,19 +223,19 @@ def setAdjustedColor(value) {
     log.debug "level is: ${level}"
     value.level = level
 
-	def c = hexToRgb(value.hex) 
+	def c = hexToRgb(value.hex)
 	value.rh = hex(c.r * (level/100))
 	value.gh = hex(c.g * (level/100))
 	value.bh = hex(c.b * (level/100))
-	
-    setColor(value)  
+
+    setColor(value)
 }
 
 def setColor(value) {
 	log.debug "setColor: ${value}"
     log.debug "hue is: ${value.hue}"
     log.debug "saturation is: ${value.saturation}"
-    
+
     if (value.size() < 8)
     	toggleTiles("off")
 
@@ -246,22 +246,22 @@ def setColor(value) {
         value.gh = hex(rgb.g)
         value.bh = hex(rgb.b)
     }
-    
+
     if ((value.size() == 3) && (value.hue != null) && (value.saturation != null) && (value.level)) { //user passed in a level value too from outside (App)
     	def rgb = hslToRGB(value.hue, value.saturation, 0.5)
         value.hex = rgbToHex(rgb)
         value.rh = hex(rgb.r * value.level/100)
         value.gh = hex(rgb.g * value.level/100)
-        value.bh = hex(rgb.b * value.level/100)       
+        value.bh = hex(rgb.b * value.level/100)
     }
-    
+
     if (( value.size() == 1) && (value.hex)) { //being called from outside of device (App) with only hex
 		def rgbInt = hexToRgb(value.hex)
         value.rh = hex(rgbInt.r)
         value.gh = hex(rgbInt.g)
         value.bh = hex(rgbInt.b)
     }
-    
+
     if (( value.size() == 2) && (value.hex) && (value.level)) { //being called from outside of device (App) with only hex and level
 
         def rgbInt = hexToRgb(value.hex)
@@ -269,7 +269,7 @@ def setColor(value) {
         value.gh = hex(rgbInt.g * value.level/100)
         value.bh = hex(rgbInt.b * value.level/100)
     }
-    
+
     if (( value.size() == 1) && (value.colorName)) { //being called from outside of device (App) with only color name
         def colorData = getColorData(value.colorName)
         value.rh = colorData.rh
@@ -277,7 +277,7 @@ def setColor(value) {
         value.bh = colorData.bh
         value.hex = "#${value.rh}${value.gh}${value.bh}"
     }
-    
+
     if (( value.size() == 2) && (value.colorName) && (value.level)) { //being called from outside of device (App) with only color name and level
 		def colorData = getColorData(value.colorName)
         value.rh = hex(colorData.r * value.level/100)
@@ -285,7 +285,7 @@ def setColor(value) {
         value.bh = hex(colorData.b * value.level/100)
         value.hex = "#${hex(colorData.r)}${hex(colorData.g)}${hex(colorData.b)}"
     }
-    
+
     if (( value.size() == 3) && (value.red != null) && (value.green != null) && (value.blue != null)) { //being called from outside of device (App) with only color values (0-255)
         value.rh = hex(value.red)
         value.gh = hex(value.green)
@@ -299,7 +299,7 @@ def setColor(value) {
         value.bh = hex(value.blue * value.level/100)
         value.hex = "#${hex(value.red)}${hex(value.green)}${hex(value.blue)}"
     }
-    
+
 	sendEvent(name: "hue", value: value.hue, displayed: false)
 	sendEvent(name: "saturation", value: value.saturation, displayed: false)
 	sendEvent(name: "color", value: value.hex, displayed: false)
@@ -309,26 +309,26 @@ def setColor(value) {
 	if (value.switch) {
 		sendEvent(name: "switch", value: value.switch)
 	}
-	   
+
     sendRGB(value.rh, value.gh, value.bh)
 }
 
 def setLevel(level) {
 	log.debug "setLevel($level)"
-    
+
 	if (level == 0) { off() }
 	else if (device.latestValue("switch") == "off") { on() }
-    
+
     def colorHex = device.latestValue("color")
     if (colorHex == null)
 		colorHex = "#FFFFFF"
-        
+
     def c = hexToRgb(colorHex)
-    
+
     def r = hex(c.r * (level/100))
     def g = hex(c.g * (level/100))
     def b = hex(c.b * (level/100))
-    
+
 	sendEvent(name: "level", value: level)
     sendEvent(name: "setLevel", value: level, displayed: false)
 	sendRGB(r, g, b)
@@ -337,14 +337,14 @@ def setLevel(level) {
 
 def setWhiteLevel(value) {
 	log.debug "setWhiteLevel: ${value}"
-    def level = Math.min(value as Integer, 99)    
+    def level = Math.min(value as Integer, 99)
     level = 255 * level/99 as Integer
     def channel = 0
 
 	if (device.latestValue("switch") == "off") { on() }
-    
+
     sendEvent(name: "whiteLevel", value: value)
-    sendWhite(channel, value)       
+    sendWhite(channel, value)
 }
 
 def sendWhite(channel, value) {
@@ -367,20 +367,20 @@ def sendRGBW(redHex, greenHex, blueHex, whiteHex) {
 
 def configure() {
 	log.debug "Configuring Device For SmartThings Use"
-    
 
-    
+
+
     def cmds = []
-    
+
     // send associate to group 3 to get sensor data reported only to hub
     cmds << zwave.associationV2.associationSet(groupingIdentifier:5, nodeId:[zwaveHubNodeId]).format()
-    
-    
+
+
     //cmds << sendEvent(name: "level", value: 50)
     //cmds << on()
     //cmds << doColorButton("Green")
     delayBetween(cmds, 500)
-    
+
 }
 
 def parse(String description) {
@@ -411,11 +411,11 @@ def parse(String description) {
 
 def getDeviceData() {
     def cmd = []
-    
-    cmd << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet()) 
+
+    cmd << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
     cmd << response(zwave.versionV1.versionGet())
 	cmd << response(zwave.firmwareUpdateMdV1.firmwareMdGet())
-    
+
     delayBetween(cmd, 500)
 }
 
@@ -426,7 +426,7 @@ def createEvent(physicalgraph.zwave.commands.manufacturerspecificv2.Manufacturer
     log.debug "productTypeId:    ${cmd.productTypeId}"
 }
 
-def createEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd, Map item1) {	
+def createEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd, Map item1) {
     updateDataValue("applicationVersion", "${cmd.applicationVersion}")
     log.debug "applicationVersion:      ${cmd.applicationVersion}"
     log.debug "applicationSubVersion:   ${cmd.applicationSubVersion}"
@@ -435,13 +435,13 @@ def createEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd, Map it
     log.debug "zWaveProtocolSubVersion: ${cmd.zWaveProtocolSubVersion}"
 }
 
-def createEvent(physicalgraph.zwave.commands.firmwareupdatemdv1.FirmwareMdReport cmd, Map item1) { 
+def createEvent(physicalgraph.zwave.commands.firmwareupdatemdv1.FirmwareMdReport cmd, Map item1) {
     log.debug "checksum:       ${cmd.checksum}"
     log.debug "firmwareId:     ${cmd.firmwareId}"
     log.debug "manufacturerId: ${cmd.manufacturerId}"
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.colorcontrolv1.CapabilityReport cmd, Map item1) { 
+def zwaveEvent(physicalgraph.zwave.commands.colorcontrolv1.CapabilityReport cmd, Map item1) {
 
 	log.debug "In CapabilityReport"
 }
@@ -546,7 +546,7 @@ def zwaveEvent(physicalgraph.zwave.commands.configurationv1.ConfigurationReport
      def value = "when off"
      if (cmd.configurationValue[0] == 1) {value = "when on"}
      if (cmd.configurationValue[0] == 2) {value = "never"}
-     [name: "indicatorStatus", value: value, display: false]
+     [name: "indicatorStatus", value: value, displayed: false]
 }
 */
 def createEvent(physicalgraph.zwave.Command cmd,  Map map) {
@@ -557,7 +557,7 @@ def createEvent(physicalgraph.zwave.Command cmd,  Map map) {
 def on() {
 	log.debug "on()"
 	sendEvent(name: "switch", value: "on")
-	delayBetween([zwave.basicV1.basicSet(value: 0xFF).format(), 
+	delayBetween([zwave.basicV1.basicSet(value: 0xFF).format(),
     			  zwave.switchMultilevelV1.switchMultilevelGet().format()], 5000)
 }
 
@@ -593,7 +593,7 @@ def refresh() {
  * @return none
  */
 def updateZwaveParam(params) {
-	if ( params ) {   
+	if ( params ) {
         def pNumber = params.paramNumber
         def pSize	= params.size
         def pValue	= [params.value]
@@ -601,9 +601,9 @@ def updateZwaveParam(params) {
 
 		def cmds = []
         cmds << zwave.configurationV1.configurationSet(configurationValue: pValue, parameterNumber: pNumber, size: pSize).format()
-        
+
         cmds << zwave.configurationV1.configurationGet(parameterNumber: pNumber).format()
-        delayBetween(cmds, 1500)        
+        delayBetween(cmds, 1500)
     }
 }
 
@@ -612,22 +612,22 @@ def test() {
     //value = [hue: 0, saturation: 100, level: 5]
     //value = [red: 255, green: 0, blue: 255, level: 60]
 	//setColor(value)
-    
+
     def cmd = []
-    
+
     if ( !state.cnt ) {
     	state.cnt = 6
     } else {
     	state.cnt = state.cnt + 1
     }
-    
+
     if ( state.cnt > 10 )
     	state.cnt = 6
-    
+
     // run programmed light show
 	cmd << zwave.configurationV1.configurationSet(configurationValue: [state.cnt], parameterNumber: 72, size: 1).format()
-    cmd << zwave.configurationV1.configurationGet(parameterNumber: 72).format()  
-    
+    cmd << zwave.configurationV1.configurationGet(parameterNumber: 72).format()
+
     delayBetween(cmd, 500)
 
 }
@@ -638,23 +638,23 @@ def colorNameToRgb(color) {
         [name:"Soft White",	r: 255, g: 241, b: 224	],
         [name:"Daylight", 	r: 255, g: 255, b: 251	],
         [name:"Warm White", r: 255, g: 244, b: 229	],
-        
+
         [name:"Red", 		r: 255, g: 0,	b: 0	],
 		[name:"Green", 		r: 0, 	g: 255,	b: 0	],
         [name:"Blue", 		r: 0, 	g: 0,	b: 255	],
-        
+
 		[name:"Cyan", 		r: 0, 	g: 255,	b: 255	],
-        [name:"Magenta", 	r: 255, g: 0,	b: 33	],       
+        [name:"Magenta", 	r: 255, g: 0,	b: 33	],
         [name:"Orange", 	r: 255, g: 102, b: 0	],
-        
+
         [name:"Purple", 	r: 170, g: 0,	b: 255	],
 		[name:"Yellow", 	r: 255, g: 255, b: 0	],
         [name:"White", 		r: 255, g: 255, b: 255	]
 	]
-    
-    def colorData = [:]    
+
+    def colorData = [:]
     colorData = colors.find { it.name == color }
-    
+
     colorData
 }
 
@@ -670,7 +670,7 @@ def hexToRgb(colorHex) {
 	def rrInt = Integer.parseInt(colorHex.substring(1,3),16)
     def ggInt = Integer.parseInt(colorHex.substring(3,5),16)
     def bbInt = Integer.parseInt(colorHex.substring(5,7),16)
-    
+
     def colorData = [:]
     colorData = [r: rrInt, g: ggInt, b: bbInt]
     colorData
@@ -681,7 +681,7 @@ def rgbToHex(rgb) {
     def g = hex(rgb.g)
     def b = hex(rgb.b)
     def hexColor = "#${r}${g}${b}"
-    
+
     hexColor
 }
 
@@ -689,11 +689,11 @@ def hslToRGB(float var_h, float var_s, float var_l) {
 	float h = var_h / 100
     float s = var_s / 100
     float l = var_l
-    
+
     def r = 0
     def g = 0
     def b = 0
-    
+
 	if (s == 0) {
     	r = l * 255
         g = l * 255
@@ -705,26 +705,26 @@ def hslToRGB(float var_h, float var_s, float var_l) {
         } else {
         	var_2 = (l + s) - (s * l)
         }
-                
+
         float var_1 = 2 * l - var_2
-        
+
         r = 255 * hueToRgb(var_1, var_2, h + (1 / 3))
         g = 255 * hueToRgb(var_1, var_2, h)
-        b = 255 * hueToRgb(var_1, var_2, h - (1 / 3))    
+        b = 255 * hueToRgb(var_1, var_2, h - (1 / 3))
     }
-    
+
     def rgb = [:]
     rgb = [r: r, g: g, b: b]
 
-    rgb 
+    rgb
 }
 
 def hueToRgb(v1, v2, vh) {
-	if (vh < 0) { vh += 1 }            
+	if (vh < 0) { vh += 1 }
 	if (vh > 1) { vh -= 1 }
 	if ((6 * vh) < 1) { return (v1 + (v2 - v1) * 6 * vh) }
     if ((2 * vh) < 1) { return (v2) }
-    if ((3 * vh) < 2) { return (v1 + (v2 - $v1) * ((2 / 3 - vh) * 6)) }    
+    if ((3 * vh) < 2) { return (v1 + (v2 - $v1) * ((2 / 3 - vh) * 6)) }
     return (v1)
 }
 
@@ -735,49 +735,49 @@ def rgbToHSL(rgb) {
     def h = 0
     def s = 0
     def l = 0
-    
+
     def var_min = [r,g,b].min()
     def var_max = [r,g,b].max()
     def del_max = var_max - var_min
-    
+
     l = (var_max + var_min) / 2
-    
+
     if (del_max == 0) {
             h = 0
             s = 0
     } else {
-    	if (l < 0.5) { s = del_max / (var_max + var_min) } 
+    	if (l < 0.5) { s = del_max / (var_max + var_min) }
         else { s = del_max / (2 - var_max - var_min) }
 
         def del_r = (((var_max - r) / 6) + (del_max / 2)) / del_max
         def del_g = (((var_max - g) / 6) + (del_max / 2)) / del_max
         def del_b = (((var_max - b) / 6) + (del_max / 2)) / del_max
 
-        if (r == var_max) { h = del_b - del_g } 
-        else if (g == var_max) { h = (1 / 3) + del_r - del_b } 
+        if (r == var_max) { h = del_b - del_g }
+        else if (g == var_max) { h = (1 / 3) + del_r - del_b }
         else if (b == var_max) { h = (2 / 3) + del_g - del_r }
-        
+
 		if (h < 0) { h += 1 }
         if (h > 1) { h -= 1 }
 	}
-    def hsl = [:]    
+    def hsl = [:]
     hsl = [h: h * 100, s: s * 100, l: l]
-    
+
     hsl
 }
 
 def getColorData(colorName) {
 	log.debug "getColorData: ${colorName}"
-    
+
     def colorRGB = colorNameToRgb(colorName)
     def colorHex = rgbToHex(colorRGB)
 	def colorHSL = rgbToHSL(colorRGB)
-        
+
     def colorData = [:]
-    colorData = [h: colorHSL.h, 
-    			 s: colorHSL.s, 
-                 l: device.latestValue("level"), 
-                 r: colorRGB.r, 
+    colorData = [h: colorHSL.h,
+    			 s: colorHSL.s,
+                 l: device.latestValue("level"),
+                 r: colorRGB.r,
                  g: colorRGB.g,
                  b: colorRGB.b,
                  rh: hex(colorRGB.r),
@@ -785,8 +785,8 @@ def getColorData(colorName) {
                  bh: hex(colorRGB.b),
                  hex: colorHex,
                  alpha: 1]
-     
-     colorData                 
+
+     colorData
 }
 
 def doColorButton(colorName) {
@@ -798,7 +798,7 @@ def doColorButton(colorName) {
     def maxLevel = hex(99)
 
     toggleTiles(colorName.toLowerCase().replaceAll("\\s",""))
-    
+
     if 		( colorName == "Fire Place" ) 	{ updateZwaveParam([paramNumber:72, value:6,  size:1]) }
 	else if ( colorName == "Storm" ) 		{ updateZwaveParam([paramNumber:72, value:7,  size:1]) }
     else if ( colorName == "Deep Fade" ) 	{ updateZwaveParam([paramNumber:72, value:8,  size:1]) }
@@ -808,8 +808,8 @@ def doColorButton(colorName) {
     else if ( colorName == "Daylight" ) 	{ String.format("33050400${maxLevel}02${maxLevel}03${maxLevel}04${maxLevel}%02X", 100) }
     else {
 		def c = getColorData(colorName)
-		def newValue = ["hue": c.h, "saturation": c.s, "level": level, "red": c.r, "green": c.g, "blue": c.b, "hex": c.hex, "alpha": c.alpha]  
-    	setColor(newValue)            
+		def newValue = ["hue": c.h, "saturation": c.s, "level": level, "red": c.r, "green": c.g, "blue": c.b, "hex": c.hex, "alpha": c.alpha]
+    	setColor(newValue)
     	def r = hex(c.r * (level/100))
     	def g = hex(c.g * (level/100))
     	def b = hex(c.b * (level/100))
@@ -823,19 +823,19 @@ def toggleTiles(color) {
 	if ( !state.colorTiles ) {
     	state.colorTiles = ["softwhite","daylight","warmwhite","red","green","blue","cyan","magenta","orange","purple","yellow","white","fireplace","storm","deepfade","litefade","police"]
     }
-    
+
     def cmds = []
-    
+
     state.colorTiles.each({
     	if ( it == color ) {
         	log.debug "Turning ${it} on"
-            cmds << sendEvent(name: it, value: "on${it}", display: True, descriptionText: "${device.displayName} ${color} is 'ON'", isStateChange: true)
+            cmds << sendEvent(name: it, value: "on${it}", displayed: True, descriptionText: "${device.displayName} ${color} is 'ON'", isStateChange: true)
         } else {
         	//log.debug "Turning ${it} off"
         	cmds << sendEvent(name: it, value: "off${it}", displayed: false)
         }
     })
-    
+
     delayBetween(cmds, 2500)
 }
 

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

@@ -21,6 +21,7 @@ metadata {
         attribute "tamper", "enum", ["detected", "clear"]
         attribute "heatAlarm", "enum", ["overheat detected", "clear", "rapid temperature rise", "underheat detected"]
         fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x86, 0x72, 0x5A, 0x59, 0x85, 0x73, 0x84, 0x80, 0x71, 0x56, 0x70, 0x31, 0x8E, 0x22, 0x9C, 0x98, 0x7A", outClusters: "0x20, 0x8B"
+        fingerprint mfr:"010F", prod:"0C02", model:"1002"
     }
     simulator {
         //battery

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

@@ -682,7 +682,7 @@ def setHeatingSetpoint(degrees) {
 	def temperatureScale = getTemperatureScale()
 
 	def degreesInteger = degrees as Integer
-	sendEvent("name":"heatingSetpoint", "value":degreesInteger)
+	sendEvent("name":"heatingSetpoint", "value":degreesInteger, "unit":temperatureScale)
 
 	def celsius = (getTemperatureScale() == "C") ? degreesInteger : (fahrenheitToCelsius(degreesInteger) as Double).round(2)
 	"st wattr 0x${device.deviceNetworkId} 1 0x201 0x12 0x29 {" + hex(celsius*100) + "}"
@@ -691,7 +691,7 @@ def setHeatingSetpoint(degrees) {
 
 def setCoolingSetpoint(degrees) {
 	def degreesInteger = degrees as Integer
-	sendEvent("name":"coolingSetpoint", "value":degreesInteger)
+	sendEvent("name":"coolingSetpoint", "value":degreesInteger, "unit":temperatureScale)
 	def celsius = (getTemperatureScale() == "C") ? degreesInteger : (fahrenheitToCelsius(degreesInteger) as Double).round(2)
 	"st wattr 0x${device.deviceNetworkId} 1 0x201 0x11 0x29 {" + hex(celsius*100) + "}"
 

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

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

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

@@ -0,0 +1,39 @@
+# FortrezZ Water Valve
+
+Cloud Execution
+
+Works with: 
+
+* [FortrezZ Water Valve](https://www.smartthings.com/works-with-smartthings/other/fortrezz-water-valve)
+
+## Table of contents
+
+* [Capabilities](#capabilities)
+* [Health](#device-health)
+* [Troubleshooting](#troubleshooting)
+
+## Capabilities
+
+* **Actuator** - represents that a Device has commands
+* **Health Check** - indicates ability to get device health notifications
+* **Valve** - allows for the control of a valve device
+* **Refresh** - _refresh()_ command for status updates
+* **Sensor** - detects sensor events
+
+## Device Health
+
+FortrezZ Water Valve is polled by the hub.
+As of hubCore version 0.14.38 the hub sends up reports every 15 minutes regardless of whether the state changed.
+Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*15 + 2)mins = 32 mins.
+Not to mention after going OFFLINE when the device is plugged back in, it might take a considerable amount of time for
+the device to appear as ONLINE again. This is because if this listening device does not respond to two poll requests in a row,
+it is not polled for 5 minutes by the hub. This can delay up the process of being marked ONLINE by quite some time.
+
+* __32min__ checkInterval
+
+## Troubleshooting
+
+If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the device is out of range.
+Pairing needs to be tried again by placing the device closer to the hub.
+Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following link:
+* [FortrezZ Water Valve Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/202088434-FortrezZ-Water-Valve-Shutoff)

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

@@ -14,11 +14,13 @@
 metadata {
 	definition (name: "Fortrezz Water Valve", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
+		capability "Health Check"
 		capability "Valve"
 		capability "Refresh"
 		capability "Sensor"
         
 		fingerprint deviceId: "0x1000", inClusters: "0x25,0x72,0x86,0x71,0x22,0x70"
+		fingerprint mfr:"0084", prod:"0213", model:"0215", deviceJoinName: "FortrezZ Water Valve"
 	}
 
 	// simulator metadata
@@ -34,10 +36,10 @@ metadata {
 	// tile definitions
 	tiles {
 		standardTile("contact", "device.contact", width: 2, height: 2, canChangeIcon: true) {
-			state "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#53a7c0", nextState:"closing"
-			state "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#e86d13", nextState:"opening"
-			state "opening", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#ffe71e"
-			state "closing", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffe71e"
+			state "open", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC", nextState:"closing"
+			state "closed", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff", nextState:"opening"
+			state "opening", label: '${name}', action: "valve.close", icon: "st.valves.water.open", backgroundColor: "#00A0DC"
+			state "closing", label: '${name}', action: "valve.open", icon: "st.valves.water.closed", backgroundColor: "#ffffff"
 		}
 		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
@@ -48,6 +50,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) {
 	log.trace description
 	def result = null
@@ -76,6 +83,13 @@ def close() {
 	zwave.switchBinaryV1.switchBinarySet(switchValue: 0xFF).format()
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+	refresh()
+}
+
 def refresh() {
 	zwave.switchBinaryV1.switchBinaryGet().format()
 }

devicetypes/smartthings/foscam.src/foscam.groovy

@@ -41,7 +41,7 @@
 
 		standardTile("take", "device.image", width: 1, height: 1, canChangeIcon: false, inactiveLabel: true, canChangeBackground: false) {
 			state "take", label: "Take", action: "Image Capture.take", icon: "st.camera.dropcam", backgroundColor: "#FFFFFF", nextState:"taking"
-			state "taking", label:'Taking', action: "", icon: "st.camera.dropcam", backgroundColor: "#53a7c0"
+			state "taking", label:'Taking', action: "", icon: "st.camera.dropcam", backgroundColor: "#00A0DC"
 			state "image", label: "Take", action: "Image Capture.take", icon: "st.camera.dropcam", backgroundColor: "#FFFFFF", nextState:"taking"
 		}
 

devicetypes/smartthings/ge-link-bulb.src/ge-link-bulb.groovy

@@ -1,7 +1,7 @@
 /**
  *  GE Link Bulb
  *
- *  Copyright 2014 SmartThings
+ *  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:
@@ -53,15 +53,17 @@ metadata {
         capability "Polling"
 
         fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0019", manufacturer: "GE_Appliances", model: "ZLL Light", deviceJoinName: "GE Link Bulb"
+        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0019", manufacturer: "GE", model: "SoftWhite", deviceJoinName: "GE Link Soft White Bulb"
+        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0019", manufacturer: "GE", model: "Daylight", deviceJoinName: "GE Link Daylight Bulb"
     }
 
 	// 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.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00a0dc", nextState:"turningOff"
                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00a0dc", nextState:"turningOff"
                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
             }
             tileAttribute ("device.level", key: "SLIDER_CONTROL") {
@@ -85,7 +87,7 @@ metadata {
 def parse(String description) {
     def resultMap = zigbee.getEvent(description)
     if (resultMap) {
-        if ((resultMap.name == "level" && state.trigger == "setLevel") || resultMap.name != "level") {  //doing this to account for weird level reporting bug with GE Link Bulbs
+        if (resultMap.name != "level" || resultMap.value != 0) {  // Ignore level reports of 0 sent when bulb turns off
             sendEvent(resultMap)
         }
     }
@@ -97,7 +99,7 @@ def parse(String description) {
 
 def poll() {
     def refreshCmds = [
-        "st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {${state?.dOnOff ?: '0000'}}", "delay 500"
+        "st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {${state?.dOnOff ?: '0000'}}", "delay 2000"
     ]
 
     return refreshCmds + zigbee.onOffRefresh() + zigbee.levelRefresh()
@@ -186,25 +188,22 @@ def updated() {
 }
 
 def on() {
-    state.trigger = "on/off"
     zigbee.on()
 }
 
 def off() {
-    state.trigger = "on/off"
     zigbee.off()
 }
 
 def refresh() {
     def refreshCmds = [
-        "st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {${state?.dOnOff ?: '0000'}}", "delay 500"
+        "st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {${state?.dOnOff ?: '0000'}}", "delay 2000"
     ]
 
     return refreshCmds + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig()
 }
 
 def setLevel(value) {
-    state.trigger = "setLevel"
     def cmd
     def delayForRefresh = 500
     if (dimRate && (state?.rate != null)) {

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

@@ -1,351 +0,0 @@
-/**
- *  Copyright 2015 SmartThings
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- *	    GE/Jasco ZigBee Dimmer
- *
- *	Author: SmartThings
- *	Date: 2015-07-01
- */
-
-metadata {
-	definition (name: "GE ZigBee Dimmer", namespace: "smartthings", author: "SmartThings") {
-		capability "Switch"
-		capability "Switch Level"
-		capability "Power Meter"
-		capability "Configuration"
-		capability "Refresh"
-		capability "Actuator"
-		capability "Sensor"
-
-	}
-
-	// simulator metadata
-	simulator {
-		// status messages
-		status "on": "on/off: 1"
-		status "off": "on/off: 0"
-
-		// reply messages
-		reply "zcl on-off on": "on/off: 1"
-		reply "zcl on-off off": "on/off: 0"
-	}
-
-	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"
-			}
-			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-				attributeState "level", action:"switch level.setLevel"
-			}
-		}
-		valueTile("level", "device.level", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "level", label: 'Level ${currentValue}%'
-		}
-		valueTile("power", "device.power", decoration: "flat", width: 2, height: 2) {
-			state "power", label:'${currentValue} W'
-		}
-		standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-		main "switch"
-		details(["switch", "level", "power","levelSliderControl","refresh"])
-	}
-}
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-	log.debug "description is $description"
-
-	def finalResult = isKnownDescription(description)
-	if (finalResult != "false") {
-		log.info finalResult
-		if (finalResult.type == "update") {
-			log.info "$device updates: ${finalResult.value}"
-		}
-		else if (finalResult.type == "power") {
-			def powerValue = (finalResult.value as Integer)/10
-			sendEvent(name: "power", value: powerValue)
-
-			/*
-				Dividing by 10 as the Divisor is 10000 and unit is kW for the device. AttrId: 0302 and 0300. Simplifying to 10
-
-				power level is an integer. The exact power level with correct units needs to be handled in the device type
-				to account for the different Divisor value (AttrId: 0302) and POWER Unit (AttrId: 0300). CLUSTER for simple metering is 0702
-			*/
-		}
-		else {
-			sendEvent(name: finalResult.type, value: finalResult.value)
-		}
-	}
-	else {
-		log.warn "DID NOT PARSE MESSAGE for description : $description"
-		log.debug parseDescriptionAsMap(description)
-	}
-}
-
-// Commands to device
-def zigbeeCommand(cluster, attribute){
-	["st cmd 0x${device.deviceNetworkId} ${endpointId} ${cluster} ${attribute} {}"]
-}
-
-def off() {
-	zigbeeCommand("6", "0")
-}
-
-def on() {
-	zigbeeCommand("6", "1")
-}
-
-def setLevel(value) {
-	value = value as Integer
-	if (value == 0) {
-		off()
-	}
-	else {
-		sendEvent(name: "level", value: value)
-		setLevelWithRate(value, "0000") + ["delay 1000"] + on()	//value is between 0 to 100; GE does NOT switch on if OFF
-	}
-}
-
-def refresh() {
-	[
-			"st rattr 0x${device.deviceNetworkId} ${endpointId} 6 0", "delay 500",
-			"st rattr 0x${device.deviceNetworkId} ${endpointId} 8 0", "delay 500",
-			"st rattr 0x${device.deviceNetworkId} ${endpointId} 0x0702 0x0400", "delay 500"
-	]
-
-}
-
-def configure() {
-	onOffConfig() + levelConfig() + powerConfig() + refresh()
-}
-
-
-private getEndpointId() {
-	new BigInteger(device.endpointId, 16).toString()
-}
-
-private hex(value, width=2) {
-	def s = new BigInteger(Math.round(value).toString()).toString(16)
-	while (s.size() < width) {
-		s = "0" + s
-	}
-	s
-}
-
-private String swapEndianHex(String hex) {
-	reverseArray(hex.decodeHex()).encodeHex()
-}
-
-private Integer convertHexToInt(hex) {
-	Integer.parseInt(hex,16)
-}
-
-//Need to reverse array of size 2
-private byte[] reverseArray(byte[] array) {
-	byte tmp;
-	tmp = array[1];
-	array[1] = array[0];
-	array[0] = tmp;
-	return array
-}
-
-def parseDescriptionAsMap(description) {
-	if (description?.startsWith("read attr -")) {
-		(description - "read attr - ").split(",").inject([:]) { map, param ->
-			def nameAndValue = param.split(":")
-			map += [(nameAndValue[0].trim()): nameAndValue[1].trim()]
-		}
-	}
-	else if (description?.startsWith("catchall: ")) {
-		def seg = (description - "catchall: ").split(" ")
-		def zigbeeMap = [:]
-		zigbeeMap += [raw: (description - "catchall: ")]
-		zigbeeMap += [profileId: seg[0]]
-		zigbeeMap += [clusterId: seg[1]]
-		zigbeeMap += [sourceEndpoint: seg[2]]
-		zigbeeMap += [destinationEndpoint: seg[3]]
-		zigbeeMap += [options: seg[4]]
-		zigbeeMap += [messageType: seg[5]]
-		zigbeeMap += [dni: seg[6]]
-		zigbeeMap += [isClusterSpecific: Short.valueOf(seg[7], 16) != 0]
-		zigbeeMap += [isManufacturerSpecific: Short.valueOf(seg[8], 16) != 0]
-		zigbeeMap += [manufacturerId: seg[9]]
-		zigbeeMap += [command: seg[10]]
-		zigbeeMap += [direction: seg[11]]
-		zigbeeMap += [data: seg.size() > 12 ? seg[12].split("").findAll { it }.collate(2).collect {
-			it.join('')
-		} : []]
-
-		zigbeeMap
-	}
-}
-
-def isKnownDescription(description) {
-	if ((description?.startsWith("catchall:")) || (description?.startsWith("read attr -"))) {
-		def descMap = parseDescriptionAsMap(description)
-		if (descMap.cluster == "0006" || descMap.clusterId == "0006") {
-			isDescriptionOnOff(descMap)
-		}
-		else if (descMap.cluster == "0008" || descMap.clusterId == "0008"){
-			isDescriptionLevel(descMap)
-		}
-		else if (descMap.cluster == "0702" || descMap.clusterId == "0702"){
-			isDescriptionPower(descMap)
-		}
-		else {
-			return "false"
-		}
-	}
-	else if(description?.startsWith("on/off:")) {
-		def switchValue = description?.endsWith("1") ? "on" : "off"
-		return	[type: "switch", value : switchValue]
-	}
-	else {
-		return "false"
-	}
-}
-
-def isDescriptionOnOff(descMap) {
-	def switchValue = "undefined"
-	if (descMap.cluster == "0006") {				//cluster info from read attr
-		value = descMap.value
-		if (value == "01"){
-			switchValue = "on"
-		}
-		else if (value == "00"){
-			switchValue = "off"
-		}
-	}
-	else if (descMap.clusterId == "0006") {
-		//cluster info from catch all
-		//command 0B is Default response and the last two bytes are [on/off][success]. on/off=00, success=00
-		//command 01 is Read attr response. the last two bytes are [datatype][value]. boolean datatype=10; on/off value = 01/00
-		if ((descMap.command=="0B" && descMap.raw.endsWith("0100")) || (descMap.command=="01" && descMap.raw.endsWith("1001"))){
-			switchValue = "on"
-		}
-		else if ((descMap.command=="0B" && descMap.raw.endsWith("0000")) || (descMap.command=="01" && descMap.raw.endsWith("1000"))){
-			switchValue = "off"
-		}
-		else if(descMap.command=="07"){
-			return	[type: "update", value : "switch (0006) capability configured successfully"]
-		}
-	}
-
-	if (switchValue != "undefined"){
-		return	[type: "switch", value : switchValue]
-	}
-	else {
-		return "false"
-	}
-
-}
-
-//@return - false or "success" or level [0-100]
-def isDescriptionLevel(descMap) {
-	def dimmerValue = -1
-	if (descMap.cluster == "0008"){
-		//TODO: the message returned with catchall is command 0B with clusterId 0008. That is just a confirmation message
-		def value = convertHexToInt(descMap.value)
-		dimmerValue = Math.round(value * 100 / 255)
-		if(dimmerValue==0 && value > 0) {
-			dimmerValue = 1						//handling for non-zero hex value less than 3
-		}
-	}
-	else if(descMap.clusterId == "0008") {
-		if(descMap.command=="0B"){
-			return	[type: "update", value : "level updated successfully"]					//device updating the level change was successful. no value sent.
-		}
-		else if(descMap.command=="07"){
-			return	[type: "update", value : "level (0008) capability configured successfully"]
-		}
-	}
-
-	if (dimmerValue != -1){
-		return	[type: "level", value : dimmerValue]
-
-	}
-	else {
-		return "false"
-	}
-}
-
-def isDescriptionPower(descMap) {
-	def powerValue = "undefined"
-	if (descMap.cluster == "0702") {
-		if (descMap.attrId == "0400") {
-			powerValue = convertHexToInt(descMap.value)
-		}
-	}
-	else if (descMap.clusterId == "0702") {
-		if(descMap.command=="07"){
-			return	[type: "update", value : "power (0702) capability configured successfully"]
-		}
-	}
-
-	if (powerValue != "undefined"){
-		return	[type: "power", value : powerValue]
-	}
-	else {
-		return "false"
-	}
-}
-
-
-def onOffConfig() {
-	[
-			"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 6 {${device.zigbeeId}} {}", "delay 200",
-			"zcl global send-me-a-report 6 0 0x10 0 600 {01}",
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500"
-	]
-}
-
-//level config for devices with min reporting interval as 5 seconds and reporting interval if no activity as 1hour (3600s)
-//min level change is 01
-def levelConfig() {
-	[
-			"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 8 {${device.zigbeeId}} {}", "delay 200",
-			"zcl global send-me-a-report 8 0 0x20 1 3600 {01}",
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500"
-	]
-}
-
-//power config for devices with min reporting interval as 1 seconds and reporting interval if no activity as 10min (600s)
-//min change in value is 05
-def powerConfig() {
-	[
-			//Meter (Power) Reporting
-			"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 0x0702 {${device.zigbeeId}} {}", "delay 200",
-			"zcl global send-me-a-report 0x0702 0x0400 0x2A 1 600 {05}",
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500"
-	]
-}
-
-def setLevelWithRate(level, rate) {
-	if(rate == null){
-		rate = "0000"
-	}
-	level = convertToHexString(level * 255 / 100) 				//Converting the 0-100 range to 0-FF range in hex
-	["st cmd 0x${device.deviceNetworkId} ${endpointId} 8 4 {$level $rate}"]
-}
-
-String convertToHexString(value, width=2) {
-	def s = new BigInteger(Math.round(value).toString()).toString(16)
-	while (s.size() < width) {
-		s = "0" + s
-	}
-	s
-}

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

@@ -1,284 +0,0 @@
-/**
- *  Copyright 2015 SmartThings
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- *	    GE/Jasco ZigBee Switch
- *
- *	Author: SmartThings
- *	Date: 2015-07-01
- */
-
-metadata {
-	// Automatically generated. Make future change here.
-	definition (name: "GE ZigBee Switch", namespace: "smartthings", author: "SmartThings") {
-		capability "Switch"
-		capability "Power Meter"
-		capability "Configuration"
-		capability "Refresh"
-		capability "Actuator"
-		capability "Sensor"
-
-	}
-
-	// simulator metadata
-	simulator {
-		// status messages
-		status "on": "on/off: 1"
-		status "off": "on/off: 0"
-
-		// reply messages
-		reply "zcl on-off on": "on/off: 1"
-		reply "zcl on-off off": "on/off: 0"
-	}
-
-	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"
-			}
-		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-		valueTile("power", "device.power", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "power", label:'${currentValue} Watts'
-		}
-		main "switch"
-		details(["switch", "power", "refresh"])
-	}
-}
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-	log.debug "description is $description"
-
-	def finalResult = isKnownDescription(description)
-	if (finalResult != "false") {
-		log.info finalResult
-		if (finalResult.type == "update") {
-			log.info "$device updates: ${finalResult.value}"
-		}
-		else if (finalResult.type == "power") {
-			def powerValue = (finalResult.value as Integer)/10
-			sendEvent(name: "power", value: powerValue)
-
-			/*
-				Dividing by 10 as the Divisor is 10000 and unit is kW for the device. AttrId: 0302 and 0300. Simplifying to 10
-
-				power level is an integer. The exact power level with correct units needs to be handled in the device type
-				to account for the different Divisor value (AttrId: 0302) and POWER Unit (AttrId: 0300). CLUSTER for simple metering is 0702
-			*/
-		}
-		else {
-			sendEvent(name: finalResult.type, value: finalResult.value)
-		}
-	}
-	else {
-		log.warn "DID NOT PARSE MESSAGE for description : $description"
-		log.debug parseDescriptionAsMap(description)
-	}
-}
-
-// Commands to device
-def zigbeeCommand(cluster, attribute){
-	"st cmd 0x${device.deviceNetworkId} ${endpointId} ${cluster} ${attribute} {}"
-}
-
-def off() {
-	zigbeeCommand("6", "0")
-}
-
-def on() {
-	zigbeeCommand("6", "1")
-}
-
-def refresh() {
-	[
-			"st rattr 0x${device.deviceNetworkId} ${endpointId} 6 0", "delay 500",
-			"st rattr 0x${device.deviceNetworkId} ${endpointId} 8 0", "delay 500",
-			"st rattr 0x${device.deviceNetworkId} ${endpointId} 0x0702 0x0400", "delay 500"
-	]
-
-}
-
-def configure() {
-	onOffConfig() + powerConfig() + refresh()
-}
-
-
-private getEndpointId() {
-	new BigInteger(device.endpointId, 16).toString()
-}
-
-private hex(value, width=2) {
-	def s = new BigInteger(Math.round(value).toString()).toString(16)
-	while (s.size() < width) {
-		s = "0" + s
-	}
-	s
-}
-
-private String swapEndianHex(String hex) {
-	reverseArray(hex.decodeHex()).encodeHex()
-}
-
-private Integer convertHexToInt(hex) {
-	Integer.parseInt(hex,16)
-}
-
-//Need to reverse array of size 2
-private byte[] reverseArray(byte[] array) {
-	byte tmp;
-	tmp = array[1];
-	array[1] = array[0];
-	array[0] = tmp;
-	return array
-}
-
-def parseDescriptionAsMap(description) {
-	if (description?.startsWith("read attr -")) {
-		(description - "read attr - ").split(",").inject([:]) { map, param ->
-			def nameAndValue = param.split(":")
-			map += [(nameAndValue[0].trim()): nameAndValue[1].trim()]
-		}
-	}
-	else if (description?.startsWith("catchall: ")) {
-		def seg = (description - "catchall: ").split(" ")
-		def zigbeeMap = [:]
-		zigbeeMap += [raw: (description - "catchall: ")]
-		zigbeeMap += [profileId: seg[0]]
-		zigbeeMap += [clusterId: seg[1]]
-		zigbeeMap += [sourceEndpoint: seg[2]]
-		zigbeeMap += [destinationEndpoint: seg[3]]
-		zigbeeMap += [options: seg[4]]
-		zigbeeMap += [messageType: seg[5]]
-		zigbeeMap += [dni: seg[6]]
-		zigbeeMap += [isClusterSpecific: Short.valueOf(seg[7], 16) != 0]
-		zigbeeMap += [isManufacturerSpecific: Short.valueOf(seg[8], 16) != 0]
-		zigbeeMap += [manufacturerId: seg[9]]
-		zigbeeMap += [command: seg[10]]
-		zigbeeMap += [direction: seg[11]]
-		zigbeeMap += [data: seg.size() > 12 ? seg[12].split("").findAll { it }.collate(2).collect {
-			it.join('')
-		} : []]
-
-		zigbeeMap
-	}
-}
-
-def isKnownDescription(description) {
-	if ((description?.startsWith("catchall:")) || (description?.startsWith("read attr -"))) {
-		def descMap = parseDescriptionAsMap(description)
-		if (descMap.cluster == "0006" || descMap.clusterId == "0006") {
-			isDescriptionOnOff(descMap)
-		}
-		else if (descMap.cluster == "0702" || descMap.clusterId == "0702"){
-			isDescriptionPower(descMap)
-		}
-		else {
-			return "false"
-		}
-	}
-	else if(description?.startsWith("on/off:")) {
-		def switchValue = description?.endsWith("1") ? "on" : "off"
-		return	[type: "switch", value : switchValue]
-	}
-	else {
-		return "false"
-	}
-}
-
-def isDescriptionOnOff(descMap) {
-	def switchValue = "undefined"
-	if (descMap.cluster == "0006") {				//cluster info from read attr
-		value = descMap.value
-		if (value == "01"){
-			switchValue = "on"
-		}
-		else if (value == "00"){
-			switchValue = "off"
-		}
-	}
-	else if (descMap.clusterId == "0006") {
-		//cluster info from catch all
-		//command 0B is Default response and the last two bytes are [on/off][success]. on/off=00, success=00
-		//command 01 is Read attr response. the last two bytes are [datatype][value]. boolean datatype=10; on/off value = 01/00
-		if ((descMap.command=="0B" && descMap.raw.endsWith("0100")) || (descMap.command=="01" && descMap.raw.endsWith("1001"))){
-			switchValue = "on"
-		}
-		else if ((descMap.command=="0B" && descMap.raw.endsWith("0000")) || (descMap.command=="01" && descMap.raw.endsWith("1000"))){
-			switchValue = "off"
-		}
-		else if(descMap.command=="07"){
-			return	[type: "update", value : "switch (0006) capability configured successfully"]
-		}
-	}
-
-	if (switchValue != "undefined"){
-		return	[type: "switch", value : switchValue]
-	}
-	else {
-		return "false"
-	}
-
-}
-
-def isDescriptionPower(descMap) {
-	def powerValue = "undefined"
-	if (descMap.cluster == "0702") {
-		if (descMap.attrId == "0400") {
-			powerValue = convertHexToInt(descMap.value)
-		}
-	}
-	else if (descMap.clusterId == "0702") {
-		if(descMap.command=="07"){
-			return	[type: "update", value : "power (0702) capability configured successfully"]
-		}
-	}
-
-	if (powerValue != "undefined"){
-		return	[type: "power", value : powerValue]
-	}
-	else {
-		return "false"
-	}
-}
-
-
-def onOffConfig() {
-	[
-			"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 6 {${device.zigbeeId}} {}", "delay 200",
-			"zcl global send-me-a-report 6 0 0x10 0 600 {01}",
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500"
-	]
-}
-
-//power config for devices with min reporting interval as 1 seconds and reporting interval if no activity as 10min (600s)
-//min change in value is 05
-def powerConfig() {
-	[
-			//Meter (Power) Reporting
-			"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 0x0702 {${device.zigbeeId}} {}", "delay 200",
-			"zcl global send-me-a-report 0x0702 0x0400 0x2A 1 600 {05}",
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500"
-	]
-}
-
-String convertToHexString(value, width=2) {
-	def s = new BigInteger(Math.round(value).toString()).toString(16)
-	while (s.size() < width) {
-		s = "0" + s
-	}
-	s
-}

devicetypes/smartthings/gentle-wake-up-controller.src/gentle-wake-up-controller.groovy

@@ -31,7 +31,7 @@ metadata {
             tileAttribute("sessionStatus", key: "PRIMARY_CONTROL") {
                 attributeState "cancelled", action: "timed session.start", icon: "http://f.cl.ly/items/322n181j2K3f281r2s0A/playbutton.png", backgroundColor: "#ffffff", nextState: "running"
                 attributeState "stopped", action: "timed session.start", icon: "http://f.cl.ly/items/322n181j2K3f281r2s0A/playbutton.png", backgroundColor: "#ffffff", nextState: "cancelled"
-                attributeState "running", action: "timed session.stop", icon: "http://f.cl.ly/items/0B3y3p2V3X2l3P3y3W09/stopbutton.png", backgroundColor: "#79b821", nextState: "cancelled"
+                attributeState "running", action: "timed session.stop", icon: "http://f.cl.ly/items/0B3y3p2V3X2l3P3y3W09/stopbutton.png", backgroundColor: "#00A0DC", nextState: "cancelled"
             }
             tileAttribute("timeRemaining", key: "SECONDARY_CONTROL") {
                 attributeState "timeRemaining", label:'${currentValue} remaining'
@@ -45,7 +45,7 @@ metadata {
         standardTile("sessionStatusTile", "sessionStatus", width: 1, height: 1, canChangeIcon: true) {
             state "cancelled", label: "Stopped", action: "timed session.start", backgroundColor: "#ffffff", icon: "http://f.cl.ly/items/1J1g0H2P0S1G1f2O1s1s/icon.png"
             state "stopped", label: "Stopped", action: "timed session.start", backgroundColor: "#ffffff", icon: "http://f.cl.ly/items/1J1g0H2P0S1G1f2O1s1s/icon.png"
-            state "running", label: "Running", action: "timed session.stop", backgroundColor: "#79b821", icon: "http://f.cl.ly/items/1J1g0H2P0S1G1f2O1s1s/icon.png"
+            state "running", label: "Running", action: "timed session.stop", backgroundColor: "#00A0DC", icon: "http://f.cl.ly/items/1J1g0H2P0S1G1f2O1s1s/icon.png"
         }
 
         // duration

devicetypes/smartthings/harmony-activity.src/harmony-activity.groovy

@@ -32,7 +32,7 @@ metadata {
 	tiles {
 		standardTile("button", "device.switch", width: 2, height: 2, canChangeIcon: true) {
 			state "off", label: 'Off', action: "switch.on", icon: "st.harmony.harmony-hub-icon", backgroundColor: "#ffffff", nextState: "on"
-			state "on", label: 'On', action: "switch.off", icon: "st.harmony.harmony-hub-icon", backgroundColor: "#79b821", nextState: "off"
+			state "on", label: 'On', action: "switch.off", icon: "st.harmony.harmony-hub-icon", backgroundColor: "#00A0DC", nextState: "off"
 		}
 		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"

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

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

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

@@ -16,6 +16,8 @@ metadata {
 		capability "Switch"
 		capability "Refresh"
 		capability "Sensor"
+		capability "Health Check"
+		capability "Light"
 
 		command "setAdjustedColor"
         command "reset"
@@ -30,23 +32,20 @@ metadata {
 		multiAttributeTile(name:"rich-control", 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:"#00A0DC", nextState:"turningOff"
-				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#C6C7CC", nextState:"turningOn"
+				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:"#00A0DC", nextState:"turningOff"
-				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#C6C7CC", nextState:"turningOn"
+				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", range:"(0..100)"
             }
-            tileAttribute ("device.level", key: "SECONDARY_CONTROL") {
-	            attributeState "level", label: 'Level ${currentValue}%'
-			}
 			tileAttribute ("device.color", key: "COLOR_CONTROL") {
 				attributeState "color", action:"setAdjustedColor"
 			}
 		}
 
 		standardTile("reset", "device.reset", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:"Reset Color", action:"reset", icon:"st.lights.philips.hue-single"
+			state "default", label:"Reset To White", action:"reset", icon:"st.lights.philips.hue-single"
 		}
 
 		standardTile("refresh", "device.refresh", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
@@ -54,10 +53,14 @@ metadata {
 		}
 
 		main(["rich-control"])
-		details(["rich-control", "colorTempSliderControl", "colorTemp", "reset", "refresh"])
+		details(["rich-control", "reset", "refresh"])
 	}
 }
 
+void installed() {
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}", displayed: false)
+}
+
 // parse events into attributes
 def parse(description) {
 	log.debug "parse() - $description"
@@ -78,118 +81,78 @@ def parse(description) {
 // handle commands
 void on() {
 	log.trace parent.on(this)
-	sendEvent(name: "switch", value: "on")
 }
 
 void off() {
 	log.trace parent.off(this)
-	sendEvent(name: "switch", value: "off")
-}
-
-void nextLevel() {
-	def level = device.latestValue("level") as Integer ?: 0
-	if (level <= 100) {
-		level = Math.min(25 * (Math.round(level / 25) + 1), 100) as Integer
-	}
-	else {
-		level = 25
-	}
-	setLevel(level)
 }
 
 void setLevel(percent) {
     log.debug "Executing 'setLevel'"
     if (verifyPercent(percent)) {
-        parent.setLevel(this, percent)
-        sendEvent(name: "level", value: percent, descriptionText: "Level has changed to ${percent}%")
-        sendEvent(name: "switch", value: "on")
+	    log.trace parent.setLevel(this, percent)
     }
 }
 
 void setSaturation(percent) {
     log.debug "Executing 'setSaturation'"
     if (verifyPercent(percent)) {
-        parent.setSaturation(this, percent)
-        sendEvent(name: "saturation", value: percent, displayed: false)
+	    log.trace parent.setSaturation(this, percent)
     }
 }
 
 void setHue(percent) {
     log.debug "Executing 'setHue'"
     if (verifyPercent(percent)) {
-        parent.setHue(this, percent)
-        sendEvent(name: "hue", value: percent, displayed: false)
+	    log.trace parent.setHue(this, percent)
     }
 }
 
 void setColor(value) {
-    log.debug "setColor: ${value}, $this"
     def events = []
     def validValues = [:]
 
     if (verifyPercent(value.hue)) {
-        events << createEvent(name: "hue", value: value.hue, displayed: false)
         validValues.hue = value.hue
     }
     if (verifyPercent(value.saturation)) {
-        events << createEvent(name: "saturation", value: value.saturation, displayed: false)
         validValues.saturation = value.saturation
     }
     if (value.hex != null) {
         if (value.hex ==~ /^\#([A-Fa-f0-9]){6}$/) {
-            events << createEvent(name: "color", value: value.hex)
             validValues.hex = value.hex
         } else {
             log.warn "$value.hex is not a valid color"
         }
     }
     if (verifyPercent(value.level)) {
-        events << createEvent(name: "level", value: value.level, descriptionText: "Level has changed to ${value.level}%")
         validValues.level = value.level
     }
     if (value.switch == "off" || (value.level != null && value.level <= 0)) {
-        events << createEvent(name: "switch", value: "off")
         validValues.switch = "off"
     } else {
-        events << createEvent(name: "switch", value: "on")
         validValues.switch = "on"
     }
-    if (!events.isEmpty()) {
-        parent.setColor(this, validValues)
-    }
-    events.each {
-        sendEvent(it)
+    if (!validValues.isEmpty()) {
+	    log.trace parent.setColor(this, validValues)
     }
 }
 
 void reset() {
     log.debug "Executing 'reset'"
-    def value = [level:100, saturation:56, hue:23]
-    setAdjustedColor(value)
-    parent.poll()
+	def value = [hue:20, saturation:2]
+	setAdjustedColor(value)
 }
 
 void setAdjustedColor(value) {
     if (value) {
         log.trace "setAdjustedColor: ${value}"
         def adjusted = value + [:]
-        adjusted.hue = adjustOutgoingHue(value.hue)
         // Needed because color picker always sends 100
         adjusted.level = null
-        setColor(adjusted)
+	    setColor(adjusted)
     } else {
-        log.warn "Invalid color input"
-    }
-}
-
-void setColorTemperature(value) {
-    if (value) {
-        log.trace "setColorTemperature: ${value}k"
-        parent.setColorTemperature(this, value)
-        sendEvent(name: "colorTemperature", value: value)
-        sendEvent(name: "switch", value: "on")
-    } else {
-        log.warn "Invalid color temperature"
+        log.warn "Invalid color input $value"
     }
 }
 
@@ -198,22 +161,6 @@ void refresh() {
     parent.manualRefresh()
 }
 
-def adjustOutgoingHue(percent) {
-	def adjusted = percent
-	if (percent > 31) {
-		if (percent < 63.0) {
-			adjusted = percent + (7 * (percent -30 ) / 32)
-		}
-		else if (percent < 73.0) {
-			adjusted = 69 + (5 * (percent - 62) / 10)
-		}
-		else {
-			adjusted = percent + (2 * (100 - percent) / 28)
-		}
-	}
-	log.info "percent: $percent, adjusted: $adjusted"
-	adjusted
-}
 
 def verifyPercent(percent) {
     if (percent == null)
@@ -225,3 +172,4 @@ def verifyPercent(percent) {
         return false
     }
 }
+

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

@@ -7,8 +7,16 @@
 metadata {
 	// Automatically generated. Make future change here.
 	definition (name: "Hue Bridge", namespace: "smartthings", author: "SmartThings") {
-		attribute "serialNumber", "string"
+		capability "Bridge"
+		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"
+		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
+		attribute "idNumber", "string"
 	}
 
 	simulator {
@@ -17,25 +25,30 @@ metadata {
 
 	tiles(scale: 2) {
      	multiAttributeTile(name:"rich-control"){
-			tileAttribute ("", key: "PRIMARY_CONTROL") {
-	            attributeState "default", label: "Hue Bridge", action: "", icon: "st.Lighting.light99-hue", backgroundColor: "#F3C200"
+			tileAttribute ("device.status", key: "PRIMARY_CONTROL") {
+				attributeState "Offline", label: '${currentValue}', action: "", icon: "st.Lighting.light99-hue", backgroundColor: "#ffffff"
+	            attributeState "Online", label: '${currentValue}', action: "", icon: "st.Lighting.light99-hue", backgroundColor: "#00A0DC"
 			}
-	        tileAttribute ("serialNumber", key: "SECONDARY_CONTROL") {
-	            attributeState "default", label:'SN: ${currentValue}'
 			}
-        }
-		valueTile("serialNumber", "device.serialNumber", decoration: "flat", height: 1, width: 2, inactiveLabel: false) {
-			state "default", label:'SN: ${currentValue}'
+		valueTile("doNotRemove", "v", decoration: "flat", height: 2, width: 6, inactiveLabel: false) {
+			state "default", label:'If removed, Hue lights will not work properly'
 		}
-		valueTile("networkAddress", "device.networkAddress", decoration: "flat", height: 2, width: 4, inactiveLabel: false) {
-			state "default", label:'${currentValue}', height: 1, width: 2, inactiveLabel: false
+		valueTile("idNumber", "device.idNumber", decoration: "flat", height: 2, width: 6, inactiveLabel: false) {
+			state "default", label:'ID: ${currentValue}'
+		}
+		valueTile("networkAddress", "device.networkAddress", decoration: "flat", height: 2, width: 6, inactiveLabel: false) {
+			state "default", label:'IP: ${currentValue}'
 		}
 
 		main (["rich-control"])
-		details(["rich-control", "networkAddress"])
+		details(["rich-control", "doNotRemove", "idNumber", "networkAddress"])
 	}
 }
 
+void installed() {
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}", displayed: false)
+}
+
 // parse events into attributes
 def parse(description) {
 	log.debug "Parsing '${description}'"
@@ -56,7 +69,7 @@ def parse(description) {
 			log.trace "HUE BRIDGE, GENERATING EVENT: $map.name: $map.value"
 			results << createEvent(name: "${map.name}", value: "${map.value}")
 		} else {
-        	log.trace "Parsing description"
+			log.trace "Parsing description"
 			def msg = parseLanMessage(description)
 			if (msg.body) {
 				def contentType = msg.headers["Content-Type"]
@@ -64,18 +77,14 @@ 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.state.inBulbDiscovery)
-                        	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)
+					parent.hubVerification(device.hub.id, msg.body)
 				}
 			}
 		}
 	}
 	results
 }
+

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

@@ -17,6 +17,8 @@ metadata {
 		capability "Switch"
 		capability "Refresh"
 		capability "Sensor"
+		capability "Health Check"
+		capability "Light"
 
 		command "setAdjustedColor"
         command "reset"
@@ -31,31 +33,28 @@ metadata {
 		multiAttributeTile(name:"rich-control", 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:"#00A0DC", nextState:"turningOff"
-				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#C6C7CC", nextState:"turningOn"
+				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:"#00A0DC", nextState:"turningOff"
-				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#C6C7CC", nextState:"turningOn"
+				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", range:"(0..100)"
             }
-            tileAttribute ("device.level", key: "SECONDARY_CONTROL") {
-	            attributeState "level", label: 'Level ${currentValue}%'
-			}
 			tileAttribute ("device.color", key: "COLOR_CONTROL") {
 				attributeState "color", action:"setAdjustedColor"
 			}
 		}
 
-        controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2000..6500)") {
-            state "colorTemperature", action:"color temperature.setColorTemperature"
-        }
+    controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2000..6500)") {
+        state "colorTemperature", action:"color temperature.setColorTemperature"
+    }
 
-        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "colorTemperature", label: '${currentValue} K'
-        }
+    valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+        state "colorTemperature", label: 'WHITES'
+    }
 
 		standardTile("reset", "device.reset", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:"Reset Color", action:"reset", icon:"st.lights.philips.hue-single"
+			state "default", label:"Reset To White", action:"reset", icon:"st.lights.philips.hue-single"
 		}
 
 		standardTile("refresh", "device.refresh", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
@@ -67,6 +66,10 @@ metadata {
 	}
 }
 
+void installed() {
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}", displayed: false)
+}
+
 // parse events into attributes
 def parse(description) {
 	log.debug "parse() - $description"
@@ -87,141 +90,92 @@ def parse(description) {
 // handle commands
 void on() {
 	log.trace parent.on(this)
-	sendEvent(name: "switch", value: "on")
 }
 
 void off() {
 	log.trace parent.off(this)
-	sendEvent(name: "switch", value: "off")
-}
-
-void nextLevel() {
-	def level = device.latestValue("level") as Integer ?: 0
-	if (level <= 100) {
-		level = Math.min(25 * (Math.round(level / 25) + 1), 100) as Integer
-	}
-	else {
-		level = 25
-	}
-	setLevel(level)
 }
 
 void setLevel(percent) {
     log.debug "Executing 'setLevel'"
     if (verifyPercent(percent)) {
-        parent.setLevel(this, percent)
-        sendEvent(name: "level", value: percent, descriptionText: "Level has changed to ${percent}%")
-        sendEvent(name: "switch", value: "on")
+	    log.trace parent.setLevel(this, percent)
     }
 }
 
 void setSaturation(percent) {
     log.debug "Executing 'setSaturation'"
     if (verifyPercent(percent)) {
-        parent.setSaturation(this, percent)
-        sendEvent(name: "saturation", value: percent, displayed: false)
+	    log.trace parent.setSaturation(this, percent)
     }
 }
 
 void setHue(percent) {
     log.debug "Executing 'setHue'"
     if (verifyPercent(percent)) {
-        parent.setHue(this, percent)
-        sendEvent(name: "hue", value: percent, displayed: false)
+	    log.trace parent.setHue(this, percent)
     }
 }
 
 void setColor(value) {
-    log.debug "setColor: ${value}, $this"
     def events = []
     def validValues = [:]
 
     if (verifyPercent(value.hue)) {
-        events << createEvent(name: "hue", value: value.hue, displayed: false)
         validValues.hue = value.hue
     }
     if (verifyPercent(value.saturation)) {
-        events << createEvent(name: "saturation", value: value.saturation, displayed: false)
         validValues.saturation = value.saturation
     }
     if (value.hex != null) {
         if (value.hex ==~ /^\#([A-Fa-f0-9]){6}$/) {
-            events << createEvent(name: "color", value: value.hex)
             validValues.hex = value.hex
         } else {
             log.warn "$value.hex is not a valid color"
         }
     }
     if (verifyPercent(value.level)) {
-        events << createEvent(name: "level", value: value.level, descriptionText: "Level has changed to ${value.level}%")
         validValues.level = value.level
     }
     if (value.switch == "off" || (value.level != null && value.level <= 0)) {
-        events << createEvent(name: "switch", value: "off")
         validValues.switch = "off"
     } else {
-        events << createEvent(name: "switch", value: "on")
         validValues.switch = "on"
     }
-    if (!events.isEmpty()) {
-        parent.setColor(this, validValues)
-    }
-    events.each {
-        sendEvent(it)
+    if (!validValues.isEmpty()) {
+	    log.trace parent.setColor(this, validValues)
     }
 }
 
 void reset() {
     log.debug "Executing 'reset'"
-    def value = [level:100, saturation:56, hue:23]
-    setAdjustedColor(value)
-    parent.poll()
+	setColorTemperature(4000)
 }
 
 void setAdjustedColor(value) {
     if (value) {
         log.trace "setAdjustedColor: ${value}"
         def adjusted = value + [:]
-        adjusted.hue = adjustOutgoingHue(value.hue)
         // Needed because color picker always sends 100
         adjusted.level = null
-        setColor(adjusted)
+	    setColor(adjusted)
     } else {
-        log.warn "Invalid color input"
+        log.warn "Invalid color input $value"
     }
 }
 
 void setColorTemperature(value) {
     if (value) {
         log.trace "setColorTemperature: ${value}k"
-        parent.setColorTemperature(this, value)
-        sendEvent(name: "colorTemperature", value: value)
-        sendEvent(name: "switch", value: "on")
+	    log.trace parent.setColorTemperature(this, value)
     } else {
-        log.warn "Invalid color temperature"
+        log.warn "Invalid color temperature $value"
     }
 }
 
 void refresh() {
     log.debug "Executing 'refresh'"
-    parent.manualRefresh()
-}
-
-def adjustOutgoingHue(percent) {
-	def adjusted = percent
-	if (percent > 31) {
-		if (percent < 63.0) {
-			adjusted = percent + (7 * (percent -30 ) / 32)
-		}
-		else if (percent < 73.0) {
-			adjusted = 69 + (5 * (percent - 62) / 10)
-		}
-		else {
-			adjusted = percent + (2 * (100 - percent) / 28)
-		}
-	}
-	log.info "percent: $percent, adjusted: $adjusted"
-	adjusted
+    parent?.manualRefresh()
 }
 
 def verifyPercent(percent) {
@@ -234,3 +188,4 @@ def verifyPercent(percent) {
         return false
     }
 }
+

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

@@ -14,6 +14,8 @@ metadata {
 		capability "Switch"
 		capability "Refresh"
 		capability "Sensor"
+		capability "Health Check"
+		capability "Light"
 
         command "refresh"
 	}
@@ -26,16 +28,13 @@ metadata {
         multiAttributeTile(name:"rich-control", type: "lighting", canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
               attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#00A0DC", nextState:"turningOff"
-              attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#C6C7CC", nextState:"turningOn"
+              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:"#00A0DC", nextState:"turningOff"
-              attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#C6C7CC", nextState:"turningOn"
+              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", range:"(0..100)"
             }
-            tileAttribute ("device.level", key: "SECONDARY_CONTROL") {
-	            attributeState "level", label: 'Level ${currentValue}%'
-			}
         }
 
         controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false, range:"(0..100)") {
@@ -51,6 +50,10 @@ metadata {
     }
 }
 
+void installed() {
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}", displayed: false)
+}
+
 // parse events into attributes
 def parse(description) {
 	log.debug "parse() - $description"
@@ -71,20 +74,16 @@ def parse(description) {
 // handle commands
 void on() {
 	log.trace parent.on(this)
-	sendEvent(name: "switch", value: "on")
 }
 
 void off() {
 	log.trace parent.off(this)
-	sendEvent(name: "switch", value: "off")
 }
 
 void setLevel(percent) {
 	log.debug "Executing 'setLevel'"
     if (percent != null && percent >= 0 && percent <= 100) {
 		parent.setLevel(this, percent)
-		sendEvent(name: "level", value: percent)
-		sendEvent(name: "switch", value: "on")
 	} else {
     	log.warn "$percent is not 0-100"
     }
@@ -94,3 +93,4 @@ void refresh() {
 	log.debug "Executing 'refresh'"
 	parent.manualRefresh()
 }
+

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

@@ -0,0 +1,110 @@
+/**
+ *  Hue White Ambiance Bulb
+ *
+ *  Philips Hue Type "Color Temperature Light"
+ *
+ *  Author: SmartThings
+ */
+
+// for the UI
+metadata {
+    // Automatically generated. Make future change here.
+    definition (name: "Hue White Ambiance Bulb", namespace: "smartthings", author: "SmartThings") {
+        capability "Switch Level"
+        capability "Actuator"
+        capability "Color Temperature"
+        capability "Switch"
+        capability "Refresh"
+        capability "Health Check"
+        capability "Light"
+
+        command "refresh"
+    }
+
+    simulator {
+        // TODO: define status and reply messages here
+    }
+
+    tiles (scale: 2){
+        multiAttributeTile(name:"rich-control", 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:"#00A0DC", nextState:"turningOff"
+                attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#00A0DC", nextState:"turningOff"
+                attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+            }
+            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+                attributeState "level", action:"switch level.setLevel", range:"(0..100)"
+            }
+        }
+
+        controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2200..6500)") {
+            state "colorTemperature", action:"color temperature.setColorTemperature"
+        }
+
+        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "colorTemperature", label: 'WHITES'
+        }
+
+        standardTile("refresh", "device.refresh", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+
+        main(["rich-control"])
+        details(["rich-control", "colorTempSliderControl", "colorTemp", "refresh"])
+    }
+}
+
+void installed() {
+	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}", displayed: false)
+}
+
+// parse events into attributes
+def parse(description) {
+    log.debug "parse() - $description"
+    def results = []
+
+    def map = description
+    if (description instanceof String)  {
+        log.debug "Hue Ambience Bulb stringToMap - ${map}"
+        map = stringToMap(description)
+    }
+
+    if (map?.name && map?.value) {
+        results << createEvent(name: "${map?.name}", value: "${map?.value}")
+    }
+    results
+}
+
+// handle commands
+void on() {
+    log.trace parent.on(this)
+}
+
+void off() {
+    log.trace parent.off(this)
+}
+
+void setLevel(percent) {
+    log.debug "Executing 'setLevel'"
+    if (percent != null && percent >= 0 && percent <= 100) {
+        log.trace parent.setLevel(this, percent)
+    } else {
+        log.warn "$percent is not 0-100"
+    }
+}
+
+void setColorTemperature(value) {
+    if (value) {
+        log.trace "setColorTemperature: ${value}k"
+        log.trace parent.setColorTemperature(this, value)
+    } else {
+        log.warn "Invalid color temperature"
+    }
+}
+
+void refresh() {
+    log.debug "Executing 'refresh'"
+    parent.manualRefresh()
+}
+

devicetypes/smartthings/life360-user.src/life360-user.groovy

@@ -29,7 +29,7 @@ metadata {
 
 	tiles {
 		standardTile("presence", "device.presence", width: 2, height: 2, canChangeBackground: true) {
-			state("present", labelIcon:"st.presence.tile.mobile-present", backgroundColor:"#53a7c0")
+			state("present", labelIcon:"st.presence.tile.mobile-present", backgroundColor:"#00A0DC")
 			state("not present", labelIcon:"st.presence.tile.mobile-not-present", backgroundColor:"#ffffff")
 		}
 
@@ -39,7 +39,7 @@ metadata {
 }
 
 def generatePresenceEvent(boolean present) {
-	log.debug "Here in generatePresenceEvent!"
+	log.info "Life360 generatePresenceEvent($present)"
 	def value = formatValue(present)
 	def linkText = getLinkText(device)
 	def descriptionText = formatDescriptionText(linkText, present)

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

@@ -11,9 +11,10 @@ metadata {
 		capability "Color Temperature"
 		capability "Switch"
 		capability "Switch Level" // brightness
-		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
+		capability "Health Check"
+		capability "Light"
 	}
 
 	simulator {
@@ -23,10 +24,9 @@ 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 "on", label:'${name}', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#00A0DC", 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 "turningOn", label:'Turning on', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#00A0DC", nextState:"turningOff"
 				attributeState "turningOff", label:'Turning off', action:"switch.on", icon:"http://hosted.lifx.co/smartthings/v1/196xOff.png", backgroundColor:"#ffffff", nextState:"turningOn"
 			}
 
@@ -64,12 +64,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 +137,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 +188,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 +207,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,10 @@ metadata {
 		capability "Color Temperature"
 		capability "Switch"
 		capability "Switch Level" // brightness
-		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
+		capability "Health Check"
+		capability "Light"
 	}
 
 	simulator {
@@ -22,13 +23,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 "on", label:'${name}', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#00A0DC", 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 "turningOn", label:'Turning on', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#00A0DC", 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 +53,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 +66,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 +117,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 +135,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/mimolite-garage-door-controller.src/mimolite-garage-door-controller.groovy

@@ -36,6 +36,7 @@ metadata {
 		capability "Switch"
 		capability "Refresh"
 		capability "Contact Sensor"
+		capability "Light"
 
 		attribute "powered", "string"
 
@@ -53,11 +54,11 @@ metadata {
 	// UI tile definitions 
 	tiles {
         standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "doorClosed", label: "Closed", action: "on", icon: "st.doors.garage.garage-closed", backgroundColor: "#79b821"
-            state "doorOpen", label: "Open", action: "on", icon: "st.doors.garage.garage-open", backgroundColor: "#ffa81e"
-            state "doorOpening", label: "Opening", action: "on", icon: "st.doors.garage.garage-opening", backgroundColor: "#ffa81e"
-            state "doorClosing", label: "Closing", action: "on", icon: "st.doors.garage.garage-closing", backgroundColor: "#ffa81e"
-            state "on", label: "Actuate", action: "off", icon: "st.doors.garage.garage-closed", backgroundColor: "#53a7c0"
+			state "doorClosed", label: "Closed", action: "on", icon: "st.doors.garage.garage-closed", backgroundColor: "#00A0DC"
+            state "doorOpen", label: "Open", action: "on", icon: "st.doors.garage.garage-open", backgroundColor: "#e86d13"
+            state "doorOpening", label: "Opening", action: "on", icon: "st.doors.garage.garage-opening", backgroundColor: "#e86d13"
+            state "doorClosing", label: "Closing", action: "on", icon: "st.doors.garage.garage-closing", backgroundColor: "#00A0DC"
+            state "on", label: "Actuate", action: "off", icon: "st.doors.garage.garage-closed", backgroundColor: "#00A0DC"
 			state "off", label: '${name}', action: "on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
         }
         standardTile("contact", "device.contact", inactiveLabel: false) {

devicetypes/smartthings/mobile-presence.src/i18n/messages.properties

@@ -1,4 +1,3 @@
-#==============================================================================
 #  Copyright 2016 SmartThings
 #
 #  Licensed under the Apache License, Version 2.0 (the "License"); you may not 
@@ -12,21 +11,12 @@
 #  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
 #  License for the specific language governing permissions and limitations 
 #  under the License.
-#==============================================================================
-# Purpose: Mobile Presence i18n Translation File
-#
-# Filename: mobile-presence.src/i18n/messages.properties
-#
-# Change History:
-#	1. 20160205 TW Initial release with informal Korean translation.
-#	2. 20160224 TW Updated with formal Korean translation.
-#==============================================================================
 # Korean (ko)
 # Device Preferences
-'''Give your device a name'''.ko=기기 이름 바꾸기
+'''Give your device a name'''.ko=기기 이름 설정
 '''Set Device Image'''.ko=기기 이미지 설정
 # Events / Notifications
-'''{{ linkText }} has left'''.ko={{ linkText }}집을 나갔습니다.
-'''{{ linkText }} has arrived'''.ko={{ linkText }}집에 도착했습니다.
+'''{{ linkText }} has left'''.ko={{ linkText }} 외출
+'''{{ linkText }} has arrived'''.ko={{ linkText }} 귀가
 '''present'''.ko=집안
 '''not present'''.ko=외출

devicetypes/smartthings/mobile-presence.src/mobile-presence.groovy

@@ -1,5 +1,4 @@
 /*
-===============================================================================
  *  Copyright 2016 SmartThings
  *
  *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
@@ -13,14 +12,6 @@
  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
  *  License for the specific language governing permissions and limitations 
  *  under the License.
-===============================================================================
- *  Purpose: Mobile Presence DTH File
- *
- *  Filename: mobile-presence.src/mobile-presence.groovy
- *
- *  Change History:
- *  1. 20160205 TW - Update/Edit to support i18n translations
-===============================================================================
  */
  
 metadata {
@@ -36,8 +27,8 @@ metadata {
 
 	tiles {
 		standardTile("presence", "device.presence", width: 2, height: 2, canChangeBackground: true) {
-			state("present", labelIcon:"st.presence.tile.mobile-present", backgroundColor:"#53a7c0")
-			state("not present", labelIcon:"st.presence.tile.mobile-not-present", backgroundColor:"#ebeef2")
+			state("present", labelIcon:"st.presence.tile.mobile-present", backgroundColor:"#00A0DC")
+			state("not present", labelIcon:"st.presence.tile.mobile-not-present", backgroundColor:"#ffffff")
 		}
 		main "presence"
 		details "presence"

devicetypes/smartthings/momentary-button-tile.src/momentary-button-tile.groovy

@@ -32,7 +32,7 @@ metadata {
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
 			state "off", label: 'Push', action: "momentary.push", backgroundColor: "#ffffff", nextState: "on"
-			state "on", label: 'Push', action: "momentary.push", backgroundColor: "#53a7c0"
+			state "on", label: 'Push', action: "momentary.push", backgroundColor: "#00A0DC"
 		}
 		main "switch"
 		details "switch"
@@ -43,8 +43,8 @@ def parse(String description) {
 }
 
 def push() {
-	sendEvent(name: "switch", value: "on", isStateChange: true, display: false)
-	sendEvent(name: "switch", value: "off", isStateChange: true, display: false)
+	sendEvent(name: "switch", value: "on", isStateChange: true, displayed: false)
+	sendEvent(name: "switch", value: "off", isStateChange: true, displayed: false)
 	sendEvent(name: "momentary", value: "pushed", isStateChange: true)
 }
 

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

@@ -28,8 +28,8 @@ metadata {
 	// UI tile definitions
 	tiles {
 		standardTile("motion", "device.motion", width: 2, height: 2) {
-			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0")
-			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff")
+			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC")
+			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#cccccc")
 		}
 
 		main "motion"

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

@@ -13,6 +13,7 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
+import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
 
 metadata {
 	definition (name: "NYCE Motion Sensor", namespace: "smartthings", author: "SmartThings") {
@@ -20,6 +21,7 @@ metadata {
 		capability "Configuration"
 		capability "Battery"
 		capability "Refresh"
+		capability "Sensor"
         
         command "enrollResponse"
 
@@ -30,8 +32,8 @@ metadata {
 
 	tiles {
 		standardTile("motion", "device.motion", width: 2, height: 2) {
-			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0")
-			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff")
+			state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#00A0DC")
+			state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#cccccc")
 		}
         
          valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false) {
@@ -143,51 +145,14 @@ private Map parseReportAttributeMessage(String description) {
  
 
 private Map parseIasMessage(String description) {
-    List parsedMsg = description.split(' ')
-    String msgCode = parsedMsg[2]
-    
-    Map resultMap = [:]
-    switch(msgCode) {
-        case '0x0030': // Closed/No Motion/Dry
-            log.debug 'no motion'
-            resultMap.name = 'motion'
-            resultMap.value = 'inactive'
-            break
+	ZoneStatus zs = zigbee.parseZoneStatus(description)
+	Map resultMap = [:]
 
-        case '0x0032': // Open/Motion/Wet
-            log.debug 'motion'
-            resultMap.name = 'motion'
-            resultMap.value = 'active'
-            break
+	resultMap.name = 'motion'
+	resultMap.value = zs.isAlarm2Set() ? 'active' : 'inactive'
+	log.debug(zs.isAlarm2Set() ? 'motion' : 'no motion')
 
-        case '0x0032': // Tamper Alarm
-        	log.debug 'motion with tamper alarm'
-            resultMap.name = 'motion'
-            resultMap.value = 'active'
-            break
-
-        case '0x0033': // Battery Alarm
-            break
-
-        case '0x0034': // Supervision Report
-        	log.debug 'no motion with tamper alarm'
-            resultMap.name = 'motion'
-            resultMap.value = 'inactive'
-            break
-
-        case '0x0035': // Restore Report
-            break
-
-        case '0x0036': // Trouble/Failure
-        	log.debug 'motion with failure alarm'
-            resultMap.name = 'motion'
-            resultMap.value = 'active'
-            break
-
-        case '0x0038': // Test Mode
-            break
-    }
-    return resultMap
+	return resultMap
 }
 
 def refresh()

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,41 @@
+# Nyce Door/Window Sensor (Open/Close Sensor)
+
+Cloud Execution
+
+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
+
+Nyce Door/Window sensor with reporting interval of 5 min.
+SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
+ 
+* __12min__ checkInterval
+
+
+## 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

@@ -13,31 +13,37 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
- 
+
+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"
- 
- 
+		capability "Health Check"
+		capability "Sensor"
+
+		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")
-			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
+			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#e86d13")
+			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#00a0dc")
 		}
 
 		valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false) {
@@ -218,40 +224,33 @@ private Map parseReportAttributeMessage(String description) {
 }
 
 private List parseIasMessage(String description) {
-	List parsedMsg = description.split(" ")
-	String msgCode = parsedMsg[2]
+	ZoneStatus zs = zigbee.parseZoneStatus(description)
+	log.debug "parseIasMessage: $description"
 
 	List resultListMap = []
 	Map resultMap_battery = [:]
 	Map resultMap_battery_state = [:]
 	Map resultMap_sensor = [:]
 
-	// Relevant bit field definitions from ZigBee spec
-	def BATTERY_BIT = ( 1 << 3 )
-	def TROUBLE_BIT = ( 1 << 6 )
-	def SENSOR_BIT = ( 1 << 0 )		// it's ALARM1 bit from the ZCL spec
-
-	// Convert hex string to integer
-	def zoneStatus = Integer.parseInt(msgCode[-4..-1],16)
-
-	log.debug "parseIasMessage: zoneStatus: ${zoneStatus}"
+	resultMap_sensor.name = "contact"
+	resultMap_sensor.value = zs.isAlarm1Set() ? "open" : "closed"
 
 	// Check each relevant bit, create map for it, and add to list
-	log.debug "parseIasMessage: Battery Status ${zoneStatus & BATTERY_BIT}"
-	log.debug "parseIasMessage: Trouble Status ${zoneStatus & TROUBLE_BIT}"
-	log.debug "parseIasMessage: Sensor Status ${zoneStatus & SENSOR_BIT}"
+	log.debug "parseIasMessage: Battery Status ${zs.battery}"
+	log.debug "parseIasMessage: Trouble Status ${zs.trouble}"
+	log.debug "parseIasMessage: Sensor Status ${zs.alarm1}"
 
 	/* 	Comment out this path to check the battery state to avoid overwriting the
 		battery value (Change log #2), but keep these conditions for later use
 	 resultMap_battery_state.name = "battery_state"
-	 if (zoneStatus & TROUBLE_BIT) {
+	 if (zs.isTroubleSet()) {
 		 resultMap_battery_state.value = "failed"
 
 		 resultMap_battery.name = "battery"
 		 resultMap_battery.value = 0
 	 }
 	 else {
-		 if (zoneStatus & BATTERY_BIT) {
+		 if (zs.isBatterySet()) {
 			 resultMap_battery_state.value = "low"
 
 			 // to generate low battery notification by the platform
@@ -269,9 +268,6 @@ private List parseIasMessage(String description) {
 	 }
 	*/
 
-	resultMap_sensor.name = "contact"
-	resultMap_sensor.value = (zoneStatus & SENSOR_BIT) ? "open" : "closed"
-
 	resultListMap << resultMap_battery_state
 	resultListMap << resultMap_battery
 	resultListMap << resultMap_sensor
@@ -279,23 +275,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() {
@@ -340,7 +341,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/on-off-button-tile.src/on-off-button-tile.groovy

@@ -31,7 +31,7 @@ metadata {
 	tiles {
 		standardTile("button", "device.switch", width: 2, height: 2, canChangeIcon: true) {
 			state "off", label: 'Off', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "on"
-			state "on", label: 'On', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821", nextState: "off"
+			state "on", label: 'On', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00A0DC", nextState: "off"
 		}
 		main "button"
 		details "button"

devicetypes/smartthings/on-off-shield.src/on-off-shield.groovy

@@ -31,7 +31,7 @@ metadata {
 	// UI tile definitions
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true, canChangeBackground: true) {
-			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#00A0DC"
 			state "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
 		}
 

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

@@ -29,8 +29,8 @@ metadata {
 	// UI tile definitions
 	tiles {
 		standardTile("contact", "device.contact", width: 2, height: 2) {
-			state "open", label: '${name}', icon: "st.contact.contact.open", backgroundColor: "#ffa81e"
-			state "closed", label: '${name}', icon: "st.contact.contact.closed", backgroundColor: "#79b821"
+			state "open", label: '${name}', icon: "st.contact.contact.open", backgroundColor: "#e86d13"
+			state "closed", label: '${name}', icon: "st.contact.contact.closed", backgroundColor: "#00A0DC"
 		}
 
 		main "contact"
@@ -40,14 +40,11 @@ metadata {
 
 // Parse incoming device messages to generate events
 def parse(String description) {
-	def name = null
-	def value = description
-	if (zigbee.isZoneType19(description)) {
-		name = "contact"
-		value = zigbee.translateStatusZoneType19(description) ? "open" : "closed"
+	def resMap
+	if (description.startsWith("zone")) {
+		resMap = createEvent(name: "contact", value: zigbee.parseZoneStatus(description).isAlarm1Set() ? "open" : "closed")
 	}
 	
-	def result = createEvent(name: name, value: value)
-	log.debug "Parse returned ${result?.descriptionText}"
-	return result
+	log.debug "Parse returned $resMap"
+	return resMap
 }

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

@@ -1,384 +0,0 @@
-/*
-    Osram Lightify Gardenspot Mini RGB
-
-    Osram bulbs have a firmware issue causing it to forget its dimming level when turned off (via commands). Handling
-    that issue by using state variables
-*/
-
-metadata {
-    definition (name: "OSRAM LIGHTIFY Gardenspot mini RGB", namespace: "smartthings", author: "SmartThings") {
-
-        capability "Color Temperature"
-        capability "Actuator"
-        capability "Switch"
-        capability "Switch Level"
-        capability "Configuration"
-        capability "Polling"
-        capability "Refresh"
-        capability "Sensor"
-        capability "Color Control"
-
-        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
-    simulator {
-        // status messages
-        status "on": "on/off: 1"
-        status "off": "on/off: 0"
-
-        // reply messages
-        reply "zcl on-off on": "on/off: 1"
-        reply "zcl on-off off": "on/off: 0"
-    }
-
-    // UI tile definitions
-    tiles {
-        standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-            state "on", label: '${name}', action: "switch.off", icon: "st.switches.light.on", backgroundColor: "#79b821"
-            state "off", label: '${name}', action: "switch.on", icon: "st.switches.light.off", backgroundColor: "#ffffff"
-        }
-        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-
-        controlTile("rgbSelector", "device.color", "color", height: 3, width: 3, inactiveLabel: false) {
-            state "color", action:"setAdjustedColor"
-        }
-        valueTile("colorName", "device.colorName", inactiveLabel: false, decoration: "flat") {
-            state "colorName", label: '${currentValue}'
-        }
-
-        controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false, range:"(0..100)") {
-            state "level", action:"switch level.setLevel"
-        }
-        valueTile("level", "device.level", inactiveLabel: false, decoration: "flat") {
-            state "level", label: 'Level ${currentValue}%'
-        }
-
-        main(["switch"])
-        details(["switch", "refresh", "colorName", "levelSliderControl", "level", "rgbSelector"])
-    }
-}
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-    //log.info "description is $description"
-    if (description?.startsWith("catchall:")) {
-        if(description?.endsWith("0100") ||description?.endsWith("1001") || description?.matches("on/off\\s*:\\s*1"))
-        {
-            def result = createEvent(name: "switch", value: "on")
-            log.debug "Parse returned ${result?.descriptionText}"
-            return result
-        }
-        else if(description?.endsWith("0000") || description?.endsWith("1000") || description?.matches("on/off\\s*:\\s*0"))
-        {
-            if(!(description?.startsWith("catchall: 0104 0300"))){
-                def result = createEvent(name: "switch", value: "off")
-                log.debug "Parse returned ${result?.descriptionText}"
-                return result
-            }
-        }
-    }
-    else if (description?.startsWith("read attr -")) {
-        def descMap = parseDescriptionAsMap(description)
-        log.trace "descMap : $descMap"
-
-        if (descMap.cluster == "0300") {
-            if(descMap.attrId == "0000"){  //Hue Attribute
-                def hueValue = Math.round(convertHexToInt(descMap.value) / 255 * 360)
-                log.debug "Hue value returned is $hueValue"
-                sendEvent(name: "hue", value: hueValue, displayed:false)
-            }
-            else if(descMap.attrId == "0001"){ //Saturation Attribute
-                def saturationValue = Math.round(convertHexToInt(descMap.value) / 255 * 100)
-                log.debug "Saturation from refresh is $saturationValue"
-                sendEvent(name: "saturation", value: saturationValue, displayed:false)
-            }
-        }
-        else if(descMap.cluster == "0008"){
-            def dimmerValue = Math.round(convertHexToInt(descMap.value) * 100 / 255)
-            log.debug "dimmer value is $dimmerValue"
-            sendEvent(name: "level", value: dimmerValue)
-        }
-    }
-    else {
-        def name = description?.startsWith("on/off: ") ? "switch" : null
-        def value = name == "switch" ? (description?.endsWith(" 1") ? "on" : "off") : null
-        def result = createEvent(name: name, value: value)
-        log.debug "Parse returned ${result?.descriptionText}"
-        return result
-    }
-
-
-}
-
-def on() {
-    log.debug "on()"
-    sendEvent(name: "switch", value: "on")
-    setLevel(state?.levelValue)
-}
-
-def zigbeeOff() {
-    "st cmd 0x${device.deviceNetworkId} ${endpointId} 6 0 {}"
-}
-
-def off() {
-    log.debug "off()"
-    sendEvent(name: "switch", value: "off")
-    zigbeeOff()
-}
-
-def refresh() {
-    [
-            "st rattr 0x${device.deviceNetworkId} ${endpointId} 6 0", "delay 500",
-            "st rattr 0x${device.deviceNetworkId} ${endpointId} 8 0", "delay 500",
-            "st rattr 0x${device.deviceNetworkId} ${endpointId} 0x0300 0", "delay 500",
-            "st rattr 0x${device.deviceNetworkId} ${endpointId} 0x0300 1"
-    ]
-
-}
-
-def configure() {
-    state.levelValue = 100
-    log.debug "Configuring Reporting and Bindings."
-    def configCmds = [
-
-            //Switch Reporting
-            "zcl global send-me-a-report 6 0 0x10 0 3600 {01}", "delay 500",
-            "send 0x${device.deviceNetworkId} ${endpointId} 1", "delay 1000",
-
-            //Level Control Reporting
-            "zcl global send-me-a-report 8 0 0x20 5 3600 {0010}", "delay 200",
-            "send 0x${device.deviceNetworkId} ${endpointId} 1", "delay 1500",
-
-            "zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 6 {${device.zigbeeId}} {}", "delay 1000",
-            "zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 8 {${device.zigbeeId}} {}", "delay 500",
-            "zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0x0300 {${device.zigbeeId}} {}", "delay 500"
-    ]
-    return configCmds + refresh() // send refresh cmds as part of config
-}
-
-def parseDescriptionAsMap(description) {
-    (description - "read attr - ").split(",").inject([:]) { map, param ->
-        def nameAndValue = param.split(":")
-        map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
-    }
-}
-
-def poll(){
-    log.debug "Poll is calling refresh"
-    refresh()
-}
-
-def zigbeeSetLevel(level) {
-    "st cmd 0x${device.deviceNetworkId} ${endpointId} 8 4 {${level} 0000}"
-}
-
-def setLevel(value) {
-	state.levelValue = (value==null) ? 100 : value
-    log.trace "setLevel($value)"
-    def cmds = []
-
-    if (value == 0) {
-        sendEvent(name: "switch", value: "off")
-        cmds << zigbeeOff()
-    }
-    else if (device.latestValue("switch") == "off") {
-        sendEvent(name: "switch", value: "on")
-    }
-
-    sendEvent(name: "level", value: state.levelValue)
-    def level = hex(state.levelValue * 255 / 100)
-    cmds << zigbeeSetLevel(level)
-
-    //log.debug cmds
-    cmds
-}
-
-//input Hue Integer values; returns color name for saturation 100%
-private getColorName(hueValue){
-    if(hueValue>360 || hueValue<0)
-        return
-
-    hueValue = Math.round(hueValue / 100 * 360)
-
-    log.debug "hue value is $hueValue"
-
-    def colorName = "Color Mode"
-    if(hueValue>=0 && hueValue <= 4){
-        colorName = "Red"
-    }
-    else if (hueValue>=5 && hueValue <=21 ){
-        colorName = "Brick Red"
-    }
-    else if (hueValue>=22 && hueValue <=30 ){
-        colorName = "Safety Orange"
-    }
-    else if (hueValue>=31 && hueValue <=40 ){
-        colorName = "Dark Orange"
-    }
-    else if (hueValue>=41 && hueValue <=49 ){
-        colorName = "Amber"
-    }
-    else if (hueValue>=50 && hueValue <=56 ){
-        colorName = "Gold"
-    }
-    else if (hueValue>=57 && hueValue <=65 ){
-        colorName = "Yellow"
-    }
-    else if (hueValue>=66 && hueValue <=83 ){
-        colorName = "Electric Lime"
-    }
-    else if (hueValue>=84 && hueValue <=93 ){
-        colorName = "Lawn Green"
-    }
-    else if (hueValue>=94 && hueValue <=112 ){
-        colorName = "Bright Green"
-    }
-    else if (hueValue>=113 && hueValue <=135 ){
-        colorName = "Lime"
-    }
-    else if (hueValue>=136 && hueValue <=166 ){
-        colorName = "Spring Green"
-    }
-    else if (hueValue>=167 && hueValue <=171 ){
-        colorName = "Turquoise"
-    }
-    else if (hueValue>=172 && hueValue <=187 ){
-        colorName = "Aqua"
-    }
-    else if (hueValue>=188 && hueValue <=203 ){
-        colorName = "Sky Blue"
-    }
-    else if (hueValue>=204 && hueValue <=217 ){
-        colorName = "Dodger Blue"
-    }
-    else if (hueValue>=218 && hueValue <=223 ){
-        colorName = "Navy Blue"
-    }
-    else if (hueValue>=224 && hueValue <=251 ){
-        colorName = "Blue"
-    }
-    else if (hueValue>=252 && hueValue <=256 ){
-        colorName = "Han Purple"
-    }
-    else if (hueValue>=257 && hueValue <=274 ){
-        colorName = "Electric Indigo"
-    }
-    else if (hueValue>=275 && hueValue <=289 ){
-        colorName = "Electric Purple"
-    }
-    else if (hueValue>=290 && hueValue <=300 ){
-        colorName = "Orchid Purple"
-    }
-    else if (hueValue>=301 && hueValue <=315 ){
-        colorName = "Magenta"
-    }
-    else if (hueValue>=316 && hueValue <=326 ){
-        colorName = "Hot Pink"
-    }
-    else if (hueValue>=327 && hueValue <=335 ){
-        colorName = "Deep Pink"
-    }
-    else if (hueValue>=336 && hueValue <=339 ){
-        colorName = "Raspberry"
-    }
-    else if (hueValue>=340 && hueValue <=352 ){
-        colorName = "Crimson"
-    }
-    else if (hueValue>=353 && hueValue <=360 ){
-        colorName = "Red"
-    }
-
-    colorName
-}
-
-private getEndpointId() {
-    new BigInteger(device.endpointId, 16).toString()
-}
-
-private hex(value, width=2) {
-    def s = new BigInteger(Math.round(value).toString()).toString(16)
-    while (s.size() < width) {
-        s = "0" + s
-    }
-    s
-}
-
-private evenHex(value){
-    def s = new BigInteger(Math.round(value).toString()).toString(16)
-    while (s.size() % 2 != 0) {
-        s = "0" + s
-    }
-    s
-}
-
-private String swapEndianHex(String hex) {
-    reverseArray(hex.decodeHex()).encodeHex()
-}
-
-private Integer convertHexToInt(hex) {
-    Integer.parseInt(hex,16)
-}
-
-//Need to reverse array of size 2
-private byte[] reverseArray(byte[] array) {
-    byte tmp;
-    tmp = array[1];
-    array[1] = array[0];
-    array[0] = tmp;
-    return array
-}
-
-def setAdjustedColor(value) {
-	log.debug "setAdjustedColor: ${value}"
-	def adjusted = value + [:]
-	adjusted.level = null // needed because color picker always sends 100
-	setColor(adjusted)
-}
-
-def setColor(value){
-    log.trace "setColor($value)"
-    def max = 0xfe
-
-    if (value.hex) { sendEvent(name: "color", value: value.hex, displayed:false)}
-
-    def colorName = getColorName(value.hue)
-    sendEvent(name: "colorName", value: colorName)
-
-    log.debug "color name is : $colorName"
-    sendEvent(name: "hue", value: value.hue, displayed:false)
-    sendEvent(name: "saturation", value: value.saturation, displayed:false)
-    def scaledHueValue = evenHex(Math.round(value.hue * max / 100.0))
-    def scaledSatValue = evenHex(Math.round(value.saturation * max / 100.0))
-
-    def cmd = []
-    if (value.switch != "off" && device.latestValue("switch") == "off") {
-        cmd << "st cmd 0x${device.deviceNetworkId} ${endpointId} 6 1 {}"
-        cmd << "delay 150"
-    }
-
-    cmd << "st cmd 0x${device.deviceNetworkId} ${endpointId} 0x300 0x00 {${scaledHueValue} 00 0000}"
-    cmd << "delay 150"
-    cmd << "st cmd 0x${device.deviceNetworkId} ${endpointId} 0x300 0x03 {${scaledSatValue} 0000}"
-    
-    if (value.level) {
-        state.levelValue = value.level
-        sendEvent(name: "level", value: value.level)
-        def level = hex(value.level * 255 / 100)
-        cmd << zigbeeSetLevel(level)
-    }
-    
-    if (value.switch == "off") {
-        cmd << "delay 150"
-        cmd << off()
-    }
-
-    cmd
-}