Merge pull request #797 from SmartThingsCommunity/staging

Rolling up changes to production from staging 2016-04-19 Release

.gitignore

@@ -0,0 +1,23 @@
+# Eclipse files
+/.settings
+/.classpath
+/.project
+/eclipse/
+/target-eclipse
+
+# IntelliJ files
+*.iws
+*.iml
+.idea
+/out
+*.ipr
+
+# Gradle files
+.gradletasknamecache
+.gradle/
+
+# Mac OS files
+.DS_Store
+
+# Build files
+/build

build.gradle

@@ -0,0 +1,105 @@
+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-slack'
+
+buildscript {
+    dependencies {
+        classpath "com.smartthings.deployment:executable-deployment-scripts:1.0.7"
+    }
+    repositories {
+        mavenLocal()
+        jcenter()
+        maven {
+            credentials {
+                username smartThingsArtifactoryUserName
+                password smartThingsArtifactoryPassword
+            }
+            url "http://artifactory.smartthings.com/libs-release-local"
+        }
+    }
+}
+
+repositories {
+    mavenLocal()
+    jcenter()
+}
+
+dependencies {
+}
+
+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()) {
+        // Create a list of archives which were deployed.
+        java.nio.file.Path rootPath = Paths.get(rootDir.absolutePath)
+        rootDir.eachFileRecurse { File file ->
+            if (file.name.endsWith('.tar.gz')) {
+                java.nio.file.Path archivePath = Paths.get(file.absolutePath)
+                archives.add(rootPath.relativize(archivePath).toString())
+            }
+        }
+    }
+    Date date = new Date()
+    String fileDate = date.format('yyyy-MM-dd_HH-mm-ss', TimeZone.getTimeZone('GMT'))
+
+    // 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

@@ -0,0 +1,25 @@
+machine:
+  java:
+    version:
+      oraclejdk8
+
+dependencies:
+  override:
+    - echo "Nothing to do."
+
+test:
+  override:
+    - echo "We don't have any tests :-("
+
+deployment:
+  develop:
+    branch: master
+    commands:
+      - ./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 slackSendMessage -PsmartThingsArtifactoryUserName="$ARTIFACTORY_USERNAME" -PsmartThingsArtifactoryPassword="$ARTIFACTORY_PASSWORD" -Pbranch="$CIRCLE_BRANCH" -PslackToken="$SLACK_TOKEN" -PslackWebhookUrl="$SLACK_WEBHOOK_URL" -PslackChannel="$SLACK_CHANNEL" --stacktrace

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

@@ -0,0 +1,107 @@
+/**
+*  BeaconThing
+*
+*  Copyright 2015 obycode
+*
+*  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+*  in compliance with the License. You may obtain a copy of the License at:
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+*  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+*  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+*  for the specific language governing permissions and limitations under the License.
+*
+*/
+
+import groovy.json.JsonSlurper
+
+metadata {
+	definition (name: "BeaconThing", namespace: "com.obycode", author: "obycode") {
+		capability "Beacon"
+		capability "Presence Sensor"
+		capability "Sensor"
+
+		attribute "inRange", "json_object"
+		attribute "inRangeFriendly", "string"
+
+		command "setPresence", ["string"]
+		command "arrived", ["string"]
+		command "left", ["string"]
+	}
+
+	simulator {
+		status "present": "presence: 1"
+		status "not present": "presence: 0"
+	}
+
+	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:"#ffffff")
+		}
+		valueTile("inRange", "device.inRangeFriendly", inactiveLabel: true, height:1, width:3, decoration: "flat") {
+			state "default", label:'${currentValue}', backgroundColor:"#ffffff"
+		}
+		main "presence"
+		details (["presence","inRange"])
+	}
+}
+
+// parse events into attributes
+def parse(String description) {
+	log.debug "Parsing '${description}'"
+}
+
+def installed() {
+	sendEvent(name: "presence", value: "not present")
+	def emptyList = []
+	def json = new groovy.json.JsonBuilder(emptyList)
+	sendEvent(name:"inRange", value:json.toString())
+}
+
+def setPresence(status) {
+	log.debug "Status is $status"
+	sendEvent(name:"presence", value:status)
+}
+
+def arrived(id) {
+	log.debug "$id has arrived"
+	def theList = device.latestValue("inRange")
+	def inRangeList = new JsonSlurper().parseText(theList)
+	if (inRangeList.contains(id)) {
+		return
+	}
+	inRangeList += id
+	def json = new groovy.json.JsonBuilder(inRangeList)
+	log.debug "Now in range: ${json.toString()}"
+	sendEvent(name:"inRange", value:json.toString())
+
+	// Generate human friendly string for tile
+	def friendlyList = "Nearby: " + inRangeList.join(", ")
+	sendEvent(name:"inRangeFriendly", value:friendlyList)
+
+	if (inRangeList.size() == 1) {
+		setPresence("present")
+	}
+}
+
+def left(id) {
+	log.debug "$id has left"
+	def theList = device.latestValue("inRange")
+	def inRangeList = new JsonSlurper().parseText(theList)
+	inRangeList -= id
+	def json = new groovy.json.JsonBuilder(inRangeList)
+	log.debug "Now in range: ${json.toString()}"
+	sendEvent(name:"inRange", value:json.toString())
+
+	// Generate human friendly string for tile
+	def friendlyList = "Nearby: " + inRangeList.join(", ")
+
+	if (inRangeList.empty) {
+		setPresence("not present")
+		friendlyList = "No one is nearby"
+	}
+
+	sendEvent(name:"inRangeFriendly", value:friendlyList)
+}

devicetypes/encored-technologies/enertalk-energy-meter.src/enertalk-energy-meter.groovy

@@ -0,0 +1,104 @@
+/**
+ *  EnerTalk Energy Meter
+ *
+ *  Copyright 2015 hyeon seok yang
+ *
+ *  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: "EnerTalk Energy Meter", namespace: "Encored Technologies", author: "hyeon seok yang") {
+	}
+
+	simulator {
+		// TODO: define status and reply messages here
+	}
+
+	tiles(scale:2) {
+    	valueTile("view", "device.view", decoration: "flat") {
+       		state "view", label:' ${currentValue} kWh'
+		}
+		valueTile("month", "device.month", width: 6, height : 3, decoration: "flat") {
+       		state "month", label:' ${currentValue}'
+		}
+        valueTile("real", "device.real", width: 2, height : 2, decoration: "flat") {
+       		state "real", label:' ${currentValue}'
+		}
+        valueTile("tier", "device.tier", width: 2, height : 2, decoration: "flat") {
+       		state "tier", label:' ${currentValue}'
+		}
+        valueTile("plan", "device.plan", width: 2, height : 2, decoration: "flat") {
+       		state "plan", label:' ${currentValue}'
+		}
+        
+        htmlTile(name:"deepLink", action:"linkApp", whitelist:["code.jquery.com", 
+    	"ajax.googleapis.com", 
+        "fonts.googleapis.com",
+    	"code.highcharts.com", 
+    	"enertalk-card.encoredtech.com", 
+    	"s3-ap-northeast-1.amazonaws.com",
+        "s3.amazonaws.com", 
+    	"ui-hub.encoredtech.com",
+        "enertalk-auth.encoredtech.com",
+        "api.encoredtech.com",
+        "cdnjs.cloudflare.com",
+        "encoredtech.com",
+        "itunes.apple.com"], width:2, height:2){}
+        
+        main (["view"])
+        details (["month", "real", "tier", "plan", "deepLink"])
+	}
+}
+
+mappings {
+	
+      path("/linkApp") {action: [ GET: "getLinkedApp" ]}
+}
+
+def getLinkedApp() {
+	def lang = clientLocale?.language
+    if ("${lang}" == "ko") {
+    	lang = "<p style=\'margin-left:15vw; color: #aeaeb0;\'>기기 설정</p>"
+    } else {
+    	lang = "<p style=\'margin-left:5vw; color: #aeaeb0;\'>Setup Device</p>"
+    }
+	renderHTML() {
+        head {
+           """
+			<meta name="viewport" content="initial-scale=1, maximum-scale=1, user-scalable=no, width=device-width, height=device-height">
+           	<style>
+            	#레이어_1 { margin-left : 17vw; width : 50vw; height : 50vw;}
+                .st0{fill:#B5B6BB;}
+            </style>
+        """ 
+        }
+        body {
+        """
+            <div id="container">
+            	<a id="st-deep-link" href="#">
+                	<svg version="1.1" id="레이어_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 40 40" style="enable-background:new 0 0 40 40;" xml:space="preserve"><path class="st0" d="M20,0C9,0,0,9,0,20C0,30.5,8,39,18.2,40l3.8-4.8l-3.9-4.8c-4.9-0.9-8.6-5.2-8.6-10.4c0-5.8,4.7-10.5,10.5-10.5
+					S30.5,14.2,30.5,20c0,5.1-3.7,9.4-8.5,10.3l3.7,4.5L21.8,40C32,39.1,40,30.5,40,20C40,9,31,0,20,0z"/></svg>
+                </a>
+                ${lang} 
+            </div>
+            <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>
+            <script>
+           		var ua = navigator.userAgent.toLowerCase();
+                var isAndroid = ua.indexOf("android") > -1;
+                if(!isAndroid) { 
+                	\$("#st-deep-link").attr("href", "https://itunes.apple.com/kr/app/enertalk-for-home/id1024660780?mt=8");
+                } else {
+                	\$("#st-deep-link").attr("href", "market://details?id=com.ionicframework.enertalkhome874425");
+                }
+            </script>
+        """
+        }
+	}
+}

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:"#ffa81e")
+                attributeState("closed", icon:"st.contact.contact.closed", backgroundColor:"#79b821")
+            }
+            
+            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:"#ffa81e")
+                attributeState("closed", icon:"st.contact.contact.closed", backgroundColor:"#79b821")
+            }
+            
+            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,269 @@
+/**
+ *  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"
+        
+        fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x22, 0x85, 0x59, 0x20, 0x80, 0x70, 0x56, 0x5A, 0x7A, 0x72, 0x8E, 0x71, 0x73, 0x98, 0x9C, 0x31, 0x86", outClusters: ""
+	}
+
+	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:"#79b821")
+            	attributeState("wet", icon:"st.alarm.water.wet", backgroundColor:"#ffa81e")
+            }
+            
+            tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
+				attributeState("active", label:'tamper active', backgroundColor:"#53a7c0")
+				attributeState("inactive", label:'tamper inactive', backgroundColor:"#ffffff")
+			}       
+        }
+        
+        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.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.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.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'"
+	
+    def cmds = []
+    
+	cmds += zwave.wakeUpV2.wakeUpIntervalSet(seconds:21600, nodeid: zwaveHubNodeId)//FGFS' 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, 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-motion-sensor-zw5.src/fibaro-motion-sensor-zw5.groovy

@@ -0,0 +1,281 @@
+/**
+ *  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"
+        
+        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", icon:"st.motion.motion.inactive", backgroundColor:"#79b821")
+            	attributeState("active", icon:"st.motion.motion.active", backgroundColor:"#ffa81e")   
+            }
+            
+            tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
+				attributeState("active", label:'tamper active', backgroundColor:"#53a7c0")
+				attributeState("inactive", label:'tamper inactive', backgroundColor:"#ffffff")
+			}  
+        }
+        
+        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:
+        	map.name = "temperature"
+            map.unit = cmd.scale == 1 ? "F" : "C"
+            map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, map.unit, 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'"
+    
+    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: "#0000ff", nextState:"Sent"
+            attributeState "opening", label: '${name}', action:"closeDoor", icon: "st.doors.garage.garage-opening", backgroundColor: "#ffa81e" 
+            attributeState "closed", label: '${name}', action:"openDoor", icon: "st.doors.garage.garage-closed", backgroundColor: "#79b821", nextState:"Sent"
+            attributeState "closing", label: '${name}', action:"openDoor", icon: "st.doors.garage.garage-closing", backgroundColor: "#ffa81e" 
+            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/keen-home/keen-home-smart-vent.src/keen-home-smart-vent.groovy

@@ -1,12 +1,9 @@
-/**
- *  Keen Home Smart Vent
- *
- *  Author: Keen Home
- *  Date: 2015-06-23
- */
+// keen home smart vent
+// http://www.keenhome.io
+// SmartThings Device Handler v1.0.0
 
 metadata {
-    definition (name: "Keen Home Smart Vent", namespace: "Keen Home", author: "Gregg Altschul") {
+    definition (name: "Keen Home Smart Vent", namespace: "Keen Home", author: "Keen Home") {
         capability "Switch Level"
         capability "Switch"
         capability "Configuration"
@@ -21,6 +18,7 @@ metadata {
         command "getBattery"
         command "getTemperature"
         command "setZigBeeIdTile"
+        command "clearObstruction"
 
         fingerprint endpoint: "1",
         profileId: "0104",
@@ -42,9 +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 "off", action:"switch.on", icon:"st.vents.vent-closed", backgroundColor:"#ffffff"
-            state "obstructed", action: "switch.off", icon:"st.vents.vent-closed", backgroundColor:"#ff0000"
+            state "on", action: "switch.off", icon: "st.vents.vent-open-text", backgroundColor: "#53a7c0"
+            state "off", action: "switch.on", icon: "st.vents.vent-closed", backgroundColor: "#ffffff"
+            state "obstructed", action: "clearObstruction", icon: "st.vents.vent-closed", backgroundColor: "#ff0000"
+            state "clearing", action: "", icon: "st.vents.vent-closed", backgroundColor: "#ffff33"
         }
         controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false) {
             state "level", action:"switch level.setLevel"
@@ -206,12 +205,12 @@ private Map makeOnOffResult(rawValue) {
 
 private Map makeLevelResult(rawValue) {
     def linkText = getLinkText(device)
-    // log.debug "rawValue: ${rawValue}"
     def value = Integer.parseInt(rawValue, 16)
     def rangeMax = 254
 
+    // catch obstruction level
     if (value == 255) {
-        log.debug "obstructed"
+        log.debug "${linkText} is obstructed"
         // Just return here. Once the vent is power cycled
         // it will go back to the previous level before obstruction.
         // Therefore, no need to update level on the display.
@@ -220,24 +219,9 @@ private Map makeLevelResult(rawValue) {
             value: "obstructed",
             descriptionText: "${linkText} is obstructed. Please power cycle."
         ]
-    } else if ( device.currentValue("switch") == "obstructed" &&
-                value == 254)  {
-        // When the device is reset after an obstruction, the switch
-        // state will be obstructed and the value coming from the device
-        // will be 254. Since we're not using heating/cooling mode from
-        // the device type handler, we need to bump it down to the lower
-        // (cooling) range
-        sendEvent(makeOnOffResult(1)) // clear the obstructed switch state
-        value = rangeMax
     }
-    // else if (device.currentValue("switch") == "off") {
-    //     sendEvent(makeOnOffResult(1)) // turn back on if in off state
-    // }
 
-
-    // log.debug "pre-value: ${value}"
     value = Math.floor(value / rangeMax * 100)
-    // log.debug "post-value: ${value}"
 
     return [
         name: "level",
@@ -327,35 +311,79 @@ private def makeSerialResult(serial) {
         value: serial,
         descriptionText: "${linkText} has serial ${serial}" ]
 }
-/**** COMMAND METHODS ****/
-// def mfgCode() {
-// 	 ["zcl mfg-code 0x115B", "delay 200"]
-// }
 
+// takes a level from 0 to 100 and translates it to a ZigBee move to level with on/off command
+private def makeLevelCommand(level) {
+    def rangeMax = 254
+    def scaledLevel = Math.round(level * rangeMax / 100)
+    log.debug "scaled level for ${level}%: ${scaledLevel}"
+
+    // convert to hex string and pad to two digits
+    def hexLevel = new BigInteger(scaledLevel.toString()).toString(16).padLeft(2, '0')
+
+    "st cmd 0x${device.deviceNetworkId} 1 8 4 {${hexLevel} 0000}"
+}
+
+/**** COMMAND METHODS ****/
 def on() {
-    log.debug "on()"
+    def linkText = getLinkText(device)
+    log.debug "open ${linkText}"
+
+    // only change the state if the vent is not obstructed
+    if (device.currentValue("switch") == "obstructed") {
+        log.error("cannot open because ${linkText} is obstructed")
+        return
+    }
+
     sendEvent(makeOnOffResult(1))
     "st cmd 0x${device.deviceNetworkId} 1 6 1 {}"
 }
 
 def off() {
-    log.debug "off()"
+    def linkText = getLinkText(device)
+    log.debug "close ${linkText}"
+
+    // only change the state if the vent is not obstructed
+    if (device.currentValue("switch") == "obstructed") {
+        log.error("cannot close because ${linkText} is obstructed")
+        return
+    }
+
     sendEvent(makeOnOffResult(0))
     "st cmd 0x${device.deviceNetworkId} 1 6 0 {}"
 }
 
-// does this work?
-def toggle() {
-    log.debug "toggle()"
+def clearObstruction() {
+    def linkText = getLinkText(device)
+    log.debug "attempting to clear ${linkText} obstruction"
 
-    "st cmd 0x${device.deviceNetworkId} 1 6 2 {}"
+    sendEvent([
+        name: "switch",
+        value: "clearing",
+        descriptionText: "${linkText} is clearing obstruction"
+    ])
+
+    // send a move command to ensure level attribute gets reset for old, buggy firmware
+    // then send a reset to factory defaults
+    // finally re-configure to ensure reports and binding is still properly set after the rtfd
+    [
+        makeLevelCommand(device.currentValue("level")), "delay 500",
+        "st cmd 0x${device.deviceNetworkId} 1 0 0 {}", "delay 5000"
+    ] + configure()
 }
 
 def setLevel(value) {
     log.debug "setting level: ${value}"
-
     def linkText = getLinkText(device)
 
+    // only change the level if the vent is not obstructed
+    def currentState = device.currentValue("switch")
+
+    if (currentState == "obstructed") {
+        log.error("cannot set level because ${linkText} is obstructed")
+        return
+    }
+
     sendEvent(name: "level", value: value)
     if (value > 0) {
         sendEvent(name: "switch", value: "on", descriptionText: "${linkText} is on by setting a level")
@@ -363,29 +391,26 @@ def setLevel(value) {
     else {
         sendEvent(name: "switch", value: "off", descriptionText: "${linkText} is off by setting level to 0")
     }
-    def rangeMax = 254
-    def computedLevel = Math.round(value * rangeMax / 100)
-    log.debug "computedLevel: ${computedLevel}"
 
-    def level = new BigInteger(computedLevel.toString()).toString(16)
-    log.debug "level: ${level}"
-
-    if (level.size() < 2){
-        level = '0' + level
-    }
-
-    "st cmd 0x${device.deviceNetworkId} 1 8 4 {${level} 0000}"
+    makeLevelCommand(value)
 }
 
-
 def getOnOff() {
     log.debug "getOnOff()"
 
+    // disallow on/off updates while vent is obstructed
+    if (device.currentValue("switch") == "obstructed") {
+        log.error("cannot update open/close status because ${getLinkText(device)} is obstructed")
+        return []
+    }
+
     ["st rattr 0x${device.deviceNetworkId} 1 0x0006 0"]
 }
 
 def getPressure() {
     log.debug "getPressure()"
+
+    // using a Keen Home specific attribute in the pressure measurement cluster
     [
         "zcl mfg-code 0x115B", "delay 200",
         "zcl global read 0x0403 0x20", "delay 200",
@@ -395,12 +420,13 @@ def getPressure() {
 
 def getLevel() {
     log.debug "getLevel()"
-    // rattr = read attribute
-    // 0x${} = device net id
-    // 1 = endpoint
-    // 8 = cluster id (level control, in this case)
-    // 0 = attribute within cluster
-    // sendEvent(name: "level", value: value)
+
+    // disallow level updates while vent is obstructed
+    if (device.currentValue("switch") == "obstructed") {
+        log.error("cannot update level status because ${getLinkText(device)} is obstructed")
+        return []
+    }
+
     ["st rattr 0x${device.deviceNetworkId} 1 0x0008 0x0000"]
 }
 
@@ -425,78 +451,59 @@ def setZigBeeIdTile() {
         name: "zigbeeId",
         value: device.zigbeeId,
         descriptionText: "${linkText} has zigbeeId ${device.zigbeeId}" ])
-	return [
+    return [
         name: "zigbeeId",
         value: device.zigbeeId,
         descriptionText: "${linkText} has zigbeeId ${device.zigbeeId}" ]
 }
 
 def refresh() {
-	getOnOff() +
+    getOnOff() +
     getLevel() +
     getTemperature() +
     getPressure() +
     getBattery()
 }
 
-private byte[] reverseArray(byte[] array) {
-    int i = 0;
-    int j = array.length - 1;
-    byte tmp;
-    while (j > i) {
-        tmp = array[j];
-        array[j] = array[i];
-        array[i] = tmp;
-        j--;
-        i++;
-    }
-    return array
-}
-
-private String swapEndianHex(String hex) {
-    reverseArray(hex.decodeHex()).encodeHex()
-}
-
 def configure() {
     log.debug "CONFIGURE"
-    log.debug "zigbeeId: ${device.hub.zigbeeId}"
 
+    // get ZigBee ID by hidden tile because that's the only way we can do it
     setZigBeeIdTile()
 
     def configCmds = [
-        // binding commands
+        // bind reporting clusters to hub
         "zdo bind 0x${device.deviceNetworkId} 1 1 0x0006 {${device.zigbeeId}} {}", "delay 500",
         "zdo bind 0x${device.deviceNetworkId} 1 1 0x0008 {${device.zigbeeId}} {}", "delay 500",
         "zdo bind 0x${device.deviceNetworkId} 1 1 0x0402 {${device.zigbeeId}} {}", "delay 500",
         "zdo bind 0x${device.deviceNetworkId} 1 1 0x0403 {${device.zigbeeId}} {}", "delay 500",
-        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0001 {${device.zigbeeId}} {}", "delay 500",
-        
-        // configure report commands
-        // [cluster] [attr] [type] [min-interval] [max-interval] [min-change]
+        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0001 {${device.zigbeeId}} {}", "delay 500"
 
-        // mike 2015/06/22: preconfigured; see tech spec
+        // configure report commands
+        // zcl global send-me-a-report [cluster] [attr] [type] [min-interval] [max-interval] [min-change]
+
+        // report with these parameters is preconfigured in firmware, can be overridden here
         // vent on/off state - type: boolean, change: 1
         // "zcl global send-me-a-report 6 0 0x10 5 60 {01}", "delay 200",
         // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
 
-        // mike 2015/06/22: preconfigured; see tech spec
+        // report with these parameters is preconfigured in firmware, can be overridden here
         // vent level - type: int8u, change: 1
         // "zcl global send-me-a-report 8 0 0x20 5 60 {01}", "delay 200",
         // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
 
-        // mike 2015/06/22: temp and pressure reports are preconfigured, but
-        //   we'd like to override their settings for our own purposes
+        // report with these parameters is preconfigured in firmware, can be overridden here
         // temperature - type: int16s, change: 0xA = 10 = 0.1C
-        "zcl global send-me-a-report 0x0402 0 0x29 10 60 {0A00}", "delay 200",
-        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        // "zcl global send-me-a-report 0x0402 0 0x29 60 60 {0A00}", "delay 200",
+        // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
 
-        // mike 2015/06/22: use new custom pressure attribute
-        // pressure - type: int32u, change: 1 = 0.1Pa
-        "zcl mfg-code 0x115B", "delay 200",
-        "zcl global send-me-a-report 0x0403 0x20 0x22 10 60 {010000}", "delay 200",
-        "send 0x${device.deviceNetworkId} 1 1", "delay 1500"
+        // report with these parameters is preconfigured in firmware, can be overridden here
+        // keen home custom pressure (tenths of Pascals) - type: int32u, change: 1 = 0.1Pa
+        // "zcl mfg-code 0x115B", "delay 200",
+        // "zcl global send-me-a-report 0x0403 0x20 0x22 60 60 {010000}", "delay 200",
+        // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
 
-        // mike 2015/06/22: preconfigured; see tech spec
+        // report with these parameters is preconfigured in firmware, can be overridden here
         // battery - type: int8u, change: 1
         // "zcl global send-me-a-report 1 0x21 0x20 60 3600 {01}", "delay 200",
         // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",

devicetypes/osotech/plantlink.src/plantlink.groovy

@@ -0,0 +1,164 @@
+/**
+ *  PlantLink
+ *
+ *  This device type takes sensor data and converts it into a json packet to send to myplantlink.com
+ *  where its values will be computed for soil and plant type to show user readable values of how your
+ *  specific plant is doing.
+ *
+ *
+ *  Copyright 2015 Oso Technologies
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ */
+ 
+import groovy.json.JsonBuilder
+
+metadata {
+    definition (name: "PlantLink", namespace: "OsoTech", author: "Oso Technologies") {
+        capability "Sensor"
+
+        command "setStatusIcon"
+        command "setPlantFuelLevel"
+        command "setBatteryLevel"
+        command "setInstallSmartApp"
+
+        attribute "plantStatus","string"
+        attribute "plantFuelLevel","number"
+        attribute "linkBatteryLevel","string"
+        attribute "installSmartApp","string"
+
+        fingerprint profileId: "0104", inClusters: "0000,0001,0B04"
+    }
+
+    simulator {
+        status "battery": "read attr - raw: C0720100010A000021340A, dni: C072, endpoint: 01, cluster: 0001, size: 0A, attrId: 0000, encoding: 21, value: 0a34"
+        status "moisture": "read attr - raw: C072010B040A0001290000, dni: C072, endpoint: 01, cluster: 0B04, size: 0A, attrId: 0100, encoding: 29, value: 0000"
+    }
+
+    tiles {
+        standardTile("Title", "device.label") {
+            state("label", label:'PlantLink ${device.label}')
+        }
+
+        valueTile("plantMoistureTile", "device.plantFuelLevel", width: 1, height: 1) {
+            state("plantMoisture", label: '${currentValue}% Moisture')
+        }
+
+        valueTile("plantStatusTextTile", "device.plantStatus", decoration: "flat", width: 2, height: 2) {
+            state("plantStatusTextTile", label:'${currentValue}')
+        }
+
+        valueTile("battery", "device.linkBatteryLevel" ) {
+            state("battery", label:'${currentValue}% battery')
+        }
+        
+        valueTile("installSmartApp","device.installSmartApp", decoration: "flat", width: 3, height: 1) {
+        	state "needSmartApp", label:'Please install SmartApp "Required PlantLink Connector"', defaultState:true
+            state "connectedToSmartApp", label:'Connected to myplantlink.com'
+        }
+
+        main "plantStatusTextTile"
+        details(['plantStatusTextTile', "plantMoistureTile", "battery", "installSmartApp"])
+    }
+}
+
+def setStatusIcon(value){
+    def status = ''
+    switch (value) {
+    	case '0':
+	        status = 'Needs Water'
+            break
+    	case '1':
+        	status = 'Dry'
+            break
+    	case '2':
+   		case '3':
+        	status = 'Good'
+            break
+        case '4':
+        	status = 'Too Wet'
+            break
+    	case 'No Soil':
+        	status = 'Too Dry'
+        	setPlantFuelLevel(0)
+            break
+    	case 'Recently Watered':
+        	status = 'Watered'
+            setPlantFuelLevel(100)
+    		break
+    	case 'Low Battery':
+        	status = 'Low Battery'
+    		break
+    	case 'Waiting on First Measurement':
+	        status = 'Calibrating'
+            break
+    	default:
+        	status = "?"
+            break
+    }
+    sendEvent("name":"plantStatus", "value":status, "description":statusText, displayed: true, isStateChange: true)
+}
+
+def setPlantFuelLevel(value){
+    sendEvent("name":"plantFuelLevel", "value":value, "description":statusText, displayed: true, isStateChange: true)	
+}
+
+def setBatteryLevel(value){
+    sendEvent("name":"linkBatteryLevel", "value":value, "description":statusText, displayed: true, isStateChange: true)
+}
+
+def setInstallSmartApp(value){
+	sendEvent("name":"installSmartApp", "value":value)
+}
+
+def parse(String description) {
+	log.debug description
+	def description_map = parseDescriptionAsMap(description)
+    def event_name = ""
+    def measurement_map = [
+            type: "link",
+            signal: "0x00",
+            zigbeedeviceid: device.zigbeeId,
+            created: new Date().time /1000 as int
+    ]
+    if (description_map.cluster == "0001"){
+        /* battery voltage in mV (device needs minimium 2.1v to run) */
+        log.debug "PlantLink - id ${device.zigbeeId} battery ${description_map.value}"
+        event_name = "battery_status"
+        measurement_map["battery"] = "0x${description_map.value}"
+        
+    } else if (description_map.cluster == "0B04"){
+        /* raw moisture reading (needs to be sent to plantlink for soil/plant type conversion) */
+        log.debug "PlantLink - id ${device.zigbeeId}  raw moisture ${description_map.value}"
+        measurement_map["moisture"] = "0x${description_map.value}"
+        event_name = "moisture_status"
+        
+    } else{
+        log.debug "PlantLink - id ${device.zigbeeId} Unknown '${description}'"
+        return
+    }
+    
+    def json_builder = new JsonBuilder(measurement_map)
+    def result = createEvent(name: event_name, value: json_builder.toString())
+    return result
+}
+
+
+def parseDescriptionAsMap(description) {
+    (description - "read attr - ").split(",").inject([:]) { map, param ->
+        def nameAndValue = param.split(":")
+        if(nameAndValue.length == 2){
+	        map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
+        }else{
+        	map += []
+        }
+    }
+}

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

@@ -0,0 +1,627 @@
+/**
+ *  Spruce Controller - Pre Release V2 10/11/2015
+ *
+ *  Copyright 2015 Plaid Systems
+ *
+ *	Author: NC
+ *	Date: 2015-11
+ *
+ *  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.
+ *
+ -----------V3 updates-11-2015------------
+ -Start program button updated to signal schedule check in Scheduler
+ 11/17 alarm "0" -> 0	(ln 305)
+ */
+
+metadata {
+	definition (name: "Spruce Controller", namespace: "plaidsystems", author: "NCauffman") {
+		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"        
+        
+        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 "refresh"        
+        command "rain"
+        command "manual"
+        command "setDisplay"
+        
+        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"
+		
+	}
+
+	// simulator metadata
+	simulator {
+		// status 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
+	}
+
+	// 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"
+        }
+		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"
+		}        
+        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("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("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("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("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("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("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("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("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("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
+			state "default", action: "refresh", icon:"st.secondary.refresh"            
+		}
+        standardTile("configure", "device.configure", inactiveLabel: false, decoration: "flat") {
+			state "configure", label:'', action:"configuration.configure", icon:"st.secondary.configure"
+		}		
+		
+        main (["status"])        
+        details(["status","rainsensor","switch","switch1","switch2","switch3","switch4","switch5","switch6","switch7","switch8","switch9","switch10","switch11","switch12","switch13","switch14","switch15","switch16","refresh","configure"])		
+    }    
+}
+
+def programOn(){
+    sendEvent(name: "switch", value: "programOn", descriptionText: "Program turned on")    
+    }
+    
+def programOff(){    
+    sendEvent(name: "switch", value: "off", descriptionText: "Program turned off")
+    off()
+    }
+    
+def updated(){
+	log.debug "updated"    
+}
+
+// Parse incoming device messages to generate events
+def parse(String description) {	
+	//log.debug "Parse description $description"
+    def result = null
+    def map = [:]
+	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"
+            map = getZone(descMap)            
+		}
+        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"
+	return result
+}
+
+def parseDescriptionAsMap(description) {
+	(description - "read attr - ").split(",").inject([:]) { map, param ->
+		def nameAndValue = param.split(":")
+		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
+	}
+}
+
+def getZone(descMap){
+	def map = [:]
+    
+    def EP = Integer.parseInt(descMap.endpoint.trim(), 16)
+    
+    String onoff
+    if(descMap.value == "00"){
+    	onoff = "off"        
+    }    
+    else onoff = "on"
+            
+    if (EP == 1){
+    	map.name = "switch"
+        map.value = 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"
+        }
+   	else {
+        EP -= 1
+        map.name = "switch" + EP
+    	map.value = "z" + EP + onoff
+    	map.descriptionText = "${device.displayName} turned Zone $EP $onoff"
+    	}
+        
+    map.isStateChange = true 
+    map.displayed = true    
+    return map
+}
+
+def getAlarm(descMap){
+	def map = [:]
+    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.displayed = true
+    return map        
+}
+
+//status notify and change status
+def notify(value, text){	
+	sendEvent(name:"status", value:"$value", descriptionText:"$text", isStateChange: true, display: false)
+
+}
+
+//prefrences - rain sensor, manual time
+def rain() {
+    log.debug "Rain $RainEnable"
+    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}}"
+    
+    }
+
+//write switch time settings map
+def settingsMap(WriteTimes, attrType){
+	log.debug WriteTimes    
+	
+    def i = 1
+    def runTime
+    def sendCmds = []
+    while(i <= 17){
+    	  
+    	if (WriteTimes."${i}"){        	
+        	runTime = hex(Integer.parseInt(WriteTimes."${i}"))
+        	log.debug "${i} : $runTime"
+		
+        	if (attrType == 4001) sendCmds.push("st wattr 0x${device.deviceNetworkId} ${i} 0x06 0x4001 0x21 {00${runTime}}")
+        	else sendCmds.push("st wattr 0x${device.deviceNetworkId} ${i} 0x06 0x4002 0x21 {00${runTime}}")
+            sendCmds.push("delay 500")
+        }
+        i++
+    }    
+    return sendCmds
+}
+
+//send switch time
+def writeType(wEP, cycle){
+	log.debug "wt ${wEP} ${cycle}"
+    "st wattr 0x${device.deviceNetworkId} ${wEP} 0x06 0x4001 0x21 {00" + hex(cycle) + "}"
+    }
+//send switch off time
+def writeTime(wEP, runTime){    
+    "st wattr 0x${device.deviceNetworkId} ${wEP} 0x06 0x4002 0x21 {00" + hex(runTime) + "}"
+    }
+
+//set reporting and binding
+def configure() {
+
+	String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+	log.debug "Confuguring Reporting and Bindings ${device.deviceNetworkId} ${device.zigbeeId}"
+	sendEvent(name: 'configuration',value: 100, descriptionText: "Configuration initialized")
+    
+    def configCmds = [	
+        //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",
+        //zones 1-8
+        "zdo bind 0x${device.deviceNetworkId} 2 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        "zdo bind 0x${device.deviceNetworkId} 3 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+		"zdo bind 0x${device.deviceNetworkId} 4 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        "zdo bind 0x${device.deviceNetworkId} 5 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        "zdo bind 0x${device.deviceNetworkId} 6 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        "zdo bind 0x${device.deviceNetworkId} 7 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        "zdo bind 0x${device.deviceNetworkId} 8 1 0x0F {${device.zigbeeId}} {}", "delay 1000",        
+        "zdo bind 0x${device.deviceNetworkId} 9 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        //zones 9-16
+        "zdo bind 0x${device.deviceNetworkId} 10 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        "zdo bind 0x${device.deviceNetworkId} 11 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+		"zdo bind 0x${device.deviceNetworkId} 12 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        "zdo bind 0x${device.deviceNetworkId} 13 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        "zdo bind 0x${device.deviceNetworkId} 14 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        "zdo bind 0x${device.deviceNetworkId} 15 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        "zdo bind 0x${device.deviceNetworkId} 16 1 0x0F {${device.zigbeeId}} {}", "delay 1000",        
+        "zdo bind 0x${device.deviceNetworkId} 17 1 0x0F {${device.zigbeeId}} {}", "delay 1000",
+        //rain sensor
+        "zdo bind 0x${device.deviceNetworkId} 18 1 0x0F {${device.zigbeeId}} {}",
+        
+        "zcl global send-me-a-report 6 0 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 500",
+       
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 2", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 3", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 4", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 5", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 6", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 7", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 8", "delay 500",      
+        
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 9", "delay 500",
+       
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 10", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 11", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 12", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 13", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 14", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 15", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 16", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 17", "delay 500",
+        
+        "zcl global send-me-a-report 0x0F 0x55 0x10 1 0 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 18", "delay 500",
+        
+        "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()
+}
+
+
+
+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 = [
+	        
+        "st rattr 0x${device.deviceNetworkId} 1 0x0F 0x55", "delay 500",
+        
+        "st rattr 0x${device.deviceNetworkId} 2 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 3 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 4 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 5 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 6 0x0F 0x55", "delay 500",        
+        "st rattr 0x${device.deviceNetworkId} 7 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 8 0x0F 0x55", "delay 500",        
+        "st rattr 0x${device.deviceNetworkId} 9 0x0F 0x55", "delay 500",
+        
+        "st rattr 0x${device.deviceNetworkId} 10 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 11 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 12 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 13 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 14 0x0F 0x55", "delay 500",        
+        "st rattr 0x${device.deviceNetworkId} 15 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 16 0x0F 0x55", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 17 0x0F 0x55", "delay 500",
+        
+        "st rattr 0x${device.deviceNetworkId} 18 0x0F 0x51","delay 500",
+ 	
+    ]
+    return refreshCmds + rain() + manual()
+}
+
+// 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 off() {
+    log.debug "off"
+    "st cmd 0x${device.deviceNetworkId} 1 6 0 {}"    
+}
+def z1on() {	
+    "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 {}"    
+}
+def z2off() {    
+    "st cmd 0x${device.deviceNetworkId} 3 6 0 {}"    
+}
+def z3on() {        
+    "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 {}"    
+}
+def z4off() {    
+    "st cmd 0x${device.deviceNetworkId} 5 6 0 {}"    
+}
+def z5on() {	
+	"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 {}"
+}
+def z6off() {
+    "st cmd 0x${device.deviceNetworkId} 7 6 0 {}"
+}
+def z7on() {
+	"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 {}"    
+}
+def z8off() {
+	"st cmd 0x${device.deviceNetworkId} 9 6 0 {}"    
+}
+
+//zones 9 - 16
+def z9on() {	
+    "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 {}"    
+}
+def z10off() {    
+    "st cmd 0x${device.deviceNetworkId} 11 6 0 {}"    
+}
+def z11on() {        
+    "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 {}"    
+}
+def z12off() {    
+    "st cmd 0x${device.deviceNetworkId} 13 6 0 {}"    
+}
+def z13on() {	
+	"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 {}"
+}
+def z14off() {
+    "st cmd 0x${device.deviceNetworkId} 15 6 0 {}"
+}
+def z15on() {
+	"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 {}"    
+}
+def z16off() {
+	"st cmd 0x${device.deviceNetworkId} 17 6 0 {}"    
+}

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

@@ -0,0 +1,397 @@
+/**
+ *  Spruce Sensor -Pre-release V2 10/8/2015
+ *
+ *  Copyright 2014 Plaid Systems
+ *
+ *  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.
+ *
+ -------10/20/2015 Updates--------
+ -Fix/add battery reporting interval to update
+ -remove polling and/or refresh(?)
+ */
+metadata {
+	definition (name: "Spruce Sensor", namespace: "plaidsystems", author: "NCauffman") {
+		
+		capability "Configuration"
+		capability "Battery"
+        capability "Relative Humidity Measurement"
+        capability "Temperature Measurement"
+        capability "Sensor"
+        //capability "Polling"
+		
+        attribute "maxHum", "string"
+        attribute "minHum", "string"        
+        
+        command "resetHumidity"
+        command "refresh"
+        
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0402,0405", outClusters: "0003, 0019", manufacturer: "PLAID SYSTEMS", model: "PS-SPRZMS-01"
+	}
+
+	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", title: ""
+		input "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+        input "interval", "number", title: "Measurement Interval 1-120 minutes (default: 10 minutes)", description: "Set how often you would like to check soil moisture in minutes", range: "1..120", defaultValue: 10, displayDuringSetup: false
+        input "resetMinMax", "bool", title: "Reset Humidity min and max", required: false, displayDuringSetup: false
+      }
+
+	tiles {
+		valueTile("temperature", "device.temperature", canChangeIcon: false, canChangeBackground: false) {
+			state "temperature", label:'${currentValue}°',
+				backgroundColors:[
+					[value: 31, color: "#153591"],
+					[value: 44, color: "#1e9cbb"],
+					[value: 59, color: "#90d2a7"],
+					[value: 74, color: "#44b621"],
+					[value: 84, color: "#f1d801"],
+					[value: 95, color: "#d04e00"],
+					[value: 96, color: "#bc2323"]
+				]
+		}
+		valueTile("humidity", "device.humidity", width: 2, height: 2, canChangeIcon: false, canChangeBackground: true) {
+			state "humidity", label:'${currentValue}%', unit:"",
+            	backgroundColors:[
+					[value: 0, color: "#635C0C"],
+					[value: 16, color: "#EBEB21"],
+					[value: 22, color: "#C7DE6A"],
+					[value: 42, color: "#9AD290"],
+					[value: 64, color: "#44B621"],
+					[value: 80, color: "#3D79D9"],
+					[value: 96, color: "#0A50C2"]
+				]
+		}
+        
+        valueTile("maxHum", "device.maxHum", canChangeIcon: false, canChangeBackground: false) {
+			state "maxHum", label:'High ${currentValue}%', unit:"",
+            	backgroundColors:[
+					[value: 0, color: "#635C0C"],
+					[value: 16, color: "#EBEB21"],
+					[value: 22, color: "#C7DE6A"],
+					[value: 42, color: "#9AD290"],
+					[value: 64, color: "#44B621"],
+					[value: 80, color: "#3D79D9"],
+					[value: 96, color: "#0A50C2"]
+				]
+		}
+		valueTile("minHum", "device.minHum", canChangeIcon: false, canChangeBackground: false) {
+			state "minHum", label:'Low ${currentValue}%', unit:"",
+            	backgroundColors:[
+					[value: 0, color: "#635C0C"],
+					[value: 16, color: "#EBEB21"],
+					[value: 22, color: "#C7DE6A"],
+					[value: 42, color: "#9AD290"],
+					[value: 64, color: "#44B621"],
+					[value: 80, color: "#3D79D9"],
+					[value: 96, color: "#0A50C2"]
+				]
+		} 
+ 
+		valueTile("battery", "device.battery", decoration: "flat", canChangeIcon: false, canChangeBackground: false) {
+			state "battery", label:'${currentValue}% battery'
+		}
+        
+		main  (["humidity"])
+		details(["humidity","maxHum","minHum","temperature","battery"])
+	}
+}
+
+def parse(String description) {
+	log.debug "Parse description $description config: ${device.latestValue('configuration')} interval: $interval"      
+    
+    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)
+	}
+    def result = map ? createEvent(map) : null
+ 	
+    //check in configuration change
+    if (!device.latestValue('configuration')) result = poll()
+    if (device.latestValue('configuration').toInteger() != interval && interval != null) {  	
+        result = poll()            
+    }
+ 	log.debug "result: $result"
+    return result
+    
+}
+
+
+
+private Map parseCatchAllMessage(String description) {
+    Map resultMap = [:]
+    def linkText = getLinkText(device)
+	//log.debug "Catchall"
+    def descMap = zigbee.parse(description)
+    
+    //check humidity configuration is complete
+    if (descMap.command == 0x07 && descMap.clusterId == 0x0405){    	
+        def configInterval = 10
+        if (interval != null) configInterval = interval        
+        sendEvent(name: 'configuration',value: configInterval, descriptionText: "Configuration Successful")        
+        //setConfig()
+        log.debug "config complete"        
+        //return resultMap = [name: 'configuration', value: configInterval, descriptionText: "Settings configured successfully"]                
+    }
+    else if (descMap.command == 0x0001){    
+    	def hexString = "${hex(descMap.data[5])}" + "${hex(descMap.data[4])}"
+    	def intString = Integer.parseInt(hexString, 16)    
+    	//log.debug "command: $descMap.command clusterid: $descMap.clusterId $hexString $intString"
+    
+    	if (descMap.clusterId == 0x0402){    	
+            def value = getTemperature(hexString)
+            resultMap = getTemperatureResult(value)    
+        }
+        else if (descMap.clusterId == 0x0405){
+            def value = Math.round(new BigDecimal(intString / 100)).toString()
+            resultMap = getHumidityResult(value)
+
+        }
+        else return null
+    }
+    else return null 
+    
+    return resultMap
+}    
+    
+private Map parseReportAttributeMessage(String description) {	
+    def descMap = parseDescriptionAsMap(description)
+	log.debug "Desc Map: $descMap"
+    log.debug "Report Attributes"
+ 
+	Map resultMap = [:]
+	if (descMap.cluster == "0001" && descMap.attrId == "0000") {		
+        resultMap = getBatteryResult(descMap.value)
+	}    
+    return resultMap
+}
+
+def parseDescriptionAsMap(description) {
+	(description - "read attr - ").split(",").inject([:]) { map, param ->
+		def nameAndValue = param.split(":")
+		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
+	}
+}
+
+private Map parseCustomMessage(String description) {
+	Map resultMap = [:]  
+        
+	log.debug "parseCustom"
+	if (description?.startsWith('temperature: ')) {
+		def value = zigbee.parseHATemperatureValue(description, "temperature: ", getTemperatureScale())
+		resultMap = getTemperatureResult(value)
+	}
+	else if (description?.startsWith('humidity: ')) {
+		def pct = (description - "humidity: " - "%").trim()
+		if (pct.isNumber()) {        	
+            def value = Math.round(new BigDecimal(pct)).toString()
+			resultMap = getHumidityResult(value)
+		} else {
+			log.error "invalid humidity: ${pct}"
+		}    
+	}
+	return resultMap
+}
+ 
+private Map getHumidityResult(value) {
+    def linkText = getLinkText(device)
+    def maxHumValue = 0
+    def minHumValue = 0
+    if (device.currentValue("maxHum") != null) maxHumValue = device.currentValue("maxHum").toInteger()
+    if (device.currentValue("minHum") != null) minHumValue = device.currentValue("minHum").toInteger()
+    log.debug "Humidity max: ${maxHumValue} min: ${minHumValue}"
+    def compare = value.toInteger()
+    
+    if (compare > maxHumValue) {
+        sendEvent(name: 'maxHum', value: value, unit: '%', descriptionText: "${linkText} soil moisture high is ${value}%")
+        }
+    else if (((compare < minHumValue) || (minHumValue <= 2)) && (compare != 0)) {
+        sendEvent(name: 'minHum', value: value, unit: '%', descriptionText: "${linkText} soil moisture low is ${value}%")
+        }    
+    
+    return [
+    	name: 'humidity',
+    	value: value,
+    	unit: '%',
+        descriptionText: "${linkText} soil moisture is ${value}%"
+    ]
+}
+
+
+
+def getTemperature(value) {
+	def celsius = (Integer.parseInt(value, 16).shortValue()/100)
+    //log.debug "Report Temp $value : $celsius C"
+	if(getTemperatureScale() == "C"){
+		return celsius
+	} else {
+		return celsiusToFahrenheit(celsius) as Integer
+	}
+}
+
+private Map getTemperatureResult(value) {
+	log.debug "Temperature: $value"
+	def linkText = getLinkText(device)
+        
+	if (tempOffset) {
+		def offset = tempOffset as int
+		def v = value as int
+		value = v + offset        
+	}
+	def descriptionText = "${linkText} is ${value}°${temperatureScale}"
+	return [
+		name: 'temperature',
+		value: value,
+		descriptionText: descriptionText
+	]
+}
+
+private Map getBatteryResult(value) {
+	log.debug 'Battery'
+	def linkText = getLinkText(device)
+        
+    def result = [
+    	name: 'battery'
+    ]
+    	
+	def min = 2500   
+	def percent = ((Integer.parseInt(value, 16) - min) / 5)
+	percent = Math.max(0, Math.min(percent, 100.0))
+    result.value = Math.round(percent)
+    
+    def descriptionText
+    if (percent < 10) result.descriptionText = "${linkText} battery is getting low $percent %."
+	else result.descriptionText = "${linkText} battery is ${result.value}%"
+	
+	return result
+}
+
+def resetHumidity(){
+	def linkText = getLinkText(device)
+    def minHumValue = 0
+    def maxHumValue = 0
+    sendEvent(name: 'minHum', value: minHumValue, unit: '%', descriptionText: "${linkText} min soil moisture reset to ${minHumValue}%")
+    sendEvent(name: 'maxHum', value: maxHumValue, unit: '%', descriptionText: "${linkText} max soil moisture reset to ${maxHumValue}%")
+}	
+
+def setConfig(){
+	def configInterval = 100
+    if (interval != null) configInterval = interval        
+    sendEvent(name: 'configuration',value: configInterval, descriptionText: "Configuration initialized")
+}
+
+//when device preferences are changed
+def updated(){	
+    log.debug "device updated"
+    if (!device.latestValue('configuration')) configure()
+    else{
+    	if (resetMinMax == true) resetHumidity()
+        if (device.latestValue('configuration').toInteger() != interval && interval != null){    	
+            sendEvent(name: 'configuration',value: 0, descriptionText: "Settings changed and will update at next report. Measure interval set to ${interval} mins")
+    	}
+    }
+}
+
+//poll
+def poll() {
+	log.debug "poll called"
+    List cmds = []
+    if (!device.latestValue('configuration')) cmds += configure()
+    else if (device.latestValue('configuration').toInteger() != interval && interval != null) { 
+    	cmds += intervalUpdate()
+    }
+    //cmds += refresh()
+    log.debug "commands $cmds"
+    return cmds?.collect { new physicalgraph.device.HubAction(it) }    
+}
+
+//update intervals
+def intervalUpdate(){
+	log.debug "intervalUpdate"
+    def minReport = 10
+    def maxReport = 610
+    if (interval != null) {
+    	minReport = interval
+        maxReport = interval * 61
+    }
+    [    
+    	"zcl global send-me-a-report 0x405 0x0000 0x21 $minReport $maxReport {6400}", "delay 500",
+    	"send 0x${device.deviceNetworkId} 1 1", "delay 500",
+        "zcl global send-me-a-report 1 0x0000 0x21 0x0C 0 {0500}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 500",
+    ]    
+}
+
+def refresh() {
+	log.debug "refresh"
+    [
+        "st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 500",
+        "st rattr 0x${device.deviceNetworkId} 1 0x405 0", "delay 500",    
+        "st rattr 0x${device.deviceNetworkId} 1 1 0"
+    ]    
+}
+
+//configure
+def configure() {
+	//set minReport = measurement in minutes
+    def minReport = 10
+    def maxReport = 610
+	    
+    //String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+	//log.debug "zigbeeid ${device.zigbeeId} deviceId ${device.deviceNetworkId}"
+    if (!device.zigbeeId) sendEvent(name: 'configuration',value: 0, descriptionText: "Device Zigbee Id not found, remove and attempt to rejoin device")
+    else sendEvent(name: 'configuration',value: 100, descriptionText: "Configuration initialized")
+    //log.debug "Configuring Reporting and Bindings. min: $minReport max: $maxReport "
+	
+    [
+        "zdo bind 0x${device.deviceNetworkId} 1 1 0x402 {${device.zigbeeId}} {}", "delay 500",
+        "zdo bind 0x${device.deviceNetworkId} 1 1 0x405 {${device.zigbeeId}} {}", "delay 500",                
+		"zdo bind 0x${device.deviceNetworkId} 1 1 1 {${device.zigbeeId}} {}", "delay 1000",
+        
+        //temperature
+        "zcl global send-me-a-report 0x402 0x0000 0x29 1 0 {3200}",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 500",
+        
+        //min = soil measure interval
+        "zcl global send-me-a-report 0x405 0x0000 0x21 $minReport $maxReport {6400}",        
+        "send 0x${device.deviceNetworkId} 1 1", "delay 500",       
+     
+        //min = battery measure interval  1 = 1 hour     
+        "zcl global send-me-a-report 1 0x0000 0x21 0x0C 0 {0500}",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 500"
+	] + refresh()
+}
+
+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
+}

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

@@ -0,0 +1,128 @@
+/**
+ *  Simple Sync
+ *
+ *  Copyright 2015 Roomie Remote, Inc.
+ *
+ *	Date: 2015-09-22
+ */
+metadata
+{
+	definition (name: "Simple Sync", namespace: "roomieremote-agent", author: "Roomie Remote, Inc.")
+    {
+		capability "Media Controller"
+	}
+
+	// simulator metadata
+	simulator
+    {
+	}
+
+	// UI tile definitions
+	tiles
+    {
+		standardTile("mainTile", "device.status", width: 1, height: 1, icon: "st.Entertainment.entertainment11")
+        {
+        	state "default", label: "Simple Sync", icon: "st.Home.home2", backgroundColor: "#55A7FF"
+		}
+        
+    	def detailTiles = ["mainTile"]
+		
+		main "mainTile"
+		details(detailTiles)
+	}
+}
+
+def parse(String description)
+{
+	def results = []
+	
+	try
+	{
+		def msg = parseLanMessage(description)
+		
+		if (msg.headers && msg.body)
+		{
+        	switch (msg.headers["X-Roomie-Echo"])
+			{
+            	case "getAllActivities":
+                    handleGetAllActivitiesResponse(msg)
+                	break
+			}
+    	}
+	}
+    catch (Throwable t)
+    {
+	    sendEvent(name: "parseError", value: "$t", description: description)
+    	throw t
+    }
+    
+    results
+}
+
+def handleGetAllActivitiesResponse(response)
+{
+	def body = parseJson(response.body)
+    
+    if (body.status == "success")
+    {
+	    def json = new groovy.json.JsonBuilder()
+	    def root = json activities: body.data
+	    def data = json.toString()
+    	
+	    sendEvent(name: "activities", value: data)
+    }
+}
+
+def getAllActivities(evt)
+{
+    def host = getHostAddress(device.deviceNetworkId)
+	
+	def action = new physicalgraph.device.HubAction(method: "GET",
+													path: "/api/v1/activities",
+													headers: [HOST: host, "X-Roomie-Echo": "getAllActivities"])
+	
+	action
+}
+
+def startActivity(evt)
+{
+    def uuid = evt
+    def host = getHostAddress(device.deviceNetworkId)
+    def activity = new groovy.json.JsonSlurper().parseText(device.currentValue('activities') ?: "{ 'activities' : [] }").activities.find { it.uuid == uuid }
+    def toggle = activity["toggle"]
+    def jsonMap = ["activity_uuid": uuid]
+    
+    if (toggle != null)
+    {
+        jsonMap << ["toggle_state": toggle ? "on" : "off"]
+    }
+    
+    def json = new groovy.json.JsonBuilder(jsonMap)
+    def jsonBody = json.toString()
+    def headers = [HOST: host, "Content-Type": "application/json"]
+    
+    def action = new physicalgraph.device.HubAction(method: "POST",
+													path: "/api/v1/runactivity",
+													body: jsonBody,
+													headers: headers)
+	
+    action
+}
+
+def getHostAddress(d)
+{
+	def parts = d.split(":")
+	def ip = convertHexToIP(parts[0])
+	def port = convertHexToInt(parts[1])
+	return ip + ":" + port
+}
+
+def String convertHexToIP(hex)
+{
+	[convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
+}
+
+def Integer convertHexToInt(hex)
+{
+	Integer.parseInt(hex,16)
+}

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

@@ -24,6 +24,8 @@ metadata {
 		capability "Battery"
 
 		attribute "tamper", "enum", ["detected", "clear"]
+		attribute "batteryStatus", "string"
+		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"
 	}
@@ -63,6 +65,19 @@ metadata {
 		status "wake up" : "command: 8407, payload: "
 	}
 
+	preferences {
+		input description: "Please consult AEOTEC MULTISENSOR 6 operating manual for advanced setting options. You can skip this configuration to use default settings",
+				title: "Advanced Configuration", displayDuringSetup: true, type: "paragraph", element: "paragraph"
+
+		input "motionDelayTime", "enum", title: "Motion Sensor Delay Time",
+				options: ["20 seconds", "40 seconds", "1 minute", "2 minutes", "3 minutes", "4 minutes"], defaultValue: "${motionDelayTime}", displayDuringSetup: true
+
+		input "motionSensitivity", "enum", title: "Motion Sensor Sensitivity", options: ["normal","maximum","minimum"], defaultValue: "${motionSensitivity}", displayDuringSetup: true
+
+		input "reportInterval", "enum", title: "Sensors Report Interval",
+				options: ["8 minutes", "15 minutes", "30 minutes", "1 hour", "6 hours", "12 hours", "18 hours", "24 hours"], defaultValue: "${reportInterval}", displayDuringSetup: true
+	}
+
 	tiles(scale: 2) {
 		multiAttributeTile(name:"motion", type: "generic", width: 6, height: 4){
 			tileAttribute ("device.motion", key: "PRIMARY_CONTROL") {
@@ -85,53 +100,78 @@ metadata {
 		valueTile("humidity", "device.humidity", inactiveLabel: false, width: 2, height: 2) {
 			state "humidity", label:'${currentValue}% humidity', unit:""
 		}
+
 		valueTile("illuminance", "device.illuminance", inactiveLabel: false, width: 2, height: 2) {
-			state "luminosity", label:'${currentValue} ${unit}', unit:"lux"
+			state "illuminance", label:'${currentValue} ${unit}', unit:"lux"
 		}
+
+		valueTile("ultravioletIndex", "device.ultravioletIndex", inactiveLabel: false, width: 2, height: 2) {
+			state "ultravioletIndex", label:'${currentValue} UV index', unit:""
+		}
+
 		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
 			state "battery", label:'${currentValue}% battery', unit:""
 		}
 
-		main(["motion", "temperature", "humidity", "illuminance"])
-		details(["motion", "temperature", "humidity", "illuminance", "battery"])
+		valueTile("batteryStatus", "device.batteryStatus", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "batteryStatus", label:'${currentValue}', unit:""
+		}
+
+		valueTile("powerSupply", "device.powerSupply", height: 2, width: 2, decoration: "flat") {
+			state "powerSupply", label:'${currentValue} powered', backgroundColor:"#ffffff"
+		}
+
+		main(["motion", "temperature", "humidity", "illuminance", "ultravioletIndex"])
+		details(["motion", "temperature", "humidity", "illuminance", "ultravioletIndex", "batteryStatus"])
 	}
 }
 
-def updated()
-{
-	if (state.sec && !isConfigured()) {
-		// in case we miss the SCSR
+def updated() {
+	log.debug "Updated with settings: ${settings}"
+	log.debug "${device.displayName} is now ${device.latestValue("powerSupply")}"
+
+	if (device.latestValue("powerSupply") == "USB Cable") {  //case1: USB powered
 		response(configure())
+	} else if (device.latestValue("powerSupply") == "Battery") {  //case2: battery powered
+		// setConfigured("false") is used by WakeUpNotification
+		setConfigured("false") //wait until the next time device wakeup to send configure command after user change preference
+	} else { //case3: power source is not identified, ask user to properly pair the sensor again
+		log.warn "power source is not identified, check it sensor is powered by USB, if so > configure()"
+		def request = []
+		request << zwave.configurationV1.configurationGet(parameterNumber: 101)
+		response(commands(request))
 	}
 }
 
-def parse(String description)
-{
+def parse(String description) {
+	log.debug "parse() >> description: $description"
 	def result = null
 	if (description.startsWith("Err 106")) {
-		state.sec = 0
+		log.debug "parse() >> Err 106"
 		result = createEvent( name: "secureInclusion", value: "failed", isStateChange: true,
-			descriptionText: "This sensor failed to complete the network security key exchange. If you are unable to control it via SmartThings, you must remove it from your network and add it again.")
+				descriptionText: "This sensor failed to complete the network security key exchange. If you are unable to control it via SmartThings, you must remove it from your network and add it again.")
 	} else if (description != "updated") {
+		log.debug "parse() >> zwave.parse(description)"
 		def cmd = zwave.parse(description, [0x31: 5, 0x30: 2, 0x84: 1])
 		if (cmd) {
 			result = zwaveEvent(cmd)
 		}
 	}
-	log.debug "Parsed '${description}' to ${result.inspect()}"
+	log.debug "After zwaveEvent(cmd) >> Parsed '${description}' to ${result.inspect()}"
 	return result
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd)
-{
+//this notification will be sent only when device is battery powered
+def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd) {
 	def result = [createEvent(descriptionText: "${device.displayName} woke up", isStateChange: false)]
-
+	def cmds = []
 	if (!isConfigured()) {
-		// we're still in the process of configuring a newly joined device
 		log.debug("late configure")
-		result += response(configure())
+		result << response(configure())
 	} else {
-		result += response(zwave.wakeUpV1.wakeUpNoMoreInformation())
+		log.debug("Device has been configured sending >> wakeUpNoMoreInformation()")
+		cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
+		result << response(cmds)
 	}
 	result
 }
@@ -149,10 +189,29 @@ def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulat
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityCommandsSupportedReport cmd) {
-	response(configure())
+	log.info "Executing zwaveEvent 98 (SecurityV1): 03 (SecurityCommandsSupportedReport) with cmd: $cmd"
+	state.sec = 1
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.securityv1.NetworkKeyVerify cmd) {
+	state.sec = 1
+	log.info "Executing zwaveEvent 98 (SecurityV1): 07 (NetworkKeyVerify) with cmd: $cmd (node is securely included)"
+	def result = [createEvent(name:"secureInclusion", value:"success", descriptionText:"Secure inclusion was successful", isStateChange: true)]
+	result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
+	log.info "Executing zwaveEvent 72 (ManufacturerSpecificV2) : 05 (ManufacturerSpecificReport) with cmd: $cmd"
+	log.debug "manufacturerId:   ${cmd.manufacturerId}"
+	log.debug "manufacturerName: ${cmd.manufacturerName}"
+	log.debug "productId:        ${cmd.productId}"
+	log.debug "productTypeId:    ${cmd.productTypeId}"
+	def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
+	updateDataValue("MSR", msr)
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
+	def result = []
 	def map = [ name: "battery", unit: "%" ]
 	if (cmd.batteryLevel == 0xFF) {
 		map.value = 1
@@ -162,11 +221,14 @@ def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
 		map.value = cmd.batteryLevel
 	}
 	state.lastbatt = now()
-	createEvent(map)
+	result << createEvent(map)
+	if (device.latestValue("powerSupply") != "USB Cable"){
+		result << createEvent(name: "batteryStatus", value: "${map.value} % battery", displayed: false)
+	}
+	result
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd)
-{
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd){
 	def map = [:]
 	switch (cmd.sensorType) {
 		case 1:
@@ -208,7 +270,6 @@ def motionEvent(value) {
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.sensorbinaryv2.SensorBinaryReport cmd) {
-	setConfigured()
 	motionEvent(cmd.sensorValue)
 }
 
@@ -225,47 +286,112 @@ def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cm
 				result << createEvent(name: "tamper", value: "clear", displayed: false)
 				break
 			case 3:
-				result << createEvent(name: "tamper", value: "detected", descriptionText: "$device.displayName was moved")
+				result << createEvent(name: "tamper", value: "detected", descriptionText: "$device.displayName was tampered")
 				break
 			case 7:
 				result << motionEvent(1)
 				break
 		}
 	} else {
+		log.warn "Need to handle this cmd.notificationType: ${cmd.notificationType}"
 		result << createEvent(descriptionText: cmd.toString(), isStateChange: false)
 	}
 	result
 }
 
+def zwaveEvent(physicalgraph.zwave.commands.configurationv2.ConfigurationReport cmd) {
+	log.debug "ConfigurationReport: $cmd"
+	def result = []
+	def value
+	if (cmd.parameterNumber == 9 && cmd.configurationValue[0] == 0) {
+		value = "USB Cable"
+		if (!isConfigured()) {
+			log.debug("ConfigurationReport: configuring device")
+			result << response(configure())
+		}
+		result << createEvent(name: "batteryStatus", value: value, displayed: false)
+		result << createEvent(name: "powerSupply", value: value, displayed: false)
+	}else if (cmd.parameterNumber == 9 && cmd.configurationValue[0] == 1) {
+		value = "Battery"
+		result << createEvent(name: "powerSupply", value: value, displayed: false)
+	} else if (cmd.parameterNumber == 101){
+		result << response(configure())
+	}
+	result
+}
+
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
+	log.debug "General zwaveEvent cmd: ${cmd}"
 	createEvent(descriptionText: cmd.toString(), isStateChange: false)
 }
 
 def configure() {
 	// This sensor joins as a secure device if you double-click the button to include it
-	if (device.device.rawDescription =~ /98/ && !state.sec) {
-		log.debug "Multi 6 not sending configure until secure"
-		return []
-	}
-	log.debug "Multi 6 configure()"
-	def request = [
-		// send no-motion report 20 seconds after motion stops
-		zwave.configurationV1.configurationSet(parameterNumber: 3, size: 2, scaledConfigurationValue: 20),
+	log.debug "${device.displayName} is configuring its settings"
+	def request = []
 
-		// report every 8 minutes (threshold reports don't work on battery power)
-		zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: 8*60),
+	//1. set association groups for hub
+	request << zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId)
 
-		// report automatically on threshold change
-		zwave.configurationV1.configurationSet(parameterNumber: 40, size: 1, scaledConfigurationValue: 1),
+	request << zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId)
+
+	//2. automatic report flags
+	// param 101 -103 [4 bytes] 128: light sensor, 64 humidity, 32 temperature sensor, 2 ultraviolet sensor, 1 battery sensor -> send command 227 to get all reports
+	request << zwave.configurationV1.configurationSet(parameterNumber: 101, size: 4, scaledConfigurationValue: 226) //association group 1
+
+	request << zwave.configurationV1.configurationSet(parameterNumber: 102, size: 4, scaledConfigurationValue: 1) //association group 2
+
+	//3. no-motion report x seconds after motion stops (default 20 secs)
+	request << zwave.configurationV1.configurationSet(parameterNumber: 3, size: 2, scaledConfigurationValue: timeOptionValueMap[motionDelayTime] ?: 20)
+
+	//4. motionSensitivity 3 levels: 64-normal (default), 127-maximum, 0-minimum
+	request << zwave.configurationV1.configurationSet(parameterNumber: 6, size: 1,
+			scaledConfigurationValue:
+					motionSensitivity == "normal" ? 64 :
+							motionSensitivity == "maximum" ? 127 :
+									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: 112, size: 4, scaledConfigurationValue: 6*60*60)  //association group 2
+
+	//6. report automatically on threshold change
+	request << zwave.configurationV1.configurationSet(parameterNumber: 40, size: 1, scaledConfigurationValue: 1)
+
+	//7. query sensor data
+	request << zwave.batteryV1.batteryGet()
+	request << zwave.sensorBinaryV2.sensorBinaryGet(sensorType: 0x0C) //motion
+	request << zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 0x01) //temperature
+	request << zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 0x03) //illuminance
+	request << zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 0x05) //humidity
+	request << zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 0x1B) //ultravioletIndex
+
+	setConfigured("true")
 
-		zwave.batteryV1.batteryGet(),
-		zwave.sensorBinaryV2.sensorBinaryGet(sensorType: 0x0C),
-    ]
 	commands(request) + ["delay 20000", zwave.wakeUpV1.wakeUpNoMoreInformation().format()]
 }
 
-private setConfigured() {
-	updateDataValue("configured", "true")
+private def getTimeOptionValueMap() { [
+		"20 seconds" : 20,
+		"40 seconds" : 40,
+		"1 minute"   : 60,
+		"2 minutes"  : 2*60,
+		"3 minutes"  : 3*60,
+		"4 minutes"  : 4*60,
+		"5 minutes"  : 5*60,
+		"8 minutes"  : 8*60,
+		"15 minutes" : 15*60,
+		"30 minutes" : 30*60,
+		"1 hours"    : 1*60*60,
+		"6 hours"    : 6*60*60,
+		"12 hours"   : 12*60*60,
+		"18 hours"   : 6*60*60,
+		"24 hours"   : 24*60*60,
+]}
+
+private setConfigured(configure) {
+	updateDataValue("configured", configure)
 }
 
 private isConfigured() {
@@ -281,5 +407,6 @@ private command(physicalgraph.zwave.Command cmd) {
 }
 
 private commands(commands, delay=200) {
+	log.info "sending commands: ${commands}"
 	delayBetween(commands.collect{ command(it) }, delay)
 }

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

@@ -0,0 +1,180 @@
+/**
+ *  Copyright 2016 SmartThings
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ */
+ 
+ /*
+ *  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"
+        capability "Actuator"
+        capability "Presence Sensor"
+        capability "Sensor"
+        capability "Battery"
+        capability "Configuration"
+
+        fingerprint inClusters: "0000,0001,0003,000F,0020", outClusters: "0003,0019",
+                        manufacturer: "SmartThings", model: "tagv4", deviceJoinName: "Arrival Sensor"
+    }
+
+    preferences {
+        section {
+            image(name: 'educationalcontent', multiple: true, images: [
+                "http://cdn.device-gse.smartthings.com/Arrival/Arrival1.png",
+                "http://cdn.device-gse.smartthings.com/Arrival/Arrival2.png"
+                ])
+        }
+        section {
+            input "checkInterval", "enum", title: "Presence timeout (minutes)", description: "Tap to set",
+                    defaultValue:"2", options: ["2", "3", "5"], displayDuringSetup: false
+        }
+    }
+
+    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:"#ffffff"
+        }
+        standardTile("beep", "device.beep", decoration: "flat") {
+            state "beep", label:'', action:"tone.beep", icon:"st.secondary.beep", backgroundColor:"#ffffff"
+        }
+        valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false) {
+            state "battery", label:'${currentValue}% battery', unit:""
+        }
+
+        main "presence"
+        details(["presence", "beep", "battery"])
+    }
+}
+
+def updated() {
+    startTimer()
+}
+
+def configure() {
+    def cmds = zigbee.configureReporting(0x0001, 0x0020, 0x20, 20, 20, 0x01)
+    log.debug "configure -- cmds: ${cmds}"
+    return cmds
+}
+
+def beep() {
+    log.debug "Sending Identify command to beep the sensor for 5 seconds"
+    return zigbee.command(0x0003, 0x00, "0500")
+}
+
+def parse(String description) {
+    state.lastCheckin = now()
+    handlePresenceEvent(true)
+
+    if (description?.startsWith('read attr -')) {
+        handleReportAttributeMessage(description)
+    }
+
+    return []
+}
+
+private handleReportAttributeMessage(String description) {
+    def descMap = zigbee.parseDescriptionAsMap(description)
+    if (descMap.clusterInt == 0x0001 && descMap.attrInt == 0x0020) {
+        handleBatteryEvent(Integer.parseInt(descMap.value, 16))
+    }
+}
+
+/**
+ * Create battery event from reported battery voltage.
+ *
+ * @param volts Battery voltage in .1V increments
+ */
+private handleBatteryEvent(volts) {
+	def descriptionText
+    if (volts == 0 || volts == 255) {
+        log.debug "Ignoring invalid value for voltage (${volts/10}V)"
+    }
+    else {
+        def batteryMap = [28:100, 27:100, 26:100, 25:90, 24:90, 23:70,
+                          22:70, 21:50, 20:50, 19:30, 18:30, 17:15, 16:1, 15:0]
+        def minVolts = 15
+        def maxVolts = 28
+
+        if (volts < minVolts)
+            volts = minVolts
+        else if (volts > maxVolts)
+            volts = maxVolts
+        def value = batteryMap[volts]
+        if (value != null) {
+            def linkText = getLinkText(device)
+            descriptionText = '{{ linkText }} battery was {{ value }}'
+            def eventMap = [
+                name: 'battery',
+                value: value,
+                descriptionText: descriptionText,
+                translatable: true
+            ]
+            log.debug "Creating battery event for voltage=${volts/10}V: ${linkText} ${eventMap.name} is ${eventMap.value}%"
+            sendEvent(eventMap)
+        }
+    }
+}
+
+private handlePresenceEvent(present) {
+    def wasPresent = device.currentState("presence")?.value == "present"
+    if (!wasPresent && present) {
+        log.debug "Sensor is present"
+        startTimer()
+    } else if (!present) {
+        log.debug "Sensor is not present"
+        stopTimer()
+    }
+    def linkText = getLinkText(device)
+    def descriptionText
+    if ( present )
+    	descriptionText = "{{ linkText }} has arrived"
+    else
+    	descriptionText = "{{ linkText }} has left"
+    def eventMap = [
+        name: "presence",
+        value: present ? "present" : "not present",
+        linkText: linkText,
+        descriptionText: descriptionText,
+        translatable: true
+    ]
+    log.debug "Creating presence event: ${device.displayName} ${eventMap.name} is ${eventMap.value}"
+    sendEvent(eventMap)
+}
+
+private startTimer() {
+    log.debug "Scheduling periodic timer"
+    schedule("0 * * * * ?", checkPresenceCallback)
+}
+
+private stopTimer() {
+    log.debug "Stopping periodic timer"
+    unschedule()
+}
+
+def checkPresenceCallback() {
+    def timeSinceLastCheckin = (now() - state.lastCheckin) / 1000
+    def theCheckInterval = (checkInterval ? checkInterval as int : 2) * 60
+    log.debug "Sensor checked in ${timeSinceLastCheckin} seconds ago"
+    if (timeSinceLastCheckin >= theCheckInterval) {
+        handlePresenceEvent(false)
+    }
+}

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

@@ -0,0 +1,36 @@
+#==============================================================================
+#  Copyright 2016 SmartThings
+#
+#  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+#  use this file except in compliance with the License. You may obtain a copy
+#  of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#  License for the specific language governing permissions and limitations
+#  under the License.
+#==============================================================================
+# 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=기기 이름 설정
+'''Set Device Image'''.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 }} 외출
+#==============================================================================

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

@@ -43,7 +43,7 @@ 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:"#ffffff"
+			state "not present", labelIcon:"st.presence.tile.not-present", backgroundColor:"#ebeef2"
 		}
 		standardTile("beep", "device.beep", decoration: "flat") {
 			state "beep", label:'', action:"tone.beep", icon:"st.secondary.beep", backgroundColor:"#ffffff"

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

@@ -15,6 +15,7 @@
  *	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"
@@ -25,7 +26,6 @@ metadata {
 		capability "Refresh"
 		capability "Sensor"
 
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0B04,0B05", outClusters: "0019"
 	}
 
 	// simulator metadata

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

@@ -1,7 +1,7 @@
 /**
  *  Cree 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:
@@ -15,191 +15,80 @@
  */
  
 metadata {
-	definition (name: "Cree Bulb", namespace: "smartthings", author: "SmartThings") {
+    definition (name: "Cree Bulb", namespace: "smartthings", author: "SmartThings") {
 
-		capability "Actuator"
+        capability "Actuator"
         capability "Configuration"
-		capability "Refresh"
-		capability "Switch"
-		capability "Switch Level"
+        capability "Refresh"
+        capability "Switch"
+        capability "Switch Level"
 
-		fingerprint profileId: "C05E", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0000,0019"
-	}
+        fingerprint profileId: "C05E", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0000,0019"
+    }
 
-	// simulator metadata
-	simulator {
-		// status messages
-		status "on": "on/off: 1"
-		status "off": "on/off: 0"
+    // 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"
-	}
+        // 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 "off", label: '${name}', action: "switch.on", icon: "st.switches.light.off", backgroundColor: "#ffffff"
-			state "on", label: '${name}', action: "switch.off", icon: "st.switches.light.on", backgroundColor: "#79b821"
-		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-		controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 3, inactiveLabel: false) {
-			state "level", action:"switch level.setLevel"
-		}
-		valueTile("level", "device.level", inactiveLabel: false, decoration: "flat") {
-			state "level", label: 'Level ${currentValue}%'
-		}
-		
-
-		main(["switch"])
-		details(["switch", "level", "levelSliderControl", "refresh"])
-	}
+    // 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 "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 "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
+            }
+            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+                attributeState "level", action:"switch level.setLevel"
+            }
+        }
+        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+        main "switch"
+        details(["switch", "refresh"])
+    }
 }
 
 // Parse incoming device messages to generate events
-
 def parse(String description) {
-	log.trace description
-	if (description?.startsWith("catchall:")) {
-		def msg = zigbee.parse(description)
-		log.trace msg
-		log.trace "data: $msg.data"
-        
-        if(description?.endsWith("0100") ||description?.endsWith("1001"))
-        {
-        	def result = createEvent(name: "switch", value: "on")
-            log.debug "Parse returned ${result?.descriptionText}"
-            return result
-        }
-        
-        if(description?.endsWith("0000") || description?.endsWith("1000"))
-        {
-        	def result = createEvent(name: "switch", value: "off")
-            log.debug "Parse returned ${result?.descriptionText}"
-            return result
-        }
-	}
-    
-    
-   if (description?.startsWith("read attr")) {
-   		
-        log.debug description[-2..-1]
-        def i = Math.round(convertHexToInt(description[-2..-1]) / 256 * 100 )
-        
-		sendEvent( name: "level", value: i )
+    log.debug "description is $description"
+
+    def resultMap = zigbee.getEvent(description)
+    if (resultMap) {
+        sendEvent(resultMap)
     }
-    
-	
+    else {
+        log.debug "DID NOT PARSE MESSAGE for description : $description"
+        log.debug zigbee.parseDescriptionAsMap(description)
+    }
+}
+
+def off() {
+    zigbee.off()
 }
 
 def on() {
-	log.debug "on()"
-	sendEvent(name: "switch", value: "on")
-    
-    "st cmd 0x${device.deviceNetworkId} ${endpointId} 6 1 {}"
-    }
-
-def off() {
-	log.debug "off()"
-	sendEvent(name: "switch", value: "off")
-    
-	"st cmd 0x${device.deviceNetworkId} ${endpointId} 6 0 {}"
- 
-}
-
-def refresh() {
-    // Schedule poll every 1 min
-    //schedule("0 */1 * * * ?", poll)
-    //poll()
-    
-    [
-	"st rattr 0x${device.deviceNetworkId} ${endpointId} 6 0", "delay 500",
-    "st rattr 0x${device.deviceNetworkId} ${endpointId} 8 0"
-    ]
+    zigbee.on()
 }
 
 def setLevel(value) {
-	log.trace "setLevel($value)"
-	def cmds = []
+    zigbee.setLevel(value) + ["delay 500"] + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
+}
 
-	if (value == 0) {
-		sendEvent(name: "switch", value: "off")
-		cmds << "st cmd 0x${device.deviceNetworkId} ${endpointId} 6 0 {0000 0000}"
-	}
-	else if (device.latestValue("switch") == "off") {
-		sendEvent(name: "switch", value: "on")
-	}
-
-	sendEvent(name: "level", value: value)
-    def level = hex(value * 255/100)
-	cmds << "st cmd 0x${device.deviceNetworkId} ${endpointId} 8 4 {${level} 0000}"
-
-	//log.debug cmds
-	cmds
+def refresh() {
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig() + zigbee.levelConfig()
 }
 
 def configure() {
-
-	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",
-	]
-    return configCmds + refresh() // send refresh cmds as part of config
-}
-
-def uninstalled() {
-
-	log.debug "uninstalled()"
-		
-	response("zcl rftd")
- 
-}
-
-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 Integer convertHexToInt(hex) {
-	Integer.parseInt(hex,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
+    log.debug "Configuring Reporting and Bindings."
+    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
 }

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

@@ -55,141 +55,136 @@ metadata {
 			}
 		}
 
-		standardTile("indicator", "device.indicatorStatus", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
+		standardTile("indicator", "device.indicatorStatus", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "when off", action:"indicator.indicatorWhenOn", icon:"st.indicators.lit-when-off"
 			state "when on", action:"indicator.indicatorNever", icon:"st.indicators.lit-when-on"
 			state "never", action:"indicator.indicatorWhenOff", icon:"st.indicators.never-lit"
 		}
-		standardTile("refresh", "device.switch", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+
+		standardTile("refresh", "device.switch", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+
+		valueTile("level", "device.level", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "level", label:'${currentValue} %', unit:"%", backgroundColor:"#ffffff"
 		}
 
 		main(["switch"])
-		details(["switch", "refresh", "indicator"])
+		details(["switch", "level", "indicator", "refresh"])
+
 	}
 }
 
 def parse(String description) {
-	def item1 = [
-		canBeCurrentState: false,
-		linkText: getLinkText(device),
-		isStateChange: false,
-		displayed: false,
-		descriptionText: description,
-		value:  description
-	]
-	def result
-	def cmd = zwave.parse(description, [0x20: 1, 0x26: 1, 0x70: 1])
-	if (cmd) {
-		result = createEvent(cmd, item1)
+	def result = null
+	if (description != "updated") {
+		log.debug "parse() >> zwave.parse($description)"
+		def cmd = zwave.parse(description, [0x20: 1, 0x26: 1, 0x70: 1])
+		if (cmd) {
+			result = zwaveEvent(cmd)
+		}
 	}
-	else {
-		item1.displayed = displayed(description, item1.isStateChange)
-		result = [item1]
+	if (result?.name == 'hail' && hubFirmwareLessThan("000.011.00602")) {
+		result = [result, response(zwave.basicV1.basicGet())]
+		log.debug "Was hailed: requesting state update"
+	} else {
+		log.debug "Parse returned ${result?.descriptionText}"
 	}
-	log.debug "Parse returned ${result?.descriptionText}"
-	result
+	return result
 }
 
-def createEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd, Map item1) {
-	def result = doCreateEvent(cmd, item1)
-	for (int i = 0; i < result.size(); i++) {
-		result[i].type = "physical"
+def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
+	dimmerEvents(cmd)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
+	dimmerEvents(cmd)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.switchmultilevelv1.SwitchMultilevelReport cmd) {
+	dimmerEvents(cmd)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.switchmultilevelv1.SwitchMultilevelSet cmd) {
+	dimmerEvents(cmd)
+}
+
+private dimmerEvents(physicalgraph.zwave.Command cmd) {
+	def value = (cmd.value ? "on" : "off")
+	def result = [createEvent(name: "switch", value: value)]
+	if (cmd.value && cmd.value <= 100) {
+		result << createEvent(name: "level", value: cmd.value, unit: "%")
 	}
-	result
+	return result
 }
 
-def createEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd, Map item1) {
-	def result = doCreateEvent(cmd, item1)
-	for (int i = 0; i < result.size(); i++) {
-		result[i].type = "physical"
-	}
-	result
-}
-
-def createEvent(physicalgraph.zwave.commands.switchmultilevelv1.SwitchMultilevelStartLevelChange cmd, Map item1) {
-	[]
-}
-
-def createEvent(physicalgraph.zwave.commands.switchmultilevelv1.SwitchMultilevelStopLevelChange cmd, Map item1) {
-	[response(zwave.basicV1.basicGet())]
-}
-
-def createEvent(physicalgraph.zwave.commands.switchmultilevelv1.SwitchMultilevelSet cmd, Map item1) {
-	def result = doCreateEvent(cmd, item1)
-	for (int i = 0; i < result.size(); i++) {
-		result[i].type = "physical"
-	}
-	result
-}
-
-def createEvent(physicalgraph.zwave.commands.switchmultilevelv1.SwitchMultilevelReport cmd, Map item1) {
-	def result = doCreateEvent(cmd, item1)
-	result[0].descriptionText = "${item1.linkText} is ${item1.value}"
-	result[0].handlerName = cmd.value ? "statusOn" : "statusOff"
-	for (int i = 0; i < result.size(); i++) {
-		result[i].type = "digital"
-	}
-	result
-}
-
-def doCreateEvent(physicalgraph.zwave.Command cmd, Map item1) {
-	def result = [item1]
-
-	item1.name = "switch"
-	item1.value = cmd.value ? "on" : "off"
-	item1.handlerName = item1.value
-	item1.descriptionText = "${item1.linkText} was turned ${item1.value}"
-	item1.canBeCurrentState = true
-	item1.isStateChange = isStateChange(device, item1.name, item1.value)
-	item1.displayed = item1.isStateChange
-
-	if (cmd.value >= 5) {
-		def item2 = new LinkedHashMap(item1)
-		item2.name = "level"
-		item2.value = cmd.value as String
-		item2.unit = "%"
-		item2.descriptionText = "${item1.linkText} dimmed ${item2.value} %"
-		item2.canBeCurrentState = true
-		item2.isStateChange = isStateChange(device, item2.name, item2.value)
-		item2.displayed = false
-		result << item2
-	}
-	result
-}
 
 def zwaveEvent(physicalgraph.zwave.commands.configurationv1.ConfigurationReport cmd) {
+	log.debug "ConfigurationReport $cmd"
 	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]
+	createEvent([name: "indicatorStatus", value: value])
 }
 
-def createEvent(physicalgraph.zwave.Command cmd,  Map map) {
-	// Handles any Z-Wave commands we aren't interested in
-	log.debug "UNHANDLED COMMAND $cmd"
+def zwaveEvent(physicalgraph.zwave.commands.hailv1.Hail cmd) {
+	createEvent([name: "hail", value: "hail", descriptionText: "Switch button was pressed", displayed: false])
+}
+
+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 msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
+	updateDataValue("MSR", msr)
+	createEvent([descriptionText: "$device.displayName MSR: $msr", isStateChange: false])
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.switchmultilevelv1.SwitchMultilevelStopLevelChange cmd) {
+	[createEvent(name:"switch", value:"on"), response(zwave.switchMultilevelV1.switchMultilevelGet().format())]
+}
+
+def zwaveEvent(physicalgraph.zwave.Command cmd) {
+	// Handles all Z-Wave commands we aren't interested in
+	[:]
 }
 
 def on() {
-	log.info "on"
-	delayBetween([zwave.basicV1.basicSet(value: 0xFF).format(), zwave.switchMultilevelV1.switchMultilevelGet().format()], 5000)
+	delayBetween([
+			zwave.basicV1.basicSet(value: 0xFF).format(),
+			zwave.switchMultilevelV1.switchMultilevelGet().format()
+	],5000)
 }
 
 def off() {
-	delayBetween ([zwave.basicV1.basicSet(value: 0x00).format(), zwave.switchMultilevelV1.switchMultilevelGet().format()], 5000)
+	delayBetween([
+			zwave.basicV1.basicSet(value: 0x00).format(),
+			zwave.switchMultilevelV1.switchMultilevelGet().format()
+	],5000)
 }
 
 def setLevel(value) {
+	log.debug "setLevel >> value: $value"
 	def valueaux = value as Integer
-	def level = Math.min(valueaux, 99)
+	def level = Math.max(Math.min(valueaux, 99), 0)
+	if (level > 0) {
+		sendEvent(name: "switch", value: "on")
+	} else {
+		sendEvent(name: "switch", value: "off")
+	}
+	sendEvent(name: "level", value: level, unit: "%")
 	delayBetween ([zwave.basicV1.basicSet(value: level).format(), zwave.switchMultilevelV1.switchMultilevelGet().format()], 5000)
 }
 
 def setLevel(value, duration) {
+	log.debug "setLevel >> value: $value, duration: $duration"
 	def valueaux = value as Integer
-	def level = Math.min(valueaux, 99)
+	def level = Math.max(Math.min(valueaux, 99), 0)
 	def dimmingDuration = duration < 128 ? duration : 128 + Math.round(duration / 60)
-	zwave.switchMultilevelV2.switchMultilevelSet(value: level, dimmingDuration: dimmingDuration).format()
+	def getStatusDelay = duration < 128 ? (duration*1000)+2000 : (Math.round(duration / 60)*60*1000)+2000
+	delayBetween ([zwave.switchMultilevelV2.switchMultilevelSet(value: level, dimmingDuration: dimmingDuration).format(),
+				   zwave.switchMultilevelV1.switchMultilevelGet().format()], getStatusDelay)
 }
 
 def poll() {
@@ -197,21 +192,27 @@ def poll() {
 }
 
 def refresh() {
-	zwave.switchMultilevelV1.switchMultilevelGet().format()
+	log.debug "refresh() is called"
+	def commands = []
+	commands << zwave.switchMultilevelV1.switchMultilevelGet().format()
+	if (getDataValue("MSR") == null) {
+		commands << zwave.manufacturerSpecificV1.manufacturerSpecificGet().format()
+	}
+	delayBetween(commands,100)
 }
 
 def indicatorWhenOn() {
-	sendEvent(name: "indicatorStatus", value: "when on", display: false)
+	sendEvent(name: "indicatorStatus", value: "when on")
 	zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()
 }
 
 def indicatorWhenOff() {
-	sendEvent(name: "indicatorStatus", value: "when off", display: false)
+	sendEvent(name: "indicatorStatus", value: "when off")
 	zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 3, size: 1).format()
 }
 
 def indicatorNever() {
-	sendEvent(name: "indicatorStatus", value: "never", display: false)
+	sendEvent(name: "indicatorStatus", value: "never")
 	zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 3, size: 1).format()
 }
 
@@ -222,4 +223,4 @@ def invertSwitch(invert=true) {
 	else {
 		zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 4, size: 1).format()
 	}
-}
+}

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

@@ -0,0 +1,72 @@
+/**
+ *  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.
+ *
+ *	Ecobee Sensor
+ *
+ *	Author: SmartThings
+ */
+metadata {
+	definition (name: "Ecobee Sensor", namespace: "smartthings", author: "SmartThings") {
+		capability "Sensor"
+		capability "Temperature Measurement"
+		capability "Motion Sensor"
+		capability "Refresh"
+	}
+
+	tiles {
+		valueTile("temperature", "device.temperature", width: 2, height: 2) {
+			state("temperature", label:'${currentValue}°', unit:"F",
+					backgroundColors:[
+							// Celsius
+							[value: 0, color: "#153591"],
+							[value: 7, color: "#1e9cbb"],
+							[value: 15, color: "#90d2a7"],
+							[value: 23, color: "#44b621"],
+							[value: 28, color: "#f1d801"],
+							[value: 35, color: "#d04e00"],
+							[value: 37, color: "#bc2323"],
+							// Fahrenheit
+							[value: 40, color: "#153591"],
+							[value: 44, color: "#1e9cbb"],
+							[value: 59, color: "#90d2a7"],
+							[value: 74, color: "#44b621"],
+							[value: 84, color: "#f1d801"],
+							[value: 95, color: "#d04e00"],
+							[value: 96, color: "#bc2323"]
+					]
+			)
+		}
+
+		standardTile("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")
+		}
+
+		standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat") {
+			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+
+		main (["temperature","motion"])
+		details(["temperature","motion","refresh"])
+	}
+}
+
+def refresh() {
+	log.debug "refresh called"
+	poll()
+}
+
+void poll() {
+	log.debug "Executing 'poll' using parent SmartApp"
+	parent.pollChild()
+
+}

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

@@ -0,0 +1,455 @@
+/**
+ *  Copyright 2015 SmartThings
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ */
+metadata {
+    definition (name: "Fibaro Smoke Sensor", namespace: "smartthings", author: "SmartThings") {
+        capability "Battery" //attributes: battery
+        capability "Configuration"  //commands: configure()
+        capability "Sensor"
+        capability "Smoke Detector" //attributes: smoke ("detected","clear","tested")
+        capability "Temperature Measurement" //attributes: temperature
+        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"
+    }
+    simulator {
+        //battery
+        for (int i in [0, 5, 10, 15, 50, 99, 100]) {
+            status "battery ${i}%":  new physicalgraph.zwave.Zwave().securityV1.securityMessageEncapsulation().encapsulate(
+                    new physicalgraph.zwave.Zwave().batteryV1.batteryReport(batteryLevel: i)
+            ).incomingMessage()
+        }
+        status "battery 100%": "command: 8003, payload: 64"
+        status "battery 5%": "command: 8003, payload: 05"
+        //smoke
+        status "smoke detected": "command: 7105, payload: 01 01"
+        status "smoke clear": "command: 7105, payload: 01 00"
+        status "smoke tested": "command: 7105, payload: 01 03"
+        //temperature
+        for (int i = 0; i <= 100; i += 20) {
+            status "temperature ${i}F": new physicalgraph.zwave.Zwave().securityV1.securityMessageEncapsulation().encapsulate(
+                    new physicalgraph.zwave.Zwave().sensorMultilevelV5.sensorMultilevelReport(scaledSensorValue: i, precision: 1, sensorType: 1, scale: 1)
+            ).incomingMessage()
+        }
+    }
+    preferences {
+        input description: "After successful installation, please click B-button at the Fibaro Smoke Sensor to update device status and configuration",
+                title: "Instructions", displayDuringSetup: true, type: "paragraph", element: "paragraph"
+        input description: "Enter the menu by press and hold B-button for 3 seconds. Once indicator glows WHITE, release the B-button. Visual indicator will start changing colours in sequence. Press B-button briefly when visual indicator glows GREEN",
+                title: "To check smoke detection state", displayDuringSetup: true, type: "paragraph", element: "paragraph"
+        input description: "Please consult Fibaro Smoke Sensor operating manual for advanced setting options. You can skip this configuration to use default settings",
+                title: "Advanced Configuration", displayDuringSetup: true, type: "paragraph", element: "paragraph"
+        input "smokeSensorSensitivity", "enum", title: "Smoke Sensor Sensitivity", options: ["High","Medium","Low"], defaultValue: "${smokeSensorSensitivity}", displayDuringSetup: true
+        input "zwaveNotificationStatus", "enum", title: "Notifications Status", options: ["disabled","casing opened","exceeding temperature threshold", "lack of Z-Wave range", "all notifications"],
+                defaultValue: "${zwaveNotificationStatus}", displayDuringSetup: true
+        input "visualIndicatorNotificationStatus", "enum", title: "Visual Indicator Notifications Status",
+                options: ["disabled","casing opened","exceeding temperature threshold", "lack of Z-Wave range", "all notifications"],
+                defaultValue: "${visualIndicatorNotificationStatus}", displayDuringSetup: true
+        input "soundNotificationStatus", "enum", title: "Sound Notifications Status",
+                options: ["disabled","casing opened","exceeding temperature threshold", "lack of Z-Wave range", "all notifications"],
+                defaultValue: "${soundNotificationStatus}", displayDuringSetup: true
+        input "temperatureReportInterval", "enum", title: "Temperature Report Interval",
+                options: ["reports inactive", "5 minutes", "15 minutes", "30 minutes", "1 hour", "6 hours", "12 hours", "18 hours", "24 hours"], defaultValue: "${temperatureReportInterval}", displayDuringSetup: true
+        input "temperatureReportHysteresis", "number", title: "Temperature Report Hysteresis", description: "Available settings: 1-100 C", range: "1..100", displayDuringSetup: true
+        input "temperatureThreshold", "number", title: "Overheat Temperature Threshold", description: "Available settings: 0 or 2-100 C", range: "0..100", displayDuringSetup: true
+        input "excessTemperatureSignalingInterval", "enum", title: "Excess Temperature Signaling Interval",
+                options: ["5 minutes", "15 minutes", "30 minutes", "1 hour", "6 hours", "12 hours", "18 hours", "24 hours"], defaultValue: "${excessTemperatureSignalingInterval}", displayDuringSetup: true
+        input "lackOfZwaveRangeIndicationInterval", "enum", title: "Lack of Z-Wave Range Indication Interval",
+                options: ["5 minutes", "15 minutes", "30 minutes", "1 hour", "6 hours", "12 hours", "18 hours", "24 hours"], defaultValue: "${lackOfZwaveRangeIndicationInterval}", displayDuringSetup: true
+    }
+    tiles (scale: 2){
+        multiAttributeTile(name:"smoke", type: "lighting", width: 6, height: 4){
+            tileAttribute ("device.smoke", key: "PRIMARY_CONTROL") {
+                attributeState("clear", label:"CLEAR", icon:"st.alarm.smoke.clear", backgroundColor:"#ffffff")
+                attributeState("detected", label:"SMOKE", icon:"st.alarm.smoke.smoke", backgroundColor:"#e86d13")
+                attributeState("tested", label:"TEST", icon:"st.alarm.smoke.test", backgroundColor:"#e86d13")
+                attributeState("replacement required", label:"REPLACE", icon:"st.alarm.smoke.test", backgroundColor:"#FFFF66")
+                attributeState("unknown", label:"UNKNOWN", icon:"st.alarm.smoke.test", backgroundColor:"#ffffff")
+            }
+            tileAttribute ("device.battery", key: "SECONDARY_CONTROL") {
+                attributeState "battery", label:'Battery: ${currentValue}%', unit:"%"
+            }
+        }
+        valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "battery", label:'${currentValue}% battery', unit:"%"
+        }
+        valueTile("temperature", "device.temperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "temperature", label:'${currentValue}°', unit:"C"
+        }
+        valueTile("heatAlarm", "device.heatAlarm", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "clear", label:'TEMPERATURE OK', backgroundColor:"#ffffff"
+            state "overheat detected", label:'OVERHEAT DETECTED', backgroundColor:"#ffffff"
+            state "rapid temperature rise", label:'RAPID TEMP RISE', backgroundColor:"#ffffff"
+            state "underheat detected", label:'UNDERHEAT DETECTED', backgroundColor:"#ffffff"
+        }
+        valueTile("tamper", "device.tamper", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "clear", label:'NO TAMPER', backgroundColor:"#ffffff"
+            state "detected", label:'TAMPER DETECTED', backgroundColor:"#ffffff"
+        }
+
+        main "smoke"
+        details(["smoke","temperature"])
+    }
+}
+
+def updated() {
+    log.debug "Updated with settings: ${settings}"
+    setConfigured("false") //wait until the next time device wakeup to send configure command
+}
+
+def parse(String description) {
+    log.debug "parse() >> description: $description"
+    def result = null
+    if (description.startsWith("Err 106")) {
+        log.debug "parse() >> Err 106"
+        result = createEvent( name: "secureInclusion", value: "failed", isStateChange: true,
+                descriptionText: "This sensor failed to complete the network security key exchange. " +
+                        "If you are unable to control it via SmartThings, you must remove it from your network and add it again.")
+    } else if (description != "updated") {
+        log.debug "parse() >> zwave.parse(description)"
+        def cmd = zwave.parse(description, [0x31: 5, 0x71: 3, 0x84: 1])
+        if (cmd) {
+            result = zwaveEvent(cmd)
+        }
+    }
+    log.debug "After zwaveEvent(cmd) >> Parsed '${description}' to ${result.inspect()}"
+    return result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {
+    log.info "Executing zwaveEvent 86 (VersionV1): 12 (VersionReport) with cmd: $cmd"
+    def fw = "${cmd.applicationVersion}.${cmd.applicationSubVersion}"
+    updateDataValue("fw", fw)
+    def text = "$device.displayName: firmware version: $fw, Z-Wave version: ${cmd.zWaveProtocolVersion}.${cmd.zWaveProtocolSubVersion}"
+    createEvent(descriptionText: text, isStateChange: false)
+}
+
+
+def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
+    def map = [ name: "battery", unit: "%" ]
+    if (cmd.batteryLevel == 0xFF) {
+        map.value = 1
+        map.descriptionText = "${device.displayName} battery is low"
+        map.isStateChange = true
+    } else {
+        map.value = cmd.batteryLevel
+    }
+    setConfigured("true")  //when battery is reported back meaning configuration is done
+    //Store time of last battery update so we don't ask every wakeup, see WakeUpNotification handler
+    state.lastbatt = now()
+    createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.applicationstatusv1.ApplicationBusy cmd) {
+    def msg = cmd.status == 0 ? "try again later" :
+            cmd.status == 1 ? "try again in $cmd.waitTime seconds" :
+                    cmd.status == 2 ? "request queued" : "sorry"
+    createEvent(displayed: true, descriptionText: "$device.displayName is busy, $msg")
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.applicationstatusv1.ApplicationRejectedRequest cmd) {
+    createEvent(displayed: true, descriptionText: "$device.displayName rejected the last request")
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
+    setSecured()
+    def encapsulatedCommand = cmd.encapsulatedCommand([0x31: 5, 0x71: 3, 0x84: 1])
+    if (encapsulatedCommand) {
+        log.debug "command: 98 (Security) 81(SecurityMessageEncapsulation) encapsulatedCommand:  $encapsulatedCommand"
+        zwaveEvent(encapsulatedCommand)
+    } else {
+        log.warn "Unable to extract encapsulated cmd from $cmd"
+        createEvent(descriptionText: cmd.toString())
+    }
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityCommandsSupportedReport cmd) {
+    log.info "Executing zwaveEvent 98 (SecurityV1): 03 (SecurityCommandsSupportedReport) with cmd: $cmd"
+    setSecured()
+    log.info "checking this MSR : ${getDataValue("MSR")} before sending configuration to device"
+    if (getDataValue("MSR")?.startsWith("010F-0C02")){
+        response(configure()) //configure device using SmartThings default settings
+    }
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.securityv1.NetworkKeyVerify cmd) {
+    log.info "Executing zwaveEvent 98 (SecurityV1): 07 (NetworkKeyVerify) with cmd: $cmd (node is securely included)"
+    createEvent(name:"secureInclusion", value:"success", descriptionText:"Secure inclusion was successful", isStateChange: true, displayed: true)
+    //after device securely joined the network, call configure() to config device
+    setSecured()
+    log.info "checking this MSR : ${getDataValue("MSR")} before sending configuration to device"
+    if (getDataValue("MSR")?.startsWith("010F-0C02")){
+        response(configure()) //configure device using SmartThings default settings
+    }
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
+    log.info "Executing zwaveEvent 71 (NotificationV3): 05 (NotificationReport) with cmd: $cmd"
+    def result = []
+    if (cmd.notificationType == 7) {
+        switch (cmd.event) {
+            case 0:
+                result << createEvent(name: "tamper", value: "clear", displayed: false)
+                break
+            case 3:
+                result << createEvent(name: "tamper", value: "detected", descriptionText: "$device.displayName casing was opened")
+                break
+        }
+    } else if (cmd.notificationType == 1) { //Smoke Alarm (V2)
+        log.debug "notificationv3.NotificationReport: for Smoke Alarm (V2)"
+        result << smokeAlarmEvent(cmd.event)
+    }  else if (cmd.notificationType == 4) { // Heat Alarm (V2)
+        log.debug "notificationv3.NotificationReport: for Heat Alarm (V2)"
+        result << heatAlarmEvent(cmd.event)
+    } else {
+        log.warn "Need to handle this cmd.notificationType: ${cmd.notificationType}"
+        result << createEvent(descriptionText: cmd.toString(), isStateChange: false)
+    }
+    result
+}
+
+def smokeAlarmEvent(value) {
+    log.debug "smokeAlarmEvent(value): $value"
+    def map = [name: "smoke"]
+    if (value == 1 || value == 2) {
+        map.value = "detected"
+        map.descriptionText = "$device.displayName detected smoke"
+    } else if (value == 0) {
+        map.value = "clear"
+        map.descriptionText = "$device.displayName is clear (no smoke)"
+    } else if (value == 3) {
+        map.value = "tested"
+        map.descriptionText = "$device.displayName smoke alarm test"
+    } else if (value == 4) {
+        map.value = "replacement required"
+        map.descriptionText = "$device.displayName replacement required"
+    } else {
+        map.value = "unknown"
+        map.descriptionText = "$device.displayName unknown event"
+    }
+    createEvent(map)
+}
+
+def heatAlarmEvent(value) {
+    log.debug "heatAlarmEvent(value): $value"
+    def map = [name: "heatAlarm"]
+    if (value == 1 || value == 2) {
+        map.value = "overheat detected"
+        map.descriptionText = "$device.displayName overheat detected"
+    } else if (value == 0) {
+        map.value = "clear"
+        map.descriptionText = "$device.displayName heat alarm cleared (no overheat)"
+    } else if (value == 3 || value == 4) {
+        map.value = "rapid temperature rise"
+        map.descriptionText = "$device.displayName rapid temperature rise"
+    } else if (value == 5 || value == 6) {
+        map.value = "underheat detected"
+        map.descriptionText = "$device.displayName underheat detected"
+    } else {
+        map.value = "unknown"
+        map.descriptionText = "$device.displayName unknown event"
+    }
+    createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd) {
+    log.info "Executing zwaveEvent 84 (WakeUpV1): 07 (WakeUpNotification) with cmd: $cmd"
+    log.info "checking this MSR : ${getDataValue("MSR")} before sending configuration to device"
+    def result = [createEvent(descriptionText: "${device.displayName} woke up", isStateChange: false)]
+    def cmds = []
+    /* check MSR = "manufacturerId-productTypeId" to make sure configuration commands are sent to the right model */
+    if (!isConfigured() && getDataValue("MSR")?.startsWith("010F-0C02")) {
+        result << response(configure()) // configure a newly joined device or joined device with preference update
+    } else {
+        //Only ask for battery if we haven't had a BatteryReport in a while
+        if (!state.lastbatt || (new Date().time) - state.lastbatt > 24*60*60*1000) {
+            log.debug("Device has been configured sending >> batteryGet()")
+            cmds << zwave.securityV1.securityMessageEncapsulation().encapsulate(zwave.batteryV1.batteryGet()).format()
+            cmds << "delay 1200"
+        }
+        log.debug("Device has been configured sending >> wakeUpNoMoreInformation()")
+        cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
+        result << response(cmds) //tell device back to sleep
+    }
+    result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd) {
+    log.info "Executing zwaveEvent 31 (SensorMultilevelV5): 05 (SensorMultilevelReport) with cmd: $cmd"
+    def map = [:]
+    switch (cmd.sensorType) {
+        case 1:
+            map.name = "temperature"
+            def cmdScale = cmd.scale == 1 ? "F" : "C"
+            map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmdScale, cmd.precision)
+            map.unit = getTemperatureScale()
+            break
+        default:
+            map.descriptionText = cmd.toString()
+    }
+    createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLocallyNotification cmd) {
+    log.info "Executing zwaveEvent 5A (DeviceResetLocallyV1) : 01 (DeviceResetLocallyNotification) with cmd: $cmd"
+    createEvent(descriptionText: cmd.toString(), isStateChange: true, displayed: true)
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
+    log.info "Executing zwaveEvent 72 (ManufacturerSpecificV2) : 05 (ManufacturerSpecificReport) with cmd: $cmd"
+    log.debug "manufacturerId:   ${cmd.manufacturerId}"
+    log.debug "manufacturerName: ${cmd.manufacturerName}"
+    log.debug "productId:        ${cmd.productId}"
+    log.debug "productTypeId:    ${cmd.productTypeId}"
+    def result = []
+    def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
+    updateDataValue("MSR", msr)
+    log.debug "After device is securely joined, send commands to update tiles"
+    result << zwave.batteryV1.batteryGet()
+    result << zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 0x01)
+    result << zwave.wakeUpV1.wakeUpNoMoreInformation()
+    [[descriptionText:"${device.displayName} MSR report"], response(commands(result, 5000))]
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.associationv2.AssociationReport cmd) {
+    def result = []
+    if (cmd.nodeId.any { it == zwaveHubNodeId }) {
+        result << createEvent(descriptionText: "$device.displayName is associated in group ${cmd.groupingIdentifier}")
+    } else if (cmd.groupingIdentifier == 1) {
+        result << createEvent(descriptionText: "Associating $device.displayName in group ${cmd.groupingIdentifier}")
+        result << response(zwave.associationV1.associationSet(groupingIdentifier:cmd.groupingIdentifier, nodeId:zwaveHubNodeId))
+    }
+    result
+}
+
+def zwaveEvent(physicalgraph.zwave.Command cmd) {
+    log.warn "General zwaveEvent cmd: ${cmd}"
+    createEvent(descriptionText: cmd.toString(), isStateChange: false)
+}
+
+def configure() {
+// This sensor joins as a secure device if you tripple-click the button to include it
+    log.debug "configure() >> isSecured() : ${isSecured()}"
+    if (!isSecured()) {
+        log.debug "Fibaro smoke sensor not sending configure until secure"
+        return []
+    } else {
+        log.info "${device.displayName} is configuring its settings"
+        def request = []
+
+        //1. configure wakeup interval : available: 0, 4200s-65535s, device default 21600s(6hr)
+        request += zwave.wakeUpV1.wakeUpIntervalSet(seconds:6*3600, nodeid:zwaveHubNodeId)
+
+        //2. Smoke Sensitivity 3 levels: 1-HIGH , 2-MEDIUM (default), 3-LOW
+        if (smokeSensorSensitivity && smokeSensorSensitivity != "null") {
+            request += zwave.configurationV1.configurationSet(parameterNumber: 1, size: 1,
+                    scaledConfigurationValue:
+                            smokeSensorSensitivity == "High" ? 1 :
+                                    smokeSensorSensitivity == "Medium" ? 2 :
+                                            smokeSensorSensitivity == "Low" ? 3 : 2)
+        }
+        //3. Z-Wave notification status: 0-all disabled (default), 1-casing open enabled, 2-exceeding temp enable
+        if (zwaveNotificationStatus && zwaveNotificationStatus != "null"){
+            request += zwave.configurationV1.configurationSet(parameterNumber: 2, size: 1, scaledConfigurationValue: notificationOptionValueMap[zwaveNotificationStatus] ?: 0)
+        }
+        //4. Visual indicator notification status: 0-all disabled (default), 1-casing open enabled, 2-exceeding temp enable, 4-lack of range notification
+        if (visualIndicatorNotificationStatus && visualIndicatorNotificationStatus != "null") {
+            request += zwave.configurationV1.configurationSet(parameterNumber: 3, size: 1, scaledConfigurationValue: notificationOptionValueMap[visualIndicatorNotificationStatus] ?: 0)
+        }
+        //5. Sound notification status: 0-all disabled (default), 1-casing open enabled, 2-exceeding temp enable, 4-lack of range notification
+        if (soundNotificationStatus && soundNotificationStatus != "null") {
+            request += zwave.configurationV1.configurationSet(parameterNumber: 4, size: 1, scaledConfigurationValue: notificationOptionValueMap[soundNotificationStatus] ?: 0)
+        }
+        //6. Temperature report interval: 0-report inactive, 1-8640 (multiply by 10 secs) [10s-24hr], default 180 (30 minutes)
+        if (temperatureReportInterval && temperatureReportInterval != "null") {
+            request += zwave.configurationV1.configurationSet(parameterNumber: 20, size: 2, scaledConfigurationValue: timeOptionValueMap[temperatureReportInterval] ?: 180)
+        } else { //send SmartThings default configuration
+            request += zwave.configurationV1.configurationSet(parameterNumber: 20, size: 2, scaledConfigurationValue: 180)
+        }
+        //7. Temperature report hysteresis: 1-100 (in 0.1C step) [0.1C - 10C], default 10 (1 C)
+        if (temperatureReportHysteresis && temperatureReportHysteresis != null) {
+            request += zwave.configurationV1.configurationSet(parameterNumber: 21, size: 1, scaledConfigurationValue: temperatureReportHysteresis < 1 ? 1 : temperatureReportHysteresis > 100 ? 100 : temperatureReportHysteresis)
+        }
+        //8. Temperature threshold: 1-100 (C), default 55 (C)
+        if (temperatureThreshold && temperatureThreshold != null) {
+            request += zwave.configurationV1.configurationSet(parameterNumber: 30, size: 1, scaledConfigurationValue: temperatureThreshold < 1 ? 1 : temperatureThreshold > 100 ? 100 : temperatureThreshold)
+        }
+        //9. Excess temperature signaling interval: 1-8640 (multiply by 10 secs) [10s-24hr], default 180 (30 minutes)
+        if (excessTemperatureSignalingInterval && excessTemperatureSignalingInterval != "null") {
+            request += zwave.configurationV1.configurationSet(parameterNumber: 31, size: 2, scaledConfigurationValue: timeOptionValueMap[excessTemperatureSignalingInterval] ?: 180)
+        } else { //send SmartThings default configuration
+            request += zwave.configurationV1.configurationSet(parameterNumber: 31, size: 2, scaledConfigurationValue: 180)
+        }
+        //10. Lack of Z-Wave range indication interval: 1-8640 (multiply by 10 secs) [10s-24hr], default 2160 (6 hours)
+        if (lackOfZwaveRangeIndicationInterval && lackOfZwaveRangeIndicationInterval != "null") {
+            request += zwave.configurationV1.configurationSet(parameterNumber: 32, size: 2, scaledConfigurationValue: timeOptionValueMap[lackOfZwaveRangeIndicationInterval] ?: 2160)
+        } else {
+            request += zwave.configurationV1.configurationSet(parameterNumber: 32, size: 2, scaledConfigurationValue: 2160)
+        }
+        //11. get battery level when device is paired
+        request += zwave.batteryV1.batteryGet()
+
+        //12. get temperature reading from device
+        request += zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 0x01)
+
+        commands(request) + ["delay 10000", zwave.wakeUpV1.wakeUpNoMoreInformation().format()]
+    }
+}
+
+private def getTimeOptionValueMap() { [
+        "5 minutes"  : 30,
+        "15 minutes" : 90,
+        "30 minutes" : 180,
+        "1 hour"     : 360,
+        "6 hours"    : 2160,
+        "12 hours"   : 4320,
+        "18 hours"   : 6480,
+        "24 hours"   : 8640,
+        "reports inactive" : 0,
+]}
+
+private def getNotificationOptionValueMap() { [
+        "disabled" : 0,
+        "casing opened" : 1,
+        "exceeding temperature threshold" : 2,
+        "lack of Z-Wave range" : 4,
+        "all notifications" : 7,
+]}
+
+private command(physicalgraph.zwave.Command cmd) {
+    if (isSecured()) {
+        log.info "Sending secured command: ${cmd}"
+        zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
+    } else {
+        log.info "Sending unsecured command: ${cmd}"
+        cmd.format()
+    }
+}
+
+private commands(commands, delay=200) {
+    log.info "inside commands: ${commands}"
+    delayBetween(commands.collect{ command(it) }, delay)
+}
+
+private setConfigured(configure) {
+    updateDataValue("configured", configure)
+}
+private isConfigured() {
+    getDataValue("configured") == "true"
+}
+private setSecured() {
+    updateDataValue("secured", "true")
+}
+private isSecured() {
+    getDataValue("secured") == "true"
+}

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

@@ -36,155 +36,71 @@
  *				Slider range from 0..100
  *	Change 9:	2015-03-06	(Juan Risso)
  *				Setlevel -> value to integer (to prevent smartapp calling this function from not working).
+ *	Change 10: 	2016-03-06	(Vinay Rao/Tom Manley)
+ *				changed 2/3rds of the file to clean up code and add zigbee library improvements
  *
  */
 
 metadata {
-	definition (name: "GE Link Bulb", namespace: "smartthings", author: "SmartThings") {
+    definition (name: "GE Link Bulb", namespace: "smartthings", author: "SmartThings") {
 
-    	capability "Actuator"
+        capability "Actuator"
         capability "Configuration"
         capability "Refresh"
-		capability "Sensor"
+        capability "Sensor"
         capability "Switch"
-		capability "Switch Level"
+        capability "Switch Level"
         capability "Polling"
 
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0019"
-	}
+        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0019", manufacturer: "GE_Appliances", model: "ZLL Light", deviceJoinName: "GE Link Bulb"
+    }
 
 	// 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", nextState:"turningOff"
-			state "off", label: '${name}', action: "switch.on", icon: "st.switches.light.off", backgroundColor: "#ffffff", nextState:"turningOn"
- 			state "turningOn", label:'${name}', action: "switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
-            state "turningOff", label:'${name}', action: "switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-		controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 3, 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", "level", "levelSliderControl", "refresh"])
-	}
-
-	    preferences {
-
-        	input("dimRate", "enum", title: "Dim Rate", options: ["Instant", "Normal", "Slow", "Very Slow"], defaultValue: "Normal", required: false, displayDuringSetup: true)
-            input("dimOnOff", "enum", title: "Dim transition for On/Off commands?", options: ["Yes", "No"], defaultValue: "No", required: false, displayDuringSetup: true)
+    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 "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 "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
+            }
+            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+                attributeState "level", action:"switch level.setLevel"
+            }
+        }
+        standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+        main "switch"
+        details(["switch", "refresh"])
+    }
 
+    preferences {
+        input("dimRate", "enum", title: "Dim Rate", options: ["Instant", "Normal", "Slow", "Very Slow"], defaultValue: "Normal", required: false, displayDuringSetup: true)
+        input("dimOnOff", "enum", title: "Dim transition for On/Off commands?", options: ["Yes", "No"], defaultValue: "No", required: false, displayDuringSetup: true)
     }
 }
 
 // Parse incoming device messages to generate events
 def parse(String description) {
-	log.trace description
-
-    if (description?.startsWith("on/off:")) {
-		log.debug "The bulb was sent a command to do something just now..."
-		if (description[-1] == "1") {
-        	def result = createEvent(name: "switch", value: "on")
-            log.debug "On command was sent maybe from manually turning on? : Parse returned ${result?.descriptionText}"
-            return result
-        } else if (description[-1] == "0") {
-        	def result = createEvent(name: "switch", value: "off")
-            log.debug "Off command was sent : Parse returned ${result?.descriptionText}"
-            return result
+    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
+            sendEvent(resultMap)
         }
     }
-
-    def msg = zigbee.parse(description)
-
-	if (description?.startsWith("catchall:")) {
-		// log.trace msg
-		// log.trace "data: $msg.data"
-
-        def x = description[-4..-1]
-        // log.debug x
-
-        switch (x)
-        {
-
-        	case "0000":
-
-            	def result = createEvent(name: "switch", value: "off")
-            	log.debug "${result?.descriptionText}"
-           		return result
-                break
-
-            case "1000":
-
-            	def result = createEvent(name: "switch", value: "off")
-            	log.debug "${result?.descriptionText}"
-           		return result
-                break
-
-            case "0100":
-
-            	def result = createEvent(name: "switch", value: "on")
-            	log.debug "${result?.descriptionText}"
-           		return result
-                break
-
-            case "1001":
-
-            	def result = createEvent(name: "switch", value: "on")
-            	log.debug "${result?.descriptionText}"
-           		return result
-                break
-        }
+    else {
+        log.debug "DID NOT PARSE MESSAGE for description : $description"
+        log.debug zigbee.parseDescriptionAsMap(description)
     }
-
-    if (description?.startsWith("read attr")) {
-
-        // log.trace description[27..28]
-        // log.trace description[-2..-1]
-
-    	if (description[27..28] == "0A") {
-
-        	// log.debug description[-2..-1]
-        	def i = Math.round(convertHexToInt(description[-2..-1]) / 256 * 100 )
-			sendEvent( name: "level", value: i )
-        	sendEvent( name: "switch.setLevel", value: i) //added to help subscribers
-
-    	}
-
-    	else {
-
-    		if (description[-2..-1] == "00" && state.trigger == "setLevel") {
-        		// log.debug description[-2..-1]
-        		def i = Math.round(convertHexToInt(description[-2..-1]) / 256 * 100 )
-				sendEvent( name: "level", value: i )
-        		sendEvent( name: "switch.setLevel", value: i) //added to help subscribers
-        	}
-
-        	if (description[-2..-1] == state.lvl) {
-        		// log.debug description[-2..-1]
-        		def i = Math.round(convertHexToInt(description[-2..-1]) / 256 * 100 )
-				sendEvent( name: "level", value: i )
-        		sendEvent( name: "switch.setLevel", value: i) //added to help subscribers
-        	}
-
-    	}
-    }
-
 }
 
 def poll() {
-
-    [
-	"st rattr 0x${device.deviceNetworkId} 1 6 0", "delay 500",
-    "st rattr 0x${device.deviceNetworkId} 1 8 0", "delay 500",
-    "st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {${state?.dOnOff ?: '0000'}}"
+    def refreshCmds = [
+        "st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {${state?.dOnOff ?: '0000'}}", "delay 500"
     ]
 
+    return refreshCmds + zigbee.onOffRefresh() + zigbee.levelRefresh()
 }
 
 def updated() {
@@ -270,109 +186,63 @@ def updated() {
 }
 
 def on() {
-	state.lvl = "00"
     state.trigger = "on/off"
-
-    // log.debug "on()"
-	sendEvent(name: "switch", value: "on")
-	"st cmd 0x${device.deviceNetworkId} 1 6 1 {}"
+    zigbee.on()
 }
 
 def off() {
-	state.lvl = "00"
     state.trigger = "on/off"
-
-    // log.debug "off()"
-	sendEvent(name: "switch", value: "off")
-	"st cmd 0x${device.deviceNetworkId} 1 6 0 {}"
+    zigbee.off()
 }
 
 def refresh() {
-
-    [
-	"st rattr 0x${device.deviceNetworkId} 1 6 0", "delay 500",
-    "st rattr 0x${device.deviceNetworkId} 1 8 0", "delay 500",
-    "st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {${state?.dOnOff ?: '0000'}}"
+    def refreshCmds = [
+        "st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {${state?.dOnOff ?: '0000'}}", "delay 500"
     ]
-    poll()
 
+    return refreshCmds + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig()
 }
 
 def setLevel(value) {
-
-    def cmds = []
-	value = value as Integer
-	if (value == 0) {
-		sendEvent(name: "switch", value: "off")
-		cmds << "st cmd 0x${device.deviceNetworkId} 1 8 0 {0000 ${state.rate}}"
-	}
-	else if (device.latestValue("switch") == "off") {
-		sendEvent(name: "switch", value: "on")
-	}
-
-    sendEvent(name: "level", value: value)
-    value = (value * 255 / 100)
-    def level = hex(value);
-
     state.trigger = "setLevel"
-    state.lvl = "${level}"
-
+    def cmd
+    def delayForRefresh = 500
     if (dimRate && (state?.rate != null)) {
-    	cmds << "st cmd 0x${device.deviceNetworkId} 1 8 4 {${level} ${state.rate}}"
+        def computedRate = convertRateValue(state.rate)
+        cmd = zigbee.setLevel(value, computedRate)
+        delayForRefresh += computedRate * 100       //converting tenth of second to milliseconds
     }
     else {
-    	cmds << "st cmd 0x${device.deviceNetworkId} 1 8 4 {${level} 1500}"
+        cmd = zigbee.setLevel(value, 20)
+        delayForRefresh += 2000
     }
+    cmd + ["delay $delayForRefresh"] + zigbee.levelRefresh()
+}
 
-    log.debug cmds
-    cmds
+int convertRateValue(rate) {
+    int convertedRate = 0
+    switch (rate)
+    {
+        case "0000":
+            convertedRate = 0
+            break
+
+        case "1500":
+            convertedRate = 20      //0015 hex in int is 2.1
+            break
+
+        case "2500":
+            convertedRate = 35      //0025 hex in int is 3.7
+            break
+
+        case "3500":
+            convertedRate = 50      //0035 hex in int is 5.1
+            break
+    }
+    convertedRate
 }
 
 def configure() {
-
-	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} 1 1", "delay 1000",
-
-        //Level Control Reporting
-        "zcl global send-me-a-report 8 0 0x20 5 3600 {0010}", "delay 200",
-        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-
-        "zdo bind 0x${device.deviceNetworkId} 1 1 6 {${device.zigbeeId}} {}", "delay 1000",
-		"zdo bind 0x${device.deviceNetworkId} 1 1 8 {${device.zigbeeId}} {}", "delay 500",
-	]
-    return configCmds + refresh() // send refresh cmds as part of config
+    log.debug "Configuring Reporting and Bindings."
+    return zigbee.onOffConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
 }
-
-private hex(value, width=2) {
-	def s = new BigInteger(Math.round(value).toString()).toString(16)
-	while (s.size() < width) {
-		s = "0" + s
-	}
-	s
-}
-
-private Integer convertHexToInt(hex) {
-	Integer.parseInt(hex,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
-}

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

@@ -26,8 +26,6 @@ metadata {
 		capability "Actuator"
 		capability "Sensor"
 
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0B05,0702", outClusters: "000A,0019", manufacturer: "Jasco Products", model: "45852"
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0B05,0702", outClusters: "000A,0019", manufacturer: "Jasco Products", model: "45857"
 	}
 
 	// simulator metadata

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

@@ -26,8 +26,6 @@ metadata {
 		capability "Actuator"
 		capability "Sensor"
 
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B05,0702", outClusters: "0003, 000A,0019", manufacturer: "Jasco Products", model: "45853"
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B05,0702", outClusters: "000A,0019", manufacturer: "Jasco Products", model: "45856"
 	}
 
 	// simulator metadata

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

@@ -0,0 +1,126 @@
+/**
+ *  Copyright 2016 SmartThings
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ */
+metadata {
+    definition (name: "Gentle Wake Up Controller", namespace: "smartthings", author: "SmartThings") {
+        capability "Switch"
+        capability "Timed Session"
+
+        attribute "percentComplete", "number"
+
+        command "setPercentComplete", ["number"]
+    }
+
+    simulator {
+        // TODO: define status and reply messages here
+    }
+
+    tiles(scale: 2) {
+
+        multiAttributeTile(name: "richTile", type:"generic", width:6, height:4) {
+            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"
+            }
+            tileAttribute("timeRemaining", key: "SECONDARY_CONTROL") {
+                attributeState "timeRemaining", label:'${currentValue} remaining'
+            }
+            tileAttribute("percentComplete", key: "SLIDER_CONTROL") {
+                attributeState "percentComplete", action: "timed session.setTimeRemaining"
+            }
+        }
+
+        // start/stop
+        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"
+        }
+
+        // duration
+        valueTile("timeRemainingTile", "timeRemaining", decoration: "flat", width: 2) {
+            state "timeRemaining", label:'${currentValue} left'
+        }
+        controlTile("percentCompleteTile", "percentComplete", "slider", height: 1, width: 3) {
+            state "percentComplete", action: "timed session.setTimeRemaining"
+        }
+
+        main "sessionStatusTile"
+        details "richTile"
+//        details(["richTile", "sessionStatusTile", "timeRemainingTile", "percentCompleteTile"])
+    }
+}
+
+// parse events into attributes
+def parse(description) {
+    log.debug "Parsing '${description}'"
+    // TODO: handle 'switch' attribute
+    // TODO: handle 'level' attribute
+    // TODO: handle 'sessionStatus' attribute
+    // TODO: handle 'timeRemaining' attribute
+
+}
+
+// handle commands
+def on() {
+    log.debug "Executing 'on'"
+    startDimming()
+}
+
+def off() {
+    log.debug "Executing 'off'"
+    stopDimming()
+}
+
+def setTimeRemaining(percentComplete) {
+    log.debug "Executing 'setTimeRemaining' to ${percentComplete}% complete"
+    parent.jumpTo(percentComplete)
+}
+
+def start() {
+    log.debug "Executing 'start'"
+    startDimming()
+}
+
+def stop() {
+    log.debug "Executing 'stop'"
+    stopDimming()
+}
+
+def pause() {
+    log.debug "Executing 'pause'"
+    // TODO: handle 'pause' command
+}
+
+def cancel() {
+    log.debug "Executing 'cancel'"
+    stopDimming()
+}
+
+def startDimming() {
+    log.trace "startDimming"
+    log.debug "parent: ${parent}"
+    parent.start("controller")
+}
+
+def stopDimming() {
+    log.trace "stopDimming"
+    log.debug "parent: ${parent}"
+    parent.stop("controller")
+}
+
+def controllerEvent(eventData) {
+    log.trace "controllerEvent"
+    sendEvent(eventData)
+}

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

@@ -0,0 +1,81 @@
+/**
+ *  Logitech Harmony Activity
+ *
+ *  Copyright 2015 Juan Risso
+ *
+ *  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: "Harmony Activity", namespace: "smartthings", author: "Juan Risso") {
+        capability "Switch"
+        capability "Actuator"
+		capability "Refresh"
+
+        command "huboff"
+        command "alloff"
+        command "refresh"
+	}
+
+	// simulator metadata
+	simulator {
+	}
+
+	// UI tile definitions
+	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"
+		}
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
+			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+		standardTile("forceoff", "device.switch", inactiveLabel: false, decoration: "flat") {
+			state "default", label:'Force End', action:"switch.off", icon:"st.secondary.off"
+		}
+		standardTile("huboff", "device.switch", inactiveLabel: false, decoration: "flat") {
+			state "default", label:'End Hub Action', action:"huboff", icon:"st.harmony.harmony-hub-icon"
+		}
+		standardTile("alloff", "device.switch", inactiveLabel: false, decoration: "flat") {
+			state "default", label:'All Actions', action:"alloff", icon:"st.secondary.off"
+		}
+		main "button"
+		details(["button", "refresh", "forceoff", "huboff", "alloff"])
+	}
+}
+
+def parse(String description) {
+}
+
+def on() {
+	sendEvent(name: "switch", value: "on")
+    log.trace parent.activity(device.deviceNetworkId,"start")
+}
+
+def off() {
+	sendEvent(name: "switch", value: "off")
+    log.trace parent.activity(device.deviceNetworkId,"end")
+}
+
+def huboff() {
+	sendEvent(name: "switch", value: "off")
+    log.trace parent.activity(device.deviceNetworkId,"hub")
+}
+
+def alloff() {
+	sendEvent(name: "switch", value: "off")
+    log.trace parent.activity("all","end")
+}
+
+
+def refresh() {
+	log.debug "Executing 'refresh'"
+	log.trace parent.poll()
+}

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

@@ -80,19 +80,12 @@ def parse(String description) {
 	if (cmd) {
 		result = zwaveEvent(cmd)
 	}
-	// log.debug "Parsed ${description.inspect()} to ${result.inspect()}"
+	log.debug "Parsed ${description.inspect()} to ${result.inspect()}"
 	return result
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.multiinstancev1.MultiInstanceCmdEncap cmd) {
-	def encapsulated = null
-	if (cmd.respondsTo("encapsulatedCommand")) {
-		encapsulated = cmd.encapsulatedCommand()
-	} else {
-		def hex1 = { n -> String.format("%02X", n) }
-		def sorry = "command: ${hex1(cmd.commandClass)}${hex1(cmd.command)}, payload: " + cmd.parameter.collect{ hex1(it) }.join(" ")
-		encapsulated = zwave.parse(sorry, [0x31: 1, 0x84: 2, 0x60: 1, 0x85: 1, 0x70: 1])
-	}
+	def encapsulated = cmd.encapsulatedCommand([0x31: 1, 0x84: 2, 0x60: 1, 0x85: 1, 0x70: 1])
 	return encapsulated ? zwaveEvent(encapsulated) : null
 }
 

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

@@ -0,0 +1,227 @@
+/**
+ *  Hue Bloom
+ *
+ *  Philips Hue Type "Color Light"
+ *
+ *  Author: SmartThings
+ */
+
+// for the UI
+metadata {
+	// Automatically generated. Make future change here.
+	definition (name: "Hue Bloom", namespace: "smartthings", author: "SmartThings") {
+		capability "Switch Level"
+		capability "Actuator"
+		capability "Color Control"
+		capability "Switch"
+		capability "Refresh"
+		capability "Sensor"
+
+		command "setAdjustedColor"
+        command "reset"
+        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:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+				attributeState "level", action:"switch level.setLevel", 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"
+		}
+
+		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", "reset", "refresh"])
+	}
+}
+
+// parse events into attributes
+def parse(description) {
+	log.debug "parse() - $description"
+	def results = []
+
+	def map = description
+	if (description instanceof String)  {
+		log.debug "Hue 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)
+	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")
+    }
+}
+
+void setSaturation(percent) {
+    log.debug "Executing 'setSaturation'"
+    if (verifyPercent(percent)) {
+        parent.setSaturation(this, percent)
+        sendEvent(name: "saturation", value: percent, displayed: false)
+    }
+}
+
+void setHue(percent) {
+    log.debug "Executing 'setHue'"
+    if (verifyPercent(percent)) {
+        parent.setHue(this, percent)
+        sendEvent(name: "hue", value: percent, displayed: false)
+    }
+}
+
+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)
+    }
+}
+
+void reset() {
+    log.debug "Executing 'reset'"
+    def value = [level:100, saturation:56, hue:23]
+    setAdjustedColor(value)
+    parent.poll()
+}
+
+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)
+    } 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"
+    }
+}
+
+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
+}
+
+def verifyPercent(percent) {
+    if (percent == null)
+        return false
+    else if (percent >= 0 && percent <= 100) {
+        return true
+    } else {
+        log.warn "$percent is not 0-100"
+        return false
+    }
+}

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

@@ -17,16 +17,13 @@ metadata {
 
 	tiles(scale: 2) {
      	multiAttributeTile(name:"rich-control"){
-			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+			tileAttribute ("", key: "PRIMARY_CONTROL") {
 	            attributeState "default", label: "Hue Bridge", action: "", icon: "st.Lighting.light99-hue", backgroundColor: "#F3C200"
-			}    
+			}
 	        tileAttribute ("serialNumber", key: "SECONDARY_CONTROL") {
 	            attributeState "default", label:'SN: ${currentValue}'
-			}    
-        }    
-		standardTile("icon", "icon", width: 1, height: 1, canChangeIcon: false, inactiveLabel: true, canChangeBackground: false) {
-			state "default", label: "Hue Bridge", action: "", icon: "st.Lighting.light99-hue", backgroundColor: "#FFFFFF"
-		}
+			}
+        }
 		valueTile("serialNumber", "device.serialNumber", decoration: "flat", height: 1, width: 2, inactiveLabel: false) {
 			state "default", label:'SN: ${currentValue}'
 		}
@@ -34,7 +31,7 @@ metadata {
 			state "default", label:'${currentValue}', height: 1, width: 2, inactiveLabel: false
 		}
 
-		main (["icon"])
+		main (["rich-control"])
 		details(["rich-control", "networkAddress"])
 	}
 }
@@ -75,6 +72,7 @@ def parse(description) {
 				}
 				else if (contentType?.contains("xml")) {
 					log.debug "HUE BRIDGE ALREADY PRESENT"
+                    parent.hubVerification(device.hub.id, msg.body)
 				}
 			}
 		}

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

@@ -1,9 +1,11 @@
-
 /**
  *  Hue Bulb
  *
+ *  Philips Hue Type "Extended Color Light"
+ *
  *  Author: SmartThings
  */
+
 // for the UI
 metadata {
 	// Automatically generated. Make future change here.
@@ -11,13 +13,14 @@ metadata {
 		capability "Switch Level"
 		capability "Actuator"
 		capability "Color Control"
+		capability "Color Temperature"
 		capability "Switch"
 		capability "Refresh"
 		capability "Sensor"
 
 		command "setAdjustedColor"
-                command "reset"        
-                command "refresh"
+        command "reset"
+        command "refresh"
 	}
 
 	simulator {
@@ -25,7 +28,7 @@ metadata {
 	}
 
 	tiles (scale: 2){
-		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+		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:"#79b821", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
@@ -33,34 +36,48 @@ metadata {
 				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"
+				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", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+        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'
+        }
+
+		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"
 		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+
+		standardTile("refresh", "device.refresh", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
-	}
 
-	main(["switch"])
-	details(["switch", "levelSliderControl", "rgbSelector", "refresh", "reset"])
+		main(["rich-control"])
+		details(["rich-control", "colorTempSliderControl", "colorTemp", "reset", "refresh"])
+	}
 }
 
 // parse events into attributes
 def parse(description) {
 	log.debug "parse() - $description"
 	def results = []
+
 	def map = description
 	if (description instanceof String)  {
 		log.debug "Hue Bulb stringToMap - ${map}"
 		map = stringToMap(description)
 	}
+
 	if (map?.name && map?.value) {
 		results << createEvent(name: "${map?.name}", value: "${map?.value}")
 	}
@@ -68,17 +85,17 @@ def parse(description) {
 }
 
 // handle commands
-def on() {
+void on() {
 	log.trace parent.on(this)
 	sendEvent(name: "switch", value: "on")
 }
 
-def off() {
+void off() {
 	log.trace parent.off(this)
 	sendEvent(name: "switch", value: "off")
 }
 
-def nextLevel() {
+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
@@ -89,55 +106,105 @@ def nextLevel() {
 	setLevel(level)
 }
 
-def setLevel(percent) {
-	log.debug "Executing 'setLevel'"
-	parent.setLevel(this, percent)
-	sendEvent(name: "level", value: percent)
+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")
+    }
 }
 
-def setSaturation(percent) {
-	log.debug "Executing 'setSaturation'"
-	parent.setSaturation(this, percent)
-	sendEvent(name: "saturation", value: percent)
+void setSaturation(percent) {
+    log.debug "Executing 'setSaturation'"
+    if (verifyPercent(percent)) {
+        parent.setSaturation(this, percent)
+        sendEvent(name: "saturation", value: percent, displayed: false)
+    }
 }
 
-def setHue(percent) {
-	log.debug "Executing 'setHue'"
-	parent.setHue(this, percent)
-	sendEvent(name: "hue", value: percent)
+void setHue(percent) {
+    log.debug "Executing 'setHue'"
+    if (verifyPercent(percent)) {
+        parent.setHue(this, percent)
+        sendEvent(name: "hue", value: percent, displayed: false)
+    }
 }
 
-def setColor(value) {
-	log.debug "setColor: ${value}, $this"
-	parent.setColor(this, value)
-	if (value.hue) { sendEvent(name: "hue", value: value.hue)}
-	if (value.saturation) { sendEvent(name: "saturation", value: value.saturation)}
-	if (value.hex) { sendEvent(name: "color", value: value.hex)}
-	if (value.level) { sendEvent(name: "level", value: value.level)}
-	if (value.switch) { sendEvent(name: "switch", value: value.switch)}
+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)
+    }
 }
 
-def reset() {
-	log.debug "Executing 'reset'"
-    def value = [level:100, hex:"#90C638", saturation:56, hue:23]
+void reset() {
+    log.debug "Executing 'reset'"
+    def value = [level:100, saturation:56, hue:23]
     setAdjustedColor(value)
-	parent.poll()
+    parent.poll()
 }
 
-def setAdjustedColor(value) {
-	if (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 
+        adjusted.level = null
         setColor(adjusted)
+    } else {
+        log.warn "Invalid color input"
     }
 }
 
-def refresh() {
-	log.debug "Executing 'refresh'"
-	parent.manualRefresh()
+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"
+    }
+}
+
+void refresh() {
+    log.debug "Executing 'refresh'"
+    parent.manualRefresh()
 }
 
 def adjustOutgoingHue(percent) {
@@ -156,3 +223,14 @@ def adjustOutgoingHue(percent) {
 	log.info "percent: $percent, adjusted: $adjusted"
 	adjusted
 }
+
+def verifyPercent(percent) {
+    if (percent == null)
+        return false
+    else if (percent >= 0 && percent <= 100) {
+        return true
+    } else {
+        log.warn "$percent is not 0-100"
+        return false
+    }
+}

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

@@ -1,6 +1,8 @@
 /**
  *  Hue Lux Bulb
  *
+ *  Philips Hue Type "Dimmable Light"
+ *
  *  Author: SmartThings
  */
 // for the UI
@@ -12,14 +14,14 @@ metadata {
 		capability "Switch"
 		capability "Refresh"
 		capability "Sensor"
-       
-        command "refresh"       
+
+        command "refresh"
 	}
 
 	simulator {
 		// TODO: define status and reply messages here
 	}
-    
+
     tiles(scale: 2) {
         multiAttributeTile(name:"rich-control", type: "lighting", canChangeIcon: true){
             tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
@@ -35,25 +37,18 @@ metadata {
 	            attributeState "level", label: 'Level ${currentValue}%'
 			}
         }
-    
-		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", 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 "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-        }
-        
+
         controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false, range:"(0..100)") {
             state "level", action:"switch level.setLevel"
         }
-           
-        standardTile("refresh", "device.switch", inactiveLabel: false, height: 2, width: 2, decoration: "flat") {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }        
 
-        main(["switch"])
+        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+
+        main(["rich-control"])
         details(["rich-control", "refresh"])
-    }    
+    }
 }
 
 // parse events into attributes
@@ -74,23 +69,28 @@ def parse(description) {
 }
 
 // handle commands
-def on() {
-	parent.on(this)
+void on() {
+	log.trace parent.on(this)
 	sendEvent(name: "switch", value: "on")
 }
 
-def off() {
-	parent.off(this)
+void off() {
+	log.trace parent.off(this)
 	sendEvent(name: "switch", value: "off")
 }
 
-def setLevel(percent) {
+void setLevel(percent) {
 	log.debug "Executing 'setLevel'"
-	parent.setLevel(this, percent)
-	sendEvent(name: "level", value: percent)
+    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"
+    }
 }
 
-def refresh() {
+void refresh() {
 	log.debug "Executing 'refresh'"
 	parent.manualRefresh()
 }

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

@@ -17,44 +17,50 @@ metadata {
 	}
 
 	simulator {
-		// TODO: define status and reply messages here
+
 	}
 
-	tiles {
-		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "unreachable", label: "?", action:"refresh.refresh", icon:"st.switches.light.off", backgroundColor:"#666666"
-			state "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
-			state "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			state "turningOn", label:'Turning on', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
-			state "turningOff", label:'Turning off', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
+	tiles(scale: 2) {
+		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "unreachable", label: "?", action:"refresh.refresh", icon:"http://hosted.lifx.co/smartthings/v1/196xUnreachable.png", backgroundColor:"#666666"
+				attributeState "on", label:'${name}', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", icon:"http://hosted.lifx.co/smartthings/v1/196xOff.png", backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'Turning on', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'Turning off', action:"switch.on", icon:"http://hosted.lifx.co/smartthings/v1/196xOff.png", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+
+			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+				attributeState "level", action:"switch level.setLevel"
+			}
+
+			tileAttribute ("device.color", key: "COLOR_CONTROL") {
+				attributeState "color", action:"setColor"
+			}
+
+			tileAttribute ("device.model", key: "SECONDARY_CONTROL") {
+				attributeState "model", label: '${currentValue}'
+			}
 		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
+
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
 			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
+
 		valueTile("null", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:''
 		}
 
-		controlTile("rgbSelector", "device.color", "color", height: 3, width: 3, inactiveLabel: false) {
-			state "color", action:"setColor"
-		}
-
-		controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 3, inactiveLabel: false, range:"(0..100)") {
-			state "level", action:"switch level.setLevel"
-		}
-		valueTile("level", "device.level", inactiveLabel: false, icon: "st.illuminance.illuminance.light", decoration: "flat") {
-			state "level", label: '${currentValue}%'
-		}
-
-		controlTile("colorTempSliderControl", "device.colorTemperature", "slider", height: 1, width: 2, inactiveLabel: false, range:"(2700..9000)") {
+		controlTile("colorTempSliderControl", "device.colorTemperature", "slider", height: 2, width: 4, inactiveLabel: false, range:"(2700..9000)") {
 			state "colorTemp", action:"color temperature.setColorTemperature"
 		}
-		valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat") {
+
+		valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", height: 2, width: 2) {
 			state "colorTemp", label: '${currentValue}K'
 		}
 
-		main(["switch"])
-		details(["switch", "refresh", "level", "levelSliderControl", "rgbSelector", "colorTempSliderControl", "colorTemp"])
+		main "switch"
+		details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
 	}
 }
 
@@ -70,7 +76,7 @@ def parse(String description) {
 def setHue(percentage) {
 	log.debug "setHue ${percentage}"
 	parent.logErrors(logObject: log) {
-		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", [color: "hue:${percentage * 3.6}"])
+		def resp = parent.apiPUT("/lights/${selector()}/state", [color: "hue:${percentage * 3.6}", power: "on"])
 		if (resp.status < 300) {
 			sendEvent(name: "hue", value: percentage)
 			sendEvent(name: "switch", value: "on")
@@ -78,12 +84,13 @@ def setHue(percentage) {
 			log.error("Bad setHue result: [${resp.status}] ${resp.data}")
 		}
 	}
+	return []
 }
 
 def setSaturation(percentage) {
 	log.debug "setSaturation ${percentage}"
 	parent.logErrors(logObject: log) {
-		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", [color: "saturation:${percentage / 100}"])
+		def resp = parent.apiPUT("/lights/${selector()}/state", [color: "saturation:${percentage / 100}", power: "on"])
 		if (resp.status < 300) {
 			sendEvent(name: "saturation", value: percentage)
 			sendEvent(name: "switch", value: "on")
@@ -91,6 +98,7 @@ def setSaturation(percentage) {
 			log.error("Bad setSaturation result: [${resp.status}] ${resp.data}")
 		}
 	}
+	return []
 }
 
 def setColor(Map color) {
@@ -114,15 +122,17 @@ def setColor(Map color) {
 		}
 	}
 	parent.logErrors(logObject:log) {
-		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", [color: attrs.join(" ")])
+		def resp = parent.apiPUT("/lights/${selector()}/state", [color: attrs.join(" "), power: "on"])
 		if (resp.status < 300) {
-			sendEvent(name: "color", value: color.hex)
+			if (color.hex)
+				sendEvent(name: "color", value: color.hex)
 			sendEvent(name: "switch", value: "on")
 			events.each { sendEvent(it) }
 		} else {
 			log.error("Bad setColor result: [${resp.status}] ${resp.data}")
 		}
 	}
+	return []
 }
 
 def setLevel(percentage) {
@@ -135,20 +145,22 @@ def setLevel(percentage) {
 		return off() // if the brightness is set to 0, just turn it off
 	}
 	parent.logErrors(logObject:log) {
-		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", ["color": "brightness:${percentage / 100}"])
+		def resp = parent.apiPUT("/lights/${selector()}/state", ["brightness": percentage / 100, "power": "on"])
 		if (resp.status < 300) {
 			sendEvent(name: "level", value: percentage)
+			sendEvent(name: "switch.setLevel", value: percentage)
 			sendEvent(name: "switch", value: "on")
 		} else {
 			log.error("Bad setLevel result: [${resp.status}] ${resp.data}")
 		}
 	}
+	return []
 }
 
 def setColorTemperature(kelvin) {
 	log.debug "Executing 'setColorTemperature' to ${kelvin}"
 	parent.logErrors() {
-		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", [color: "kelvin:${kelvin}"])
+		def resp = parent.apiPUT("/lights/${selector()}/state", [color: "kelvin:${kelvin}", power: "on"])
 		if (resp.status < 300) {
 			sendEvent(name: "colorTemperature", value: kelvin)
 			sendEvent(name: "color", value: "#ffffff")
@@ -158,41 +170,51 @@ def setColorTemperature(kelvin) {
 		}
 
 	}
+	return []
 }
 
 def on() {
 	log.debug "Device setOn"
 	parent.logErrors() {
-		if (parent.apiPUT("/lights/${device.deviceNetworkId}/power", [state: "on"]) != null) {
+		if (parent.apiPUT("/lights/${selector()}/state", [power: "on"]) != null) {
 			sendEvent(name: "switch", value: "on")
 		}
 	}
+	return []
 }
 
 def off() {
 	log.debug "Device setOff"
 	parent.logErrors() {
-		if (parent.apiPUT("/lights/${device.deviceNetworkId}/power", [state: "off"]) != null) {
+		if (parent.apiPUT("/lights/${selector()}/state", [power: "off"]) != null) {
 			sendEvent(name: "switch", value: "off")
 		}
 	}
+	return []
 }
 
 def poll() {
 	log.debug "Executing 'poll' for ${device} ${this} ${device.deviceNetworkId}"
-	def resp = parent.apiGET("/lights/${device.deviceNetworkId}")
-	if (resp.status != 200) {
+	def resp = parent.apiGET("/lights/${selector()}")
+	if (resp.status == 404) {
+		sendEvent(name: "switch", value: "unreachable")
+		return []
+	} else if (resp.status != 200) {
 		log.error("Unexpected result in poll(): [${resp.status}] ${resp.data}")
 		return []
 	}
-	def data = resp.data
+	def data = resp.data[0]
+	log.debug("Data: ${data}")
 
-	sendEvent(name: "level", value: sprintf("%.1f", (data.brightness ?: 1) * 100))
+	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: "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: "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}")
 
 	return []
 }
@@ -201,3 +223,11 @@ def refresh() {
 	log.debug "Executing 'refresh'"
 	poll()
 }
+
+def selector() {
+	if (device.deviceNetworkId.contains(":")) {
+		return device.deviceNetworkId
+	} else {
+		return "id:${device.deviceNetworkId}"
+	}
+}

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

@@ -16,41 +16,44 @@ metadata {
 	}
 
 	simulator {
-		// TODO: define status and reply messages here
+
 	}
 
-	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", nextState:"turningOff"
-			state "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			state "turningOn", label:'Turning on', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
-			state "turningOff", label:'Turning off', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			state "unreachable", label: "?", action:"refresh.refresh", icon:"st.switches.light.off", backgroundColor:"#666666"
+	tiles(scale: 2) {
+		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "unreachable", label: "?", action:"refresh.refresh", icon:"http://hosted.lifx.co/smartthings/v1/196xUnreachable.png", backgroundColor:"#666666"
+				attributeState "on", label:'${name}', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", icon:"http://hosted.lifx.co/smartthings/v1/196xOff.png", backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'Turning on', action:"switch.off", icon:"http://hosted.lifx.co/smartthings/v1/196xOn.png", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'Turning off', action:"switch.on", icon:"http://hosted.lifx.co/smartthings/v1/196xOff.png", backgroundColor:"#ffffff", nextState:"turningOn"
+
+			}
+			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+				attributeState "level", action:"switch level.setLevel"
+			}
 		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
+
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
 			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
+
 		valueTile("null", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:''
 		}
 
-		controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 3, inactiveLabel: false, range:"(0..100)") {
-			state "level", action:"switch level.setLevel"
-		}
-		valueTile("level", "device.level", inactiveLabel: false, icon: "st.illuminance.illuminance.light", decoration: "flat") {
-			state "level", label: '${currentValue}%'
-		}
-
-		controlTile("colorTempSliderControl", "device.colorTemperature", "slider", height: 1, width: 2, inactiveLabel: false, range:"(2700..6500)") {
+		controlTile("colorTempSliderControl", "device.colorTemperature", "slider", height: 2, width: 4, inactiveLabel: false, range:"(2700..9000)") {
 			state "colorTemp", action:"color temperature.setColorTemperature"
 		}
-		valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat") {
+
+		valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", height: 2, width: 2) {
 			state "colorTemp", label: '${currentValue}K'
 		}
 
-		main(["switch"])
-		details(["switch", "refresh", "level", "levelSliderControl", "colorTempSliderControl", "colorTemp"])
+		main "switch"
+		details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
 	}
+
 }
 
 // parse events into attributes
@@ -72,20 +75,22 @@ def setLevel(percentage) {
 		return off() // if the brightness is set to 0, just turn it off
 	}
 	parent.logErrors(logObject:log) {
-		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", ["color": "brightness:${percentage / 100}"])
+		def resp = parent.apiPUT("/lights/${selector()}/state", [brightness: percentage / 100, power: "on"])
 		if (resp.status < 300) {
 			sendEvent(name: "level", value: percentage)
+			sendEvent(name: "switch.setLevel", value: percentage)
 			sendEvent(name: "switch", value: "on")
 		} else {
 			log.error("Bad setLevel result: [${resp.status}] ${resp.data}")
 		}
 	}
+	return []
 }
 
 def setColorTemperature(kelvin) {
 	log.debug "Executing 'setColorTemperature' to ${kelvin}"
 	parent.logErrors() {
-		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", [color: "kelvin:${kelvin}"])
+		def resp = parent.apiPUT("/lights/${selector()}/state", [color: "kelvin:${kelvin}", power: "on"])
 		if (resp.status < 300) {
 			sendEvent(name: "colorTemperature", value: kelvin)
 			sendEvent(name: "color", value: "#ffffff")
@@ -95,38 +100,47 @@ def setColorTemperature(kelvin) {
 			log.error("Bad setColorTemperature result: [${resp.status}] ${resp.data}")
 		}
 	}
+	return []
 }
 
 def on() {
 	log.debug "Device setOn"
 	parent.logErrors() {
-		if (parent.apiPUT("/lights/${device.deviceNetworkId}/power", [state: "on"]) != null) {
+		if (parent.apiPUT("/lights/${selector()}/state", [power: "on"]) != null) {
 			sendEvent(name: "switch", value: "on")
 		}
 	}
+	return []
 }
 
 def off() {
 	log.debug "Device setOff"
 	parent.logErrors() {
-		if (parent.apiPUT("/lights/${device.deviceNetworkId}/power", [state: "off"]) != null) {
+		if (parent.apiPUT("/lights/${selector()}/state", [power: "off"]) != null) {
 			sendEvent(name: "switch", value: "off")
 		}
 	}
+	return []
 }
 
 def poll() {
 	log.debug "Executing 'poll' for ${device} ${this} ${device.deviceNetworkId}"
-	def resp = parent.apiGET("/lights/${device.deviceNetworkId}")
-	if (resp.status != 200) {
+	def resp = parent.apiGET("/lights/${selector()}")
+	if (resp.status == 404) {
+		sendEvent(name: "switch", value: "unreachable")
+		return []
+	} else if (resp.status != 200) {
 		log.error("Unexpected result in poll(): [${resp.status}] ${resp.data}")
 		return []
 	}
-	def data = resp.data
+	def data = resp.data[0]
 
-	sendEvent(name: "level", value: sprintf("%f", (data.brightness ?: 1) * 100))
+	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: "colorTemperature", value: data.color.kelvin)
+	sendEvent(name: "model", value: data.product.name)
 
 	return []
 }
@@ -135,3 +149,11 @@ def refresh() {
 	log.debug "Executing 'refresh'"
 	poll()
 }
+
+def selector() {
+	if (device.deviceNetworkId.contains(":")) {
+		return device.deviceNetworkId
+	} else {
+		return "id:${device.deviceNetworkId}"
+	}
+}

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

@@ -0,0 +1,32 @@
+#==============================================================================
+#  Copyright 2016 SmartThings
+#
+#  Licensed under the Apache License, Version 2.0 (the "License"); you may not 
+#  use this file except in compliance with the License. You may obtain a copy 
+#  of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software 
+#  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 
+#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
+#  License for the specific language governing permissions and limitations 
+#  under the License.
+#==============================================================================
+# 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=기기 이름 설정
+'''Set Device Image'''.ko=기기 이미지 설정
+# Events / Notifications
+'''{{ linkText }} has left'''.ko={{ linkText }} 외출
+'''{{ linkText }} has arrived'''.ko={{ linkText }} 귀가
+'''present'''.ko=집안
+'''not present'''.ko=외출

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

@@ -1,16 +1,28 @@
-/**
- *  Copyright 2015 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:
+ *  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.
+ *  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: Mobile Presence DTH File
  *
+ *  Filename: mobile-presence.src/mobile-presence.groovy
+ *
+ *  Change History:
+ *  1. 20160205 TW - Update/Edit to support i18n translations
+===============================================================================
  */
+ 
 metadata {
 	definition (name: "Mobile Presence", namespace: "smartthings", author: "SmartThings") {
 		capability "Presence Sensor"
@@ -25,7 +37,7 @@ 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:"#ffffff")
+			state("not present", labelIcon:"st.presence.tile.mobile-not-present", backgroundColor:"#ebeef2")
 		}
 		main "presence"
 		details "presence"
@@ -41,6 +53,7 @@ def parse(String description) {
 	def isStateChange = isStateChange(device, name, value)
 
 	def results = [
+    	translatable: true,
 		name: name,
 		value: value,
 		unit: null,
@@ -72,8 +85,8 @@ private String parseValue(String description) {
 
 private parseDescriptionText(String linkText, String value, String description) {
 	switch(value) {
-		case "present": return "$linkText has arrived"
-		case "not present": return "$linkText has left"
+		case "present": return "{{ linkText }} has arrived"
+		case "not present": return "{{ linkText }} has left"
 		default: return value
 	}
 }
@@ -84,4 +97,4 @@ private getState(String value) {
 		case "not present": return "left"
 		default: return value
 	}
-}
+}

devicetypes/smartthings/osram-lightify-led-flexible-strip-rgbw.src/osram-lightify-led-flexible-strip-rgbw.groovy

@@ -4,6 +4,7 @@
     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
 */
+//DEPRECATED - Using the generic DTH for this device. Users need to be moved before deleting this DTH
 
 metadata {
 	definition (name: "OSRAM LIGHTIFY LED Flexible Strip RGBW", namespace: "smartthings", author: "SmartThings") {
@@ -23,8 +24,8 @@ metadata {
         command "setAdjustedColor"
 
 
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY Flex RGBW"
-        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Flex RGBW"
+		//fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY Flex RGBW"
+        //fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Flex RGBW"
 
     }
 

devicetypes/smartthings/osram-lightify-led-tunable-white-60w.src/osram-lightify-led-tunable-white-60w.groovy

@@ -5,6 +5,8 @@
     that issue by using state variables
 */
 
+//DEPRECATED - Using the generic DTH for this device. Users need to be moved before deleting this DTH
+
 metadata {
     definition (name: "OSRAM LIGHTIFY LED Tunable White 60W", namespace: "smartthings", author: "SmartThings") {
 
@@ -20,10 +22,7 @@ metadata {
 
         // indicates that device keeps track of heartbeat (in state.heartbeat)
         attribute "heartbeat", "string"
-
-
-        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Classic A60 TW"
-        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY A19 Tunable White"
+        
 
     }
 

devicetypes/smartthings/samsung-smart-tv.src/samsung-smart-tv.groovy

@@ -1,235 +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.
- *
- *  Samsung TV
- *
- *  Author: SmartThings (juano23@gmail.com)
- *  Date: 2015-01-08
- */
- 
-metadata {
-	definition (name: "Samsung Smart TV", namespace: "smartthings", author: "SmartThings") {
-    		capability "switch" 
-            
-			command "mute" 
-			command "source"
-			command "menu"    
-            command "tools"           
-			command "HDMI"    
-            command "Sleep"
-            command "Up"
-            command "Down"
-            command "Left"
-            command "Right" 
-			command "chup" 
- 			command "chdown"               
-			command "prech"
-			command "volup"    
-            command "voldown"           
-            command "Enter"
-            command "Return"
-            command "Exit"
-            command "Info"            
-            command "Size"
-	}
-
-    standardTile("switch", "device.switch", width: 1, height: 1, canChangeIcon: true) {
-        state "default", label:'TV', action:"switch.off", icon:"st.Electronics.electronics15", backgroundColor:"#ffffff"
-    }
-    standardTile("power", "device.switch", width: 1, height: 1, canChangeIcon: false) {
-        state "default", label:'', action:"switch.off", decoration: "flat", icon:"st.thermostat.heating-cooling-off", backgroundColor:"#ffffff"
-    }    
-    standardTile("mute", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Mute', action:"mute", icon:"st.custom.sonos.muted", backgroundColor:"#ffffff"
-    }    
-	standardTile("source", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Source', action:"source", icon:"st.Electronics.electronics15"
-    }
-	standardTile("tools", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Tools', action:"tools", icon:"st.secondary.tools"
-    }
-	standardTile("menu", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Menu', action:"menu", icon:"st.vents.vent"
-    }
-	standardTile("HDMI", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Source', action:"HDMI", icon:"st.Electronics.electronics15"
-    }
-    standardTile("Sleep", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Sleep', action:"Sleep", icon:"st.Bedroom.bedroom10"
-    }
-    standardTile("Up", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Up', action:"Up", icon:"st.thermostat.thermostat-up"
-    }
-    standardTile("Down", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Down', action:"Down", icon:"st.thermostat.thermostat-down"
-    }
-    standardTile("Left", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Left', action:"Left", icon:"st.thermostat.thermostat-left"
-    }
-    standardTile("Right", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Right', action:"Right", icon:"st.thermostat.thermostat-right"
-    }  
-	standardTile("chup", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'CH Up', action:"chup", icon:"st.thermostat.thermostat-up"
-    }
-	standardTile("chdown", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'CH Down', action:"chdown", icon:"st.thermostat.thermostat-down"
-    }
-	standardTile("prech", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Pre CH', action:"prech", icon:"st.secondary.refresh-icon"
-    }
-    standardTile("volup", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Vol Up', action:"volup", icon:"st.thermostat.thermostat-up"
-    }
-    standardTile("voldown", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Vol Down', action:"voldown", icon:"st.thermostat.thermostat-down"
-    }
-    standardTile("Enter", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Enter', action:"Enter", icon:"st.illuminance.illuminance.dark"
-    }
-    standardTile("Return", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Return', action:"Return", icon:"st.secondary.refresh-icon"
-    }
-    standardTile("Exit", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Exit', action:"Exit", icon:"st.locks.lock.unlocked"
-    }    
-    standardTile("Info", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Info', action:"Info", icon:"st.motion.acceleration.active"
-    }    
-    standardTile("Size", "device.switch", decoration: "flat", canChangeIcon: false) {
-        state "default", label:'Picture Size', action:"Size", icon:"st.contact.contact.open"
-    }      
-    main "switch"
-    details (["power","HDMI","Sleep","chup","prech","volup","chdown","mute","voldown", "menu", "Up", "tools", "Left", "Enter", "Right", "Return", "Down", "Exit", "Info","Size"])	
-}
-
-def parse(String description) {
-	return null
-}
-
-def off() {
-	log.debug "Turning TV OFF"
-    parent.tvAction("POWEROFF",device.deviceNetworkId) 
-    sendEvent(name:"Command", value: "Power Off", displayed: true) 
-}
-
-def mute() {
-	log.trace "MUTE pressed"
-    parent.tvAction("MUTE",device.deviceNetworkId) 
-    sendEvent(name:"Command", value: "Mute", displayed: true) 
-}
-
-def source() {
-	log.debug "SOURCE pressed"
-    parent.tvAction("SOURCE",device.deviceNetworkId) 
-    sendEvent(name:"Command", value: "Source", displayed: true) 
-}
-
-def menu() {
-	log.debug "MENU pressed"
-    parent.tvAction("MENU",device.deviceNetworkId) 
-}
-
-def tools() {
-	log.debug "TOOLS pressed"
-    parent.tvAction("TOOLS",device.deviceNetworkId) 
-    sendEvent(name:"Command", value: "Tools", displayed: true)     
-}
-
-def HDMI() {
-	log.debug "HDMI pressed"
-    parent.tvAction("HDMI",device.deviceNetworkId) 
-    sendEvent(name:"Command sent", value: "Source", displayed: true)
-}
-
-def Sleep() {
-	log.debug "SLEEP pressed"
-    parent.tvAction("SLEEP",device.deviceNetworkId) 
-    sendEvent(name:"Command", value: "Sleep", displayed: true)
-}
-
-def Up() {
-	log.debug "UP pressed"
-    parent.tvAction("UP",device.deviceNetworkId)
-}
-
-def Down() {
-	log.debug "DOWN pressed"
-    parent.tvAction("DOWN",device.deviceNetworkId) 
-}
-
-def Left() {
-	log.debug "LEFT pressed"
-    parent.tvAction("LEFT",device.deviceNetworkId) 
-}
-
-def Right() {
-	log.debug "RIGHT pressed"
-    parent.tvAction("RIGHT",device.deviceNetworkId) 
-}
-
-def chup() {
-	log.debug "CHUP pressed"
-    parent.tvAction("CHUP",device.deviceNetworkId)
-    sendEvent(name:"Command", value: "Channel Up", displayed: true)         
-}
-
-def chdown() {
-	log.debug "CHDOWN pressed"
-    parent.tvAction("CHDOWN",device.deviceNetworkId) 
-    sendEvent(name:"Command", value: "Channel Down", displayed: true)     
-}
-
-def prech() {
-	log.debug "PRECH pressed"
-    parent.tvAction("PRECH",device.deviceNetworkId)
-    sendEvent(name:"Command", value: "Prev Channel", displayed: true)       
-}
-
-def Exit() {
-	log.debug "EXIT pressed"
-    parent.tvAction("EXIT",device.deviceNetworkId) 
-}
-
-def volup() {
-	log.debug "VOLUP pressed"
-    parent.tvAction("VOLUP",device.deviceNetworkId)
-    sendEvent(name:"Command", value: "Volume Up", displayed: true)         
-}
-
-def voldown() {
-	log.debug "VOLDOWN pressed"
-    parent.tvAction("VOLDOWN",device.deviceNetworkId) 
-    sendEvent(name:"Command", value: "Volume Down", displayed: true)         
-}
-
-def Enter() {
-	log.debug "ENTER pressed"
-    parent.tvAction("ENTER",device.deviceNetworkId) 
-}
-
-def Return() {
-	log.debug "RETURN pressed"
-    parent.tvAction("RETURN",device.deviceNetworkId) 
-}
-
-def Info() {
-	log.debug "INFO pressed"
-    parent.tvAction("INFO",device.deviceNetworkId) 
-	sendEvent(name:"Command", value: "Info", displayed: true)    
-}
-
-def Size() {
-	log.debug "PICTURE_SIZE pressed"
-    parent.tvAction("PICTURE_SIZE",device.deviceNetworkId) 
-    sendEvent(name:"Command", value: "Picture Size", displayed: true)
-}

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

@@ -5,7 +5,7 @@ metadata {
 		capability "Switch"
 		capability "Sensor"
 
-		fingerprint profileId: "0104", inClusters: "0000,0003,0006", outClusters: "0019"
+		fingerprint profileId: "0104", inClusters: "0006, 0004, 0003, 0000, 0005", outClusters: "0019", manufacturer: "Compacta International, Ltd", model: "ZBMPlug15", deviceJoinName: "SmartPower Outlet V1"
 	}
 
 	// simulator metadata

devicetypes/smartthings/smartpower-outlet.src/i18n/messages.properties

@@ -0,0 +1,35 @@
+#==============================================================================
+#  Copyright 2016 SmartThings
+#
+#  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+#  use this file except in compliance with the License. You may obtain a copy
+#  of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#  License for the specific language governing permissions and limitations
+#  under the License.
+#==============================================================================
+# Purpose: SmartPower Outlet i18n Translation File
+#
+# Filename: SmartPower-Outlet.src/i18n/messages.properties
+#
+# Change History:
+#	1. 20160116 TW Initial release with informal Korean translation.
+#==============================================================================
+# Korean (ko)
+# Device Preferences
+'''Give your device a name'''.ko=기기 이름 설정
+'''Outlet'''.ko= 스마트 플러그 
+# Events descriptionText
+'''{{ device.displayName }} is On'''.ko={{ device.displayName }} 켜짐
+'''{{ device.displayName }} is Off'''.ko={{ device.displayName }} 꺼짐
+'''{{ device.displayName }} power is {{ value }} Watts'''.ko={{ device.displayName }} 전력은 {{ value }}와트입니다.
+'''On'''.ko= 켜짐
+'''Off'''.ko=꺼짐
+'''Turning On'''.ko=켜는 중
+'''Turning Off'''.ko=끄는 중
+#==============================================================================

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

@@ -1,19 +1,26 @@
-/**
- *  Copyright 2015 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:
+ *  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.
+ *  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: SmartPower Outlet DTH File
  *
- *	SmartPower Outlet (CentraLite)
+ *  Filename: SmartPower-Outlet.src/SmartPower-Outlet.groovy
  *
- *	Author: SmartThings
- *	Date: 2015-08-23
+ *  Change History:
+ *  1. 20160117 TW - Update/Edit to support i18n translations
+===============================================================================
  */
 metadata {
 	// Automatically generated. Make future change here.
@@ -58,10 +65,10 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821", nextState: "turningOff"
-				attributeState "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "turningOn"
-				attributeState "turningOn", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821", nextState: "turningOff"
-				attributeState "turningOff", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "turningOn"
+				attributeState "on", label: 'On', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821", nextState: "turningOff"
+				attributeState "off", label: 'Off', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "turningOn"
+				attributeState "turningOn", label: 'Turning On', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821", nextState: "turningOff"
+				attributeState "turningOff", label: 'Turning Off', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "turningOn"
 			}
 			tileAttribute ("power", key: "SECONDARY_CONTROL") {
 				attributeState "power", label:'${currentValue} W'
@@ -91,22 +98,22 @@ def parse(String description) {
 		finalResult = getPowerDescription(zigbee.parseDescriptionAsMap(description))
 
 	if (finalResult) {
-		log.info finalResult
+		log.info "final result = $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)
+			sendEvent(name: "power", value: powerValue, descriptionText: '{{ device.displayName }} power is {{ value }} Watts', translatable: true )
 			/*
 				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)
+			def descriptionText = finalResult.value == "on" ? '{{ device.displayName }} is On' : '{{ device.displayName }} is Off'
+			sendEvent(name: finalResult.type, value: finalResult.value, descriptionText: descriptionText, translatable: true)
 		}
 	}
 	else {

devicetypes/smartthings/smartsense-garage-door-multi.src/smartsense-garage-door-multi.groovy

@@ -79,8 +79,8 @@ metadata {
 	}
     
 	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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+		input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 	}    
 }
 

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

@@ -88,8 +88,8 @@ metadata {
 	}
 
 	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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+		input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 	}
 }
 

devicetypes/smartthings/smartsense-moisture-sensor.src/i18n/messages.properties

@@ -0,0 +1,44 @@
+#==============================================================================
+#  Copyright 2016 SmartThings
+#
+#  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+#  use this file except in compliance with the License. You may obtain a copy
+#  of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#  License for the specific language governing permissions and limitations
+#  under the License.
+#==============================================================================
+# Purpose: SmartSense Moisture Sensor i18n Translation File
+#
+# Filename: SmartSense-Moisture-Sensor.src/i18n/messages.properties
+#
+# Change History:
+#	1. 20160116 TW Initial release with formal Korean translation.
+#==============================================================================
+# Korean (ko)
+# Device Preferences
+'''Dry'''.ko=건조
+'''Wet'''.ko=누수
+'''dry'''.ko=건조
+'''wet'''.ko=누수
+'''battery'''.ko=배터리
+'''Temperature Offset'''.ko=온도 직접 설정
+'''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'.'''.ko=기준 온도를 원하는대로 몇 도 올리거나 내려서 설정할 수 있습니다.
+'''Degrees'''.ko=온도
+'''Adjust temperature by this many degrees'''.ko=몇 도씩 온도를 조절하십시오
+'''Give your device a name'''.ko=기기 이름 설정
+'''Water Leak Sensor'''.ko=누수감지 센서
+'''${currentValue}% battery'''.ko=${currentValue}% 배터리
+# Events descriptionText
+'''{{ device.displayName }} is dry'''.ko={{ device.displayName }}가 건조
+'''{{ device.displayName }} is wet'''.ko={{ device.displayName }}누수
+'''{{ device.displayName }} was {{ value }}°C'''.ko={{ device.displayName }}에서 {{ value }}°C 감지
+'''{{ device.displayName }} was {{ value }}°F'''.ko={{ device.displayName }}이(가) {{ value }}°F였습니다
+'''{{ device.displayName }} battery has too much power: (> 3.5) volts.'''.ko={{ device.displayName }} 배터리 전력이 너무 높습니다(3.5볼트 초과).
+'''{{ device.displayName }} battery was {{ value }}%'''.ko={{ device.displayName }}의 남은 배터리 {{ value }}%
+#==============================================================================

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

@@ -1,18 +1,29 @@
-/**
- *  SmartSense Moisture Sensor
+/*
+===============================================================================
+ *  Copyright 2016 SmartThings
  *
- *  Copyright 2014 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:
+ *  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.
+ *  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: SmartSense Moisture Sensor DTH File
  *
+ *  Filename: SmartSense-Moisture-Sensor.src/SmartSense-Moisture-Sensor.groovy
+ *
+ *  Change History:
+ *  1. 20160116 TW - Update/Edit to support i18n translations
+ *  2. 20160125 TW = Incorporated new battery mapping from TM
+===============================================================================
  */
+
 metadata {
 	definition (name: "SmartSense Moisture Sensor",namespace: "smartthings", author: "SmartThings") {
 		capability "Configuration"
@@ -20,18 +31,18 @@ metadata {
 		capability "Refresh"
 		capability "Temperature Measurement"
 		capability "Water Sensor"
-        
-        command "enrollResponse"
+
+		command "enrollResponse"
 
 
 		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite",  model: "3315-S", deviceJoinName: "Water Leak Sensor"
 		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite",  model: "3315"
 		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite",  model: "3315-Seu", deviceJoinName: "Water Leak Sensor"
-
+		fingerprint inClusters: "0000,0001,0003,000F,0020,0402,0500", outClusters: "0019", manufacturer: "SmartThings", model: "moisturev4", deviceJoinName: "Water Leak Sensor"
 	}
- 
+
 	simulator {
- 
+
 	}
 
 	preferences {
@@ -43,11 +54,11 @@ metadata {
 				])
 		}
 		section {
-			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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+			input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 		}
 	}
- 
+
 	tiles(scale: 2) {
 		multiAttributeTile(name:"water", type: "generic", width: 6, height: 4){
 			tileAttribute ("device.water", key: "PRIMARY_CONTROL") {
@@ -78,7 +89,7 @@ metadata {
 		details(["water", "temperature", "battery", "refresh"])
 	}
 }
- 
+
 def parse(String description) {
 	log.debug "description: $description"
 
@@ -92,29 +103,29 @@ def parse(String description) {
 	else if (description?.startsWith('temperature: ')) {
 		map = parseCustomMessage(description)
 	}
-    else if (description?.startsWith('zone status')) {
-	    map = parseIasMessage(description)
-    }
- 
+	else if (description?.startsWith('zone status')) {
+		map = parseIasMessage(description)
+	}
+
 	log.debug "Parse returned $map"
 	def result = map ? createEvent(map) : null
-    
-    if (description?.startsWith('enroll request')) {
-    	List cmds = enrollResponse()
-        log.debug "enroll response: ${cmds}"
-        result = cmds?.collect { new physicalgraph.device.HubAction(it) }
-    }
-    return result
+
+	if (description?.startsWith('enroll request')) {
+		List cmds = enrollResponse()
+		log.debug "enroll response: ${cmds}"
+		result = cmds?.collect { new physicalgraph.device.HubAction(it) }
+	}
+	return result
 }
- 
+
 private Map parseCatchAllMessage(String description) {
-    Map resultMap = [:]
-    def cluster = zigbee.parse(description)
-    if (shouldProcessMessage(cluster)) {
-        switch(cluster.clusterId) {
-            case 0x0001:
-            	resultMap = getBatteryResult(cluster.data.last())
-                break
+	Map resultMap = [:]
+	def cluster = zigbee.parse(description)
+	if (shouldProcessMessage(cluster)) {
+		switch(cluster.clusterId) {
+			case 0x0001:
+				resultMap = getBatteryResult(cluster.data.last())
+				break
 
             case 0x0402:
                 // temp is last 2 data values. reverse to swap endian
@@ -129,22 +140,22 @@ private Map parseCatchAllMessage(String description) {
 }
 
 private boolean shouldProcessMessage(cluster) {
-    // 0x0B is default response indicating message got through
-    // 0x07 is bind message
-    boolean ignoredMessage = cluster.profileId != 0x0104 || 
-        cluster.command == 0x0B ||
-        cluster.command == 0x07 ||
-        (cluster.data.size() > 0 && cluster.data.first() == 0x3e)
-    return !ignoredMessage
+	// 0x0B is default response indicating message got through
+	// 0x07 is bind message
+	boolean ignoredMessage = cluster.profileId != 0x0104 ||
+		cluster.command == 0x0B ||
+		cluster.command == 0x07 ||
+		(cluster.data.size() > 0 && cluster.data.first() == 0x3e)
+	return !ignoredMessage
 }
- 
+
 private Map parseReportAttributeMessage(String description) {
 	Map descMap = (description - "read attr - ").split(",").inject([:]) { map, param ->
 		def nameAndValue = param.split(":")
 		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
 	}
 	log.debug "Desc Map: $descMap"
- 
+
 	Map resultMap = [:]
 	if (descMap.cluster == "0402" && descMap.attrId == "0000") {
 		def value = getTemperature(descMap.value)
@@ -153,10 +164,10 @@ private Map parseReportAttributeMessage(String description) {
 	else if (descMap.cluster == "0001" && descMap.attrId == "0020") {
 		resultMap = getBatteryResult(Integer.parseInt(descMap.value, 16))
 	}
- 
+
 	return resultMap
 }
- 
+
 private Map parseCustomMessage(String description) {
 	Map resultMap = [:]
 	if (description?.startsWith('temperature: ')) {
@@ -167,42 +178,42 @@ private Map parseCustomMessage(String description) {
 }
 
 private Map parseIasMessage(String description) {
-    List parsedMsg = description.split(' ')
-    String msgCode = parsedMsg[2]
-    
-    Map resultMap = [:]
-    switch(msgCode) {
-        case '0x0020': // Closed/No Motion/Dry
-        	resultMap = getMoistureResult('dry')
-            break
+	List parsedMsg = description.split(' ')
+	String msgCode = parsedMsg[2]
 
-        case '0x0021': // Open/Motion/Wet
-        	resultMap = getMoistureResult('wet')
-            break
+	Map resultMap = [:]
+	switch(msgCode) {
+		case '0x0020': // Closed/No Motion/Dry
+			resultMap = getMoistureResult('dry')
+			break
 
-        case '0x0022': // Tamper Alarm
-            break
+		case '0x0021': // Open/Motion/Wet
+			resultMap = getMoistureResult('wet')
+			break
 
-        case '0x0023': // Battery Alarm
-            break
+		case '0x0022': // Tamper Alarm
+			break
 
-        case '0x0024': // Supervision Report
-        	 log.debug 'dry with tamper alarm'
-        	resultMap = getMoistureResult('dry')
-            break
+		case '0x0023': // Battery Alarm
+			break
 
-        case '0x0025': // Restore Report
-        	log.debug 'water with tamper alarm'
-        	resultMap = getMoistureResult('wet')
-            break
+		case '0x0024': // Supervision Report
+			 log.debug 'dry with tamper alarm'
+			resultMap = getMoistureResult('dry')
+			break
 
-        case '0x0026': // Trouble/Failure
-            break
+		case '0x0025': // Restore Report
+			log.debug 'water with tamper alarm'
+			resultMap = getMoistureResult('wet')
+			break
 
-        case '0x0028': // Test Mode
-            break
-    }
-    return resultMap
+		case '0x0026': // Trouble/Failure
+			break
+
+		case '0x0028': // Test Mode
+			break
+	}
+	return resultMap
 }
 
 def getTemperature(value) {
@@ -215,24 +226,48 @@ def getTemperature(value) {
 }
 
 private Map getBatteryResult(rawValue) {
-	log.debug 'Battery'
+	log.debug "Battery rawValue = ${rawValue}"
 	def linkText = getLinkText(device)
-    
-    def result = [
-    	name: 'battery'
-    ]
-    
+
+	def result = [
+		name: 'battery',
+		value: '--',
+		translatable: true
+	]
+
 	def volts = rawValue / 10
-	def descriptionText
-	if (volts > 3.5) {
-		result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
-	}
+
+	if (rawValue == 0 || rawValue == 255) {}
 	else {
-		def minVolts = 2.1
-    	def maxVolts = 3.0
-		def pct = (volts - minVolts) / (maxVolts - minVolts)
-		result.value = Math.min(100, (int) pct * 100)
-		result.descriptionText = "${linkText} battery was ${result.value}%"
+		if (volts > 3.5) {
+			result.descriptionText = "{{ device.displayName }} battery has too much power: (> 3.5) volts."
+		}
+		else {
+			if (device.getDataValue("manufacturer") == "SmartThings") {
+				volts = rawValue // For the batteryMap to work the key needs to be an int
+				def batteryMap = [28:100, 27:100, 26:100, 25:90, 24:90, 23:70,
+								  22:70, 21:50, 20:50, 19:30, 18:30, 17:15, 16:1, 15:0]
+				def minVolts = 15
+				def maxVolts = 28
+
+				if (volts < minVolts)
+					volts = minVolts
+				else if (volts > maxVolts)
+					volts = maxVolts
+				def pct = batteryMap[volts]
+				if (pct != null) {
+					result.value = pct
+					result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+				}
+			}
+			else {
+				def minVolts = 2.1
+				def maxVolts = 3.0
+				def pct = (volts - minVolts) / (maxVolts - minVolts)
+				result.value = Math.min(100, (int) pct * 100)
+				result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+			}
+		}
 	}
 
 	return result
@@ -240,34 +275,44 @@ private Map getBatteryResult(rawValue) {
 
 private Map getTemperatureResult(value) {
 	log.debug 'TEMP'
-	def linkText = getLinkText(device)
 	if (tempOffset) {
 		def offset = tempOffset as int
 		def v = value as int
 		value = v + offset
 	}
-	def descriptionText = "${linkText} was ${value}°${temperatureScale}"
+    def descriptionText
+    if ( temperatureScale == 'C' )
+    	descriptionText = '{{ device.displayName }} was {{ value }}°C'
+    else
+    	descriptionText = '{{ device.displayName }} was {{ value }}°F'
+
 	return [
 		name: 'temperature',
 		value: value,
-		descriptionText: descriptionText
+		descriptionText: descriptionText,
+        translatable: true
 	]
 }
 
 private Map getMoistureResult(value) {
-	log.debug 'water'
-	String descriptionText = "${device.displayName} is ${value}"
+	log.debug "water"
+    def descriptionText
+    if ( value == "wet" )
+    	descriptionText = '{{ device.displayName }} is wet'
+    else
+    	descriptionText = '{{ device.displayName }} is dry'
 	return [
 		name: 'water',
 		value: value,
-		descriptionText: descriptionText
+		descriptionText: descriptionText,
+        translatable: true
 	]
 }
 
 def refresh() {
 	log.debug "Refreshing Temperature and Battery"
 	def refreshCmds = [
-        "st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+		"st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
 		"st rattr 0x${device.deviceNetworkId} 1 1 0x20", "delay 200"
 	]
 
@@ -277,32 +322,32 @@ def refresh() {
 def configure() {
 	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting, IAS CIE, and Bindings."
-	def configCmds = [	
+	def configCmds = [
 		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 1", "delay 500",
 
 		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 1 {${device.zigbeeId}} {}", "delay 500",
 		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}",		//checkin time 6 hrs
-        "send 0x${device.deviceNetworkId} 1 1", "delay 500",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 500",
 
 		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0x402 {${device.zigbeeId}} {}", "delay 500",
-        "zcl global send-me-a-report 0x402 0 0x29 30 3600 {6400}",
-        "send 0x${device.deviceNetworkId} 1 1", "delay 500"
+		"zcl global send-me-a-report 0x402 0 0x29 30 3600 {6400}",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 500"
 	]
-    return configCmds + refresh() // send refresh cmds as part of config
+	return configCmds + refresh() // send refresh cmds as part of config
 }
 
 def enrollResponse() {
 	log.debug "Sending enroll response"
 	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
-    [
+	[
 		//Resending the CIE in case the enroll request is sent before CIE is written
 		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
 		//Enroll Response
 		"raw 0x500 {01 23 00 00 00}",
 		"send 0x${device.deviceNetworkId} 1 1", "delay 200"
-    ]
+	]
 }
 
 private getEndpointId() {
@@ -314,19 +359,19 @@ private hex(value) {
 }
 
 private String swapEndianHex(String hex) {
-    reverseArray(hex.decodeHex()).encodeHex()
+	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
+	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
 }

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

@@ -16,6 +16,7 @@ metadata {
 		capability "Water Sensor"
 		capability "Sensor"
 		capability "Battery"
+        capability "Temperature Measurement"
 
 		fingerprint deviceId: "0x2001", inClusters: "0x30,0x9C,0x9D,0x85,0x80,0x72,0x31,0x84,0x86"
 		fingerprint deviceId: "0x2101", inClusters: "0x71,0x70,0x85,0x80,0x72,0x31,0x84,0x86"
@@ -39,17 +40,29 @@ metadata {
 				attributeState "wet", label: "Wet", icon:"st.alarm.water.wet", backgroundColor:"#53a7c0"
 			}
 		}
-		standardTile("temperature", "device.temperature", width: 2, height: 2) {
+		standardTile("temperatureState", "device.temperature", width: 2, height: 2) {
 			state "normal", icon:"st.alarm.temperature.normal", backgroundColor:"#ffffff"
 			state "freezing", icon:"st.alarm.temperature.freeze", backgroundColor:"#53a7c0"
 			state "overheated", icon:"st.alarm.temperature.overheat", backgroundColor:"#F80000"
 		}
+		valueTile("temperature", "device.temperature", 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", decoration: "flat", inactiveLabel: false, width: 2, height: 2) {
 			state "battery", label:'${currentValue}% battery', unit:""
 		}
-
-		main (["water", "temperature"])
-		details(["water", "temperature", "battery"])
+		main (["water", "temperatureState"])
+		details(["water", "temperatureState", "temperature", "battery"])
 	}
 }
 
@@ -115,7 +128,7 @@ def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd)
 		map.descriptionText = "${device.displayName} is ${map.value}"
 	}
 	if(cmd.zwaveAlarmType ==  physicalgraph.zwave.commands.alarmv2.AlarmReport.ZWAVE_ALARM_TYPE_HEAT) {
-		map.name = "temperature"
+		map.name = "temperatureState"
 		if(cmd.zwaveAlarmEvent == 1) { map.value = "overheated"}
 		if(cmd.zwaveAlarmEvent == 2) { map.value = "overheated"}
 		if(cmd.zwaveAlarmEvent == 3) { map.value = "changing temperature rapidly"}
@@ -129,17 +142,30 @@ def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd)
 	map
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd)
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd)
 {
 	def map = [:]
-	map.name = "water"
-	map.value = cmd.value ? "wet" : "dry"
-	map.descriptionText = "${device.displayName} is ${map.value}"
+	if(cmd.sensorType == 1) {
+		map.name = "temperature"
+        if(cmd.scale == 0) {
+        	map.value = getTemperature(cmd.scaledSensorValue)
+        } else {
+	        map.value = cmd.scaledSensorValue
+        }
+        map.unit = location.temperatureScale
+	}
 	map
 }
 
+def getTemperature(value) {
+	if(location.temperatureScale == "C"){
+		return value
+    } else {
+        return Math.round(celsiusToFahrenheit(value))
+    }
+}
+
 def zwaveEvent(physicalgraph.zwave.Command cmd)
 {
 	log.debug "COMMAND CLASS: $cmd"
-}
-
+}

devicetypes/smartthings/smartsense-motion-sensor.src/i18n/messages.properties

@@ -0,0 +1,43 @@
+#==============================================================================
+#  Copyright 2016 SmartThings
+#
+#  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+#  use this file except in compliance with the License. You may obtain a copy
+#  of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#  License for the specific language governing permissions and limitations
+#  under the License.
+#==============================================================================
+# Purpose: SmartSense Motion Sensor i18n Translation File
+#
+# Filename: SmartSense-Motion-Sensor.src/i18n/messages.properties
+#
+# Change History:
+#	1. 20160116 TW Initial release with formal Korean translation.
+#	2. 20160224 TW Updated formal Korean translations from Mike Stoller.
+#==============================================================================
+# Korean (ko)
+# Device Preferences
+'''battery'''.ko=배터리
+'''Temperature Offset'''.ko=온도 직접 설정
+'''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'.'''.ko=기준 온도를 원하는대로 몇 도 올리거나 내려서 설정할 수 있습니다.
+'''Degrees'''.ko=온도
+'''Adjust temperature by this many degrees'''.ko=몇 도씩 온도를 조절하십시오
+'''Give your device a name'''.ko=기기 이름 설정
+'''Motion Sensor'''.ko=모션 센서
+'''motion'''.ko= 동작 감지 
+'''no motion'''.ko=동작 없음
+'''${currentValue}% battery'''.ko=${currentValue}% 배터리
+# Events descriptionText
+'''{{ device.displayName }} detected motion'''.ko={{ device.displayName }}에서 움직임이 감지되었습니다.
+'''{{ device.displayName }} motion has stopped'''.ko={{ device.displayName }}에서 움직임이 중단되었습니다.
+'''{{ device.displayName }} was {{ value }}°C'''.ko={{ device.displayName }}에서 {{ value }}°C 감지
+'''{{ device.displayName }} was {{ value }}°F'''.ko={{ device.displayName }}이(가) {{ value }}°F였습니다
+'''{{ device.displayName }} battery has too much power: (> 3.5) volts.'''.ko={{ device.displayName }} 배터리 전력이 너무 높습니다(3.5볼트 초과).
+'''{{ device.displayName }} battery was {{ value }}%'''.ko={{ device.displayName }}의 남은 배터리 {{ value }}%
+#==============================================================================

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

@@ -1,17 +1,27 @@
-/**
- *  SmartSense Motion/Temp Sensor
+/*
+===============================================================================
+ *  Copyright 2016 SmartThings
  *
- *  Copyright 2014 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:
+ *  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.
+ *  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: SmartSense Motion Sensor DTH File
  *
+ *  Filename: SmartSense-Motion-Sensor.src/SmartSense-Motion-Sensor.groovy
+ *
+ *  Change History:
+ *  1. 20160116 TW - Update/Edit to support i18n translations
+ *  2. 20160125 TW = Incorporated new battery mapping from TM
+===============================================================================
  */
 
 metadata {
@@ -19,16 +29,18 @@ metadata {
 		capability "Motion Sensor"
 		capability "Configuration"
 		capability "Battery"
-        capability "Temperature Measurement"
+		capability "Temperature Measurement"
 		capability "Refresh"
-        
-        command "enrollResponse"
+
+		command "enrollResponse"
 
 		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3305-S"
-        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3325-S", deviceJoinName: "Motion Sensor"
-        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3305"
-        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3325"
-        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3326"
+		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3325-S", deviceJoinName: "Motion Sensor"
+		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3305"
+		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3325"
+		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3326"
+		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3326-L", deviceJoinName: "Iris Motion Sensor"
+		fingerprint inClusters: "0000,0001,0003,000F,0020,0402,0500", outClusters: "0019", manufacturer: "SmartThings", model: "motionv4", deviceJoinName: "Motion Sensor"
 	}
 
 	simulator {
@@ -45,8 +57,8 @@ metadata {
 				])
 		}
 		section {
-			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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+			input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 		}
 	}
 
@@ -84,7 +96,7 @@ metadata {
 
 def parse(String description) {
 	log.debug "description: $description"
-    
+
 	Map map = [:]
 	if (description?.startsWith('catchall:')) {
 		map = parseCatchAllMessage(description)
@@ -95,55 +107,55 @@ def parse(String description) {
 	else if (description?.startsWith('temperature: ')) {
 		map = parseCustomMessage(description)
 	}
-    else if (description?.startsWith('zone status')) {
-	    map = parseIasMessage(description)
-    }
- 
+	else if (description?.startsWith('zone status')) {
+		map = parseIasMessage(description)
+	}
+
 	log.debug "Parse returned $map"
 	def result = map ? createEvent(map) : null
-    
-    if (description?.startsWith('enroll request')) {
-    	List cmds = enrollResponse()
-        log.debug "enroll response: ${cmds}"
-        result = cmds?.collect { new physicalgraph.device.HubAction(it) }
-    }
-    return result
+
+	if (description?.startsWith('enroll request')) {
+		List cmds = enrollResponse()
+		log.debug "enroll response: ${cmds}"
+		result = cmds?.collect { new physicalgraph.device.HubAction(it) }
+	}
+	return result
 }
 
 private Map parseCatchAllMessage(String description) {
-    Map resultMap = [:]
-    def cluster = zigbee.parse(description)
-    if (shouldProcessMessage(cluster)) {
-        switch(cluster.clusterId) {
-            case 0x0001:
-            	resultMap = getBatteryResult(cluster.data.last())
-                break
+	Map resultMap = [:]
+	def cluster = zigbee.parse(description)
+	if (shouldProcessMessage(cluster)) {
+		switch(cluster.clusterId) {
+			case 0x0001:
+				resultMap = getBatteryResult(cluster.data.last())
+				break
 
-            case 0x0402:
-                // temp is last 2 data values. reverse to swap endian
-                String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
-                def value = getTemperature(temp)
-                resultMap = getTemperatureResult(value)
-                break
+			case 0x0402:
+				// temp is last 2 data values. reverse to swap endian
+				String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+				def value = getTemperature(temp)
+				resultMap = getTemperatureResult(value)
+				break
 
 			case 0x0406:
-            	log.debug 'motion'
-                resultMap.name = 'motion'
-                break
-        }
-    }
+				log.debug 'motion'
+				resultMap.name = 'motion'
+				break
+		}
+	}
 
-    return resultMap
+	return resultMap
 }
 
 private boolean shouldProcessMessage(cluster) {
-    // 0x0B is default response indicating message got through
-    // 0x07 is bind message
-    boolean ignoredMessage = cluster.profileId != 0x0104 || 
-        cluster.command == 0x0B ||
-        cluster.command == 0x07 ||
-        (cluster.data.size() > 0 && cluster.data.first() == 0x3e)
-    return !ignoredMessage
+	// 0x0B is default response indicating message got through
+	// 0x07 is bind message
+	boolean ignoredMessage = cluster.profileId != 0x0104 ||
+		cluster.command == 0x0B ||
+		cluster.command == 0x07 ||
+		(cluster.data.size() > 0 && cluster.data.first() == 0x3e)
+	return !ignoredMessage
 }
 
 private Map parseReportAttributeMessage(String description) {
@@ -152,7 +164,7 @@ private Map parseReportAttributeMessage(String description) {
 		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
 	}
 	log.debug "Desc Map: $descMap"
- 
+
 	Map resultMap = [:]
 	if (descMap.cluster == "0402" && descMap.attrId == "0000") {
 		def value = getTemperature(descMap.value)
@@ -161,14 +173,14 @@ private Map parseReportAttributeMessage(String description) {
 	else if (descMap.cluster == "0001" && descMap.attrId == "0020") {
 		resultMap = getBatteryResult(Integer.parseInt(descMap.value, 16))
 	}
-    else if (descMap.cluster == "0406" && descMap.attrId == "0000") {
-    	def value = descMap.value.endsWith("01") ? "active" : "inactive"
-    	resultMap = getMotionResult(value)
-    } 
- 
+	else if (descMap.cluster == "0406" && descMap.attrId == "0000") {
+		def value = descMap.value.endsWith("01") ? "active" : "inactive"
+		resultMap = getMotionResult(value)
+	}
+
 	return resultMap
 }
- 
+
 private Map parseCustomMessage(String description) {
 	Map resultMap = [:]
 	if (description?.startsWith('temperature: ')) {
@@ -179,44 +191,44 @@ private Map parseCustomMessage(String description) {
 }
 
 private Map parseIasMessage(String description) {
-    List parsedMsg = description.split(' ')
-    String msgCode = parsedMsg[2]
-    
-    Map resultMap = [:]
-    switch(msgCode) {
-        case '0x0020': // Closed/No Motion/Dry
-        	resultMap = getMotionResult('inactive')
-            break
+	List parsedMsg = description.split(' ')
+	String msgCode = parsedMsg[2]
 
-        case '0x0021': // Open/Motion/Wet
-        	resultMap = getMotionResult('active')
-            break
+	Map resultMap = [:]
+	switch(msgCode) {
+		case '0x0020': // Closed/No Motion/Dry
+			resultMap = getMotionResult('inactive')
+			break
 
-        case '0x0022': // Tamper Alarm
-        	log.debug 'motion with tamper alarm'
-        	resultMap = getMotionResult('active')
-            break
+		case '0x0021': // Open/Motion/Wet
+			resultMap = getMotionResult('active')
+			break
 
-        case '0x0023': // Battery Alarm
-            break
+		case '0x0022': // Tamper Alarm
+			log.debug 'motion with tamper alarm'
+			resultMap = getMotionResult('active')
+			break
 
-        case '0x0024': // Supervision Report
-        	log.debug 'no motion with tamper alarm'
-        	resultMap = getMotionResult('inactive')
-            break
+		case '0x0023': // Battery Alarm
+			break
 
-        case '0x0025': // Restore Report
-            break
+		case '0x0024': // Supervision Report
+			log.debug 'no motion with tamper alarm'
+			resultMap = getMotionResult('inactive')
+			break
 
-        case '0x0026': // Trouble/Failure
-        	log.debug 'motion with failure alarm'
-        	resultMap = getMotionResult('active')
-            break
+		case '0x0025': // Restore Report
+			break
 
-        case '0x0028': // Test Mode
-            break
-    }
-    return resultMap
+		case '0x0026': // Trouble/Failure
+			log.debug 'motion with failure alarm'
+			resultMap = getMotionResult('active')
+			break
+
+		case '0x0028': // Test Mode
+			break
+	}
+	return resultMap
 }
 
 def getTemperature(value) {
@@ -229,30 +241,48 @@ def getTemperature(value) {
 }
 
 private Map getBatteryResult(rawValue) {
-	log.debug 'Battery'
+	log.debug "Battery rawValue = ${rawValue}"
 	def linkText = getLinkText(device)
 
-	log.debug rawValue
-
 	def result = [
 		name: 'battery',
-		value: '--'
+		value: '--',
+		translatable: true
 	]
 
 	def volts = rawValue / 10
-	def descriptionText
 
-	if (rawValue == 0) {}
+	if (rawValue == 0 || rawValue == 255) {}
 	else {
 		if (volts > 3.5) {
-			result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
+			result.descriptionText = "{{ device.displayName }} battery has too much power: (> 3.5) volts."
 		}
-		else if (volts > 0){
-			def minVolts = 2.1
-			def maxVolts = 3.0
-			def pct = (volts - minVolts) / (maxVolts - minVolts)
-			result.value = Math.min(100, (int) pct * 100)
-			result.descriptionText = "${linkText} battery was ${result.value}%"
+		else {
+			if (device.getDataValue("manufacturer") == "SmartThings") {
+				volts = rawValue // For the batteryMap to work the key needs to be an int
+				def batteryMap = [28:100, 27:100, 26:100, 25:90, 24:90, 23:70,
+								  22:70, 21:50, 20:50, 19:30, 18:30, 17:15, 16:1, 15:0]
+				def minVolts = 15
+				def maxVolts = 28
+
+				if (volts < minVolts)
+					volts = minVolts
+				else if (volts > maxVolts)
+					volts = maxVolts
+				def pct = batteryMap[volts]
+				if (pct != null) {
+					result.value = pct
+                    def value = pct
+					result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+				}
+			}
+			else {
+				def minVolts = 2.1
+				def maxVolts = 3.0
+				def pct = (volts - minVolts) / (maxVolts - minVolts)
+				result.value = Math.min(100, (int) pct * 100)
+				result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+			}
 		}
 	}
 
@@ -261,28 +291,33 @@ private Map getBatteryResult(rawValue) {
 
 private Map getTemperatureResult(value) {
 	log.debug 'TEMP'
-	def linkText = getLinkText(device)
 	if (tempOffset) {
 		def offset = tempOffset as int
 		def v = value as int
 		value = v + offset
 	}
-	def descriptionText = "${linkText} was ${value}°${temperatureScale}"
+    def descriptionText
+    if ( temperatureScale == 'C' )
+    	descriptionText = '{{ device.displayName }} was {{ value }}°C'
+    else
+    	descriptionText = '{{ device.displayName }} was {{ value }}°F'
+
 	return [
 		name: 'temperature',
 		value: value,
-		descriptionText: descriptionText
+		descriptionText: descriptionText,
+        translatable: true
 	]
 }
 
 private Map getMotionResult(value) {
 	log.debug 'motion'
-	String linkText = getLinkText(device)
-	String descriptionText = value == 'active' ? "${linkText} detected motion" : "${linkText} motion has stopped"
+	String descriptionText = value == 'active' ? "{{ device.displayName }} detected motion" : "{{ device.displayName }} motion has stopped"
 	return [
 		name: 'motion',
 		value: value,
-		descriptionText: descriptionText
+		descriptionText: descriptionText,
+        translatable: true
 	]
 }
 
@@ -337,19 +372,19 @@ private hex(value) {
 }
 
 private String swapEndianHex(String hex) {
-    reverseArray(hex.decodeHex()).encodeHex()
+	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
-}
+	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
+}

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

@@ -14,6 +14,8 @@
  *
  */
 
+//DEPRECATED - Using the smartsense-motion-sensor.groovy DTH for this device. Users need to be moved before deleting this DTH
+
 metadata {
 	definition (name: "SmartSense Motion/Temp Sensor", namespace: "smartthings", author: "SmartThings") {
 		capability "Motion Sensor"
@@ -25,10 +27,6 @@ metadata {
         
         command "enrollResponse"
 
-		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3305-S"
-        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3305"
-        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3325"
-        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3326"
 	}
 
 	simulator {
@@ -37,8 +35,8 @@ metadata {
 	}
 
 	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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+		input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 	}
 
 	tiles(scale: 2) {
@@ -233,7 +231,7 @@ private Map getBatteryResult(rawValue) {
 	def volts = rawValue / 10
 	def descriptionText
 
-	if (rawValue == 0) {}
+    if (rawValue == 0 || rawValue == 255) {}
 	else {
 		if (volts > 3.5) {
 			result.descriptionText = "${linkText} battery has too much power (${volts} volts)."

devicetypes/smartthings/smartsense-multi-sensor.src/i18n/messages.properties

@@ -0,0 +1,50 @@
+#==============================================================================
+#  Copyright 2016 SmartThings
+#
+#  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+#  use this file except in compliance with the License. You may obtain a copy
+#  of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#  License for the specific language governing permissions and limitations
+#  under the License.
+#==============================================================================
+# Purpose: SmartSense Multi Sensor i18n Translation File
+#
+# Filename: SmartSense-Multi-Sensor.src/i18n/messages.properties
+#
+# Change History:
+#	1. 20160117 TW Initial release with informal Korean translation.
+#==============================================================================
+# Korean (ko)
+# Device Preferences
+'''Yes'''.ko=예
+'''No'''.ko=아니요
+'''battery'''.ko=배터리
+'''Temperature Offset'''.ko=온도 직접 설정
+'''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'.'''.ko=기준 온도를 원하는대로 몇 도 올리거나 내려서 설정할 수 있습니다.
+'''Degrees'''.ko=온도
+'''Adjust temperature by this many degrees'''.ko=몇 도씩 온도를 조절하십시오
+'''Do you want to use this sensor on a garage door?'''.ko=차고 문의 센서 사용 설정하기
+'''Tap to set'''.ko=눌러서 설정
+'''Give your device a name'''.ko=기기 이름 설정
+'''Multipurpose Sensor'''.ko=문 및 창 센서
+# Events descriptionText
+'''{{ device.displayName }} was opened'''.ko={{ device.displayName }}에서 열림이 감지되었습니다.
+'''{{ device.displayName }} was closed'''.ko={{ device.displayName }}에서 닫힘이 감지되었습니다.
+'''{{ device.displayName }} was active'''.ko={{ device.displayName }} 활성화
+'''{{ device.displayName }} was inactive'''.ko={{ device.displayName }} 비활성화
+'''{{ device.displayName }} was {{ value }}°C'''.ko={{ device.displayName }}에서 {{ value }}°C 감지
+'''{{ device.displayName }} was {{ value }}°F'''.ko={{ device.displayName }}이(가) {{ value }}°F였습니다
+'''{{ device.displayName }} battery was {{ value }}%'''.ko={{ device.displayName }}의 남은 배터리 {{ value }}%
+'''Updating device to garage sensor'''.ko=기기-차고 센서 업데이트 중
+'''Updating device to open/close sensor'''.ko=기기-열림/닫힘 센서 업데이트 중
+'''Inactive'''.ko=비활성 상태
+'''Active'''.ko=활성 상태
+'''Open'''.ko= 열림이 감지될 때
+'''Closed'''.ko=닫힘
+'''${currentValue}% battery'''.ko=${currentValue}% 배터리

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

@@ -1,40 +1,51 @@
-/**
- *  SmartSense Multi
+/*
+===============================================================================
+ *  Copyright 2016 SmartThings
  *
- *  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:
+ *  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.
+ *  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: SmartSense Multi Sensor DTH File
  *
+ *  Filename: SmartSense-Multi-Sensor.src/SmartSense-Multi-Sensor.groovy
+ *
+ *  Change History:
+ *  1. 20160117 TW - Update/Edit to support i18n translations
+ *  2. 20160125 TW = Incorporated new battery mapping from TM
+===============================================================================
  */
 
- metadata {
- 	definition (name: "SmartSense Multi Sensor", namespace: "smartthings", author: "SmartThings") {
- 		
-        capability "Three Axis"
+metadata {
+	definition (name: "SmartSense Multi Sensor", namespace: "smartthings", author: "SmartThings") {
+
+		capability "Three Axis"
 		capability "Battery"
- 		capability "Configuration"
-        capability "Sensor"
+		capability "Configuration"
+		capability "Sensor"
  		capability "Contact Sensor"
  		capability "Acceleration Sensor"
  		capability "Refresh"
  		capability "Temperature Measurement"
-        
+
  		command "enrollResponse"
  		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05,FC02", outClusters: "0019", manufacturer: "CentraLite", model: "3320"
 		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05,FC02", outClusters: "0019", manufacturer: "CentraLite", model: "3321"
-        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05,FC02", outClusters: "0019", manufacturer: "CentraLite", model: "3321-S", deviceJoinName: "Multipurpose Sensor"
+		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05,FC02", outClusters: "0019", manufacturer: "CentraLite", model: "3321-S", deviceJoinName: "Multipurpose Sensor"
+		fingerprint inClusters: "0000,0001,0003,000F,0020,0402,0500,FC02", outClusters: "0019", manufacturer: "SmartThings", model: "multiv4", deviceJoinName: "Multipurpose Sensor"
 
 		attribute "status", "string"
- 	}
+	}
 
- 	simulator {
+	simulator {
 		status "open": "zone report :: type: 19 value: 0031"
 		status "closed": "zone report :: type: 19 value: 0030"
 
@@ -51,7 +62,7 @@
 		status "x,y,z: 0,1000,0": "x: 0, y: 1000, z: 0"
 		status "x,y,z: 0,0,1000": "x: 0, y: 0, z: 1000"
 	}
- 	preferences {
+	preferences {
 		section {
 			image(name: 'educationalcontent', multiple: true, images: [
 				"http://cdn.device-gse.smartthings.com/Multi/Multi1.jpg",
@@ -61,30 +72,30 @@
 				])
 		}
 		section {
- 			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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
- 		}
-		section {
- 			input("garageSensor", "enum", title: "Do you want to use this sensor on a garage door?", options: ["Yes", "No"], defaultValue: "No", required: false, displayDuringSetup: false)
+			input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 		}
- 	}
+		section {
+			input("garageSensor", "enum", title: "Do you want to use this sensor on a garage door?", description: "Tap to set", options: ["Yes", "No"], defaultValue: "No", required: false, displayDuringSetup: false)
+		}
+	}
 
 	tiles(scale: 2) {
 		multiAttributeTile(name:"status", type: "generic", width: 6, height: 4){
 			tileAttribute ("device.status", key: "PRIMARY_CONTROL") {
-				attributeState "open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e"
-				attributeState "closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821"
+				attributeState "open", label:'Open', icon:"st.contact.contact.open", backgroundColor:"#ffa81e"
+				attributeState "closed", label:'Closed', icon:"st.contact.contact.closed", backgroundColor:"#79b821"
 				attributeState "garage-open", label:'Open', icon:"st.doors.garage.garage-open", backgroundColor:"#ffa81e"
 				attributeState "garage-closed", label:'Closed', icon:"st.doors.garage.garage-closed", backgroundColor:"#79b821"
 			}
 		}
 		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:'Open', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
+			state("closed", label:'Closed', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
 		}
 		standardTile("acceleration", "device.acceleration", width: 2, height: 2) {
-			state("active", label:'${name}', icon:"st.motion.acceleration.active", backgroundColor:"#53a7c0")
-			state("inactive", label:'${name}', icon:"st.motion.acceleration.inactive", backgroundColor:"#ffffff")
+			state("active", label:'Active', icon:"st.motion.acceleration.active", backgroundColor:"#53a7c0")
+			state("inactive", label:'Inactive', icon:"st.motion.acceleration.inactive", backgroundColor:"#ffffff")
 		}
 		valueTile("temperature", "device.temperature", width: 2, height: 2) {
 			state("temperature", label:'${currentValue}°',
@@ -99,107 +110,117 @@
 				]
 			)
 		}
-		valueTile("3axis", "device.threeAxis", decoration: "flat", wordWrap: false, width: 2, height: 2) {
-			state("threeAxis", label:'${currentValue}', unit:"", backgroundColor:"#ffffff")
-		}
 		valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false, width: 2, height: 2) {
 			state "battery", label:'${currentValue}% battery', unit:""
 		}
- 		standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
- 			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
- 		}
+		standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
 
 
 		main(["status", "acceleration", "temperature"])
-		details(["status", "acceleration", "temperature", "3axis", "battery", "refresh"])
+		details(["status", "acceleration", "temperature", "battery", "refresh"])
 	}
  }
 
- def parse(String description) {
- 	
- 	Map map = [:]
- 	if (description?.startsWith('catchall:')) {
- 		map = parseCatchAllMessage(description)
- 	}
- 	else if (description?.startsWith('read attr -')) {
- 		map = parseReportAttributeMessage(description)
- 	}
-    else if (description?.startsWith('temperature: ')) {
- 		map = parseCustomMessage(description)
- 	}
- 	else if (description?.startsWith('zone status')) {
- 		map = parseIasMessage(description)
- 	}
+def parse(String description) {
+	Map map = [:]
+	if (description?.startsWith('catchall:')) {
+		map = parseCatchAllMessage(description)
+	}
+	else if (description?.startsWith('temperature: ')) {
+		map = parseCustomMessage(description)
+	}
+	else if (description?.startsWith('zone status')) {
+		map = parseIasMessage(description)
+	}
 
- 	def result = map ? createEvent(map) : null
+	def result = map ? createEvent(map) : null
 
- 	if (description?.startsWith('enroll request')) {
- 		List cmds = enrollResponse()
- 		log.debug "enroll response: ${cmds}"
- 		result = cmds?.collect { new physicalgraph.device.HubAction(it) }
- 	}
- 	return result
- }
-
- private Map parseCatchAllMessage(String description) {
- 	Map resultMap = [:]
- 	def cluster = zigbee.parse(description)
-    log.debug cluster
- 	if (shouldProcessMessage(cluster)) {
- 		switch(cluster.clusterId) {
- 			case 0x0001:
- 			resultMap = getBatteryResult(cluster.data.last())
- 			break
-
- 			case 0xFC02:
-            log.debug 'ACCELERATION'
- 			break
-
- 			case 0x0402:
- 			log.debug 'TEMP'
-                // temp is last 2 data values. reverse to swap endian
-                String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
-                def value = getTemperature(temp)
-                resultMap = getTemperatureResult(value)
-                break
-            }
-        }
-
-        return resultMap
-    }
-
-private boolean shouldProcessMessage(cluster) {
-    // 0x0B is default response indicating message got through
-    // 0x07 is bind message
-    boolean ignoredMessage = cluster.profileId != 0x0104 ||
-    cluster.command == 0x0B ||
-    cluster.command == 0x07 ||
-    (cluster.data.size() > 0 && cluster.data.first() == 0x3e)
-    return !ignoredMessage
+	if (description?.startsWith('enroll request')) {
+		List cmds = enrollResponse()
+		log.debug "enroll response: ${cmds}"
+		result = cmds?.collect { new physicalgraph.device.HubAction(it) }
+	}
+	else if (description?.startsWith('read attr -')) {
+		result = parseReportAttributeMessage(description).each { createEvent(it) }
+	}
+	return result
 }
 
-private Map parseReportAttributeMessage(String description) {
+private Map parseCatchAllMessage(String description) {
+	Map resultMap = [:]
+	def cluster = zigbee.parse(description)
+	log.debug cluster
+	if (shouldProcessMessage(cluster)) {
+		switch(cluster.clusterId) {
+			case 0x0001:
+			resultMap = getBatteryResult(cluster.data.last())
+			break
+
+			case 0xFC02:
+			log.debug 'ACCELERATION'
+			break
+
+			case 0x0402:
+			log.debug 'TEMP'
+				// temp is last 2 data values. reverse to swap endian
+				String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+				def value = getTemperature(temp)
+				resultMap = getTemperatureResult(value)
+				break
+		}
+	}
+
+	return resultMap
+}
+
+private boolean shouldProcessMessage(cluster) {
+	// 0x0B is default response indicating message got through
+	// 0x07 is bind message
+	boolean ignoredMessage = cluster.profileId != 0x0104 ||
+	cluster.command == 0x0B ||
+	cluster.command == 0x07 ||
+	(cluster.data.size() > 0 && cluster.data.first() == 0x3e)
+	return !ignoredMessage
+}
+
+private List parseReportAttributeMessage(String description) {
 	Map descMap = (description - "read attr - ").split(",").inject([:]) { map, param ->
 		def nameAndValue = param.split(":")
 		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
 	}
-    
-    Map resultMap = [:]
+
+	List result = []
 	if (descMap.cluster == "0402" && descMap.attrId == "0000") {
 		def value = getTemperature(descMap.value)
-		resultMap = getTemperatureResult(value)
+		result << getTemperatureResult(value)
 	}
 	else if (descMap.cluster == "FC02" && descMap.attrId == "0010") {
-  		resultMap = getAccelerationResult(descMap.value)
+		if (descMap.value.size() == 32) {
+			// value will look like 00ae29001403e2290013001629001201
+			// breaking this apart and swapping byte order where appropriate, this breaks down to:
+			//   X (0x0012) = 0x0016
+			//   Y (0x0013) = 0x03E2
+			//   Z (0x0014) = 0x00AE
+			// note that there is a known bug in that the x,y,z attributes are interpreted in the wrong order
+			// this will be fixed in a future update
+			def threeAxisAttributes = descMap.value[0..-9]
+			result << parseAxis(threeAxisAttributes)
+			descMap.value = descMap.value[-2..-1]
+		}
+		result << getAccelerationResult(descMap.value)
 	}
-    else if (descMap.cluster == "FC02" && descMap.attrId == "0012") {
-  		resultMap = parseAxis(descMap.value)
+	else if (descMap.cluster == "FC02" && descMap.attrId == "0012" && descMap.value.size() == 24) {
+		// The size is checked to ensure the attribute report contains X, Y and Z values
+		// If all three axis are not included then the attribute report is ignored
+		result << parseAxis(descMap.value)
 	}
 	else if (descMap.cluster == "0001" && descMap.attrId == "0020") {
-		resultMap = getBatteryResult(Integer.parseInt(descMap.value, 16))
+		result << getBatteryResult(Integer.parseInt(descMap.value, 16))
 	}
 
-	return resultMap
+	return result
 }
 
 private Map parseCustomMessage(String description) {
@@ -217,43 +238,43 @@ private Map parseIasMessage(String description) {
 
 	Map resultMap = [:]
 	switch(msgCode) {
-        case '0x0020': // Closed/No Motion/Dry
+		case '0x0020': // Closed/No Motion/Dry
 			if (garageSensor != "Yes"){
 				resultMap = getContactResult('closed')
 			}
-        break
+		break
 
-        case '0x0021': // Open/Motion/Wet
+		case '0x0021': // Open/Motion/Wet
 			if (garageSensor != "Yes"){
 				resultMap = getContactResult('open')
 			}
-        break
+		break
 
-        case '0x0022': // Tamper Alarm
-        break
+		case '0x0022': // Tamper Alarm
+		break
 
-        case '0x0023': // Battery Alarm
-        break
+		case '0x0023': // Battery Alarm
+		break
 
-        case '0x0024': // Supervision Report
+		case '0x0024': // Supervision Report
 			if (garageSensor != "Yes"){
 				resultMap = getContactResult('closed')
 			}
-        break
+		break
 
-        case '0x0025': // Restore Report
+		case '0x0025': // Restore Report
 			if (garageSensor != "Yes"){
 				resultMap = getContactResult('open')
 			}
-        break
+		break
 
-        case '0x0026': // Trouble/Failure
-        break
+		case '0x0026': // Trouble/Failure
+		break
 
-        case '0x0028': // Test Mode
-        break
-    }
-    return resultMap
+		case '0x0028': // Test Mode
+		break
+	}
+	return resultMap
 }
 
 def updated() {
@@ -262,19 +283,19 @@ def updated() {
 	if (garageSensor == "Yes") {
 		def descriptionText = "Updating device to garage sensor"
 		if (device.latestValue("status") == "open") {
-			sendEvent(name: 'status', value: 'garage-open', descriptionText: descriptionText)
+			sendEvent(name: 'status', value: 'garage-open', descriptionText: descriptionText, translatable: true)
 		}
 		else if (device.latestValue("status") == "closed") {
-			sendEvent(name: 'status', value: 'garage-closed', descriptionText: descriptionText)
+			sendEvent(name: 'status', value: 'garage-closed', descriptionText: descriptionText, translatable: true)
 		}
 	}
 	else {
 		def descriptionText = "Updating device to open/close sensor"
 		if (device.latestValue("status") == "garage-open") {
-			sendEvent(name: 'status', value: 'open', descriptionText: descriptionText)
+			sendEvent(name: 'status', value: 'open', descriptionText: descriptionText, translatable: true)
 		}
 		else if (device.latestValue("status") == "garage-closed") {
-			sendEvent(name: 'status', value: 'closed', descriptionText: descriptionText)
+			sendEvent(name: 'status', value: 'closed', descriptionText: descriptionText, translatable: true)
 		}
 	}
 }
@@ -288,146 +309,181 @@ def getTemperature(value) {
 		}
 	}
 
-	private Map getBatteryResult(rawValue) {
-		log.debug "Battery"
-        log.debug rawValue
-		def linkText = getLinkText(device)
+private Map getBatteryResult(rawValue) {
+	log.debug "Battery rawValue = ${rawValue}"
 
-		def result = [
+	def result = [
 		name: 'battery',
-        value: '--'
-		]
+		value: '--',
+		translatable: true
+	]
 
-		def volts = rawValue / 10
-		def descriptionText
-        
-        if (rawValue == 255) {}
-        else {
-		
-        if (volts > 3.5) {
-			result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
+	def volts = rawValue / 10
+
+	if (rawValue == 0 || rawValue == 255) {}
+	else {
+		if (volts > 3.5) {
+			result.descriptionText = "{{ device.displayName }} battery has too much power: (> 3.5) volts."
 		}
 		else {
-			def minVolts = 2.1
-			def maxVolts = 3.0
-			def pct = (volts - minVolts) / (maxVolts - minVolts)
-			result.value = Math.min(100, (int) pct * 100)
-			result.descriptionText = "${linkText} battery was ${result.value}%"
-		}}
+			if (device.getDataValue("manufacturer") == "SmartThings") {
+				volts = rawValue // For the batteryMap to work the key needs to be an int
+				def batteryMap = [28:100, 27:100, 26:100, 25:90, 24:90, 23:70,
+								  22:70, 21:50, 20:50, 19:30, 18:30, 17:15, 16:1, 15:0]
+				def minVolts = 15
+				def maxVolts = 28
 
-		return result
-	}
-
-	private Map getTemperatureResult(value) {
-		log.debug "Temperature"
-		def linkText = getLinkText(device)
-		if (tempOffset) {
-			def offset = tempOffset as int
-			def v = value as int
-			value = v + offset
+				if (volts < minVolts)
+					volts = minVolts
+				else if (volts > maxVolts)
+					volts = maxVolts
+				def pct = batteryMap[volts]
+				if (pct != null) {
+					result.value = pct
+					result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+				}
+			}
+			else {
+				def minVolts = 2.1
+				def maxVolts = 3.0
+				def pct = (volts - minVolts) / (maxVolts - minVolts)
+				result.value = Math.min(100, (int) pct * 100)
+				result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+			}
 		}
-		def descriptionText = "${linkText} was ${value}°${temperatureScale}"
-		return [
-		name: 'temperature',
+	}
+
+	return result
+}
+
+private Map getTemperatureResult(value) {
+	log.debug "Temperature"
+	if (tempOffset) {
+		def offset = tempOffset as int
+		def v = value as int
+		value = v + offset
+	}
+	def descriptionText = temperatureScale == 'C' ? '{{ device.displayName }} was {{ value }}°C':
+			'{{ device.displayName }} was {{ value }}°F'
+
+	return [
+	name: 'temperature',
+	value: value,
+	descriptionText: descriptionText,
+    translatable: true
+	]
+}
+
+private Map getContactResult(value) {
+	log.debug "Contact: ${device.displayName} value = ${value}"
+	def descriptionText = value == 'open' ? '{{ device.displayName }} was opened' : '{{ device.displayName }} was closed'
+	sendEvent(name: 'contact', value: value, descriptionText: descriptionText, displayed: false, translatable: true)
+	sendEvent(name: 'status', value: value, descriptionText: descriptionText, translatable: true)
+}
+
+private getAccelerationResult(numValue) {
+	log.debug "Acceleration"
+	def name = "acceleration"
+    def value
+    def descriptionText
+
+	if ( numValue.endsWith("1") ) {
+    	value = "active"
+        descriptionText = '{{ device.displayName }} was active'
+    } else {
+    	value = "inactive"
+        descriptionText = '{{ device.displayName }} was inactive'
+    }
+
+	def isStateChange = isStateChange(device, name, value)
+	return [
+		name: name,
 		value: value,
-		descriptionText: descriptionText
+		descriptionText: descriptionText,
+		isStateChange: isStateChange,
+		translatable: true
+	]
+}
+
+def refresh() {
+	log.debug "Refreshing Values "
+
+	def refreshCmds = []
+
+	if (device.getDataValue("manufacturer") == "SmartThings") {
+		log.debug "Refreshing Values for manufacturer: SmartThings "
+		refreshCmds = refreshCmds + [
+			/* These values of Motion Threshold Multiplier(01) and Motion Threshold (7602)
+				seem to be giving pretty accurate results for the XYZ co-ordinates for this manufacturer.
+				Separating these out in a separate if-else because I do not want to touch Centralite part
+				as of now.
+			*/
+
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 0 0x20 {01}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 2 0x21 {7602}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+		]
+	} else {
+		refreshCmds = refreshCmds + [
+			/* sensitivity - default value (8) */
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 0 0x20 {02}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
 		]
 	}
 
-	private Map getContactResult(value) {
-		log.debug "Contact"
-		def linkText = getLinkText(device)
-		def descriptionText = "${linkText} was ${value == 'open' ? 'opened' : 'closed'}"
-		sendEvent(name: 'contact', value: value, descriptionText: descriptionText, displayed:false)
-		sendEvent(name: 'status', value: value, descriptionText: descriptionText)
-	}
-
-	private getAccelerationResult(numValue) {
-		log.debug "Acceleration"
-        def name = "acceleration"
-		def value = numValue.endsWith("1") ? "active" : "inactive"
-		//def linkText = getLinkText(device)
-		def descriptionText = "was $value"
-		def isStateChange = isStateChange(device, name, value)
-		[
-			name: name,
-			value: value,
-			descriptionText: descriptionText,
-			isStateChange: isStateChange
-		]
-	}
-
-	def refresh() {
-		log.debug "Refreshing Values "
-		def refreshCmds = [
-        
-        /* sensitivity - default value (8) */
-        
-        "zcl mfg-code 0x104E", "delay 200",
-        "zcl global write 0xFC02 0 0x20 {02}", "delay 200",
-        "send 0x${device.deviceNetworkId} 1 1", "delay 400",
-
+	//Common refresh commands
+	refreshCmds = refreshCmds + [
 		"st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
 		"st rattr 0x${device.deviceNetworkId} 1 1 0x20", "delay 200",
 
-        "zcl mfg-code 0x104E", "delay 200",
-        "zcl global read 0xFC02 0x0010",
-        "send 0x${device.deviceNetworkId} 1 1","delay 400",
-        
-        "zcl mfg-code 0x104E", "delay 200",
-        "zcl global read 0xFC02 0x0012",
-        "send 0x${device.deviceNetworkId} 1 1","delay 400",
-        
-        "zcl mfg-code 0x104E", "delay 200",
-        "zcl global read 0xFC02 0x0013",
-        "send 0x${device.deviceNetworkId} 1 1","delay 400",
-        
-        "zcl mfg-code 0x104E", "delay 200",
-        "zcl global read 0xFC02 0x0014",
-        "send 0x${device.deviceNetworkId} 1 1", "delay 400"
-		]
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global read 0xFC02 0x0010",
+		"send 0x${device.deviceNetworkId} 1 1","delay 400"
+	]
 
-		return refreshCmds + enrollResponse()
-	}
+	return refreshCmds + enrollResponse()
+}
 
-	def configure() {
-
-		String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
-		log.debug "Configuring Reporting"
-		
-		def configCmds = [
+def configure() {
+	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
+	log.debug "Configuring Reporting"
 
+	def configCmds = [
 		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
 
 		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 1 {${device.zigbeeId}} {}", "delay 200",
-		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}",		//checkin time 6 hrs
+		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}", "delay 200",		//checkin time 6 hrs
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
 
 		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0x402 {${device.zigbeeId}} {}", "delay 200",
-		"zcl global send-me-a-report 0x402 0 0x29 30 3600 {6400}",
+		"zcl global send-me-a-report 0x402 0 0x29 30 3600 {6400}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
 
 		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0xFC02 {${device.zigbeeId}} {}", "delay 200",
-		"zcl mfg-code 0x104E", 
-		"zcl global send-me-a-report 0xFC02 0x0010 0x18 10 3600 {01}",
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0010 0x18 10 3600 {01}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
 
-		"zcl mfg-code 0x104E",
-		"zcl global send-me-a-report 0xFC02 0x0012 0x29 1 3600 {01}",
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0012 0x29 1 3600 {0100}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
 
-		"zcl mfg-code 0x104E",
-		"zcl global send-me-a-report 0xFC02 0x0013 0x29 1 3600 {01}",
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0013 0x29 1 3600 {0100}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
 
-		"zcl mfg-code 0x104E",
-		"zcl global send-me-a-report 0xFC02 0x0014 0x29 1 3600 {01}",
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0014 0x29 1 3600 {0100}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
-
 		]
-   
-   return configCmds + refresh()
+
+	return configCmds + refresh()
 }
 
 private getEndpointId() {
@@ -442,44 +498,43 @@ def enrollResponse() {
 		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
 		//Enroll Response
-		"raw 0x500 {01 23 00 00 00}",
+		"raw 0x500 {01 23 00 00 00}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 1", "delay 200"
 	]
 }
 
-
 private Map parseAxis(String description) {
-	log.debug "parseAxis"
-	def xyzResults = [x: 0, y: 0, z: 0]
-    def parts = description.split("2900")
-    parts[0] = "12" + parts[0]
-    parts.each { part ->
-    	part = part.trim()
-        if (part.startsWith("12")) {
-    		def unsignedX = hexToInt(part.split("12")[1].trim())
-			def signedX = unsignedX > 32767 ? unsignedX - 65536 : unsignedX
-			xyzResults.x = signedX
-            log.debug "X Part: ${signedX}"
-        }
-        else if (part.startsWith("13")) {
-			def unsignedY = hexToInt(part.split("13")[1].trim())
-			def signedY = unsignedY > 32767 ? unsignedY - 65536 : unsignedY
-			xyzResults.y = signedY
-            log.debug "Y Part: ${signedY}"
-        }
-        else if (part.startsWith("14")) {
-			def unsignedZ = hexToInt(part.split("14")[1].trim())
-			def signedZ = unsignedZ > 32767 ? unsignedZ - 65536 : unsignedZ
-			xyzResults.z = signedZ
-            log.debug "Z Part: ${signedZ}"
-			if (garageSensor == "Yes")
-				garageEvent(signedZ)
-        }
-    }
+	def z = hexToSignedInt(description[0..3])
+	def y = hexToSignedInt(description[10..13])
+	def x = hexToSignedInt(description[20..23])
+	def xyzResults = [x: x, y: y, z: z]
+
+	if (device.getDataValue("manufacturer") == "SmartThings") {
+		// This mapping matches the current behavior of the Device Handler for the Centralite sensors
+		xyzResults.x = z
+		xyzResults.y = y
+		xyzResults.z = -x
+	} else {
+		// The axises reported by the Device Handler differ from the axises reported by the sensor
+		// This may change in the future
+		xyzResults.x = z
+		xyzResults.y = x
+		xyzResults.z = y
+	}
+
+	log.debug "parseAxis -- ${xyzResults}"
+
+	if (garageSensor == "Yes")
+		garageEvent(xyzResults.z)
 
 	getXyzResult(xyzResults, description)
 }
 
+private hexToSignedInt(hexVal) {
+	def unsignedVal = hexToInt(hexVal)
+	unsignedVal > 32767 ? unsignedVal - 65536 : unsignedVal
+}
+
 def garageEvent(zValue) {
 	def absValue = zValue.abs()
 	def contactValue = null
@@ -493,10 +548,9 @@ def garageEvent(zValue) {
 		garageValue = 'garage-open'
 	}
 	if (contactValue != null){
-		def linkText = getLinkText(device)
-		def descriptionText = "${linkText} was ${contactValue == 'open' ? 'opened' : 'closed'}"
-		sendEvent(name: 'contact', value: contactValue, descriptionText: descriptionText, displayed:false)
-		sendEvent(name: 'status', value: garageValue, descriptionText: descriptionText)
+		def descriptionText = contactValue == 'open' ? '{{ device.displayName }} was opened' :'{{ device.displayName }} was closed'
+		sendEvent(name: 'contact', value: contactValue, descriptionText: descriptionText, displayed:false, translatable: true)
+		sendEvent(name: 'status', value: garageValue, descriptionText: descriptionText, translatable: true)
 	}
 }
 
@@ -519,6 +573,14 @@ private Map getXyzResult(results, description) {
 	]
 }
 
+private getManufacturerCode() {
+	if (device.getDataValue("manufacturer") == "SmartThings") {
+		return "0x110A"
+	} else {
+		return "0x104E"
+	}
+}
+
 private hexToInt(value) {
 	new BigInteger(value, 16)
 }
@@ -544,4 +606,3 @@ private byte[] reverseArray(byte[] array) {
 	}
 	return array
 }
-

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

@@ -22,6 +22,8 @@ metadata {
 		capability "Battery"
 
 		fingerprint profileId: "FC01", deviceId: "0139"
+
+		attribute "status", "string"
 	}
 
 	simulator {
@@ -43,8 +45,8 @@ metadata {
 	}
 
 	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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+		input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 	}
 
 	tiles(scale: 2) {
@@ -72,15 +74,12 @@ metadata {
 				]
 			)
 		}
-		valueTile("3axis", "device.threeAxis", decoration: "flat", wordWrap: false, width: 2, height: 2) {
-			state("threeAxis", label:'${currentValue}', unit:"", backgroundColor:"#ffffff")
-		}
 		valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false, width: 2, height: 2) {
 			state "battery", label:'${currentValue}% battery', unit:""
 		}
 
 		main(["contact", "acceleration", "temperature"])
-		details(["contact", "acceleration", "temperature", "3axis", "battery"])
+		details(["contact", "acceleration", "temperature", "battery"])
 	}
 }
 
@@ -102,7 +101,7 @@ def parse(String description) {
 
 }
 
-private Map parseSingleMessage(description) {
+private List parseSingleMessage(description) {
 
 	def name = parseName(description)
 	def value = parseValue(description)
@@ -111,8 +110,9 @@ private Map parseSingleMessage(description) {
 	def handlerName = value == 'open' ? 'opened' : value
 	def isStateChange = isStateChange(device, name, value)
 
-	def results = [
-		name: name,
+	def results = []
+	results << createEvent(
+		name: "contact",
 		value: value,
 		unit: null,
 		linkText: linkText,
@@ -120,8 +120,18 @@ private Map parseSingleMessage(description) {
 		handlerName: handlerName,
 		isStateChange: isStateChange,
 		displayed: displayed(description, isStateChange)
-	]
-	log.debug "Parse results for $device: $results"
+	)
+
+	results << createEvent(
+		name: "status",
+		value: value,
+		unit: null,
+		linkText: linkText,
+		descriptionText: descriptionText,
+		handlerName: handlerName,
+		isStateChange: isStateChange,
+		displayed: displayed(description, isStateChange)
+	)
 
 	results
 }
@@ -193,7 +203,7 @@ private List parseContactMessage(String description) {
 	parts.each { part ->
 		part = part.trim()
 		if (part.startsWith('contactState:')) {
-			results << getContactResult(part, description)
+			results.addAll(getContactResult(part, description))
 		}
 		else if (part.startsWith('accelerationState:')) {
 			results << getAccelerationResult(part, description)
@@ -272,7 +282,7 @@ private List parseRssiLqiMessage(String description) {
 	results
 }
 
-private getContactResult(part, description) {
+private List getContactResult(part, description) {
 	def name = "contact"
 	def value = part.endsWith("1") ? "open" : "closed"
 	def handlerName = value == 'open' ? 'opened' : value
@@ -280,19 +290,33 @@ private getContactResult(part, description) {
 	def descriptionText = "$linkText was $handlerName"
 	def isStateChange = isStateChange(device, name, value)
 
-	[
-		name: name,
-		value: value,
-		unit: null,
-		linkText: linkText,
-		descriptionText: descriptionText,
-		handlerName: handlerName,
-		isStateChange: isStateChange,
-		displayed: displayed(description, isStateChange)
-	]
+	def results = []
+	results << createEvent(
+			name: "contact",
+			value: value,
+			unit: null,
+			linkText: linkText,
+			descriptionText: descriptionText,
+			handlerName: handlerName,
+			isStateChange: isStateChange,
+			displayed:false
+	)
+
+	results << createEvent(
+			name: "status",
+			value: value,
+			unit: null,
+			linkText: linkText,
+			descriptionText: descriptionText,
+			handlerName: handlerName,
+			isStateChange: isStateChange,
+			displayed: displayed(description, isStateChange)
+	)
+
+	results
 }
 
-private getAccelerationResult(part, description) {
+private Map getAccelerationResult(part, description) {
 	def name = "acceleration"
 	def value = part.endsWith("1") ? "active" : "inactive"
 	def linkText = getLinkText(device)
@@ -311,7 +335,7 @@ private getAccelerationResult(part, description) {
 	]
 }
 
-private getTempResult(part, description) {
+private Map getTempResult(part, description) {
 	def name = "temperature"
 	def temperatureScale = getTemperatureScale()
 	def value = zigbee.parseSmartThingsTemperatureValue(part, "temp: ", temperatureScale)
@@ -336,7 +360,7 @@ private getTempResult(part, description) {
 	]
 }
 
-private getXyzResult(results, description) {
+private Map getXyzResult(results, description) {
 	def name = "threeAxis"
 	def value = "${results.x},${results.y},${results.z}"
 	def linkText = getLinkText(device)
@@ -355,7 +379,7 @@ private getXyzResult(results, description) {
 	]
 }
 
-private getBatteryResult(part, description) {
+private Map getBatteryResult(part, description) {
 	def batteryDivisor = description.split(",").find {it.split(":")[0].trim() == "batteryDivisor"} ? description.split(",").find {it.split(":")[0].trim() == "batteryDivisor"}.split(":")[1].trim() : null
 	def name = "battery"
 	def value = zigbee.parseSmartThingsBatteryValue(part, batteryDivisor)
@@ -376,7 +400,7 @@ private getBatteryResult(part, description) {
 	]
 }
 
-private getRssiResult(part, description, lastHop=false) {
+private Map getRssiResult(part, description, lastHop=false) {
 	def name = lastHop ? "lastHopRssi" : "rssi"
 	def valueString = part.split(":")[1].trim()
 	def value = (Integer.parseInt(valueString) - 128).toString()
@@ -407,7 +431,7 @@ private getRssiResult(part, description, lastHop=false) {
  * Note: To make the signal strength indicator more accurate, we could combine
  * LQI with RSSI.
  */
-private getLqiResult(part, description, lastHop=false) {
+private Map getLqiResult(part, description, lastHop=false) {
 	def name = lastHop ? "lastHopLqi" : "lqi"
 	def valueString = part.split(":")[1].trim()
 	def percentageOf = 255
@@ -452,6 +476,7 @@ private Boolean isOrientationMessage(String description) {
 	description ==~ /x:.*y:.*z:.*rssi:.*lqi:.*/
 }
 
+//Note: Not using this method anymore
 private String parseName(String description) {
 	if (isSupportedDescription(description)) {
 		return "contact"

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

@@ -13,6 +13,7 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
+//DEPRECATED - Using the smartsense-multi-sensor.groovy DTH for this device. Users need to be moved before deleting this DTH
 
  metadata {
  	definition (name: "SmartSense Open/Closed Accelerometer Sensor", namespace: "smartthings", author: "SmartThings") {
@@ -23,8 +24,7 @@
  		capability "Refresh"
  		capability "Temperature Measurement"
  		command "enrollResponse"
- 		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05,FC02", outClusters: "0019", manufacturer: "CentraLite", model: "3320"
-		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05,FC02", outClusters: "0019", manufacturer: "CentraLite", model: "3321"
+
  	}
 
  	simulator {
@@ -32,8 +32,8 @@
  	}
 
  	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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+ 		input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
  	}
 
 	tiles(scale: 2) {
@@ -225,7 +225,8 @@ def getTemperature(value) {
 
 		def volts = rawValue / 10
 		def descriptionText
-		if (volts > 3.5) {
+        if (rawValue == 0 || rawValue == 255) {}
+		else if (volts > 3.5) {
 			result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
 		}
 		else {

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

@@ -16,17 +16,18 @@
  
 metadata {
 	definition (name: "SmartSense Open/Closed Sensor", namespace: "smartthings", author: "SmartThings") {
-    	capability "Battery"
+		capability "Battery"
 		capability "Configuration"
-        capability "Contact Sensor"
+		capability "Contact Sensor"
 		capability "Refresh"
 		capability "Temperature Measurement"
         
-        command "enrollResponse"
+		command "enrollResponse"
  
  
 		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3300-S"
-        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3300"
+		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3300"
+		fingerprint inClusters: "0000,0001,0003,0020,0402,0500,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3320-L", deviceJoinName: "Iris Contact Sensor"
 	}
  
 	simulator {
@@ -34,8 +35,8 @@ metadata {
 	}
 
 	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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+		input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 	}
  
 	tiles(scale: 2) {
@@ -219,7 +220,8 @@ private Map getBatteryResult(rawValue) {
     
 	def volts = rawValue / 10
 	def descriptionText
-	if (volts > 3.5) {
+    if (rawValue == 0 || rawValue == 255) {}
+    else if (volts > 3.5) {
 		result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
 	}
 	else {

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

@@ -33,8 +33,8 @@ metadata {
 	}
 
 	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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+		input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 	}
 
 	tiles(scale: 2) {
@@ -196,7 +196,8 @@ private Map getBatteryResult(rawValue) {
 
 	def volts = rawValue / 10
 	def descriptionText
-	if (volts > 3.5) {
+    if (rawValue == 0 || rawValue == 255) {}
+    else if (volts > 3.5) {
 		result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
 	}
 	else {

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

@@ -45,8 +45,8 @@ metadata {
 	}
     
 	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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+		input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 	}    
 
 	tiles {

devicetypes/smartthings/sylvania-ultra-iq.src/sylvania-ultra-iq.groovy

@@ -11,6 +11,9 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
+
+//DEPRECATED - Using the generic DTH for this device. Users need to be moved before deleting this DTH
+
 metadata {
 	definition (name: "Sylvania Ultra iQ", namespace:"smartthings", author: "SmartThings") {
 		capability "Switch Level"

devicetypes/smartthings/testing/simulated-color-control.src/simulated-color-control.groovy

@@ -1,5 +1,5 @@
 metadata {
-	definition (name: "Color Control Capability", namespace: "capabilities", author: "SmartThings") {
+	definition (name: "Simulated Color Control", namespace: "smartthings/testing", author: "SmartThings") {
     	capability "Color Control"
 	}
 

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

@@ -1,5 +1,5 @@
 /**
- *  Copyright 2014 SmartThings
+ *  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:
@@ -15,6 +15,7 @@ metadata {
 	// Automatically generated. Make future change here.
 	definition (name: "Simulated Thermostat", namespace: "smartthings/testing", author: "SmartThings") {
 		capability "Thermostat"
+		capability "Relative Humidity Measurement"
 
 		command "tempUp"
 		command "tempDown"
@@ -22,11 +23,41 @@ metadata {
 		command "heatDown"
 		command "coolUp"
 		command "coolDown"
-        command "setTemperature", ["number"]
+		command "setTemperature", ["number"]
 	}
 
-	tiles {
-		valueTile("temperature", "device.temperature", width: 1, height: 1) {
+	tiles(scale: 2) {
+		multiAttributeTile(name:"thermostatMulti", type:"thermostat", width:6, height:4) {
+			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
+				attributeState("VALUE_UP", action: "tempUp")
+				attributeState("VALUE_DOWN", action: "tempDown")
+			}
+			tileAttribute("device.humidity", key: "SECONDARY_CONTROL") {
+				attributeState("default", label:'${currentValue}%', unit:"%")
+			}
+			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
+				attributeState("idle", backgroundColor:"#44b621")
+				attributeState("heating", backgroundColor:"#ea5462")
+				attributeState("cooling", backgroundColor:"#269bd2")
+			}
+			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {
+				attributeState("off", label:'${name}')
+				attributeState("heat", label:'${name}')
+				attributeState("cool", label:'${name}')
+				attributeState("auto", label:'${name}')
+			}
+			tileAttribute("device.heatingSetpoint", key: "HEATING_SETPOINT") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+			tileAttribute("device.coolingSetpoint", key: "COOLING_SETPOINT") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+		}
+
+		valueTile("temperature", "device.temperature", width: 2, height: 2) {
 			state("temperature", label:'${currentValue}', unit:"dF",
 				backgroundColors:[
 					[value: 31, color: "#153591"],
@@ -39,51 +70,51 @@ metadata {
 				]
 			)
 		}
-		standardTile("tempDown", "device.temperature", inactiveLabel: false, decoration: "flat") {
+		standardTile("tempDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:'down', action:"tempDown"
 		}
-		standardTile("tempUp", "device.temperature", inactiveLabel: false, decoration: "flat") {
+		standardTile("tempUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:'up', action:"tempUp"
 		}
 
-		valueTile("heatingSetpoint", "device.heatingSetpoint", inactiveLabel: false, decoration: "flat") {
+		valueTile("heatingSetpoint", "device.heatingSetpoint", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "heat", label:'${currentValue} heat', unit: "F", backgroundColor:"#ffffff"
 		}
-		standardTile("heatDown", "device.temperature", inactiveLabel: false, decoration: "flat") {
+		standardTile("heatDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:'down', action:"heatDown"
 		}
-		standardTile("heatUp", "device.temperature", inactiveLabel: false, decoration: "flat") {
+		standardTile("heatUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:'up', action:"heatUp"
 		}
 
-		valueTile("coolingSetpoint", "device.coolingSetpoint", inactiveLabel: false, decoration: "flat") {
+		valueTile("coolingSetpoint", "device.coolingSetpoint", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "cool", label:'${currentValue} cool', unit:"F", backgroundColor:"#ffffff"
 		}
-		standardTile("coolDown", "device.temperature", inactiveLabel: false, decoration: "flat") {
+		standardTile("coolDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:'down', action:"coolDown"
 		}
-		standardTile("coolUp", "device.temperature", inactiveLabel: false, decoration: "flat") {
+		standardTile("coolUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:'up', action:"coolUp"
 		}
 
-		standardTile("mode", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
+		standardTile("mode", "device.thermostatMode", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "off", label:'${name}', action:"thermostat.heat", backgroundColor:"#ffffff"
 			state "heat", label:'${name}', action:"thermostat.cool", backgroundColor:"#ffa81e"
 			state "cool", label:'${name}', action:"thermostat.auto", backgroundColor:"#269bd2"
 			state "auto", label:'${name}', action:"thermostat.off", backgroundColor:"#79b821"
 		}
-		standardTile("fanMode", "device.thermostatFanMode", inactiveLabel: false, decoration: "flat") {
+		standardTile("fanMode", "device.thermostatFanMode", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
 			state "fanAuto", label:'${name}', action:"thermostat.fanOn", backgroundColor:"#ffffff"
 			state "fanOn", label:'${name}', action:"thermostat.fanCirculate", backgroundColor:"#ffffff"
 			state "fanCirculate", label:'${name}', action:"thermostat.fanAuto", backgroundColor:"#ffffff"
 		}
-		standardTile("operatingState", "device.thermostatOperatingState") {
+		standardTile("operatingState", "device.thermostatOperatingState", width: 2, height: 2) {
 			state "idle", label:'${name}', backgroundColor:"#ffffff"
 			state "heating", label:'${name}', backgroundColor:"#ffa81e"
 			state "cooling", label:'${name}', backgroundColor:"#269bd2"
 		}
 
-		main("temperature","operatingState")
+		main("thermostatMulti")
 		details([
 			"temperature","tempDown","tempUp",
 			"mode", "fanMode", "operatingState",
@@ -101,6 +132,7 @@ def installed() {
 	sendEvent(name: "thermostatMode", value: "off")
 	sendEvent(name: "thermostatFanMode", value: "fanAuto")
 	sendEvent(name: "thermostatOperatingState", value: "idle")
+	sendEvent(name: "humidity", value: 53, unit: "%")
 }
 
 def parse(String description) {

devicetypes/smartthings/tile-ux/tile-basic-carousel.src/tile-basic-carousel.groovy

@@ -0,0 +1,225 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "carouselDeviceTile",
+		namespace: "smartthings/tile-ux",
+		author: "SmartThings") {
+
+		capability "Thermostat"
+		capability "Relative Humidity Measurement"
+
+		command "tempUp"
+		command "tempDown"
+		command "heatUp"
+		command "heatDown"
+		command "coolUp"
+		command "coolDown"
+		command "setTemperature", ["number"]
+	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name:"thermostatMulti", type:"thermostat", width:6, height:4) {
+			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
+				attributeState("default", action: "setTemperature")
+			}
+			tileAttribute("device.humidity", key: "SECONDARY_CONTROL") {
+				attributeState("default", label:'${currentValue}%', unit:"%")
+			}
+			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
+				attributeState("idle", backgroundColor:"#44b621")
+				attributeState("heating", backgroundColor:"#ffa81e")
+				attributeState("cooling", backgroundColor:"#269bd2")
+			}
+			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {
+				attributeState("off", label:'${name}')
+				attributeState("heat", label:'${name}')
+				attributeState("cool", label:'${name}')
+				attributeState("auto", label:'${name}')
+			}
+			tileAttribute("device.heatingSetpoint", key: "HEATING_SETPOINT") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+			tileAttribute("device.coolingSetpoint", key: "COOLING_SETPOINT") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+		}
+
+		main("thermostatMulti")
+		details([
+			"thermostatMulti"
+		])
+	}
+}
+
+def installed() {
+	sendEvent(name: "temperature", value: 72, unit: "F")
+	sendEvent(name: "heatingSetpoint", value: 70, unit: "F")
+	sendEvent(name: "thermostatSetpoint", value: 70, unit: "F")
+	sendEvent(name: "coolingSetpoint", value: 76, unit: "F")
+	sendEvent(name: "thermostatMode", value: "off")
+	sendEvent(name: "thermostatFanMode", value: "fanAuto")
+	sendEvent(name: "thermostatOperatingState", value: "idle")
+	sendEvent(name: "humidity", value: 53, unit: "%")
+}
+
+def parse(String description) {
+}
+
+def evaluate(temp, heatingSetpoint, coolingSetpoint) {
+	log.debug "evaluate($temp, $heatingSetpoint, $coolingSetpoint"
+	def threshold = 1.0
+	def current = device.currentValue("thermostatOperatingState")
+	def mode = device.currentValue("thermostatMode")
+
+	def heating = false
+	def cooling = false
+	def idle = false
+	if (mode in ["heat","emergency heat","auto"]) {
+		if (heatingSetpoint - temp >= threshold) {
+			heating = true
+			sendEvent(name: "thermostatOperatingState", value: "heating")
+		}
+		else if (temp - heatingSetpoint >= threshold) {
+			idle = true
+		}
+		sendEvent(name: "thermostatSetpoint", value: heatingSetpoint)
+	}
+	if (mode in ["cool","auto"]) {
+		if (temp - coolingSetpoint >= threshold) {
+			cooling = true
+			sendEvent(name: "thermostatOperatingState", value: "cooling")
+		}
+		else if (coolingSetpoint - temp >= threshold && !heating) {
+			idle = true
+		}
+		sendEvent(name: "thermostatSetpoint", value: coolingSetpoint)
+	}
+	else {
+		sendEvent(name: "thermostatSetpoint", value: heatingSetpoint)
+	}
+	if (idle && !heating && !cooling) {
+		sendEvent(name: "thermostatOperatingState", value: "idle")
+	}
+}
+
+def setHeatingSetpoint(Double degreesF) {
+	log.debug "setHeatingSetpoint($degreesF)"
+	sendEvent(name: "heatingSetpoint", value: degreesF)
+	evaluate(device.currentValue("temperature"), degreesF, device.currentValue("coolingSetpoint"))
+}
+
+def setCoolingSetpoint(Double degreesF) {
+	log.debug "setCoolingSetpoint($degreesF)"
+	sendEvent(name: "coolingSetpoint", value: degreesF)
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), degreesF)
+}
+
+def setThermostatMode(String value) {
+	sendEvent(name: "thermostatMode", value: value)
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def setThermostatFanMode(String value) {
+	sendEvent(name: "thermostatFanMode", value: value)
+}
+
+def off() {
+	sendEvent(name: "thermostatMode", value: "off")
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def heat() {
+	sendEvent(name: "thermostatMode", value: "heat")
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def auto() {
+	sendEvent(name: "thermostatMode", value: "auto")
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def emergencyHeat() {
+	sendEvent(name: "thermostatMode", value: "emergency heat")
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def cool() {
+	sendEvent(name: "thermostatMode", value: "cool")
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def fanOn() {
+	sendEvent(name: "thermostatFanMode", value: "fanOn")
+}
+
+def fanAuto() {
+	sendEvent(name: "thermostatFanMode", value: "fanAuto")
+}
+
+def fanCirculate() {
+	sendEvent(name: "thermostatFanMode", value: "fanCirculate")
+}
+
+def tempUp() {
+	def ts = device.currentState("temperature")
+	def value = ts ? ts.integerValue + 1 : 72
+	sendEvent(name:"temperature", value: value)
+	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def tempDown() {
+	def ts = device.currentState("temperature")
+	def value = ts ? ts.integerValue - 1 : 72
+	sendEvent(name:"temperature", value: value)
+	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def setTemperature(value) {
+	def ts = device.currentState("temperature")
+	sendEvent(name:"temperature", value: value)
+	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def heatUp() {
+	def ts = device.currentState("heatingSetpoint")
+	def value = ts ? ts.integerValue + 1 : 68
+	sendEvent(name:"heatingSetpoint", value: value)
+	evaluate(device.currentValue("temperature"), value, device.currentValue("coolingSetpoint"))
+}
+
+def heatDown() {
+	def ts = device.currentState("heatingSetpoint")
+	def value = ts ? ts.integerValue - 1 : 68
+	sendEvent(name:"heatingSetpoint", value: value)
+	evaluate(device.currentValue("temperature"), value, device.currentValue("coolingSetpoint"))
+}
+
+
+def coolUp() {
+	def ts = device.currentState("coolingSetpoint")
+	def value = ts ? ts.integerValue + 1 : 76
+	sendEvent(name:"coolingSetpoint", value: value)
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), value)
+}
+
+def coolDown() {
+	def ts = device.currentState("coolingSetpoint")
+	def value = ts ? ts.integerValue - 1 : 76
+	sendEvent(name:"coolingSetpoint", value: value)
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), value)
+}

devicetypes/smartthings/tile-ux/tile-basic-colorwheel.src/tile-basic-colorwheel.groovy

@@ -0,0 +1,52 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "colorWheelDeviceTile",
+		namespace: "smartthings/tile-ux",
+		author: "SmartThings") {
+
+		capability "Color Control"
+	}
+
+	tiles(scale: 2) {
+		valueTile("currentColor", "device.color") {
+			state "default", label: '${currentValue}'
+		}
+
+		controlTile("rgbSelector", "device.color", "color", height: 6, width: 6, inactiveLabel: false) {
+			state "color", action: "color control.setColor"
+		}
+
+		main("currentColor")
+		details([
+			"rgbSelector"
+		])
+	}
+}
+
+// parse events into attributes
+def parse(String description) {
+	log.debug "Parsing '${description}'"
+}
+
+def setSaturation(percent) {
+	log.debug "Executing 'setSaturation'"
+	sendEvent(name: "saturation", value: percent)
+}
+
+def setHue(percent) {
+	log.debug "Executing 'setHue'"
+	sendEvent(name: "hue", value: percent)
+}

devicetypes/smartthings/tile-ux/tile-basic-presence.src/tile-basic-presence.groovy

@@ -0,0 +1,63 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "presenceDeviceTile",
+		namespace: "smartthings/tile-ux",
+		author: "SmartThings") {
+
+		capability "Presence Sensor"
+
+		command "arrived"
+		command "departed"
+	}
+
+	tiles(scale: 2) {
+		// You only get a presence tile view when the size is 3x3 otherwise it's a value tile
+		standardTile("presence", "device.presence", width: 3, height: 3, canChangeBackground: true) {
+			state("present", labelIcon:"st.presence.tile.mobile-present", backgroundColor:"#53a7c0")
+			state("not present", labelIcon:"st.presence.tile.mobile-not-present", backgroundColor:"#ebeef2")
+		}
+
+		standardTile("notPresentBtn", "device.fake", width: 3, height: 3, decoration: "flat") {
+			state("not present", label:'not present', backgroundColor:"#ffffff", action:"departed")
+		}
+
+		standardTile("presentBtn", "device.fake", width: 3, height: 3, decoration: "flat") {
+			state("present", label:'present', backgroundColor:"#53a7c0", action:"arrived")
+		}
+
+		main("presence")
+		details([
+			"presence", "presenceControl", "notPresentBtn", "presentBtn"
+		])
+	}
+}
+
+def installed() {
+	sendEvent(name: "presence", value: "present")
+}
+
+def parse(String description) {
+}
+
+def arrived() {
+	log.trace "Executing 'arrived'"
+	sendEvent(name: "presence", value: "present")
+}
+
+def departed() {
+	log.trace "Executing 'arrived'"
+	sendEvent(name: "presence", value: "not present")
+}

devicetypes/smartthings/tile-ux/tile-basic-slider.src/tile-basic-slider.groovy

@@ -0,0 +1,75 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "sliderDeviceTile",
+		namespace: "smartthings/tile-ux",
+		author: "SmartThings") {
+
+		capability "Switch Level"
+		command "setRangedLevel", ["number"]
+	}
+
+	tiles(scale: 2) {
+		controlTile("tinySlider", "device.level", "slider", height: 2, width: 2, inactiveLabel: false) {
+			state "level", action:"switch level.setLevel"
+		}
+
+		controlTile("mediumSlider", "device.level", "slider", height: 2, width: 4, inactiveLabel: false) {
+			state "level", action:"switch level.setLevel"
+		}
+
+		controlTile("largeSlider", "device.level", "slider", decoration: "flat", height: 2, width: 6, inactiveLabel: false) {
+			state "level", action:"switch level.setLevel"
+		}
+
+		controlTile("rangeSlider", "device.rangedLevel", "slider", height: 2, width: 4, range: "(20..80)") {
+			state "level", action:"setRangedLevel"
+		}
+
+		valueTile("rangeValue", "device.rangedLevel", height: 2, width: 2) {
+			state "default", label:'${currentValue}'
+		}
+
+		controlTile("rangeSliderConstrained", "device.rangedLevel", "slider", height: 2, width: 4, range: "(40..60)") {
+			state "level", action:"setRangedLevel"
+		}
+
+		main("rangeValue")
+		details([
+			"tinySlider", "mediumSlider",
+			"largeSlider",
+			"rangeSlider", "rangeValue",
+			"rangeSliderConstrained"
+		])
+	}
+}
+
+def installed() {
+	sendEvent(name: "level", value: 63)
+	sendEvent(name: "rangedLevel", value: 47)
+}
+
+def parse(String description) {
+}
+
+def setLevel(value) {
+	log.debug "setting level to $value"
+	sendEvent(name:"level", value:value)
+}
+
+def setRangedLevel(value) {
+	log.debug "setting ranged level to $value"
+	sendEvent(name:"rangedLevel", value:value)
+}

devicetypes/smartthings/tile-ux/tile-basic-standard.src/tile-basic-standard.groovy

@@ -0,0 +1,109 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "standardDeviceTile",
+		namespace: "smartthings/tile-ux",
+		author: "SmartThings") {
+
+		capability "Switch"
+	}
+
+	tiles(scale: 2) {
+		// standard tile with actions
+		standardTile("actionRings", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+			state "off", label: '${currentValue}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
+			state "on", label: '${currentValue}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+		}
+
+		// standard flat tile with actions
+		standardTile("actionFlat", "device.switch", width: 2, height: 2, canChangeIcon: true, decoration: "flat") {
+			state "off", label: '${currentValue}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
+			state "on", label: '${currentValue}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+		}
+
+		// standard flat tile without actions
+		standardTile("noActionFlat", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+			state "off", label: '${currentValue}',icon: "st.switches.switch.off", backgroundColor: "#ffffff"
+			state "on", label: '${currentValue}', icon: "st.switches.switch.on", backgroundColor: "#79b821"
+		}
+
+		// standard flat tile with only a label
+		standardTile("flatLabel", "device.switch", width: 2, height: 2, decoration: "flat") {
+			state "default", label: 'On Action', action: "switch.on", backgroundColor: "#ffffff"
+		}
+
+		// standard flat tile with icon and label
+		standardTile("flatIconLabel", "device.switch", width: 2, height: 2, decoration: "flat") {
+			state "default", label: 'Off Action', action: "switch.off", icon:"st.switches.switch.off", backgroundColor: "#ffffff"
+		}
+
+		// standard flat tile with only icon (Refreh text is IN the icon file)
+		standardTile("flatIcon", "device.switch", width: 2, height: 2, decoration: "flat") {
+			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+
+		// standard with defaultState = true
+		standardTile("flatDefaultState", "null", width: 2, height: 2, decoration: "flat") {
+			state "off", label: 'Fail!', icon: "st.switches.switch.off"
+			state "on", label: 'Pass!', icon: "st.switches.switch.on", defaultState: true
+		}
+
+		// standard with implicit defaultState based on order (0 index is selected)
+		standardTile("flatImplicitDefaultState1", "null", width: 2, height: 2, decoration: "flat") {
+			state "on", label: 'Pass!', icon: "st.switches.switch.on"
+			state "off", label: 'Fail!', icon: "st.switches.switch.off"
+		}
+
+		// standard with implicit defaultState based on state.name == default
+		standardTile("flatImplicitDefaultState2", "null", width: 2, height: 2, decoration: "flat") {
+			state "off", label: 'Fail!', icon: "st.switches.switch.off"
+			state "default", label: 'Pass!', icon: "st.switches.switch.on"
+		}
+
+		// utility tiles to fill the spaces
+		standardTile("empty2x2", "null", width: 2, height: 2, decoration: "flat") {
+			state "default", label:''
+		}
+		standardTile("empty4x2", "null", width: 4, height: 2, decoration: "flat") {
+			state "default", label:''
+		}
+
+		main("standard1")
+		details([
+			"actionRings", "actionFlat", "noActionFlat",
+
+			"flatLabel", "flatIconLabel", "flatIcon",
+
+			"flatDefaultState", "flatImplicitDefaultState1", "flatImplicitDefaultState2",
+		])
+	}
+}
+
+def installed() {
+	sendEvent(name: "switch", value: "off")
+}
+
+def parse(String description) {
+}
+
+def on() {
+	log.debug "on()"
+	sendEvent(name: "switch", value: "on")
+}
+
+def off() {
+	log.debug "off()"
+	sendEvent(name: "switch", value: "off")
+}

devicetypes/smartthings/tile-ux/tile-basic-value.src/tile-basic-value.groovy

@@ -0,0 +1,96 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "valueDeviceTile",
+		namespace: "smartthings/tile-ux",
+		author: "SmartThings") {
+
+		capability "Sensor"
+	}
+
+	tiles(scale: 2) {
+		valueTile("text", "device.text", width: 2, height: 2) {
+			state "default", label:'${currentValue}'
+		}
+
+		valueTile("longText", "device.longText", width: 2, height: 2) {
+			state "default", label:'${currentValue}'
+		}
+
+		valueTile("integer", "device.integer", width: 2, height: 2) {
+			state "default", label:'${currentValue}'
+		}
+
+		valueTile("integerFloat", "device.integerFloat", width: 2, height: 2) {
+			state "default", label:'${currentValue}'
+		}
+
+		valueTile("pi", "device.pi", width: 2, height: 2) {
+			state "default", label:'${currentValue}'
+		}
+
+		valueTile("floatAsText", "device.floatAsText", width: 2, height: 2) {
+			state "default", label:'${currentValue}'
+		}
+
+		valueTile("bgColor", "device.integer", width: 2, height: 2) {
+			state "default", label:'${currentValue}', backgroundColor: "#e86d13"
+		}
+
+		valueTile("bgColorRange", "device.integer", width: 2, height: 2) {
+			state "default", label:'${currentValue}', backgroundColors: [
+				[value: 10, color: "#ff0000"],
+				[value: 90, color: "#0000ff"]
+			]
+		}
+
+		valueTile("bgColorRangeSingleItem", "device.integer", width: 2, height: 2) {
+			state "default", label:'${currentValue}', backgroundColors: [
+				[value: 10, color: "#333333"]
+			]
+		}
+
+		valueTile("bgColorRangeConflict", "device.integer", width: 2, height: 2) {
+			state "default", label:'${currentValue}', backgroundColors: [
+				[value: 10, color: "#990000"],
+				[value: 10, color: "#000099"]
+			]
+		}
+
+		valueTile("noValue", "device.nada", width: 2, height: 2) {
+			state "default", label:'${currentValue}'
+		}
+
+		main("text")
+		details([
+			"text", "longText", "integer", 
+            "integerFloat", "pi", "floatAsText",
+            "bgColor", "bgColorRange", "bgColorRangeSingleItem",
+            "bgColorRangeConflict", "noValue"
+		])
+	}
+}
+
+def installed() {
+	sendEvent(name: "text", value: "Test")
+	sendEvent(name: "longText", value: "The Longer The Text, The Better The Test")
+	sendEvent(name: "integer", value: 47)
+	sendEvent(name: "integerFloat", value: 47.0)
+	sendEvent(name: "pi", value: 3.14159)
+	sendEvent(name: "floatAsText", value: "3.14159")
+}
+
+def parse(String description) {
+}

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

@@ -0,0 +1,118 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "genericDeviceTile", namespace: "smartthings/tile-ux", author: "SmartThings") {
+		capability "Actuator"
+		capability "Switch"
+		capability "Switch Level"
+
+		command "levelUp"
+		command "levelDown"
+		command "randomizeLevel"
+	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name:"basicTile", type:"generic", width:6, height:4) {
+			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"
+			}
+		}
+		multiAttributeTile(name:"sliderTile", type:"generic", width:6, height:4) {
+			tileAttribute("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "on", label:'${name}', backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'${name}', backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+			tileAttribute("device.level", key: "SECONDARY_CONTROL") {
+				attributeState "default", icon: 'st.Weather.weather1', action:"randomizeLevel"
+			}
+			tileAttribute("device.level", key: "SLIDER_CONTROL") {
+				attributeState "default", action:"switch level.setLevel"
+			}
+		}
+		multiAttributeTile(name:"valueTile", type:"generic", width:6, height:4) {
+			tileAttribute("device.level", key: "PRIMARY_CONTROL") {
+				attributeState "default", label:'${currentValue}', backgroundColors:[
+					[value: 0, color: "#ff0000"],
+					[value: 20, color: "#ffff00"],
+					[value: 40, color: "#00ff00"],
+					[value: 60, color: "#00ffff"],
+					[value: 80, color: "#0000ff"],
+					[value: 100, color: "#ff00ff"]
+				]
+			}
+			tileAttribute("device.switch", key: "SECONDARY_CONTROL") {
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'…', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'…', action:"switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+			tileAttribute("device.level", key: "VALUE_CONTROL") {
+				attributeState "VALUE_UP", action: "levelUp"
+				attributeState "VALUE_DOWN", action: "levelDown"
+			}
+		}
+
+		main(["basicTile"])
+		details(["basicTile", "sliderTile", "valueTile"])
+	}
+}
+
+def installed() {
+
+}
+
+def parse() {
+	// This is a simulated device. No incoming data to parse.
+}
+
+def on() {
+	log.debug "turningOn"
+	sendEvent(name: "switch", value: "on")
+}
+
+def off() {
+	log.debug "turningOff"
+	sendEvent(name: "switch", value: "off")
+}
+
+def setLevel(percent) {
+	log.debug "setLevel: ${percent}, this"
+	sendEvent(name: "level", value: percent)
+}
+
+def randomizeLevel() {
+	def level = Math.round(Math.random() * 100)
+	setLevel(level)
+}
+
+def levelUp() {
+	def level = device.latestValue("level") as Integer ?: 0
+	if (level < 100) {
+		level = level + 1
+	}
+	setLevel(level)
+}
+
+def levelDown() {
+	def level = device.latestValue("level") as Integer ?: 0
+	if (level > 0) {
+		level = level - 1
+	}
+	setLevel(level)
+}

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

@@ -0,0 +1,211 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "lightingDeviceTile",
+		namespace: "smartthings/tile-ux",
+		author: "SmartThings") {
+
+		capability "Switch Level"
+		capability "Actuator"
+		capability "Color Control"
+		capability "Power Meter"
+		capability "Switch"
+		capability "Refresh"
+		capability "Sensor"
+
+		command "setAdjustedColor"
+		command "reset"
+		command "refresh"
+	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true) {
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+			tileAttribute ("device.power", key: "SECONDARY_CONTROL") {
+				attributeState "power", label:'Power level: ${currentValue}W', icon: "st.Appliances.appliances17"
+			}
+			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+				attributeState "level", action:"switch level.setLevel"
+			}
+			tileAttribute ("device.color", key: "COLOR_CONTROL") {
+				attributeState "color", action:"setAdjustedColor"
+			}
+		}
+
+		multiAttributeTile(name:"switchNoPower", type: "lighting", width: 6, height: 4, canChangeIcon: true) {
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+				attributeState "level", action:"switch level.setLevel"
+			}
+			tileAttribute ("device.color", key: "COLOR_CONTROL") {
+				attributeState "color", action:"setAdjustedColor"
+			}
+		}
+
+		multiAttributeTile(name:"switchNoSlider", type: "lighting", width: 6, height: 4, canChangeIcon: true) {
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+			tileAttribute ("device.power", key: "SECONDARY_CONTROL") {
+				attributeState "power", label:'The power level is currently: ${currentValue}W', icon: "st.Appliances.appliances17"
+			}
+			tileAttribute ("device.color", key: "COLOR_CONTROL") {
+				attributeState "color", action:"setAdjustedColor"
+			}
+		}
+
+		multiAttributeTile(name:"switchNoSliderOrColor", type: "lighting", width: 6, height: 4, canChangeIcon: true) {
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+			tileAttribute ("device.power", key: "SECONDARY_CONTROL") {
+				attributeState "power", label:'The light is currently consuming this amount of power: ${currentValue}W', icon: "st.Appliances.appliances17"
+			}
+		}
+
+		valueTile("color", "device.color", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "color", label: '${currentValue}'
+		}
+
+		standardTile("reset", "device.reset", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "default", label:"Reset Color", action:"reset", icon:"st.lights.philips.hue-single"
+		}
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+
+		main(["switch"])
+		details(["switch", "switchNoPower", "switchNoSlider", "switchNoSliderOrColor", "color", "refresh", "reset"])
+	}
+}
+
+// parse events into attributes
+def parse(description) {
+	log.debug "parse() - $description"
+	def results = []
+	def map = description
+	if (description instanceof String)  {
+		log.debug "Hue Bulb stringToMap - ${map}"
+		map = stringToMap(description)
+	}
+	if (map?.name && map?.value) {
+		results << createEvent(name: "${map?.name}", value: "${map?.value}")
+	}
+	results
+}
+
+// handle commands
+def on() {
+	//log.trace parent.on(this)
+	sendEvent(name: "switch", value: "on")
+}
+
+def off() {
+	//log.trace parent.off(this)
+	sendEvent(name: "switch", value: "off")
+}
+
+def 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)
+}
+
+def setLevel(percent) {
+	log.debug "setLevel: ${percent}, this"
+	sendEvent(name: "level", value: percent)
+	def power = Math.round(percent / 1.175) * 0.1
+	sendEvent(name: "power", value: power)
+}
+
+def setSaturation(percent) {
+	log.debug "setSaturation: ${percent}, $this"
+	sendEvent(name: "saturation", value: percent)
+}
+
+def setHue(percent) {
+	log.debug "setHue: ${percent}, $this"
+	sendEvent(name: "hue", value: percent)
+}
+
+def setColor(value) {
+	log.debug "setColor: ${value}, $this"
+	if (value.hue) { sendEvent(name: "hue", value: value.hue)}
+	if (value.saturation) { sendEvent(name: "saturation", value: value.saturation)}
+	if (value.hex) { sendEvent(name: "color", value: value.hex)}
+	if (value.level) { sendEvent(name: "level", value: value.level)}
+	if (value.switch) { sendEvent(name: "switch", value: value.switch)}
+}
+
+def reset() {
+	log.debug "Executing 'reset'"
+	setAdjustedColor([level:100, hex:"#90C638", saturation:56, hue:23])
+	//parent.poll()
+}
+
+def 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)
+	}
+}
+
+def 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
+}
+

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

@@ -0,0 +1,122 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "mediaPlayerDeviceTile",
+		namespace: "smartthings/tile-ux",
+		author: "SmartThings") {
+
+		capability "Actuator"
+		capability "Switch"
+		capability "Refresh"
+		capability "Sensor"
+		capability "Music Player"
+	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name: "mediaMulti", type:"mediaPlayer", width:6, height:4) {
+			tileAttribute("device.status", key: "PRIMARY_CONTROL") {
+				attributeState("paused", label:"Paused",)
+				attributeState("playing", label:"Playing")
+				attributeState("stopped", label:"Stopped")
+			}
+			tileAttribute("device.status", key: "MEDIA_STATUS") {
+				attributeState("paused", label:"Paused", action:"music Player.play", nextState: "playing")
+				attributeState("playing", label:"Playing", action:"music Player.pause", nextState: "paused")
+				attributeState("stopped", label:"Stopped", action:"music Player.play", nextState: "playing")
+			}
+			tileAttribute("device.status", key: "PREVIOUS_TRACK") {
+				attributeState("default", action:"music Player.previousTrack")
+			}
+			tileAttribute("device.status", key: "NEXT_TRACK") {
+				attributeState("default", action:"music Player.nextTrack")
+			}
+			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+				attributeState("level", action:"music Player.setLevel")
+			}
+			tileAttribute ("device.mute", key: "MEDIA_MUTED") {
+				attributeState("unmuted", action:"music Player.mute", nextState: "muted")
+				attributeState("muted", action:"music Player.unmute", nextState: "unmuted")
+			}
+			tileAttribute("device.trackDescription", key: "MARQUEE") {
+				attributeState("default", label:"${currentValue}")
+			}
+		}
+
+		main "mediaMulti"
+		details(["mediaMulti"])
+	}
+}
+
+def installed() {
+	state.tracks = [
+		"Gangnam Style (강남스타일)\nPSY\nPsy 6 (Six Rules), Part 1",
+		"Careless Whisper\nWham!\nMake It Big",
+		"Never Gonna Give You Up\nRick Astley\nWhenever You Need Somebody",
+		"Shake It Off\nTaylor Swift\n1989",
+		"Ironic\nAlanis Morissette\nJagged Little Pill",
+		"Hotline Bling\nDrake\nHotline Bling - Single"
+	]
+	state.currentTrack = 0
+
+	sendEvent(name: "level", value: 72)
+	sendEvent(name: "mute", value: "unmuted")
+	sendEvent(name: "status", value: "stopped")
+}
+
+def parse(description) {
+	// No parsing will happen with this simulated device.
+}
+
+def play() {
+	sendEvent(name: "status", value: "playing")
+	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
+}
+
+def pause() {
+	sendEvent(name: "status", value: "paused")
+	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
+}
+
+def stop() {
+	sendEvent(name: "status", value: "stopped")
+}
+
+def previousTrack() {
+	state.currentTrack = state.currentTrack - 1
+	if (state.currentTrack < 0)
+		state.currentTrack = state.tracks.size()-1
+
+	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
+}
+
+def nextTrack() {
+	state.currentTrack = state.currentTrack + 1
+	if (state.currentTrack == state.tracks.size())
+		state.currentTrack = 0
+
+	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
+}
+
+def mute() {
+	sendEvent(name: "mute", value: "muted")
+}
+
+def unmute() {
+	sendEvent(name: "mute", value: "unmuted")
+}
+
+def setLevel(level) {
+	sendEvent(name: "level", value: level)
+}

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

@@ -0,0 +1,341 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "thermostatDeviceTile",
+		namespace: "smartthings/tile-ux",
+		author: "SmartThings") {
+
+		capability "Thermostat"
+		capability "Relative Humidity Measurement"
+
+		command "tempUp"
+		command "tempDown"
+		command "heatUp"
+		command "heatDown"
+		command "coolUp"
+		command "coolDown"
+		command "setTemperature", ["number"]
+	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name:"thermostatFull", type:"thermostat", width:6, height:4) {
+			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
+				attributeState("VALUE_UP", action: "tempUp")
+				attributeState("VALUE_DOWN", action: "tempDown")
+			}
+			tileAttribute("device.humidity", key: "SECONDARY_CONTROL") {
+				attributeState("default", label:'${currentValue}%', unit:"%")
+			}
+			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
+				attributeState("idle", backgroundColor:"#44b621")
+				attributeState("heating", backgroundColor:"#ffa81e")
+				attributeState("cooling", backgroundColor:"#269bd2")
+			}
+			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {
+				attributeState("off", label:'${name}')
+				attributeState("heat", label:'${name}')
+				attributeState("cool", label:'${name}')
+				attributeState("auto", label:'${name}')
+			}
+			tileAttribute("device.heatingSetpoint", key: "HEATING_SETPOINT") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+			tileAttribute("device.coolingSetpoint", key: "COOLING_SETPOINT") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+		}
+		multiAttributeTile(name:"thermostatNoHumidity", type:"thermostat", width:6, height:4) {
+			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
+				attributeState("VALUE_UP", action: "tempUp")
+				attributeState("VALUE_DOWN", action: "tempDown")
+			}
+			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
+				attributeState("idle", backgroundColor:"#44b621")
+				attributeState("heating", backgroundColor:"#ffa81e")
+				attributeState("cooling", backgroundColor:"#269bd2")
+			}
+			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {
+				attributeState("off", label:'${name}')
+				attributeState("heat", label:'${name}')
+				attributeState("cool", label:'${name}')
+				attributeState("auto", label:'${name}')
+			}
+			tileAttribute("device.heatingSetpoint", key: "HEATING_SETPOINT") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+			tileAttribute("device.coolingSetpoint", key: "COOLING_SETPOINT") {
+				attributeState("default", label:'${currentValue}', unit:"dF")
+			}
+		}
+		multiAttributeTile(name:"thermostatBasic", type:"thermostat", width:6, height:4) {
+			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
+				attributeState("default", label:'${currentValue}', unit:"dF",
+				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"]
+				])
+			}
+			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
+				attributeState("VALUE_UP", action: "tempUp")
+				attributeState("VALUE_DOWN", action: "tempDown")
+			}
+		}
+
+		valueTile("temperature", "device.temperature", width: 2, height: 2) {
+			state("temperature", label:'${currentValue}', unit:"dF",
+				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"]
+				]
+			)
+		}
+		standardTile("tempDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "default", label:'down', action:"tempDown"
+		}
+		standardTile("tempUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "default", label:'up', action:"tempUp"
+		}
+
+		valueTile("heatingSetpoint", "device.heatingSetpoint", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "heat", label:'${currentValue} heat', unit: "F", backgroundColor:"#ffffff"
+		}
+		standardTile("heatDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "default", label:'down', action:"heatDown"
+		}
+		standardTile("heatUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "default", label:'up', action:"heatUp"
+		}
+
+		valueTile("coolingSetpoint", "device.coolingSetpoint", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "cool", label:'${currentValue} cool', unit:"F", backgroundColor:"#ffffff"
+		}
+		standardTile("coolDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "default", label:'down', action:"coolDown"
+		}
+		standardTile("coolUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "default", label:'up', action:"coolUp"
+		}
+
+		standardTile("mode", "device.thermostatMode", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "off", label:'${name}', action:"thermostat.heat", backgroundColor:"#ffffff"
+			state "heat", label:'${name}', action:"thermostat.cool", backgroundColor:"#ffa81e"
+			state "cool", label:'${name}', action:"thermostat.auto", backgroundColor:"#269bd2"
+			state "auto", label:'${name}', action:"thermostat.off", backgroundColor:"#79b821"
+		}
+		standardTile("fanMode", "device.thermostatFanMode", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+			state "fanAuto", label:'${name}', action:"thermostat.fanOn", backgroundColor:"#ffffff"
+			state "fanOn", label:'${name}', action:"thermostat.fanCirculate", backgroundColor:"#ffffff"
+			state "fanCirculate", label:'${name}', action:"thermostat.fanAuto", backgroundColor:"#ffffff"
+		}
+		standardTile("operatingState", "device.thermostatOperatingState", width: 2, height: 2) {
+			state "idle", label:'${name}', backgroundColor:"#ffffff"
+			state "heating", label:'${name}', backgroundColor:"#ffa81e"
+			state "cooling", label:'${name}', backgroundColor:"#269bd2"
+		}
+
+
+		main("thermostatFull")
+		details([
+			"thermostatFull", "thermostatNoHumidity", "thermostatBasic",
+			"temperature","tempDown","tempUp",
+			"mode", "fanMode", "operatingState",
+			"heatingSetpoint", "heatDown", "heatUp",
+			"coolingSetpoint", "coolDown", "coolUp"
+		])
+	}
+}
+
+def installed() {
+	sendEvent(name: "temperature", value: 72, unit: "F")
+	sendEvent(name: "heatingSetpoint", value: 70, unit: "F")
+	sendEvent(name: "thermostatSetpoint", value: 70, unit: "F")
+	sendEvent(name: "coolingSetpoint", value: 76, unit: "F")
+	sendEvent(name: "thermostatMode", value: "off")
+	sendEvent(name: "thermostatFanMode", value: "fanAuto")
+	sendEvent(name: "thermostatOperatingState", value: "idle")
+	sendEvent(name: "humidity", value: 53, unit: "%")
+}
+
+def parse(String description) {
+}
+
+def evaluate(temp, heatingSetpoint, coolingSetpoint) {
+	log.debug "evaluate($temp, $heatingSetpoint, $coolingSetpoint"
+	def threshold = 1.0
+	def current = device.currentValue("thermostatOperatingState")
+	def mode = device.currentValue("thermostatMode")
+
+	def heating = false
+	def cooling = false
+	def idle = false
+	if (mode in ["heat","emergency heat","auto"]) {
+		if (heatingSetpoint - temp >= threshold) {
+			heating = true
+			sendEvent(name: "thermostatOperatingState", value: "heating")
+		}
+		else if (temp - heatingSetpoint >= threshold) {
+			idle = true
+		}
+		sendEvent(name: "thermostatSetpoint", value: heatingSetpoint)
+	}
+	if (mode in ["cool","auto"]) {
+		if (temp - coolingSetpoint >= threshold) {
+			cooling = true
+			sendEvent(name: "thermostatOperatingState", value: "cooling")
+		}
+		else if (coolingSetpoint - temp >= threshold && !heating) {
+			idle = true
+		}
+		sendEvent(name: "thermostatSetpoint", value: coolingSetpoint)
+	}
+	else {
+		sendEvent(name: "thermostatSetpoint", value: heatingSetpoint)
+	}
+
+	if (mode == "off") {
+		idle = true
+	}
+
+	if (idle && !heating && !cooling) {
+		sendEvent(name: "thermostatOperatingState", value: "idle")
+	}
+}
+
+def setHeatingSetpoint(Double degreesF) {
+	log.debug "setHeatingSetpoint($degreesF)"
+	sendEvent(name: "heatingSetpoint", value: degreesF)
+	evaluate(device.currentValue("temperature"), degreesF, device.currentValue("coolingSetpoint"))
+}
+
+def setCoolingSetpoint(Double degreesF) {
+	log.debug "setCoolingSetpoint($degreesF)"
+	sendEvent(name: "coolingSetpoint", value: degreesF)
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), degreesF)
+}
+
+def setThermostatMode(String value) {
+	sendEvent(name: "thermostatMode", value: value)
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def setThermostatFanMode(String value) {
+	sendEvent(name: "thermostatFanMode", value: value)
+}
+
+def off() {
+	sendEvent(name: "thermostatMode", value: "off")
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def heat() {
+	sendEvent(name: "thermostatMode", value: "heat")
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def auto() {
+	sendEvent(name: "thermostatMode", value: "auto")
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def emergencyHeat() {
+	sendEvent(name: "thermostatMode", value: "emergency heat")
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def cool() {
+	sendEvent(name: "thermostatMode", value: "cool")
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def fanOn() {
+	sendEvent(name: "thermostatFanMode", value: "fanOn")
+}
+
+def fanAuto() {
+	sendEvent(name: "thermostatFanMode", value: "fanAuto")
+}
+
+def fanCirculate() {
+	sendEvent(name: "thermostatFanMode", value: "fanCirculate")
+}
+
+def poll() {
+	null
+}
+
+def tempUp() {
+	def ts = device.currentState("temperature")
+	def value = ts ? ts.integerValue + 1 : 72
+	sendEvent(name:"temperature", value: value)
+	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def tempDown() {
+	def ts = device.currentState("temperature")
+	def value = ts ? ts.integerValue - 1 : 72
+	sendEvent(name:"temperature", value: value)
+	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def setTemperature(value) {
+	def ts = device.currentState("temperature")
+	sendEvent(name:"temperature", value: value)
+	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
+}
+
+def heatUp() {
+	def ts = device.currentState("heatingSetpoint")
+	def value = ts ? ts.integerValue + 1 : 68
+	sendEvent(name:"heatingSetpoint", value: value)
+	evaluate(device.currentValue("temperature"), value, device.currentValue("coolingSetpoint"))
+}
+
+def heatDown() {
+	def ts = device.currentState("heatingSetpoint")
+	def value = ts ? ts.integerValue - 1 : 68
+	sendEvent(name:"heatingSetpoint", value: value)
+	evaluate(device.currentValue("temperature"), value, device.currentValue("coolingSetpoint"))
+}
+
+
+def coolUp() {
+	def ts = device.currentState("coolingSetpoint")
+	def value = ts ? ts.integerValue + 1 : 76
+	sendEvent(name:"coolingSetpoint", value: value)
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), value)
+}
+
+def coolDown() {
+	def ts = device.currentState("coolingSetpoint")
+	def value = ts ? ts.integerValue - 1 : 76
+	sendEvent(name:"coolingSetpoint", value: value)
+	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), value)
+}

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

@@ -0,0 +1,169 @@
+/**
+ *  Copyright 2016 SmartThings, Inc.
+ *
+ *  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: "videoPlayerDeviceTile",
+		namespace: "smartthings/tile-ux",
+		author: "SmartThings") {
+
+		capability "Configuration"
+		capability "Video Camera"
+		capability "Video Capture"
+		capability "Refresh"
+		capability "Switch"
+
+		// custom commands
+		command "start"
+		command "stop"
+		command "setProfileHD"
+		command "setProfileSDH"
+		command "setProfileSDL"
+	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name: "videoPlayer", type: "videoPlayer", width: 6, height: 4) {
+			tileAttribute("device.switch", key: "CAMERA_STATUS") {
+				attributeState("on", label: "Active", icon: "st.camera.dlink-indoor", action: "switch.off", backgroundColor: "#79b821", defaultState: true)
+				attributeState("off", label: "Inactive", icon: "st.camera.dlink-indoor", action: "switch.on", backgroundColor: "#ffffff")
+				attributeState("restarting", label: "Connecting", icon: "st.camera.dlink-indoor", backgroundColor: "#53a7c0")
+				attributeState("unavailable", label: "Unavailable", icon: "st.camera.dlink-indoor", action: "refresh.refresh", backgroundColor: "#F22000")
+			}
+
+			tileAttribute("device.errorMessage", key: "CAMERA_ERROR_MESSAGE") {
+				attributeState("errorMessage", label: "", value: "", defaultState: true)
+			}
+
+			tileAttribute("device.camera", key: "PRIMARY_CONTROL") {
+				attributeState("on", label: "Active", icon: "st.camera.dlink-indoor", backgroundColor: "#79b821", defaultState: true)
+				attributeState("off", label: "Inactive", icon: "st.camera.dlink-indoor", backgroundColor: "#ffffff")
+				attributeState("restarting", label: "Connecting", icon: "st.camera.dlink-indoor", backgroundColor: "#53a7c0")
+				attributeState("unavailable", label: "Unavailable", icon: "st.camera.dlink-indoor", backgroundColor: "#F22000")
+			}
+
+			tileAttribute("device.startLive", key: "START_LIVE") {
+				attributeState("live", action: "start", defaultState: true)
+			}
+
+			tileAttribute("device.stream", key: "STREAM_URL") {
+				attributeState("activeURL", defaultState: true)
+			}
+
+			tileAttribute("device.profile", key: "STREAM_QUALITY") {
+				attributeState("1", label: "720p", action: "setProfileHD", defaultState: true)
+				attributeState("2", label: "h360p", action: "setProfileSDH", defaultState: true)
+				attributeState("3", label: "l360p", action: "setProfileSDL", defaultState: true)
+			}
+
+			tileAttribute("device.betaLogo", key: "BETA_LOGO") {
+				attributeState("betaLogo", label: "", value: "", defaultState: true)
+			}
+		}
+		
+		multiAttributeTile(name: "videoPlayerMin", type: "videoPlayer", width: 6, height: 4) {
+			tileAttribute("device.switch", key: "CAMERA_STATUS") {
+				attributeState("on", label: "Active", icon: "st.camera.dlink-indoor", action: "switch.off", backgroundColor: "#79b821", defaultState: true)
+				attributeState("off", label: "Inactive", icon: "st.camera.dlink-indoor", action: "switch.on", backgroundColor: "#ffffff")
+				attributeState("restarting", label: "Connecting", icon: "st.camera.dlink-indoor", backgroundColor: "#53a7c0")
+				attributeState("unavailable", label: "Unavailable", icon: "st.camera.dlink-indoor", action: "refresh.refresh", backgroundColor: "#F22000")
+			}
+
+			tileAttribute("device.errorMessage", key: "CAMERA_ERROR_MESSAGE") {
+				attributeState("errorMessage", label: "", value: "", defaultState: true)
+			}
+
+			tileAttribute("device.camera", key: "PRIMARY_CONTROL") {
+				attributeState("on", label: "Active", icon: "st.camera.dlink-indoor", backgroundColor: "#79b821", defaultState: true)
+				attributeState("off", label: "Inactive", icon: "st.camera.dlink-indoor", backgroundColor: "#ffffff")
+				attributeState("restarting", label: "Connecting", icon: "st.camera.dlink-indoor", backgroundColor: "#53a7c0")
+				attributeState("unavailable", label: "Unavailable", icon: "st.camera.dlink-indoor", backgroundColor: "#F22000")
+			}
+
+			tileAttribute("device.startLive", key: "START_LIVE") {
+				attributeState("live", action: "start", defaultState: true)
+			}
+
+			tileAttribute("device.stream", key: "STREAM_URL") {
+				attributeState("activeURL", defaultState: true)
+			}
+		}
+
+		main("videoPlayer")
+		details([
+			"videoPlayer", "videoPlayerMin"
+		])
+	}
+}
+
+def installed() {
+}
+
+def parse(String description) {
+}
+
+def refresh() {
+	log.trace "refresh()"
+	// no-op
+}
+
+def on() {
+	log.trace "on()"
+	// no-op
+}
+
+def off() {
+	log.trace "off()"
+	// no-op
+}
+
+def setProfile(profile) {
+	log.trace "setProfile(): ${profile}"
+	sendEvent(name: "profile", value: profile, displayed: false)
+}
+
+def setProfileHD() {
+	setProfile(1)
+}
+
+def setProfileSDH() {
+	setProfile(2)
+}
+
+def setProfileSDL() {
+	setProfile(3)
+}
+
+def start() {
+	log.trace "start()"
+	def dataLiveVideo = [
+		OutHomeURL  : "https://devimages.apple.com.edgekey.net/streaming/examples/bipbop_4x3/bipbop_4x3_variant.m3u8",
+		InHomeURL   : "https://devimages.apple.com.edgekey.net/streaming/examples/bipbop_4x3/bipbop_4x3_variant.m3u8",
+		ThumbnailURL: "http://cdn.device-icons.smartthings.com/camera/dlink-indoor@2x.png",
+		cookie      : [key: "key", value: "value"]
+	]
+
+	def event = [
+		name           : "stream",
+		value          : groovy.json.JsonOutput.toJson(dataLiveVideo).toString(),
+		data		   : groovy.json.JsonOutput.toJson(dataLiveVideo),
+		descriptionText: "Starting the livestream",
+		eventType      : "VIDEO",
+		displayed      : false,
+		isStateChange  : true
+	]
+	sendEvent(event)
+}
+
+def stop() {
+	log.trace "stop()"
+}

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

@@ -33,8 +33,8 @@ metadata {
 	}
 
 	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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+		input title: "Temperature Offset", 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 "tempOffset", "number", title: "Degrees", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
 	}
  
 	tiles {

devicetypes/smartthings/wattvision.src/wattvision.groovy

@@ -29,18 +29,18 @@ metadata {
 
 	tiles {
 
-		valueTile("power", "device.power") {
+		valueTile("power", "device.power", canChangeIcon: true) {
 			state "power", label: '${currentValue} W'
 		}
 
-		tile(name: "powerChart", attribute: "powerContent", type: "HTML", url: '${currentValue}', width: 3, height: 2) { }
+		htmlTile(name: "powerContent", attribute: "powerContent", type: "HTML", whitelist: "www.wattvision.com" , url: '${currentValue}', width: 3, height: 2)
 
 		standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat") {
 			state "default", label: '', action: "refresh.refresh", icon: "st.secondary.refresh"
 		}
 
 		main "power"
-		details(["powerChart", "power", "refresh"])
+		details(["powerContent", "power", "refresh"])
 
 	}
 }
@@ -74,10 +74,10 @@ public addWattvisionData(json) {
 
 	log.trace "Adding data from Wattvision"
 
-	def data = json.data
+	def data = parseJson(json.data.toString())
 	def units = json.units ?: "watts"
 
-	if (data) {
+	if (data.size() > 0) {
 		def latestData = data[-1]
 		data.each {
 			sendPowerEvent(it.t, it.v, units, (latestData == it))
@@ -103,3 +103,7 @@ private sendPowerEvent(time, value, units, isLatest = false) {
 	sendEvent(eventData)
 
 }
+
+def parseJson(String s) {
+	new groovy.json.JsonSlurper().parseText(s)
+}

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

@@ -15,6 +15,8 @@
  *  Thanks to Chad Monroe @cmonroe and Patrick Stuart @pstuart
  *
  */
+//DEPRECATED - Using the generic DTH for this device. Users need to be moved before deleting this DTH
+
 metadata {
 	definition (name: "WeMo Bulb", namespace: "smartthings", author: "SmartThings") {
 	
@@ -25,7 +27,6 @@ metadata {
         capability "Switch"
 		capability "Switch Level"
 
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,FF00", outClusters: "0019"
 	}
 
 	// simulator metadata

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

@@ -25,6 +25,8 @@ metadata {
 		capability "Refresh"
 		capability "Sensor"
 
+    attribute "currentIP", "string"
+
 		command "subscribe"
 		command "resubscribe"
 		command "unsubscribe"
@@ -34,21 +36,36 @@ metadata {
 	// simulator metadata
 	simulator {}
 
-	// UI 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", 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 "turningOff", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ffffff"
-		}
-        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
-			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
+ // UI tile definitions
+    tiles(scale: 2) {
+        multiAttributeTile(name:"rich-control", type: "switch", canChangeIcon: true){
+            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+                 attributeState "on", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#79b821", nextState:"turningOff"
+                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.Home.home30", backgroundColor:"#ffffff", nextState:"turningOn"
+                 attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#79b821", nextState:"turningOff"
+                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.Home.home30", backgroundColor:"#ffffff", nextState:"turningOn"
+                 attributeState "offline", label:'${name}', icon:"st.Home.home30", backgroundColor:"#ff0000"
+ 			}
+            tileAttribute ("currentIP", key: "SECONDARY_CONTROL") {
+             	 attributeState "currentIP", label: ''
+ 			}
+        }
 
-		main "switch"
-		details (["switch", "refresh"])
-	}
+        standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+            state "on", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#79b821", nextState:"turningOff"
+            state "off", label:'${name}', action:"switch.on", icon:"st.Home.home30", backgroundColor:"#ffffff", nextState:"turningOn"
+            state "turningOn", label:'${name}', action:"switch.off", icon:"st.Home.home30", backgroundColor:"#79b821", nextState:"turningOff"
+            state "turningOff", label:'${name}', action:"switch.on", icon:"st.Home.home30", backgroundColor:"#ffffff", nextState:"turningOn"
+            state "offline", label:'${name}', icon:"st.Home.home30", backgroundColor:"#ff0000"
+        }
+
+        standardTile("refresh", "device.switch", inactiveLabel: false, height: 2, width: 2, decoration: "flat") {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+
+        main(["switch"])
+        details(["rich-control", "refresh"])
+    }
 }
 
 // parse events into attributes
@@ -68,6 +85,7 @@ def parse(String description) {
 	def result = []
 	def bodyString = msg.body
 	if (bodyString) {
+		unschedule("setOffline")
 		def body = new XmlSlurper().parseText(bodyString)
 
 		if (body?.property?.TimeSyncRequest?.text()) {
@@ -78,13 +96,14 @@ def parse(String description) {
 		} else if (body?.property?.BinaryState?.text()) {
 			def value = body?.property?.BinaryState?.text().toInteger() == 1 ? "on" : "off"
 			log.trace "Notify: BinaryState = ${value}"
-			result << createEvent(name: "switch", value: value)
+			          result << createEvent(name: "switch", value: value, descriptionText: "Switch is ${value}")
 		} else if (body?.property?.TimeZoneNotification?.text()) {
 			log.debug "Notify: TimeZoneNotification = ${body?.property?.TimeZoneNotification?.text()}"
 		} else if (body?.Body?.GetBinaryStateResponse?.BinaryState?.text()) {
 			def value = body?.Body?.GetBinaryStateResponse?.BinaryState?.text().toInteger() == 1 ? "on" : "off"
 			log.trace "GetBinaryResponse: BinaryState = ${value}"
-			result << createEvent(name: "switch", value: value)
+			def dispaux = device.currentValue("switch") != value
+			result << createEvent(name: "switch", value: value, descriptionText: "Switch is ${value}", displayed: dispaux)
 		}
 	}
 
@@ -101,14 +120,6 @@ private getCallBackAddress() {
 	device.hub.getDataValue("localIP") + ":" + device.hub.getDataValue("localSrvPortTCP")
 }
 
-private Integer convertHexToInt(hex) {
-    Integer.parseInt(hex,16)
-}
-
-private String convertHexToIP(hex) {
-    [convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
-}
-
 private getHostAddress() {
 	def ip = getDataValue("ip")
 	def port = getDataValue("port")
@@ -195,6 +206,8 @@ def subscribe(ip, port) {
 	if (ip && ip != existingIp) {
 		log.debug "Updating ip from $existingIp to $ip"
 		updateDataValue("ip", ip)
+    	def ipvalue = convertHexToIP(getDataValue("ip"))
+        sendEvent(name: "currentIP", value: ipvalue, descriptionText: "IP changed to ${ipvalue}")
 	}
 	if (port && port != existingPort) {
 		log.debug "Updating port from $existingPort to $port"
@@ -259,6 +272,8 @@ User-Agent: CyberGarage-HTTP/1.0
 
 def poll() {
 log.debug "Executing 'poll'"
+if (device.currentValue("currentIP") != "Offline")
+    runIn(30, setOffline)
 new physicalgraph.device.HubAction("""POST /upnp/control/basicevent1 HTTP/1.1
 SOAPACTION: "urn:Belkin:service:basicevent:1#GetBinaryState"
 Content-Length: 277
@@ -274,3 +289,15 @@ User-Agent: CyberGarage-HTTP/1.0
 </s:Body>
 </s:Envelope>""", physicalgraph.device.Protocol.LAN)
 }
+
+def setOffline() {
+    sendEvent(name: "switch", value: "offline", descriptionText: "The device is offline")
+}
+
+private Integer convertHexToInt(hex) {
+ 	Integer.parseInt(hex,16)
+}
+
+private String convertHexToIP(hex) {
+ 	[convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
+}

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

@@ -21,6 +21,8 @@
 		capability "Refresh"
 		capability "Sensor"
 
+    	attribute "currentIP", "string"
+
 		command "subscribe"
 		command "resubscribe"
 		command "unsubscribe"
@@ -31,17 +33,30 @@
 	}
 
 	// UI tile definitions
-	tiles {
+    tiles(scale: 2) {
+        multiAttributeTile(name:"rich-control", type: "motion", canChangeIcon: true){
+            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 "offline", label:'${name}', icon:"st.motion.motion.active", backgroundColor:"#ff0000"
+ 			}
+            tileAttribute ("currentIP", key: "SECONDARY_CONTROL") {
+             	 attributeState "currentIP", label: ''
+ 			}
+        }
+
 		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")
-		}
-		standardTile("refresh", "device.motion", inactiveLabel: false, decoration: "flat") {
-			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
+      		state("offline", label:'${name}', icon:"st.motion.motion.inactive", backgroundColor:"#ff0000")
 		}
 
+        standardTile("refresh", "device.switch", inactiveLabel: false, height: 2, width: 2, decoration: "flat") {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+
 		main "motion"
-		details (["motion", "refresh"])
+		details (["rich-control", "refresh"])
 	}
 }
 
@@ -62,8 +77,8 @@ def parse(String description) {
 	def result = []
 	def bodyString = msg.body
 	if (bodyString) {
+    	unschedule("setOffline")
 		def body = new XmlSlurper().parseText(bodyString)
-
 		if (body?.property?.TimeSyncRequest?.text()) {
 			log.trace "Got TimeSyncRequest"
 			result << timeSyncResponse()
@@ -72,7 +87,7 @@ def parse(String description) {
 		} else if (body?.property?.BinaryState?.text()) {
 			def value = body?.property?.BinaryState?.text().toInteger() == 1 ? "active" : "inactive"
 			log.debug "Notify - BinaryState = ${value}"
-			result << createEvent(name: "motion", value: value)
+      result << createEvent(name: "motion", value: value, descriptionText: "Motion is ${value}")
 		} else if (body?.property?.TimeZoneNotification?.text()) {
 			log.debug "Notify: TimeZoneNotification = ${body?.property?.TimeZoneNotification?.text()}"
 		}
@@ -91,14 +106,6 @@ private getCallBackAddress() {
 	device.hub.getDataValue("localIP") + ":" + device.hub.getDataValue("localSrvPortTCP")
 }
 
-private Integer convertHexToInt(hex) {
-	Integer.parseInt(hex,16)
-}
-
-private String convertHexToIP(hex) {
-	[convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
-}
-
 private getHostAddress() {
 	def ip = getDataValue("ip")
 	def port = getDataValue("port")
@@ -125,6 +132,8 @@ def refresh() {
 ////////////////////////////
 def getStatus() {
 log.debug "Executing WeMo Motion 'getStatus'"
+if (device.currentValue("currentIP") != "Offline")
+    runIn(30, setOffline)
 new physicalgraph.device.HubAction("""POST /upnp/control/basicevent1 HTTP/1.1
 SOAPACTION: "urn:Belkin:service:basicevent:1#GetBinaryState"
 Content-Length: 277
@@ -165,7 +174,9 @@ def subscribe(ip, port) {
 	def existingPort = getDataValue("port")
 	if (ip && ip != existingIp) {
 		log.debug "Updating ip from $existingIp to $ip"
-		updateDataValue("ip", ip)
+        updateDataValue("ip", ip)
+    	def ipvalue = convertHexToIP(getDataValue("ip"))
+    	sendEvent(name: "currentIP", value: ipvalue, descriptionText: "IP changed to ${ipvalue}")
 	}
 	if (port && port != existingPort) {
 		log.debug "Updating port from $existingPort to $port"
@@ -226,3 +237,15 @@ User-Agent: CyberGarage-HTTP/1.0
 </s:Envelope>
 """, physicalgraph.device.Protocol.LAN)
 }
+
+def setOffline() {
+    sendEvent(name: "motion", value: "offline", descriptionText: "The device is offline")
+}
+
+private Integer convertHexToInt(hex) {
+ 	Integer.parseInt(hex,16)
+}
+
+private String convertHexToIP(hex) {
+ 	[convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
+}

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

@@ -10,120 +10,143 @@
  *  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.
  *
- *	Wemo Switch
+ * Wemo Switch
  *
- *	Author: superuser
- *	Date: 2013-10-11
+ * Author: Juan Risso (SmartThings)
+ * Date: 2015-10-11
  */
  metadata {
-	definition (name: "Wemo Switch", namespace: "smartthings", author: "SmartThings") {
-		capability "Actuator"
-		capability "Switch"
-		capability "Polling"
-		capability "Refresh"
-		capability "Sensor"
+ 	definition (name: "Wemo Switch", namespace: "smartthings", author: "SmartThings") {
+        capability "Actuator"
+        capability "Switch"
+        capability "Polling"
+        capability "Refresh"
+        capability "Sensor"
 
-		command "subscribe"
-		command "resubscribe"
-		command "unsubscribe"
-	}
+        attribute "currentIP", "string"
 
-	// simulator metadata
-	simulator {}
+        command "subscribe"
+        command "resubscribe"
+        command "unsubscribe"
+        command "setOffline"
+ }
 
-	// UI tile definitions
-	tiles {
-		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821"
-			state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff"
-		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
-			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
+ // simulator metadata
+ simulator {}
 
-		main "switch"
-		details (["switch", "refresh"])
-	}
+ // UI tile definitions
+    tiles(scale: 2) {
+        multiAttributeTile(name:"rich-control", type: "switch", canChangeIcon: true){
+            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+                 attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
+                 attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
+                 attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
+                 attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
+                 attributeState "offline", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ff0000"
+ 			}
+            tileAttribute ("currentIP", key: "SECONDARY_CONTROL") {
+             	 attributeState "currentIP", label: ''
+ 			}
+        }
+
+        standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+            state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
+            state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
+            state "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.off", backgroundColor:"#79b821", nextState:"turningOff"
+            state "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
+            state "offline", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ff0000"
+        }
+
+        standardTile("refresh", "device.switch", inactiveLabel: false, height: 2, width: 2, decoration: "flat") {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+
+        main(["switch"])
+        details(["rich-control", "refresh"])
+    }
 }
 
 // parse events into attributes
 def parse(String description) {
-	log.debug "Parsing '${description}'"
+    log.debug "Parsing '${description}'"
 
-	def msg = parseLanMessage(description)
-	def headerString = msg.header
+    def msg = parseLanMessage(description)
+    def headerString = msg.header
 
-	if (headerString?.contains("SID: uuid:")) {
-		def sid = (headerString =~ /SID: uuid:.*/) ? ( headerString =~ /SID: uuid:.*/)[0] : "0"
-		sid -= "SID: uuid:".trim()
+    if (headerString?.contains("SID: uuid:")) {
+        def sid = (headerString =~ /SID: uuid:.*/) ? ( headerString =~ /SID: uuid:.*/)[0] : "0"
+        sid -= "SID: uuid:".trim()
 
-		updateDataValue("subscriptionId", sid)
-	}
+        updateDataValue("subscriptionId", sid)
+ 	}
 
-	def result = []
-	def bodyString = msg.body
-	if (bodyString) {
-		def body = new XmlSlurper().parseText(bodyString)
-
-		if (body?.property?.TimeSyncRequest?.text()) {
-			log.trace "Got TimeSyncRequest"
-			result << timeSyncResponse()
-		} else if (body?.Body?.SetBinaryStateResponse?.BinaryState?.text()) {
-			log.trace "Got SetBinaryStateResponse = ${body?.Body?.SetBinaryStateResponse?.BinaryState?.text()}"
-		} else if (body?.property?.BinaryState?.text()) {
-			def value = body?.property?.BinaryState?.text().toInteger() == 1 ? "on" : "off"
-			log.trace "Notify: BinaryState = ${value}"
-			result << createEvent(name: "switch", value: value)
-		} else if (body?.property?.TimeZoneNotification?.text()) {
-			log.debug "Notify: TimeZoneNotification = ${body?.property?.TimeZoneNotification?.text()}"
-		} else if (body?.Body?.GetBinaryStateResponse?.BinaryState?.text()) {
-			def value = body?.Body?.GetBinaryStateResponse?.BinaryState?.text().toInteger() == 1 ? "on" : "off"
-			log.trace "GetBinaryResponse: BinaryState = ${value}"
-			result << createEvent(name: "switch", value: value)
-		}
-	}
-
-	result
+    def result = []
+    def bodyString = msg.body
+    if (bodyString) {
+    	unschedule("setOffline")
+        def body = new XmlSlurper().parseText(bodyString)
+ 		if (body?.property?.TimeSyncRequest?.text()) {
+        	log.trace "Got TimeSyncRequest"
+        	result << timeSyncResponse()
+        } else if (body?.Body?.SetBinaryStateResponse?.BinaryState?.text()) {
+ 			log.trace "Got SetBinaryStateResponse = ${body?.Body?.SetBinaryStateResponse?.BinaryState?.text()}"
+ 		} else if (body?.property?.BinaryState?.text()) {
+        	def value = body?.property?.BinaryState?.text().substring(0, 1).toInteger() == 0 ? "off" : "on"
+        	log.trace "Notify: BinaryState = ${value}, ${body.property.BinaryState}"
+            def dispaux = device.currentValue("switch") != value
+            result << createEvent(name: "switch", value: value, descriptionText: "Switch is ${value}", displayed: dispaux)
+        } else if (body?.property?.TimeZoneNotification?.text()) {
+ 			log.debug "Notify: TimeZoneNotification = ${body?.property?.TimeZoneNotification?.text()}"
+ 		} else if (body?.Body?.GetBinaryStateResponse?.BinaryState?.text()) {
+ 			def value = body?.Body?.GetBinaryStateResponse?.BinaryState?.text().substring(0, 1).toInteger() == 0 ? "off" : "on"
+ 			log.trace "GetBinaryResponse: BinaryState = ${value}, ${body.property.BinaryState}"
+            log.info "Connection: ${device.currentValue("connection")}"
+            if (device.currentValue("currentIP") == "Offline") {
+                def ipvalue = convertHexToIP(getDataValue("ip"))
+                sendEvent(name: "IP", value: ipvalue, descriptionText: "IP is ${ipvalue}")
+            }
+            def dispaux2 = device.currentValue("switch") != value
+     		result << createEvent(name: "switch", value: value, descriptionText: "Switch is ${value}", displayed: dispaux2)
+ 		}
+ 	}
+ result
 }
 
 private getTime() {
-	// This is essentially System.currentTimeMillis()/1000, but System is disallowed by the sandbox.
-	((new GregorianCalendar().time.time / 1000l).toInteger()).toString()
+    // This is essentially System.currentTimeMillis()/1000, but System is disallowed by the sandbox.
+    ((new GregorianCalendar().time.time / 1000l).toInteger()).toString()
 }
 
 private getCallBackAddress() {
-	device.hub.getDataValue("localIP") + ":" + device.hub.getDataValue("localSrvPortTCP")
+ 	device.hub.getDataValue("localIP") + ":" + device.hub.getDataValue("localSrvPortTCP")
 }
 
 private Integer convertHexToInt(hex) {
-	Integer.parseInt(hex,16)
+ 	Integer.parseInt(hex,16)
 }
 
 private String convertHexToIP(hex) {
-	[convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
+ 	[convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
 }
 
 private getHostAddress() {
-	def ip = getDataValue("ip")
-	def port = getDataValue("port")
-
-	if (!ip || !port) {
-		def parts = device.deviceNetworkId.split(":")
-		if (parts.length == 2) {
-			ip = parts[0]
-			port = parts[1]
-		} else {
-			log.warn "Can't figure out ip and port for device: ${device.id}"
-		}
-	}
-	log.debug "Using ip: ${ip} and port: ${port} for device: ${device.id}"
-	return convertHexToIP(ip) + ":" + convertHexToInt(port)
+ 	def ip = getDataValue("ip")
+ 	def port = getDataValue("port")
+ 	if (!ip || !port) {
+ 		def parts = device.deviceNetworkId.split(":")
+ 		if (parts.length == 2) {
+ 			ip = parts[0]
+ 			port = parts[1]
+ 		} else {
+ 			log.warn "Can't figure out ip and port for device: ${device.id}"
+		 }
+ 	}
+ 	log.debug "Using ip: ${ip} and port: ${port} for device: ${device.id}"
+ 	return convertHexToIP(ip) + ":" + convertHexToInt(port)
 }
 
-
 def on() {
-	log.debug "Executing 'on'"
-    sendEvent(name: "switch", value: "on")
+log.debug "Executing 'on'"
 def turnOn = new physicalgraph.device.HubAction("""POST /upnp/control/basicevent1 HTTP/1.1
 SOAPAction: "urn:Belkin:service:basicevent:1#SetBinaryState"
 Host: ${getHostAddress()}
@@ -133,17 +156,16 @@ Content-Length: 333
 <?xml version="1.0"?>
 <SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
 <SOAP-ENV:Body>
-	<m:SetBinaryState xmlns:m="urn:Belkin:service:basicevent:1">
+ <m:SetBinaryState xmlns:m="urn:Belkin:service:basicevent:1">
 <BinaryState>1</BinaryState>
-	</m:SetBinaryState>
+ </m:SetBinaryState>
 </SOAP-ENV:Body>
 </SOAP-ENV:Envelope>""", physicalgraph.device.Protocol.LAN)
 }
 
 def off() {
-	log.debug "Executing 'off'"
-	sendEvent(name: "switch", value: "off")
-	def turnOff = new physicalgraph.device.HubAction("""POST /upnp/control/basicevent1 HTTP/1.1
+log.debug "Executing 'off'"
+def turnOff = new physicalgraph.device.HubAction("""POST /upnp/control/basicevent1 HTTP/1.1
 SOAPAction: "urn:Belkin:service:basicevent:1#SetBinaryState"
 Host: ${getHostAddress()}
 Content-Type: text/xml
@@ -152,36 +174,13 @@ Content-Length: 333
 <?xml version="1.0"?>
 <SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
 <SOAP-ENV:Body>
-	<m:SetBinaryState xmlns:m="urn:Belkin:service:basicevent:1">
+ <m:SetBinaryState xmlns:m="urn:Belkin:service:basicevent:1">
 <BinaryState>0</BinaryState>
-	</m:SetBinaryState>
+ </m:SetBinaryState>
 </SOAP-ENV:Body>
 </SOAP-ENV:Envelope>""", physicalgraph.device.Protocol.LAN)
 }
 
-/*def refresh() {
-	log.debug "Executing 'refresh'"
-new physicalgraph.device.HubAction("""POST /upnp/control/basicevent1 HTTP/1.1
-SOAPACTION: "urn:Belkin:service:basicevent:1#GetBinaryState"
-Content-Length: 277
-Content-Type: text/xml; charset="utf-8"
-HOST: ${getHostAddress()}
-User-Agent: CyberGarage-HTTP/1.0
-
-<?xml version="1.0" encoding="utf-8"?>
-<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
-<s:Body>
-<u:GetBinaryState xmlns:u="urn:Belkin:service:basicevent:1">
-</u:GetBinaryState>
-</s:Body>
-</s:Envelope>""", physicalgraph.device.Protocol.LAN)
-}*/
-
-def refresh() {
-	log.debug "Executing WeMo Switch 'subscribe', then 'timeSyncResponse', then 'poll'"
-	[subscribe(), timeSyncResponse(), poll()]
-}
-
 def subscribe(hostAddress) {
 log.debug "Executing 'subscribe()'"
 def address = getCallBackAddress()
@@ -200,27 +199,30 @@ def subscribe() {
 	subscribe(getHostAddress())
 }
 
-def subscribe(ip, port) {
-	def existingIp = getDataValue("ip")
-	def existingPort = getDataValue("port")
-	if (ip && ip != existingIp) {
-		log.debug "Updating ip from $existingIp to $ip"
-		updateDataValue("ip", ip)
-	}
-	if (port && port != existingPort) {
-		log.debug "Updating port from $existingPort to $port"
-		updateDataValue("port", port)
-	}
+def refresh() {
+ 	log.debug "Executing WeMo Switch 'subscribe', then 'timeSyncResponse', then 'poll'"
+ 	[subscribe(), timeSyncResponse(), poll()]
+}
 
+def subscribe(ip, port) {
+    def existingIp = getDataValue("ip")
+    def existingPort = getDataValue("port")
+    if (ip && ip != existingIp) {
+         log.debug "Updating ip from $existingIp to $ip"    
+    	 updateDataValue("ip", ip)
+    	 def ipvalue = convertHexToIP(getDataValue("ip"))
+         sendEvent(name: "currentIP", value: ipvalue, descriptionText: "IP changed to ${ipvalue}")
+    }
+ 	if (port && port != existingPort) {
+ 		log.debug "Updating port from $existingPort to $port"
+ 		updateDataValue("port", port)
+	}
 	subscribe("${ip}:${port}")
 }
 
-////////////////////////////
 def resubscribe() {
-log.debug "Executing 'resubscribe()'"
-
-def sid = getDeviceDataByName("subscriptionId")
-
+    log.debug "Executing 'resubscribe()'"
+    def sid = getDeviceDataByName("subscriptionId")
 new physicalgraph.device.HubAction("""SUBSCRIBE /upnp/event/basicevent1 HTTP/1.1
 HOST: ${getHostAddress()}
 SID: uuid:${sid}
@@ -228,12 +230,11 @@ TIMEOUT: Second-5400
 
 
 """, physicalgraph.device.Protocol.LAN)
-
 }
 
-////////////////////////////
+
 def unsubscribe() {
-def sid = getDeviceDataByName("subscriptionId")
+    def sid = getDeviceDataByName("subscriptionId")
 new physicalgraph.device.HubAction("""UNSUBSCRIBE publisher path HTTP/1.1
 HOST: ${getHostAddress()}
 SID: uuid:${sid}
@@ -242,7 +243,7 @@ SID: uuid:${sid}
 """, physicalgraph.device.Protocol.LAN)
 }
 
-////////////////////////////
+
 //TODO: Use UTC Timezone
 def timeSyncResponse() {
 log.debug "Executing 'timeSyncResponse()'"
@@ -267,9 +268,15 @@ User-Agent: CyberGarage-HTTP/1.0
 """, physicalgraph.device.Protocol.LAN)
 }
 
+def setOffline() {
+	//sendEvent(name: "currentIP", value: "Offline", displayed: false)
+    sendEvent(name: "switch", value: "offline", descriptionText: "The device is offline")
+}
 
 def poll() {
 log.debug "Executing 'poll'"
+if (device.currentValue("currentIP") != "Offline")
+    runIn(30, setOffline)
 new physicalgraph.device.HubAction("""POST /upnp/control/basicevent1 HTTP/1.1
 SOAPACTION: "urn:Belkin:service:basicevent:1#GetBinaryState"
 Content-Length: 277
@@ -284,4 +291,4 @@ User-Agent: CyberGarage-HTTP/1.0
 </u:GetBinaryState>
 </s:Body>
 </s:Envelope>""", physicalgraph.device.Protocol.LAN)
-}
+}

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

@@ -0,0 +1,194 @@
+/**
+ *  Iris Smart Fob
+ *
+ *  Copyright 2015 Mitch Pond
+ *	Presence code adapted from SmartThings Arrival Sensor HA device type
+ *
+ *  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: "ZigBee Button", namespace: "smartthings", author: "Mitch Pond") {
+		capability "Battery"
+		capability "Button"
+        capability "Configuration"
+		capability "Presence Sensor"
+		capability "Sensor"
+        
+		//fingerprint endpointId: "01", profileId: "0104", inClusters: "0000,0001,0003,0007,0020,0B05", outClusters: "0003,0006,0019", model:"3450-L", manufacturer: "CentraLite"
+	}
+    
+    preferences{
+	    input ("holdTime", "number", title: "Minimum time in seconds for a press to count as \"held\"",
+    		defaultValue: 3, displayDuringSetup: false)
+        input "checkInterval", "enum", title: "Presence timeout (minutes)",
+            defaultValue:"2", options: ["2", "3", "5"], displayDuringSetup: false
+        input "logging", "bool", title: "Enable debug logging",
+            defaultValue: false, displayDuringSetup: false
+    }
+
+	tiles(scale: 2) {
+    	standardTile("presence", "device.presence", width: 4, height: 4, canChangeBackground: true) {
+            state "present", label: "Present", labelIcon:"st.presence.tile.present", backgroundColor:"#53a7c0"
+            state "not present", labelIcon:"st.presence.tile.not-present", backgroundColor:"#ffffff"
+        }
+    	standardTile("button", "device.button", decoration: "flat", width: 2, height: 2) {
+        	state "default", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#ffffff"
+        }
+		valueTile("battery", "device.battery", decoration: "flat", width: 2, height: 2) {
+			state "battery", label:'${currentValue}% battery', unit:""
+		}
+
+		main (["presence"])
+		details(["presence","button","battery"])
+	}
+}
+
+def parse(String description) {
+    def descMap = zigbee.parseDescriptionAsMap(description)
+    logIt descMap
+    state.lastCheckin = now()
+    logIt "lastCheckin = ${state.lastCheckin}"
+    handlePresenceEvent(true)
+    
+	def results = []
+    if (description?.startsWith('catchall:'))
+		results = parseCatchAllMessage(descMap)
+	else if (description?.startsWith('read attr -'))
+		results = parseReportAttributeMessage(descMap)
+    else logIt(descMap, "trace")
+        
+	return results;
+}
+
+def updated() {
+	startTimer()
+    configure()
+}
+
+def configure(){
+	logIt "Configuring Smart Fob..."
+	[
+	"zdo bind 0x${device.deviceNetworkId} 1 1 6 {${device.zigbeeId}} {}", "delay 200",
+    "zdo bind 0x${device.deviceNetworkId} 2 1 6 {${device.zigbeeId}} {}", "delay 200",
+    "zdo bind 0x${device.deviceNetworkId} 3 1 6 {${device.zigbeeId}} {}", "delay 200",
+    "zdo bind 0x${device.deviceNetworkId} 4 1 6 {${device.zigbeeId}} {}", "delay 200",
+    "zdo bind 0x${device.deviceNetworkId} 1 1 1 {${device.zigbeeId}} {}", "delay 200"
+    ] +
+    zigbee.configureReporting(0x0001,0x0020,0x20,20,20,0x01)
+}
+
+def parseCatchAllMessage(descMap) {
+    if (descMap?.clusterId == "0006" && descMap?.command == "01") 		//button pressed
+    	handleButtonPress(descMap.sourceEndpoint as int)
+    else if (descMap?.clusterId == "0006" && descMap?.command == "00") 	//button released
+    	handleButtonRelease(descMap.sourceEndpoint as int)
+    else logIt("Parse: Unhandled message: ${descMap}","trace")
+}
+
+def parseReportAttributeMessage(descMap) {
+	if (descMap?.cluster == "0001" && descMap?.attrId == "0020") createBatteryEvent(getBatteryLevel(descMap.value))
+    else logIt descMap
+}
+
+private createBatteryEvent(percent) {
+	logIt "Battery level at " + percent
+	return createEvent([name: "battery", value: percent])
+}
+
+//this method determines if a press should count as a push or a hold and returns the relevant event type
+private handleButtonRelease(button) {
+	logIt "lastPress state variable: ${state.lastPress}"
+    def sequenceError = {logIt("Uh oh...missed a message? Dropping this event.", "error"); state.lastPress = null; return []}	
+    
+    if (!state.lastPress) return sequenceError()
+	else if (state.lastPress.button != button) return sequenceError()
+    
+    def currentTime = now()
+    def startOfPress = state.lastPress?.time
+    def timeDif = currentTime - startOfPress
+    def holdTimeMillisec = (settings.holdTime?:3).toInteger() * 1000
+    
+    state.lastPress = null	//we're done with this. clear it to make error conditions easier to catch
+    
+    if (timeDif < 0) 
+    //likely a message sequence issue or dropped packet. Drop this press and wait for another.
+    	return sequenceError()
+    else if (timeDif < holdTimeMillisec)
+    	return createButtonEvent(button,"pushed")
+    else 
+    	return createButtonEvent(button,"held")
+}
+
+private handleButtonPress(button) {
+	state.lastPress = [button: button, time: now()]
+}
+
+private createButtonEvent(button,action) {
+	logIt "Button ${button} ${action}"
+	return createEvent([
+    	name: "button",
+        value: action, 
+        data:[buttonNumber: button], 
+        descriptionText: "${device.displayName} button ${button} was ${action}",
+        isStateChange: true, 
+        displayed: true])
+}
+
+private getBatteryLevel(rawValue) {
+	def intValue = Integer.parseInt(rawValue,16)
+	def min = 2.1
+    def max = 3.0
+    def vBatt = intValue / 10
+    return ((vBatt - min) / (max - min) * 100) as int
+}
+
+private handlePresenceEvent(present) {
+    def wasPresent = device.currentState("presence")?.value == "present"
+    if (!wasPresent && present) {
+        logIt "Sensor is present"
+        startTimer()
+    } else if (!present) {
+        logIt "Sensor is not present"
+        stopTimer()
+    }
+    def linkText = getLinkText(device)
+    def eventMap = [
+        name: "presence",
+        value: present ? "present" : "not present",
+        linkText: linkText,
+        descriptionText: "${linkText} has ${present ? 'arrived' : 'left'}",
+    ]
+    logIt "Creating presence event: ${eventMap}"
+    sendEvent(eventMap)
+}
+
+private startTimer() {
+    logIt "Scheduling periodic timer"
+    schedule("0 * * * * ?", checkPresenceCallback)
+}
+
+private stopTimer() {
+    logIt "Stopping periodic timer"
+    unschedule()
+}
+
+def checkPresenceCallback() {
+    def timeSinceLastCheckin = (now() - state.lastCheckin) / 1000
+    def theCheckInterval = (checkInterval ? checkInterval as int : 2) * 60
+    logIt "Sensor checked in ${timeSinceLastCheckin} seconds ago"
+    if (timeSinceLastCheckin >= theCheckInterval) {
+        handlePresenceEvent(false)
+    }
+}
+
+// ****** Utility functions ******
+
+private logIt(str, logLevel = 'debug') {if (settings.logging) log."$logLevel"(str) }

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

@@ -0,0 +1,97 @@
+/**
+ *  Copyright 2015 SmartThings
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ */
+
+metadata {
+    definition (name: "ZigBee Dimmer Power", namespace: "smartthings", author: "SmartThings") {
+        capability "Actuator"
+        capability "Configuration"
+        capability "Refresh"
+        capability "Power Meter"
+        capability "Sensor"
+        capability "Switch"
+        capability "Switch Level"
+
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B04"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0702"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0702, 0B05", outClusters: "0019", manufacturer: "sengled", model: "Z01-CIA19NAE26", deviceJoinName: "Sengled Element touch"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0702, 0B05", outClusters: "000A, 0019", manufacturer: "Jasco Products", model: "45852", deviceJoinName: "GE Zigbee Plug-In Dimmer"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0702, 0B05", outClusters: "000A, 0019", manufacturer: "Jasco Products", model: "45857", deviceJoinName: "GE Zigbee In-Wall Dimmer"
+    }
+
+    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.refresh", 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 "description is $description"
+
+    def event = zigbee.getEvent(description)
+    if (event) {
+        log.info event
+        if (event.name == "power") {
+            if (device.getDataValue("manufacturer") != "OSRAM") {       //OSRAM devices do not reliably update power
+                event.value = (event.value as Integer) / 10             //TODO: The divisor value needs to be set as part of configuration
+                sendEvent(event)
+            }
+        }
+        else {
+            sendEvent(event)
+        }
+    }
+    else {
+        log.warn "DID NOT PARSE MESSAGE for description : $description"
+        log.debug zigbee.parseDescriptionAsMap(description)
+    }
+}
+
+def off() {
+    zigbee.off()
+}
+
+def on() {
+    zigbee.on()
+}
+
+def setLevel(value) {
+    zigbee.setLevel(value)
+}
+
+def refresh() {
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.simpleMeteringPowerRefresh() + zigbee.electricMeasurementPowerRefresh() + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.simpleMeteringPowerConfig() + zigbee.electricMeasurementPowerConfig()
+}
+
+def configure() {
+    log.debug "Configuring Reporting and Bindings."
+    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.simpleMeteringPowerConfig() + zigbee.electricMeasurementPowerConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.simpleMeteringPowerRefresh() + zigbee.electricMeasurementPowerRefresh()
+}

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

@@ -11,133 +11,73 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
+
 metadata {
-	definition (name: "ZigBee Dimmer", namespace: "smartthings", author: "SmartThings") {
-		capability "Switch Level"
-		capability "Actuator"
-		capability "Switch"
-		capability "Configuration"
-		capability "Sensor"
-		capability "Refresh"
+    definition (name: "ZigBee Dimmer", namespace: "smartthings", author: "SmartThings") {
+        capability "Actuator"
+        capability "Configuration"
+        capability "Refresh"
+        capability "Switch"
+        capability "Switch Level"
 
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0B05", outClusters: "0019"
-	}
 
-	// simulator metadata
-	simulator {
-		// status messages
-		status "on": "on/off: 1"
-		status "off": "on/off: 0"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY A19 ON/OFF/DIM", deviceJoinName: "OSRAM LIGHTIFY LED Smart Connected Light"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, FF00", outClusters: "0019", manufacturer: "MRVL", model: "MZ100", deviceJoinName: "Wemo Bulb"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B05", outClusters: "0019", manufacturer: "OSRAM SYLVANIA", model: "iQBR30", deviceJoinName: "Sylvania Ultra iQ"
+    }
 
-		// 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"
-			}
-		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-		valueTile("level", "device.level", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "level", label:'${currentValue} %', unit:"%", backgroundColor:"#ffffff"
-		}
-		main "switch"
-		details(["switch", "refresh", "level", "levelSliderControl"])
-	}
+    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 "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 "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
+            }
+            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+                attributeState "level", action:"switch level.setLevel"
+            }
+        }
+        standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+        main "switch"
+        details(["switch", "refresh"])
+    }
 }
 
 // Parse incoming device messages to generate events
 def parse(String description) {
-	log.info description
-	if (description?.startsWith("catchall:")) {
-		def msg = zigbee.parse(description)
-		log.trace msg
-		log.trace "data: $msg.data"
-	}
-	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
-	}
-}
+    log.debug "description is $description"
 
-// Commands to device
-def on() {
-	log.debug "on()"
-	sendEvent(name: "switch", value: "on")
-	"st cmd 0x${device.deviceNetworkId} ${endpointId} 6 1 {}"
+    def event = zigbee.getEvent(description)
+    if (event) {
+        sendEvent(event)
+    }
+    else {
+        log.warn "DID NOT PARSE MESSAGE for description : $description"
+        log.debug zigbee.parseDescriptionAsMap(description)
+    }
 }
 
 def off() {
-	log.debug "off()"
-	sendEvent(name: "switch", value: "off")
-	"st cmd 0x${device.deviceNetworkId} ${endpointId} 6 0 {}"
+    zigbee.off()
 }
+
+def on() {
+    zigbee.on()
+}
+
 def setLevel(value) {
-	log.trace "setLevel($value)"
-	def cmds = []
-
-	if (value == 0) {
-		sendEvent(name: "switch", value: "off")
-		cmds << "st cmd 0x${device.deviceNetworkId} ${endpointId} 6 0 {}"
-	}
-	else if (device.latestValue("switch") == "off") {
-        sendEvent(name: "switch", value: "on")
-        cmds << "st cmd 0x${device.deviceNetworkId} ${endpointId} 6 1 {}"
-        
-	}
-
-	sendEvent(name: "level", value: value)
-    def level = hexString(Math.round(value * 255/100))
-	cmds << "st cmd 0x${device.deviceNetworkId} ${endpointId} 8 4 {${level} 0000}"
-
-	//log.debug cmds
-	cmds
+    zigbee.setLevel(value)
 }
 
 def refresh() {
-	[
-		"st wattr 0x${device.deviceNetworkId} 1 6 0", "delay 200",
-		"st wattr 0x${device.deviceNetworkId} 1 8 0"
-	]
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig() + zigbee.levelConfig()
 }
 
 def configure() {
-
-	/*log.debug "binding to switch and level control cluster"
-	[
-		"zdo bind 0x${device.deviceNetworkId} 1 1 6 {${device.zigbeeId}} {}", "delay 200",
-		"zdo bind 0x${device.deviceNetworkId} 1 1 8 {${device.zigbeeId}} {}"
-	]
-    */
-
-	//set transition time to 2 seconds. Not currently working.
-	"st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {1400}"
-}
-
-
-
-private hex(value, width=2) {
-	def s = new BigInteger(Math.round(value).toString()).toString(16)
-	while (s.size() < width) {
-		s = "0" + s
-	}
-	s
-}
-
-private getEndpointId() {
-	new BigInteger(device.endpointId, 16).toString()
+    log.debug "Configuring Reporting and Bindings."
+    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
 }

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

@@ -63,7 +63,7 @@ metadata {
 			state "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", 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") {
+		standardTile("refresh", "device.refresh", 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) {

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

@@ -0,0 +1,162 @@
+/**
+ *  ZigBee Lock
+ *
+ *  Copyright 2015 SmartThings
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ */
+ metadata {
+    definition (name: "ZigBee Lock", namespace: "smartthings", author: "SmartThings")
+    {
+        capability "Actuator"
+        capability "Lock"
+        capability "Refresh"
+        capability "Sensor"
+        capability "Battery"
+        capability "Configuration"
+
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0004,0005,0009,0020,0101,0402,0B05,FDBD", outClusters: "000A,0019", manufacturer: "Kwikset", model: "SMARTCODE_DEADBOLT_5", deviceJoinName: "Kwikset 5-Button Deadbolt"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0004,0005,0009,0020,0101,0402,0B05,FDBD", outClusters: "000A,0019", manufacturer: "Kwikset", model: "SMARTCODE_LEVER_5", deviceJoinName: "Kwikset 5-Button Lever"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0004,0005,0009,0020,0101,0402,0B05,FDBD", outClusters: "000A,0019", manufacturer: "Kwikset", model: "SMARTCODE_DEADBOLT_10", deviceJoinName: "Kwikset 10-Button Deadbolt"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0004,0005,0009,0020,0101,0402,0B05,FDBD", outClusters: "000A,0019", manufacturer: "Kwikset", model: "SMARTCODE_DEADBOLT_10T", deviceJoinName: "Kwikset 10-Button Touch Deadbolt"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRL220 TS LL", deviceJoinName: "Yale Touch Screen Lever Lock"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD210 PB DB", deviceJoinName: "Yale Push Button Deadbolt Lock"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD220/240 TSDB", deviceJoinName: "Yale Touch Screen Deadbolt Lock"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRL210 PB LL", deviceJoinName: "Yale Push Button Lever Lock"
+    }
+
+    tiles(scale: 2) {
+		multiAttributeTile(name:"toggle", type:"generic", width:6, height:4){
+			tileAttribute ("device.lock", key:"PRIMARY_CONTROL") {
+				attributeState "locked", label:'locked', action:"lock.unlock", icon:"st.locks.lock.locked", backgroundColor:"#79b821", nextState:"unlocking"
+				attributeState "unlocked", label:'unlocked', action:"lock.lock", icon:"st.locks.lock.unlocked", backgroundColor:"#ffffff", nextState:"locking"
+				attributeState "unknown", label:"unknown", action:"lock.lock", icon:"st.locks.lock.unknown", backgroundColor:"#ffffff", nextState:"locking"
+				attributeState "locking", label:'locking', icon:"st.locks.lock.locked", backgroundColor:"#79b821"
+				attributeState "unlocking", label:'unlocking', icon:"st.locks.lock.unlocked", backgroundColor:"#ffffff"
+			}
+		}
+		standardTile("lock", "device.lock", inactiveLabel:false, decoration:"flat", width:2, height:2) {
+			state "default", label:'lock', action:"lock.lock", icon:"st.locks.lock.locked", nextState:"locking"
+		}
+		standardTile("unlock", "device.lock", inactiveLabel:false, decoration:"flat", width:2, height:2) {
+			state "default", label:'unlock', action:"lock.unlock", icon:"st.locks.lock.unlocked", nextState:"unlocking"
+		}
+		valueTile("battery", "device.battery", inactiveLabel:false, decoration:"flat", width:2, height:2) {
+			state "battery", label:'${currentValue}% battery', unit:""
+		}
+		standardTile("refresh", "device.refresh", inactiveLabel:false, decoration:"flat", width:2, height:2) {
+			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+
+		main "toggle"
+		details(["toggle", "lock", "unlock", "battery", "refresh"])
+	}
+}
+
+// Globals
+private getCLUSTER_POWER() { 0x0001 }
+private getCLUSTER_DOORLOCK() { 0x0101 }
+
+private getDOORLOCK_CMD_LOCK_DOOR() { 0x00 }
+private getDOORLOCK_CMD_UNLOCK_DOOR() { 0x01 }
+private getDOORLOCK_ATTR_LOCKSTATE() { 0x0000 }
+private getPOWER_ATTR_BATTERY_PERCENTAGE_REMAINING() { 0x0021 }
+
+private getTYPE_U8() { 0x20 }
+private getTYPE_ENUM8() { 0x30 }
+
+// Public methods
+def installed() {
+    log.trace "installed()"
+}
+
+def uninstalled() {
+    log.trace "uninstalled()"
+}
+
+def configure() {
+    def cmds =
+        zigbee.configureReporting(CLUSTER_DOORLOCK, DOORLOCK_ATTR_LOCKSTATE,
+                                  TYPE_ENUM8, 0, 3600, null) +
+        zigbee.configureReporting(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING,
+                                  TYPE_U8, 600, 21600, 0x01)
+    log.info "configure() --- cmds: $cmds"
+    return cmds + refresh() // send refresh cmds as part of config
+}
+
+def refresh() {
+    def cmds =
+        zigbee.readAttribute(CLUSTER_DOORLOCK, DOORLOCK_ATTR_LOCKSTATE) +
+        zigbee.readAttribute(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING)
+    log.info "refresh() --- cmds: $cmds"
+    return cmds
+}
+
+def parse(String description) {
+    log.trace "parse() --- description: $description"
+
+    Map map = [:]
+    if (description?.startsWith('read attr -')) {
+        map = parseReportAttributeMessage(description)
+    }
+
+    def result = map ? createEvent(map) : null
+    log.debug "parse() --- returned: $result"
+    return result
+}
+
+// Lock capability commands
+def lock() {
+    def cmds = zigbee.command(CLUSTER_DOORLOCK, DOORLOCK_CMD_LOCK_DOOR)
+    log.info "lock() -- cmds: $cmds"
+    return cmds
+}
+
+def unlock() {
+    def cmds = zigbee.command(CLUSTER_DOORLOCK, DOORLOCK_CMD_UNLOCK_DOOR)
+    log.info "unlock() -- cmds: $cmds"
+    return cmds
+}
+
+// Private methods
+private Map parseReportAttributeMessage(String description) {
+    Map descMap = zigbee.parseDescriptionAsMap(description)
+    Map resultMap = [:]
+    if (descMap.clusterInt == CLUSTER_POWER && descMap.attrInt == POWER_ATTR_BATTERY_PERCENTAGE_REMAINING) {
+        resultMap.name = "battery"
+        resultMap.value = Math.round(Integer.parseInt(descMap.value, 16) / 2)
+        if (device.getDataValue("manufacturer") == "Yale") {            //Handling issue with Yale locks incorrect battery reporting
+            resultMap.value = Integer.parseInt(descMap.value, 16)
+        }
+    }
+    else if (descMap.clusterInt == CLUSTER_DOORLOCK && descMap.attrInt == DOORLOCK_ATTR_LOCKSTATE) {
+        def value = Integer.parseInt(descMap.value, 16)
+        def linkText = getLinkText(device)
+        resultMap.name = "lock"
+        if (value == 0) {
+            resultMap.value = "unknown"
+            resultMap.descriptionText = "${linkText} is not fully locked"
+        } else if (value == 1) {
+            resultMap.value = "locked"
+            resultMap.descriptionText = "${linkText} is locked"
+        } else if (value == 2) {
+            resultMap.value = "unlocked"
+            resultMap.descriptionText = "${linkText} is unlocked"
+        } else {
+            resultMap.value = "unknown"
+            resultMap.descriptionText = "${linkText} is in unknown lock state"
+        }
+    }
+    else {
+        log.debug "parseReportAttributeMessage() --- ignoring attribute"
+    }
+    return resultMap
+}

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

@@ -0,0 +1,144 @@
+/**
+ *  Copyright 2016 SmartThings
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ *  Author: SmartThings
+ *  Date: 2016-01-19
+ *
+ *  This DTH should serve as the generic DTH to handle RGBW ZigBee HA devices
+ */
+
+metadata {
+    definition (name: "ZigBee RGBW Bulb", namespace: "smartthings", author: "SmartThings") {
+
+        capability "Actuator"
+        capability "Color Control"
+        capability "Color Temperature"
+        capability "Configuration"
+        capability "Polling"
+        capability "Refresh"
+        capability "Switch"
+        capability "Switch Level"
+
+        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY Flex RGBW", deviceJoinName: "OSRAM LIGHTIFY LED FLEXIBLE STRIP RGBW"
+        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Flex RGBW", deviceJoinName: "OSRAM LIGHTIFY LED FLEXIBLE STRIP RGBW"
+        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY A19 RGBW", deviceJoinName: "OSRAM LIGHTIFY LED A19 RGBW"
+        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY BR RGBW", deviceJoinName: "OSRAM LIGHTIFY LED BR30 RGBW"
+        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04,FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY RT RGBW", deviceJoinName: "OSRAM LIGHTIFY LED RT 5/6 RGBW"
+    }
+
+    // UI tile definitions
+    tiles(scale: 2) {
+        multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+                attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+                attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+            }
+            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+                attributeState "level", action:"switch level.setLevel"
+            }
+            tileAttribute ("device.color", key: "COLOR_CONTROL") {
+                attributeState "color", action:"color control.setColor"
+            }
+        }
+        controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2700..6500)") {
+            state "colorTemperature", action:"color temperature.setColorTemperature"
+        }
+        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "colorTemperature", label: '${currentValue} K'
+        }
+        standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+
+        main(["switch"])
+        details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
+    }
+}
+
+//Globals
+private getATTRIBUTE_HUE() { 0x0000 }
+private getATTRIBUTE_SATURATION() { 0x0001 }
+private getHUE_COMMAND() { 0x00 }
+private getSATURATION_COMMAND() { 0x03 }
+private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
+private getATTRIBUTE_COLOR_TEMPERATURE() { 0x0007 }
+
+// Parse incoming device messages to generate events
+def parse(String description) {
+    log.debug "description is $description"
+
+    def finalResult = zigbee.getEvent(description)
+    if (finalResult) {
+        log.debug finalResult
+        sendEvent(finalResult)
+    }
+    else {
+        def zigbeeMap = zigbee.parseDescriptionAsMap(description)
+        log.trace "zigbeeMap : $zigbeeMap"
+
+        if (zigbeeMap?.clusterInt == COLOR_CONTROL_CLUSTER) {
+            if(zigbeeMap.attrInt == ATTRIBUTE_HUE){  //Hue Attribute
+                def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 360)
+                sendEvent(name: "hue", value: hueValue, displayed:false)
+            }
+            else if(zigbeeMap.attrInt == ATTRIBUTE_SATURATION){ //Saturation Attribute
+                def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
+                sendEvent(name: "saturation", value: saturationValue, displayed:false)
+            }
+        }
+        else {
+            log.info "DID NOT PARSE MESSAGE for description : $description"
+        }
+    }
+}
+
+def on() {
+    zigbee.on()
+}
+
+def off() {
+    zigbee.off()
+}
+
+def refresh() {
+    zigbee.readAttribute(0x0006, 0x00) + zigbee.readAttribute(0x0008, 0x00) + zigbee.readAttribute(0x0300, 0x00) + zigbee.readAttribute(0x0300, ATTRIBUTE_COLOR_TEMPERATURE) + zigbee.readAttribute(0x0300, ATTRIBUTE_HUE) + zigbee.readAttribute(0x0300, ATTRIBUTE_SATURATION) + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, 0x20, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, 0x20, 1, 3600, 0x01)
+}
+
+def configure() {
+    log.debug "Configuring Reporting and Bindings."
+    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, 0x20, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, 0x20, 1, 3600, 0x01) + zigbee.readAttribute(0x0006, 0x00) + zigbee.readAttribute(0x0008, 0x00) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, 0x00) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_COLOR_TEMPERATURE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE) + zigbee.readAttribute(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION)
+}
+
+def setColorTemperature(value) {
+    zigbee.setColorTemperature(value)
+}
+
+def setLevel(value) {
+    zigbee.setLevel(value)
+}
+
+def setColor(value){
+    log.trace "setColor($value)"
+    zigbee.on() + setHue(value.hue) + "delay 300" + setSaturation(value.saturation)
+}
+
+def setHue(value) {
+    def scaledHueValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+    zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, scaledHueValue, "00", "0500")       //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second) (0500 in U16 reads 5)
+}
+
+def setSaturation(value) {
+    def scaledSatValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
+    zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500")      //payload-> sat value, transition time
+}

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

@@ -0,0 +1,86 @@
+/**
+ *  Copyright 2015 SmartThings
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ */
+
+metadata {
+    definition (name: "ZigBee Switch Power", namespace: "smartthings", author: "SmartThings") {
+        capability "Actuator"
+        capability "Configuration"
+        capability "Refresh"
+        capability "Power Meter"
+        capability "Sensor"
+        capability "Switch"
+
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0B04"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0702"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0702, 0B05", outClusters: "0003, 000A, 0019", manufacturer: "Jasco Products", model: "45853", deviceJoinName: "GE ZigBee Plug-In Switch"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0702, 0B05", outClusters: "000A, 0019", manufacturer: "Jasco Products", model: "45856", deviceJoinName: "GE ZigBee In-Wall Switch"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 000F, 0B04", outClusters: "0019", manufacturer: "SmartThings", model: "outletv4", deviceJoinName: "Outlet"
+    }
+
+    tiles(scale: 2) {
+        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 ("power", key: "SECONDARY_CONTROL") {
+                attributeState "power", label:'${currentValue} W'
+            }
+        }
+        standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+        main "switch"
+        details(["switch", "refresh"])
+    }
+}
+
+// Parse incoming device messages to generate events
+def parse(String description) {
+    log.debug "description is $description"
+    def event = zigbee.getEvent(description)
+    if (event) {
+        if (event.name == "power") {
+            def powerValue
+            powerValue = (event.value as Integer)/10            //TODO: The divisor value needs to be set as part of configuration
+            sendEvent(name: "power", value: powerValue)
+        }
+        else {
+            sendEvent(event)
+        }
+    }
+    else {
+        log.warn "DID NOT PARSE MESSAGE for description : $description"
+        log.debug zigbee.parseDescriptionAsMap(description)
+    }
+}
+
+def off() {
+    zigbee.off()
+}
+
+def on() {
+    zigbee.on()
+}
+
+def refresh() {
+    zigbee.onOffRefresh() + zigbee.simpleMeteringPowerRefresh() + zigbee.electricMeasurementPowerRefresh() + zigbee.onOffConfig() + zigbee.simpleMeteringPowerConfig() + zigbee.electricMeasurementPowerConfig()
+}
+
+def configure() {
+    log.debug "Configuring Reporting and Bindings."
+    zigbee.onOffConfig() + zigbee.simpleMeteringPowerConfig() + zigbee.electricMeasurementPowerConfig() + zigbee.onOffRefresh() + zigbee.simpleMeteringPowerRefresh() + zigbee.electricMeasurementPowerRefresh()
+}

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

@@ -0,0 +1,81 @@
+/**
+ *  Copyright 2015 SmartThings
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ */
+
+metadata {
+    definition (name: "ZigBee Switch", namespace: "smartthings", author: "SmartThings") {
+        capability "Actuator"
+        capability "Configuration"
+        capability "Refresh"
+        capability "Switch"
+
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006"
+    }
+
+    // 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.light.on", backgroundColor:"#79b821", 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 "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
+            }
+        }
+        standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+        main "switch"
+        details(["switch", "refresh"])
+    }
+}
+
+// Parse incoming device messages to generate events
+def parse(String description) {
+    log.debug "description is $description"
+    def event = zigbee.getEvent(description)
+    if (event) {
+        sendEvent(event)
+    }
+    else {
+        log.warn "DID NOT PARSE MESSAGE for description : $description"
+        log.debug zigbee.parseDescriptionAsMap(description)
+    }
+}
+
+def off() {
+    zigbee.off()
+}
+
+def on() {
+    zigbee.on()
+}
+
+def refresh() {
+    zigbee.onOffRefresh() + zigbee.onOffConfig()
+}
+
+def configure() {
+    log.debug "Configuring Reporting and Bindings."
+    zigbee.onOffConfig() + zigbee.onOffRefresh()
+}

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

@@ -0,0 +1,127 @@
+/**
+ *  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.
+ *
+ *  ZigBee White Color Temperature Bulb
+ *
+ *  Author: SmartThings
+ *  Date: 2015-09-22
+ */
+
+metadata {
+    definition (name: "ZigBee White Color Temperature Bulb", namespace: "smartthings", author: "SmartThings") {
+
+        capability "Actuator"
+        capability "Color Temperature"
+        capability "Configuration"
+        capability "Refresh"
+        capability "Switch"
+        capability "Switch Level"
+
+        attribute "colorName", "string"
+        command "setGenericName"
+
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300", outClusters: "0019"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 0B04", outClusters: "0019"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY BR Tunable White", deviceJoinName: "OSRAM LIGHTIFY LED Flood BR30 Tunable White"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY RT Tunable White", deviceJoinName: "OSRAM LIGHTIFY LED Recessed Kit RT 5/6 Tunable White"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Classic A60 TW", deviceJoinName: "OSRAM LIGHTIFY LED Tunable White 60W"
+        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "LIGHTIFY A19 Tunable White", deviceJoinName: "OSRAM LIGHTIFY LED Tunable White 60W"
+    }
+
+    // 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 "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 "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
+            }
+            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+                attributeState "level", action:"switch level.setLevel"
+            }
+            tileAttribute ("colorName", key: "SECONDARY_CONTROL") {
+                attributeState "colorName", label:'${currentValue}'
+            }
+        }
+
+        standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+
+        controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2700..6500)") {
+            state "colorTemperature", action:"color temperature.setColorTemperature"
+        }
+        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "colorTemperature", label: '${currentValue} K'
+        }
+
+        main(["switch"])
+        details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
+    }
+}
+
+// Parse incoming device messages to generate events
+def parse(String description) {
+    log.debug "description is $description"
+    def event = zigbee.getEvent(description)
+    if (event) {
+        sendEvent(event)
+    }
+    else {
+        log.warn "DID NOT PARSE MESSAGE for description : $description"
+        log.debug zigbee.parseDescriptionAsMap(description)
+    }
+}
+
+def off() {
+    zigbee.off()
+}
+
+def on() {
+    zigbee.on()
+}
+
+def setLevel(value) {
+    zigbee.setLevel(value)
+}
+
+def refresh() {
+    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh() + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig()
+}
+
+def configure() {
+    log.debug "Configuring Reporting and Bindings."
+    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
+}
+
+def setColorTemperature(value) {
+    setGenericName(value)
+    zigbee.setColorTemperature(value)
+}
+
+//Naming based on the wiki article here: http://en.wikipedia.org/wiki/Color_temperature
+def setGenericName(value){
+    if (value != null) {
+        def genericName = "White"
+        if (value < 3300) {
+            genericName = "Soft White"
+        } else if (value < 4150) {
+            genericName = "Moonlight"
+        } else if (value <= 5000) {
+            genericName = "Cool White"
+        } else if (value >= 5000) {
+            genericName = "Daylight"
+        }
+        sendEvent(name: "colorName", value: genericName)
+    }
+}

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

@@ -245,6 +245,7 @@ def retypeBasedOnMSR() {
 			break
 		case "011F-0001-0001":  // Schlage motion
 		case "014A-0001-0001":  // Ecolink motion
+		case "014A-0004-0001":  // Ecolink motion +
 		case "0060-0001-0002":  // Everspring SP814
 		case "0060-0001-0003":  // Everspring HSP02
 		case "011A-0601-0901":  // Enerwave ZWN-BPC

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

@@ -66,9 +66,20 @@ metadata {
 import physicalgraph.zwave.commands.doorlockv1.*
 import physicalgraph.zwave.commands.usercodev1.*
 
+def updated() {
+	try {
+		if (!state.init) {
+			state.init = true
+			response(secureSequence([zwave.doorLockV1.doorLockOperationGet(), zwave.batteryV1.batteryGet()]))
+		}
+	} catch (e) {
+		log.warn "updated() threw $e"
+	}
+}
+
 def parse(String description) {
 	def result = null
-	if (description.startsWith("Err")) {
+	if (description.startsWith("Err 106")) {
 		if (state.sec) {
 			result = createEvent(descriptionText:description, displayed:false)
 		} else {
@@ -80,6 +91,8 @@ def parse(String description) {
 				displayed: true,
 			)
 		}
+	} else if (description == "updated") {
+		return null
 	} else {
 		def cmd = zwave.parse(description, [ 0x98: 1, 0x72: 2, 0x85: 2, 0x86: 1 ])
 		if (cmd) {
@@ -262,6 +275,7 @@ def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd) {
 		case 32:
 			map = [ name: "codeChanged", value: "all", descriptionText: "$device.displayName: all user codes deleted", isStateChange: true ]
 			allCodesDeleted()
+			break
 		case 33:
 			map = [ name: "codeReport", value: cmd.alarmLevel, data: [ code: "" ], isStateChange: true ]
 			map.descriptionText = "$device.displayName code $cmd.alarmLevel was deleted"
@@ -286,7 +300,7 @@ def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd) {
 			}
 			break
 		case 167:
-			if (!state.lastbatt || (new Date().time) - state.lastbatt > 12*60*60*1000) {
+			if (!state.lastbatt || now() - state.lastbatt > 12*60*60*1000) {
 				map = [ descriptionText: "$device.displayName: battery low", isStateChange: true ]
 				result << response(secure(zwave.batteryV1.batteryGet()))
 			} else {
@@ -328,14 +342,14 @@ def zwaveEvent(UserCodeReport cmd) {
 			map = [ name: "codeReport", value: cmd.userIdentifier, data: [ code: code ] ]
 			map.descriptionText = "$device.displayName code $cmd.userIdentifier is set"
 			map.displayed = (cmd.userIdentifier != state.requestCode && cmd.userIdentifier != state.pollCode)
-			map.isStateChange = (code != decrypt(state[name]))
+			map.isStateChange = true
 		}
 		result << createEvent(map)
 	} else {
 		map = [ name: "codeReport", value: cmd.userIdentifier, data: [ code: "" ] ]
 		if (state.blankcodes && state["reset$name"]) {  // we deleted this code so we can tell that our new code gets set
 			map.descriptionText = "$device.displayName code $cmd.userIdentifier was reset"
-			map.displayed = map.isStateChange = false
+			map.displayed = map.isStateChange = true
 			result << createEvent(map)
 			state["set$name"] = state["reset$name"]
 			result << response(setCode(cmd.userIdentifier, state["reset$name"]))
@@ -347,7 +361,7 @@ def zwaveEvent(UserCodeReport cmd) {
 				map.descriptionText = "$device.displayName code $cmd.userIdentifier is not set"
 			}
 			map.displayed = (cmd.userIdentifier != state.requestCode && cmd.userIdentifier != state.pollCode)
-			map.isStateChange = state[name] as Boolean
+			map.isStateChange = true
 			result << createEvent(map)
 		}
 		code = ""
@@ -431,7 +445,7 @@ def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
 	} else {
 		map.value = cmd.batteryLevel
 	}
-	state.lastbatt = new Date().time
+	state.lastbatt = now()
 	createEvent(map)
 }
 
@@ -499,15 +513,14 @@ def refresh() {
 		cmds << "delay 4200"
 		cmds << zwave.associationV1.associationGet(groupingIdentifier:2).format()  // old Schlage locks use group 2 and don't secure the Association CC
 		cmds << secure(zwave.associationV1.associationGet(groupingIdentifier:1))
-		state.associationQuery = new Date().time
-	} else if (new Date().time - state.associationQuery.toLong() > 9000) {
-		log.debug "setting association"
+		state.associationQuery = now()
+	} else if (secondsPast(state.associationQuery, 9)) {
 		cmds << "delay 6000"
 		cmds << zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId).format()
 		cmds << secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId))
 		cmds << zwave.associationV1.associationGet(groupingIdentifier:2).format()
 		cmds << secure(zwave.associationV1.associationGet(groupingIdentifier:1))
-		state.associationQuery = new Date().time
+		state.associationQuery = now()
 	}
 	log.debug "refresh sending ${cmds.inspect()}"
 	cmds
@@ -515,55 +528,22 @@ def refresh() {
 
 def poll() {
 	def cmds = []
-	if (state.assoc != zwaveHubNodeId && secondsPast(state.associationQuery, 19 * 60)) {
-		log.debug "setting association"
-		cmds << zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId).format()
-		cmds << secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId))
-		cmds << zwave.associationV1.associationGet(groupingIdentifier:2).format()
-		cmds << "delay 6000"
-		cmds << secure(zwave.associationV1.associationGet(groupingIdentifier:1))
-		cmds << "delay 6000"
-		state.associationQuery = new Date().time
-	} else {
-		// Only check lock state if it changed recently or we haven't had an update in an hour
-		def latest = device.currentState("lock")?.date?.time
-		if (!latest || !secondsPast(latest, 6 * 60) || secondsPast(state.lastPoll, 55 * 60)) {
-			cmds << secure(zwave.doorLockV1.doorLockOperationGet())
-			state.lastPoll = (new Date()).time
-		} else if (!state.MSR) {
-			cmds << zwave.manufacturerSpecificV1.manufacturerSpecificGet().format()
-		} else if (!state.fw) {
-			cmds << zwave.versionV1.versionGet().format()
-		} else if (!state.codes) {
-			state.pollCode = 1
-			cmds << secure(zwave.userCodeV1.usersNumberGet())
-		} else if (state.pollCode && state.pollCode <= state.codes) {
-			cmds << requestCode(state.pollCode)
-		} else if (!state.lastbatt || (new Date().time) - state.lastbatt > 53*60*60*1000) {
-			cmds << secure(zwave.batteryV1.batteryGet())
-		} else if (!state.enc) {
-			encryptCodes()
-			state.enc = 1
-		}
+	// Only check lock state if it changed recently or we haven't had an update in an hour
+	def latest = device.currentState("lock")?.date?.time
+	if (!latest || !secondsPast(latest, 6 * 60) || secondsPast(state.lastPoll, 55 * 60)) {
+		cmds << secure(zwave.doorLockV1.doorLockOperationGet())
+		state.lastPoll = now()
+	} else if (!state.lastbatt || now() - state.lastbatt > 53*60*60*1000) {
+		cmds << secure(zwave.batteryV1.batteryGet())
+		state.lastbatt = now()  //inside-214
 	}
-	log.debug "poll is sending ${cmds.inspect()}"
-	device.activity()
-	cmds ?: null
-}
-
-private def encryptCodes() {
-	def keys = new ArrayList(state.keySet().findAll { it.startsWith("code") })
-	keys.each { key ->
-		def match = (key =~ /^code(\d+)$/)
-		if (match) try {
-			def keynum = match[0][1].toInteger()
-			if (keynum > 30 && !state[key]) {
-				state.remove(key)
-			} else if (state[key] && !state[key].startsWith("~")) {
-				log.debug "encrypting $key: ${state[key].inspect()}"
-				state[key] = encrypt(state[key])
-			}
-		} catch (java.lang.NumberFormatException e) { }
+	if (cmds) {
+		log.debug "poll is sending ${cmds.inspect()}"
+		cmds
+	} else {
+		// workaround to keep polling from stopping due to lack of activity
+		sendEvent(descriptionText: "skipping poll", isStateChange: true, displayed: false)
+		null
 	}
 }
 
@@ -672,7 +652,7 @@ private Boolean secondsPast(timestamp, seconds) {
 			return true
 		}
 	}
-	return (new Date().time - timestamp) > (seconds * 1000)
+	return (now() - timestamp) > (seconds * 1000)
 }
 
 private allCodesDeleted() {

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

@@ -57,7 +57,7 @@ def parse(String description) {
 	return result
 }
 
-def sensorValueEvent(Short value) {
+def sensorValueEvent(value) {
 	if (value) {
 		createEvent(name: "motion", value: "active", descriptionText: "$device.displayName detected motion")
 	} else {
@@ -94,24 +94,24 @@ def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cm
 {
 	def result = []
 	if (cmd.notificationType == 0x07) {
-		if (cmd.event == 0x01 || cmd.event == 0x02) {
+		if (cmd.v1AlarmType == 0x07) {  // special case for nonstandard messages from Monoprice ensors
+			result << sensorValueEvent(cmd.v1AlarmLevel)
+		} else if (cmd.event == 0x01 || cmd.event == 0x02 || cmd.event == 0x07 || cmd.event == 0x08) {
 			result << sensorValueEvent(1)
+		} else if (cmd.event == 0x00) {
+			result << sensorValueEvent(0)
 		} else if (cmd.event == 0x03) {
-			result << createEvent(descriptionText: "$device.displayName covering was removed", isStateChange: true)
-			result << response(zwave.wakeUpV1.wakeUpIntervalSet(seconds:4*3600, nodeid:zwaveHubNodeId))
-			if(!state.MSR) result << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
+			result << createEvent(name: "tamper", value: "detected", descriptionText: "$device.displayName covering was removed", isStateChange: true)
+			result << response(zwave.batteryV1.batteryGet())
 		} else if (cmd.event == 0x05 || cmd.event == 0x06) {
 			result << createEvent(descriptionText: "$device.displayName detected glass breakage", isStateChange: true)
-		} else if (cmd.event == 0x07) {
-			if(!state.MSR) result << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
-			result << sensorValueEvent(1)
 		}
 	} else if (cmd.notificationType) {
 		def text = "Notification $cmd.notificationType: event ${([cmd.event] + cmd.eventParameter).join(", ")}"
-		result << createEvent(name: "notification$cmd.notificationType", value: "$cmd.event", descriptionText: text, displayed: false)
+		result << createEvent(name: "notification$cmd.notificationType", value: "$cmd.event", descriptionText: text, isStateChange: true, displayed: false)
 	} else {
 		def value = cmd.v1AlarmLevel == 255 ? "active" : cmd.v1AlarmLevel ?: "inactive"
-		result << createEvent(name: "alarm $cmd.v1AlarmType", value: value, displayed: false)
+		result << createEvent(name: "alarm $cmd.v1AlarmType", value: value, isStateChange: true, displayed: false)
 	}
 	result
 }
@@ -119,6 +119,10 @@ def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cm
 def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd)
 {
 	def result = [createEvent(descriptionText: "${device.displayName} woke up", isStateChange: false)]
+
+	if (state.MSR == "011A-0601-0901" && device.currentState('motion') == null) {  // Enerwave motion doesn't always get the associationSet that the hub sends on join
+		result << response(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId))
+	}
 	if (!state.lastbat || (new Date().time) - state.lastbat > 53*60*60*1000) {
 		result << response(zwave.batteryV1.batteryGet())
 		result << response("delay 1200")
@@ -179,4 +183,4 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
 
 	result << createEvent(descriptionText: "$device.displayName MSR: $msr", isStateChange: false)
 	result
-}
+}

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

@@ -115,6 +115,10 @@ def strobe() {
 	]
 }
 
+def both() {
+	on()
+}
+
 def refresh() {
 	log.debug "sending battery refresh command"
 	zwave.batteryV1.batteryGet().format()

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

@@ -61,37 +61,44 @@ def parse(String description) {
 			zwaveEvent(cmd, results)
 		}
 	}
-	// log.debug "\"$description\" parsed to ${results.inspect()}"
+	log.debug "'$description' parsed to ${results.inspect()}"
 	return results
 }
 
 
 def createSmokeOrCOEvents(name, results) {
 	def text = null
-	if (name == "smoke") {
-		text = "$device.displayName smoke was detected!"
-		// these are displayed:false because the composite event is the one we want to see in the app
-		results << createEvent(name: "smoke",          value: "detected", descriptionText: text, displayed: false)
-	} else if (name == "carbonMonoxide") {
-		text = "$device.displayName carbon monoxide was detected!"
-		results << createEvent(name: "carbonMonoxide", value: "detected", descriptionText: text, displayed: false)
-	} else if (name == "tested") {
-		text = "$device.displayName was tested"
-		results << createEvent(name: "smoke",          value: "tested", descriptionText: text, displayed: false)
-		results << createEvent(name: "carbonMonoxide", value: "tested", descriptionText: text, displayed: false)
-	} else if (name == "smokeClear") {
-		text = "$device.displayName smoke is clear"
-		results << createEvent(name: "smoke",          value: "clear", descriptionText: text, displayed: false)
-		name = "clear"
-	} else if (name == "carbonMonoxideClear") {
-		text = "$device.displayName carbon monoxide is clear"
-		results << createEvent(name: "carbonMonoxide", value: "clear", descriptionText: text, displayed: false)
-		name = "clear"
-	} else if (name == "testClear") {
-		text = "$device.displayName smoke is clear"
-		results << createEvent(name: "smoke",          value: "clear", descriptionText: text, displayed: false)
-		results << createEvent(name: "carbonMonoxide", value: "clear", displayed: false)
-		name = "clear"
+	switch (name) {
+		case "smoke":
+			text = "$device.displayName smoke was detected!"
+			// these are displayed:false because the composite event is the one we want to see in the app
+			results << createEvent(name: "smoke",          value: "detected", descriptionText: text, displayed: false)
+			break
+		case "carbonMonoxide":
+			text = "$device.displayName carbon monoxide was detected!"
+			results << createEvent(name: "carbonMonoxide", value: "detected", descriptionText: text, displayed: false)
+			break
+		case "tested":
+			text = "$device.displayName was tested"
+			results << createEvent(name: "smoke",          value: "tested", descriptionText: text, displayed: false)
+			results << createEvent(name: "carbonMonoxide", value: "tested", descriptionText: text, displayed: false)
+			break
+		case "smokeClear":
+			text = "$device.displayName smoke is clear"
+			results << createEvent(name: "smoke",          value: "clear", descriptionText: text, displayed: false)
+			name = "clear"
+			break
+		case "carbonMonoxideClear":
+			text = "$device.displayName carbon monoxide is clear"
+			results << createEvent(name: "carbonMonoxide", value: "clear", descriptionText: text, displayed: false)
+			name = "clear"
+			break
+		case "testClear":
+			text = "$device.displayName test cleared"
+			results << createEvent(name: "smoke",          value: "clear", descriptionText: text, displayed: false)
+			results << createEvent(name: "carbonMonoxide", value: "clear", displayed: false)
+			name = "clear"
+			break
 	}
 	// This composite event is used for updating the tile
 	results << createEvent(name: "alarmState", value: name, descriptionText: text)
@@ -117,8 +124,10 @@ def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd, results) {
 			createSmokeOrCOEvents(cmd.alarmLevel ? "tested" : "testClear", results)
 			break
 		case 13:  // sent every hour -- not sure what this means, just a wake up notification?
-			if (cmd.alarmLevel != 255) {
-				results << createEvent(descriptionText: "$device.displayName code 13 is $cmd.alarmLevel", displayed: true)
+			if (cmd.alarmLevel == 255) {
+				results << createEvent(descriptionText: "$device.displayName checked in", isStateChange: false)
+			} else {
+				results << createEvent(descriptionText: "$device.displayName code 13 is $cmd.alarmLevel", isStateChange:true, displayed:false)
 			}
 			
 			// Clear smoke in case they pulled batteries and we missed the clear msg
@@ -127,9 +136,8 @@ def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd, results) {
 			}
 			
 			// Check battery if we don't have a recent battery event
-			def prevBattery = device.currentState("battery")
-			if (!prevBattery || (new Date().time - prevBattery.date.time)/60000 >= 60 * 53) {
-				results << new physicalgraph.device.HubAction(zwave.batteryV1.batteryGet().format())
+			if (!state.lastbatt || (now() - state.lastbatt) >= 48*60*60*1000) {
+				results << response(zwave.batteryV1.batteryGet())
 			}
 			break
 		default:
@@ -158,12 +166,17 @@ def zwaveEvent(physicalgraph.zwave.commands.sensoralarmv1.SensorAlarmReport cmd,
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd, results) {
-	results << new physicalgraph.device.HubAction(zwave.wakeUpV1.wakeUpNoMoreInformation().format())
 	results << createEvent(descriptionText: "$device.displayName woke up", isStateChange: false)
+	if (!state.lastbatt || (now() - state.lastbatt) >= 56*60*60*1000) {
+		results << response(zwave.batteryV1.batteryGet(), "delay 2000", zwave.wakeUpV1.wakeUpNoMoreInformation())
+	} else {
+		results << response(zwave.wakeUpV1.wakeUpNoMoreInformation())
+	}
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd, results) {
-	def map = [ name: "battery", unit: "%" ]
+	def map = [ name: "battery", unit: "%", isStateChange: true ]
+	state.lastbatt = now()
 	if (cmd.batteryLevel == 0xFF) {
 		map.value = 1
 		map.descriptionText = "$device.displayName battery is low!"

devicetypes/superuser/switch-too.src/switch-too.groovy

@@ -1,48 +0,0 @@
-/**
- *  Switch Too
- *
- *  Copyright 2015 Bob Florian
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (name: "Switch Too", author: "Bob Florian") {
-		capability "Switch"
-	}
-
-	simulator {
-		// TODO: define status and reply messages here
-	}
-
-	tiles {
-		// TODO: define your main and details tiles here
-	}
-}
-
-// parse events into attributes
-def parse(String description) {
-	log.debug "Parsing '${description}'"
-	// TODO: handle 'switch' attribute
-
-}
-
-// handle commands
-def on() {
-	log.debug "Executing 'on'"
-	// TODO: handle 'on' command
-}
-
-def off() {
-	log.debug "Executing 'off'"
-	// TODO: handle 'off' command
-}
-
-

devicetypes/timevalve-gaslock-t-08/timevalve-smart.src/timevalve-smart.groovy

@@ -0,0 +1,243 @@
+metadata {
+        definition (name: "Timevalve Smart", namespace: "timevalve.gaslock.t-08", author: "ruinnel") {
+                capability "Valve"
+                capability "Refresh"
+                capability "Battery"
+                capability "Temperature Measurement"
+                
+                command "setRemaining"
+                command "setTimeout"
+                command "setTimeout10"
+                command "setTimeout20"
+                command "setTimeout30"
+                command "setTimeout40"
+                
+                command "remainingLevel"
+                
+                attribute "remaining", "number"
+                attribute "remainingText", "String"
+                attribute "timeout", "number"
+                
+                //raw desc : 0 0 0x1006 0 0 0 7 0x5E 0x86 0x72 0x5A 0x73 0x98 0x80
+                //fingerprint deviceId:"0x1006", inClusters:"0x5E, 0x86, 0x72, 0x5A, 0x73, 0x98, 0x80"
+        }
+
+        tiles (scale: 2) {
+        	multiAttributeTile(name:"statusTile", type:"generic", width:6, height:4) {
+            	tileAttribute("device.contact", key: "PRIMARY_CONTROL") {
+	            	attributeState "open", label: '${name}', action: "close", icon:"st.contact.contact.open", backgroundColor:"#ffa81e"
+	            	attributeState "closed", label:'${name}', action: "", icon:"st.contact.contact.closed", backgroundColor:"#79b821"
+    	        }
+                tileAttribute("device.remainingText", key: "SECONDARY_CONTROL") {
+	            	attributeState "open", label: '${currentValue}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e"
+	            	attributeState "closed", label:'', icon:"st.contact.contact.closed", backgroundColor:"#79b821"
+    	        }
+            }
+            
+            standardTile("refreshTile", "command.refresh", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+                state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
+            }
+            
+            controlTile("remainingSliderTile", "device.remaining", "slider", inactiveLabel: false, range:"(0..590)", height: 2, width: 4) {
+            	state "level", action:"remainingLevel"
+            }
+            valueTile("setRemaining", "device.remainingText", inactiveLabel: false, decoration: "flat", height: 2, width: 2){
+                state "remainingText", label:'${currentValue}\nRemaining'//, action: "setRemaining"//, icon: "st.Office.office6"
+            }
+
+            standardTile("setTimeout10", "device.remaining", inactiveLabel: false, decoration: "flat") {
+                state "default", label:'10Min', action: "setTimeout10", icon:"st.Health & Wellness.health7", defaultState: true
+                state "10", label:'10Min', action: "setTimeout10", icon:"st.Office.office13"
+            }
+            standardTile("setTimeout20", "device.remaining", inactiveLabel: false, decoration: "flat") {
+                state "default", label:'20Min', action: "setTimeout20", icon:"st.Health & Wellness.health7", defaultState: true
+                state "20", label:'20Min', action: "setTimeout20", icon:"st.Office.office13"
+            }
+            standardTile("setTimeout30", "device.remaining", inactiveLabel: false, decoration: "flat") {
+                state "default", label:'30Min', action: "setTimeout30", icon:"st.Health & Wellness.health7", defaultState: true
+                state "30", label:'30Min', action: "setTimeout30", icon:"st.Office.office13"
+            }
+            standardTile("setTimeout40", "device.remaining", inactiveLabel: false, decoration: "flat") {
+                state "default", label:'40Min', action: "setTimeout40", icon:"st.Health & Wellness.health7", defaultState: true
+                state "40", label:'40Min', action: "setTimeout40", icon:"st.Office.office13"
+            }
+
+            valueTile("batteryTile", "device.battery", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+                state "battery", label:'${currentValue}% battery', unit:""
+            }
+
+            main (["statusTile"])
+//            details (["statusTile", "remainingSliderTile", "setRemaining", "setTimeout10", "setTimeout20", "batteryTile", "refreshTile", "setTimeout30", "setTimeout40"])
+//            details (["statusTile", "batteryTile", "setRemaining", "refreshTile"])
+            details (["statusTile", "batteryTile", "refreshTile"])
+        }
+}
+
+def parse(description) {
+//	log.debug "parse - " + description
+	def result = null
+	if (description.startsWith("Err 106")) {
+		state.sec = 0
+		result = createEvent(descriptionText: description, isStateChange: true)
+	} else if (description != "updated") {
+		def cmd = zwave.parse(description, [0x20: 1, 0x25: 1, 0x70: 1, 0x71: 1, 0x98: 1])
+		if (cmd) {
+        	log.debug "parsed cmd = " + cmd
+			result = zwaveEvent(cmd)
+			//log.debug("'$description' parsed to $result")
+		} else {
+			log.debug("Couldn't zwave.parse '$description'")
+		}
+	}
+	return result
+}
+
+// 복호화 후 zwaveEvent() 호출
+def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
+	//log.debug "SecurityMessageEncapsulation - " + cmd
+	def encapsulatedCommand = cmd.encapsulatedCommand([0x20: 1, 0x25: 1, 0x70: 1, 0x71: 1, 0x98: 1])
+	if (encapsulatedCommand) {
+		state.sec = 1
+        log.debug "encapsulatedCommand = " + encapsulatedCommand
+        zwaveEvent(encapsulatedCommand)
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd) {
+	//log.debug "switch status - " + cmd.value
+    createEvent(name:"contact", value: cmd.value ? "open" : "closed")
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
+    def map = [ name: "battery", unit: "%" ]
+    if (cmd.batteryLevel == 0xFF) {  // Special value for low battery alert
+        map.value = 1
+        map.descriptionText = "${device.displayName} has a low battery"
+        map.isStateChange = true
+    } else {
+        map.value = cmd.batteryLevel
+    }
+    
+    log.debug "battery - ${map.value}${map.unit}"
+    // Store time of last battery update so we don't ask every wakeup, see WakeUpNotification handler
+    state.lastbatt = new Date().time
+    createEvent(map)
+}
+
+def zwaveEvent(physicalgraph.zwave.Command cmd) {
+  //log.debug "zwaveEvent - ${device.displayName}: ${cmd}"
+  createEvent(descriptionText: "${device.displayName}: ${cmd}")
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.configurationv1.ConfigurationReport cmd) {
+	def result = []
+	log.info "zwave.configurationV1.configurationGet - " + cmd
+    def array = cmd.configurationValue
+    def value = ( (array[0] * 0x1000000) + (array[1] * 0x10000) + (array[2] * 0x100) + array[3] ).intdiv(60)
+    if (device.currentValue("contact") == "open") {
+    	value = ( (array[0] * 0x1000000) + (array[1] * 0x10000) + (array[2] * 0x100) + array[3] ).intdiv(60)
+    } else {
+    	value = 0
+    }
+    
+    if (device.currentValue('contact') == 'open') {
+    	def hour = value.intdiv(60);
+        def min = (value % 60).toString().padLeft(2, '0');
+        def text = "${hour}:${min}M"
+        
+        log.info "remain - " + text
+        result.add( createEvent(name: "remaining", value: value, displayed: false, isStateChange: true) )
+        result.add( createEvent(name: "remainingText", value: text, displayed: false, isStateChange: true) )
+    } else {
+    	result.add( createEvent(name: "timeout", value: value, displayed: false, isStateChange: true) )
+    }
+    return result
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
+	def type = cmd.notificationType
+    if (type == cmd.NOTIFICATION_TYPE_HEAT) {
+    	log.info "NotificationReport - ${type}"
+        createEvent(name: "temperature", value: 999, unit: "C", descriptionText: "${device.displayName} is over heat!", displayed: true, isStateChange: true)
+    }
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.alarmv1.AlarmReport cmd) {
+	def type = cmd.alarmType
+    def level = cmd.alarmLevel
+    
+    log.info "AlarmReport - type : ${type}, level : ${level}"
+    def msg = "${device.displayName} is over heat!"
+    def result = createEvent(name: "temperature", value: 999, unit: "C", descriptionText: msg, displayed: true, isStateChange: true)
+    if (sendPushMessage) {
+    	sendPushMessage(msg)
+    }
+    return result
+}
+
+// remote open not allow
+def open() {}
+
+def close() {
+//	log.debug 'cmd - close()'
+    commands([
+        zwave.switchBinaryV1.switchBinarySet(switchValue: 0x00),
+		zwave.switchBinaryV1.switchBinaryGet()
+	])
+}
+
+def setTimeout10() { setTimeout(10) }
+def setTimeout20() { setTimeout(20) }
+def setTimeout30() { setTimeout(30) }
+def setTimeout40() { setTimeout(40) }
+
+
+def setTimeout(value) {
+//	log.debug "setDefaultTime($value)"
+    commands([
+    	zwave.configurationV1.configurationSet(parameterNumber: 0x01, size: 4, scaledConfigurationValue: value * 60),
+        zwave.configurationV1.configurationGet(parameterNumber: 0x01)
+    ]);
+}
+
+def remainingLevel(value) {
+//	log.debug "remainingLevel($value)"
+    def hour = value.intdiv(60);
+    def min = (value % 60).toString().padLeft(2, '0');
+    def text = "${hour}:${min}M"
+    sendEvent(name: "remaining", value: value, displayed: false, isStateChange: true)
+    sendEvent(name: "remainingText", value: text, displayed: false, isStateChange: true)
+}
+
+def setRemaining() {
+	def remaining = device.currentValue("remaining")
+//	log.debug "setConfiguration() - remaining : $remaining"
+    commands([
+    	zwave.configurationV1.configurationSet(parameterNumber: 0x03, size: 4, scaledConfigurationValue: remaining * 60),
+        zwave.configurationV1.configurationGet(parameterNumber: 0x03)
+    ]);
+}
+
+private command(physicalgraph.zwave.Command cmd) {
+	if (state.sec != 0 && !(cmd instanceof physicalgraph.zwave.commands.batteryv1.BatteryGet)) {
+    	log.debug "cmd = " + cmd + ", encapsulation"
+		zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
+	} else {
+    	log.debug "cmd = " + cmd + ", plain"
+		cmd.format()
+	}
+}
+
+private commands(commands, delay=200) {
+	delayBetween(commands.collect{ command(it) }, delay)
+}
+
+def refresh() {
+//	log.debug 'cmd - refresh()'
+	commands([
+    			zwave.batteryV1.batteryGet(),
+                zwave.switchBinaryV1.switchBinaryGet(),
+                zwave.configurationV1.configurationGet(parameterNumber: 0x01),
+                zwave.configurationV1.configurationGet(parameterNumber: 0x03)
+        ], 400)
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Thu Feb 25 08:56:06 CST 2016
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-bin.zip