Modifying 'Smartapp to sync your simulated garage opener with physical devices.'

create a virtual device (see elsewhere for instructions) for device type use the simulated garage door.
You can also create a modified version for yourself I recommend decreasing the runin time to 1 sec, otherwise it takes 6 secs before the door starts closing or opening when you toggle the simulated device icon. (That is what I did)

install this smart app.

select your relay /switch, and actual garage door sensor in the app, Also select the virtual one twice in the app. Once for the sensor (to get the current state), and once for the door control to actually be able to toggle it.

See picts below.

It also optionally can send text or notifications

It also double checks (in 15 seconds) after opening or closing and will resync for some reason if the door didn't really close ie beam crossed, or didn't really open for some reason,

.gitignore

@@ -1,23 +0,0 @@
-# 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

README.md

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

build.gradle

@@ -1,133 +0,0 @@
-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.8"
-    }
-    repositories {
-        mavenLocal()
-        jcenter()
-        maven {
-            credentials {
-                username smartThingsArtifactoryUserName
-                password smartThingsArtifactoryPassword
-            }
-            url "https://artifactory.smartthings.com/libs-release-local"
-        }
-    }
-}
-
-repositories {
-    mavenLocal()
-    jcenter()
-    maven {
-        credentials {
-            username smartThingsArtifactoryUserName
-            password smartThingsArtifactoryPassword
-        }
-        url "https://artifactory.smartthings.com/libs-release-local"
-    }
-}
-
-sourceSets {
-    devicetypes {
-        groovy {
-            srcDirs = ['devicetypes']
-        }
-    }
-    smartapps {
-        groovy {
-            srcDirs = ['smartapps']
-        }
-    }
-}
-
-dependencies {
-    devicetypesCompile 'org.codehaus.groovy:groovy-all:2.4.7'
-    devicetypesCompile 'smartthings:appengine-z-wave:0.1.2'
-    devicetypesCompile 'smartthings:appengine-zigbee:0.1.11'
-    smartappsCompile 'org.codehaus.groovy:groovy-all:2.4.7'
-    smartappsCompile 'smartthings:appengine-common:0.1.8'
-    smartappsCompile 'org.codehaus.groovy.modules.http-builder:http-builder:0.7.1'
-    smartappsCompile 'org.grails:grails-web:2.3.11'
-    smartappsCompile 'org.json:json:20140107'
-}
-
-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

@@ -1,27 +0,0 @@
-machine:
-  java:
-    version:
-      oraclejdk8
-
-dependencies:
-  override:
-    - ./gradlew dependencies -PsmartThingsArtifactoryUserName="$ARTIFACTORY_USERNAME" -PsmartThingsArtifactoryPassword="$ARTIFACTORY_PASSWORD"
-  post:
-    - ./gradlew compileSmartappsGroovy compileDevicetypesGroovy -PsmartThingsArtifactoryUserName="$ARTIFACTORY_USERNAME" -PsmartThingsArtifactoryPassword="$ARTIFACTORY_PASSWORD"
-
-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

@@ -1,107 +0,0 @@
-/**
-*  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/dianoga/netatmo-additional-module.src/netatmo-additional-module.groovy

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

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

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

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

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

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

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

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

@@ -1,104 +0,0 @@
-/**
- *  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

@@ -1,272 +0,0 @@
-/**
- *  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

@@ -1,239 +0,0 @@
-/**
- *  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

@@ -1,269 +0,0 @@
-/**
- *  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

@@ -1,282 +0,0 @@
-/**
- *  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", label:"no motion", icon:"st.motion.motion.inactive", backgroundColor:"#79b821")
-            	attributeState("active", label:"motion", icon:"st.motion.motion.active", backgroundColor:"#ffa81e")   
-            }
-            
-            tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
-				attributeState("active", label:'tamper active', backgroundColor:"#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:
-			def cmdScale = cmd.scale == 1 ? "F" : "C"
-			map.name = "temperature"
-            map.unit = getTemperatureScale()
-            map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmdScale, cmd.precision)
-            break
-    	case 3:
-        	map.name = "illuminance"
-            map.value = cmd.scaledSensorValue.toInteger().toString()
-            map.unit = "lux"
-            break
-    }
-
-	createEvent(map)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
-	def map = [:]
-    if (cmd.notificationType == 7) {
-    	switch (cmd.event) {
-        	case 0:
-            	if (cmd.eventParameter[0] == 3) {
-            		map.name = "tamper"
-                    map.value = "inactive"
-                    map.descriptionText = "${device.displayName}: tamper alarm has been deactivated"
-            	}
-            	if (cmd.eventParameter[0] == 8) {
-                	map.name = "motion"
-                    map.value = "inactive"
-                    map.descriptionText = "${device.displayName}: motion has stopped"
-                }
-        		break
-                
-        	case 3:
-            	map.name = "tamper"
-                map.value = "active"
-                map.descriptionText = "${device.displayName}: tamper alarm activated"
-            	break
-                
-            case 8:
-                map.name = "motion"
-                map.value = "active"
-                map.descriptionText = "${device.displayName}: motion detected"
-                break
-        }
-    }
-    
-    createEvent(map)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
-	def map = [:]
-	map.name = "battery"
-	map.value = cmd.batteryLevel == 255 ? 1 : cmd.batteryLevel.toString()
-	map.unit = "%"
-	map.displayed = true
-	createEvent(map)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd)
-{
-	def event = createEvent(descriptionText: "${device.displayName} woke up", displayed: false)
-    def cmds = []
-    cmds << encap(zwave.batteryV1.batteryGet())
-    cmds << "delay 500"
-    cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0))
-    cmds << "delay 500"
-    cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 3, scale: 1))     
-    cmds << "delay 1200"
-    cmds << encap(zwave.wakeUpV1.wakeUpNoMoreInformation())
-    [event, response(cmds)]
-    
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) { 
-	log.debug "manufacturerId:   ${cmd.manufacturerId}"
-    log.debug "manufacturerName: ${cmd.manufacturerName}"
-    log.debug "productId:        ${cmd.productId}"
-    log.debug "productTypeId:    ${cmd.productTypeId}"
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.DeviceSpecificReport cmd) { 
-	log.debug "deviceIdData:                ${cmd.deviceIdData}"
-    log.debug "deviceIdDataFormat:          ${cmd.deviceIdDataFormat}"
-    log.debug "deviceIdDataLengthIndicator: ${cmd.deviceIdDataLengthIndicator}"
-    log.debug "deviceIdType:                ${cmd.deviceIdType}"
-    
-    if (cmd.deviceIdType == 1 && cmd.deviceIdDataFormat == 1) {//serial number in binary format
-		String serialNumber = "h'"
-        
-        cmd.deviceIdData.each{ data ->
-        	serialNumber += "${String.format("%02X", data)}"
-        }
-        
-        updateDataValue("serialNumber", serialNumber)
-        log.debug "${device.displayName} - serial number: ${serialNumber}"
-    }
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {	
-    updateDataValue("version", "${cmd.applicationVersion}.${cmd.applicationSubVersion}")
-    log.debug "applicationVersion:      ${cmd.applicationVersion}"
-    log.debug "applicationSubVersion:   ${cmd.applicationSubVersion}"
-    log.debug "zWaveLibraryType:        ${cmd.zWaveLibraryType}"
-    log.debug "zWaveProtocolVersion:    ${cmd.zWaveProtocolVersion}"
-    log.debug "zWaveProtocolSubVersion: ${cmd.zWaveProtocolSubVersion}"
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLocallyNotification cmd) {
-	log.info "${device.displayName}: received command: $cmd - device has reset itself"
-}
-
-def configure() {
-	log.debug "Executing 'configure'"
-    
-    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

@@ -1,795 +0,0 @@
-/**
- *  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,9 +1,12 @@
-// keen home smart vent
-// http://www.keenhome.io
-// SmartThings Device Handler v1.0.0
+/**
+ *  Keen Home Smart Vent
+ *
+ *  Author: Keen Home
+ *  Date: 2015-06-23
+ */
 
 metadata {
-    definition (name: "Keen Home Smart Vent", namespace: "Keen Home", author: "Keen Home") {
+    definition (name: "Keen Home Smart Vent", namespace: "Keen Home", author: "Gregg Altschul") {
         capability "Switch Level"
         capability "Switch"
         capability "Configuration"
@@ -18,7 +21,6 @@ metadata {
         command "getBattery"
         command "getTemperature"
         command "setZigBeeIdTile"
-        command "clearObstruction"
 
         fingerprint endpoint: "1",
         profileId: "0104",
@@ -40,10 +42,9 @@ 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: "clearObstruction", icon: "st.vents.vent-closed", backgroundColor: "#ff0000"
-            state "clearing", action: "", icon: "st.vents.vent-closed", backgroundColor: "#ffff33"
+            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"
         }
         controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false) {
             state "level", action:"switch level.setLevel"
@@ -205,12 +206,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 "${linkText} is obstructed"
+        log.debug "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.
@@ -219,9 +220,24 @@ 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",
@@ -274,7 +290,6 @@ private Map makeTemperatureResult(value) {
         name: 'temperature',
         value: "" + value,
         descriptionText: "${linkText} is ${value}°${temperatureScale}",
-        unit: temperatureScale
     ]
 }
 
@@ -312,79 +327,35 @@ private def makeSerialResult(serial) {
         value: serial,
         descriptionText: "${linkText} has serial ${serial}" ]
 }
-
-// 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 mfgCode() {
+// 	 ["zcl mfg-code 0x115B", "delay 200"]
+// }
+
 def 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
-    }
-
+    log.debug "on()"
     sendEvent(makeOnOffResult(1))
     "st cmd 0x${device.deviceNetworkId} 1 6 1 {}"
 }
 
 def 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
-    }
-
+    log.debug "off()"
     sendEvent(makeOnOffResult(0))
     "st cmd 0x${device.deviceNetworkId} 1 6 0 {}"
 }
 
-def clearObstruction() {
-    def linkText = getLinkText(device)
-    log.debug "attempting to clear ${linkText} obstruction"
+// does this work?
+def toggle() {
+    log.debug "toggle()"
 
-    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()
+    "st cmd 0x${device.deviceNetworkId} 1 6 2 {}"
 }
 
 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")
@@ -392,26 +363,29 @@ 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}"
 
-    makeLevelCommand(value)
+    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}"
 }
 
+
 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",
@@ -421,13 +395,12 @@ def getPressure() {
 
 def getLevel() {
     log.debug "getLevel()"
-
-    // disallow level updates while vent is obstructed
-    if (device.currentValue("switch") == "obstructed") {
-        log.error("cannot update level status because ${getLinkText(device)} is obstructed")
-        return []
-    }
-
+    // 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)
     ["st rattr 0x${device.deviceNetworkId} 1 0x0008 0x0000"]
 }
 
@@ -452,59 +425,78 @@ 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 = [
-        // bind reporting clusters to hub
+        // binding commands
         "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"
-
+        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0001 {${device.zigbeeId}} {}", "delay 500",
+        
         // configure report commands
-        // zcl global send-me-a-report [cluster] [attr] [type] [min-interval] [max-interval] [min-change]
+        // [cluster] [attr] [type] [min-interval] [max-interval] [min-change]
 
-        // report with these parameters is preconfigured in firmware, can be overridden here
+        // mike 2015/06/22: preconfigured; see tech spec
         // 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",
 
-        // report with these parameters is preconfigured in firmware, can be overridden here
+        // mike 2015/06/22: preconfigured; see tech spec
         // 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",
 
-        // report with these parameters is preconfigured in firmware, can be overridden here
+        // mike 2015/06/22: temp and pressure reports are preconfigured, but
+        //   we'd like to override their settings for our own purposes
         // temperature - type: int16s, change: 0xA = 10 = 0.1C
-        // "zcl global send-me-a-report 0x0402 0 0x29 60 60 {0A00}", "delay 200",
-        // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        "zcl global send-me-a-report 0x0402 0 0x29 10 60 {0A00}", "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: 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
+        // mike 2015/06/22: preconfigured; see tech spec
         // 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

@@ -1,164 +0,0 @@
-/**
- *  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

@@ -1,627 +0,0 @@
-/**
- *  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

@@ -1,398 +0,0 @@
-/**
- *  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,
-		unit: temperatureScale
-	]
-}
-
-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

@@ -1,128 +0,0 @@
-/**
- *  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-key-fob.src/aeon-key-fob.groovy

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

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

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

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

@@ -24,11 +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"
-		fingerprint deviceId: "0x2101", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x7A,0x5A"
 	}
 
 	simulator {
@@ -66,19 +63,6 @@ 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") {
@@ -101,78 +85,53 @@ 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 "illuminance", label:'${currentValue} ${unit}', unit:"lux"
+			state "luminosity", 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:""
 		}
 
-		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"])
+		main(["motion", "temperature", "humidity", "illuminance"])
+		details(["motion", "temperature", "humidity", "illuminance", "battery"])
 	}
 }
 
-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
+def updated()
+{
+	if (state.sec && !isConfigured()) {
+		// in case we miss the SCSR
 		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) {
-	log.debug "parse() >> description: $description"
+def parse(String description)
+{
 	def result = null
 	if (description.startsWith("Err 106")) {
-		log.debug "parse() >> Err 106"
+		state.sec = 0
 		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 "After zwaveEvent(cmd) >> Parsed '${description}' to ${result.inspect()}"
+	log.debug "Parsed '${description}' to ${result.inspect()}"
 	return result
 }
 
-//this notification will be sent only when device is battery powered
-def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd) {
+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 {
-		log.debug("Device has been configured sending >> wakeUpNoMoreInformation()")
-		cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
-		result << response(cmds)
+		result += response(zwave.wakeUpV1.wakeUpNoMoreInformation())
 	}
 	result
 }
@@ -190,29 +149,10 @@ def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulat
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityCommandsSupportedReport cmd) {
-	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)
+	response(configure())
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
-	def result = []
 	def map = [ name: "battery", unit: "%" ]
 	if (cmd.batteryLevel == 0xFF) {
 		map.value = 1
@@ -222,14 +162,11 @@ def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
 		map.value = cmd.batteryLevel
 	}
 	state.lastbatt = now()
-	result << createEvent(map)
-	if (device.latestValue("powerSupply") != "USB Cable"){
-		result << createEvent(name: "batteryStatus", value: "${map.value} % battery", displayed: false)
-	}
-	result
+	createEvent(map)
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd){
+def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd)
+{
 	def map = [:]
 	switch (cmd.sensorType) {
 		case 1:
@@ -271,6 +208,7 @@ def motionEvent(value) {
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.sensorbinaryv2.SensorBinaryReport cmd) {
+	setConfigured()
 	motionEvent(cmd.sensorValue)
 }
 
@@ -287,112 +225,47 @@ 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 tampered")
+				result << createEvent(name: "tamper", value: "detected", descriptionText: "$device.displayName was moved")
 				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
-	log.debug "${device.displayName} is configuring its settings"
-	def request = []
+	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),
 
-	//1. set association groups for hub
-	request << zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId)
+		// report every 8 minutes (threshold reports don't work on battery power)
+		zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: 8*60),
 
-	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")
+		// report automatically on threshold change
+		zwave.configurationV1.configurationSet(parameterNumber: 40, size: 1, scaledConfigurationValue: 1),
 
+		zwave.batteryV1.batteryGet(),
+		zwave.sensorBinaryV2.sensorBinaryGet(sensorType: 0x0C),
+    ]
 	commands(request) + ["delay 20000", zwave.wakeUpV1.wakeUpNoMoreInformation().format()]
 }
 
-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 setConfigured() {
+	updateDataValue("configured", "true")
 }
 
 private isConfigured() {
@@ -408,6 +281,5 @@ private command(physicalgraph.zwave.Command cmd) {
 }
 
 private commands(commands, delay=200) {
-	log.info "sending commands: ${commands}"
 	delayBetween(commands.collect{ command(it) }, delay)
 }

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

@@ -21,8 +21,6 @@ metadata {
 		capability "Sensor"
 		capability "Battery"
 
-		command "configureAfterSecure"
-
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x98,0x7A", outClusters:"0x5A"
 	}
 

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

@@ -1,169 +0,0 @@
-/**
- *  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: "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.batteryConfig(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

@@ -1,26 +0,0 @@
-#  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.
-# 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:"#ebeef2"
+			state "not present", labelIcon:"st.presence.tile.not-present", backgroundColor:"#ffffff"
 		}
 		standardTile("beep", "device.beep", decoration: "flat") {
 			state "beep", label:'', action:"tone.beep", icon:"st.secondary.beep", backgroundColor:"#ffffff"
@@ -87,27 +87,16 @@ def beep() {
 	up to this long from the time you send the message to the time you hear a sound.
 	*/
 
-	// Used source endpoint of 0x02 because we are using smartthings manufacturer specific cluster.
 	[
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 200",
-		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 200",
-		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 200",
-		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 200",
-		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
-		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 200",
-		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
+		"raw 0xFC05 {15 0A 11 00 00 15 01}"
 	]
 }
 

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 /**
  *  Cree Bulb
  *
- *  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:
@@ -13,99 +13,193 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-
+ 
 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 "Health Check"
+		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(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"])
-    }
+	// 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"])
+	}
 }
 
 // Parse incoming device messages to generate events
+
 def parse(String description) {
-    log.debug "description is $description"
-
-    def resultMap = zigbee.getEvent(description)
-    if (resultMap) {
-        sendEvent(resultMap)
+	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 )
     }
-    else {
-        log.debug "DID NOT PARSE MESSAGE for description : $description"
-        log.debug zigbee.parseDescriptionAsMap(description)
-    }
-}
-
-def off() {
-    zigbee.off()
+    
+	
 }
 
 def on() {
-    zigbee.on()
-}
+	log.debug "on()"
+	sendEvent(name: "switch", value: "on")
+    
+    "st cmd 0x${device.deviceNetworkId} ${endpointId} 6 1 {}"
+    }
 
-def setLevel(value) {
-    zigbee.setLevel(value) + zigbee.onOffRefresh() + zigbee.levelRefresh()       //adding refresh because of ZLL bulb not conforming to send-me-a-report
-}
-
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-    return zigbee.levelRefresh()
+def off() {
+	log.debug "off()"
+	sendEvent(name: "switch", value: "off")
+    
+	"st cmd 0x${device.deviceNetworkId} ${endpointId} 6 0 {}"
+ 
 }
 
 def refresh() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh()
+    // 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"
+    ]
 }
 
-def healthPoll() {
-    log.debug "healthPoll()"
-    def cmds = zigbee.onOffRefresh() + zigbee.levelRefresh()
-    cmds.each{ sendHubCommand(new physicalgraph.device.HubAction(it))}
+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 {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 configure() {
-    unschedule()
-    runEvery5Minutes("healthPoll")
-    // Device-Watch allows 2 check-in misses from device + ping
-    sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-    zigbee.onOffRefresh() + zigbee.levelRefresh()
+
+	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
 }

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

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

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

@@ -1,47 +0,0 @@
-# Z-wave Dimmer Switch
-
-Local Execution on V2 Hubs
-
-Works with:
-
-* [GE Z-Wave In-Wall Smart Dimmer (GE 12724)](http://products.z-wavealliance.org/products/1197)
-* [GE Z-Wave In-Wall Smart Dimmer (Toggle) (GE 12729)](http://products.z-wavealliance.org/products/1201)
-* [GE Z-Wave Plug-in Smart Dimmer (GE 12718)](http://products.z-wavealliance.org/products/1191)
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health](#device-health)
-* [Troubleshooting](#Troubleshooting)
-
-## Capabilities
-
-* **Switch Level** - it's defined to accept two parameters, the level and the rate of dimming
-* **Actuator** - represents that a Device has commands
-* **Indicator** - gives you the ability to set the indicator LED light on a Z-Wave switch
-* **Switch** - can detect state (possible values: on/off)
-* **Polling** - represents that poll() can be implemented for the device
-* **Refresh** - _refresh()_ command for status updates
-* **Sensor** - detects sensor events
-* **Health Check** - indicates ability to get device health notifications
-
-## Device Health
-
-Z-Wave Smart Dimmers (In-Wall, In-Wall(Toggle), Plug-In) are polled by the hub.
-As of hubCore version 0.14.38 the hub sends up reports every 15 minutes regardless of whether the state changed.
-Check-in interval = 32 mins.
-Not to mention after going OFFLINE when the device is plugged back in, it might take a considerable amount of time for
-the device to appear as ONLINE again. This is because if this listening device does not respond to two poll requests in a row,
-it is not polled for 5 minutes by the hub. This can delay up the process of being marked ONLINE by quite some time.
-
-* __32min__ checkInterval
-
-## Troubleshooting
-
-If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the device is out of range.
-Pairing needs to be tried again by placing the device closer to the hub.
-Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following link:
-* [General Z-Wave Dimmer/Switch Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/200955890-Troubleshooting-GE-in-wall-switch-or-dimmer-won-t-respond-to-commands-or-automations-Z-Wave-)
-* [GE Z-Wave In-Wall Smart Dimmer (GE 12724) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/200902600-GE-In-Wall-Paddle-Dimmer-Switch-GE-12724-Z-Wave-)
-* [GE Z-Wave In-Wall Smart Dimmer (Toggle) (GE 12729) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/207568463-GE-In-Wall-Smart-Toggle-Dimmer-GE-12729-Z-Wave-)
-* [GE Z-Wave Plug-in Smart Dimmer (GE 12718) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/202088474-GE-Plug-In-Smart-Dimmer-GE-12718-Z-Wave-)

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

@@ -20,12 +20,8 @@ metadata {
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
-		capability "Health Check"
 
-		fingerprint mfr:"0063", prod:"4457", deviceJoinName: "GE In-Wall Smart Dimmer "
-		fingerprint mfr:"0063", prod:"4944", deviceJoinName: "GE In-Wall Smart Dimmer "
-		fingerprint mfr:"0063", prod:"5044", deviceJoinName: "GE Plug-In Smart Dimmer "
-		fingerprint mfr:"0063", prod:"4944", model:"3034", deviceJoinName: "GE In-Wall Smart Fan Control"
+		fingerprint inClusters: "0x26"
 	}
 
 	simulator {
@@ -46,10 +42,6 @@ metadata {
 		reply "200163,delay 5000,2602": "command: 2603, payload: 63"
 	}
 
-	preferences {
-		input "ledIndicator", "enum", title: "LED Indicator", description: "Turn LED indicator... ", required: false, options:["on": "When On", "off": "When Off", "never": "Never"], defaultValue: "off"
-	}
-
 	tiles(scale: 2) {
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
@@ -63,192 +55,164 @@ metadata {
 			}
 		}
 
-		standardTile("indicator", "device.indicatorStatus", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+		standardTile("indicator", "device.indicatorStatus", height: 2, width: 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", 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"
+		standardTile("refresh", "device.switch", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
+			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 
 		main(["switch"])
-		details(["switch", "level", "refresh"])
-
+		details(["switch", "refresh", "indicator"])
 	}
 }
 
-def updated(){
-	// Device-Watch simply pings if no device events received for 32min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-  switch (ledIndicator) {
-        case "on":
-            indicatorWhenOn()
-            break
-        case "off":
-            indicatorWhenOff()
-            break
-        case "never":
-            indicatorNever()
-            break
-        default:
-            indicatorWhenOn()
-            break
-    }
-}
-
 def parse(String description) {
-	def result = null
-	if (description != "updated") {
-		log.debug "parse() >> zwave.parse($description)"
-		def cmd = zwave.parse(description, [0x20: 1, 0x26: 1, 0x70: 1])
-		if (cmd) {
-			result = zwaveEvent(cmd)
-		}
+	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)
 	}
-	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}"
+	else {
+		item1.displayed = displayed(description, item1.isStateChange)
+		result = [item1]
 	}
-	return result
+	log.debug "Parse returned ${result?.descriptionText}"
+	result
 }
 
-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: "%")
+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"
 	}
-	return result
+	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"}
-	createEvent([name: "indicatorStatus", value: value])
+	[name: "indicatorStatus", value: value, display: false]
 }
 
-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)
-	updateDataValue("manufacturer", cmd.manufacturerName)
-	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 createEvent(physicalgraph.zwave.Command cmd,  Map map) {
+	// Handles any Z-Wave commands we aren't interested in
+	log.debug "UNHANDLED COMMAND $cmd"
 }
 
 def on() {
-	delayBetween([
-			zwave.basicV1.basicSet(value: 0xFF).format(),
-			zwave.switchMultilevelV1.switchMultilevelGet().format()
-	],5000)
+	log.info "on"
+	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.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: "%")
+	def level = Math.min(valueaux, 99)
 	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.max(Math.min(valueaux, 99), 0)
+	def level = Math.min(valueaux, 99)
 	def dimmingDuration = duration < 128 ? duration : 128 + Math.round(duration / 60)
-	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)
+	zwave.switchMultilevelV2.switchMultilevelSet(value: level, dimmingDuration: dimmingDuration).format()
 }
 
 def poll() {
 	zwave.switchMultilevelV1.switchMultilevelGet().format()
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	refresh()
-}
-
 def refresh() {
-	log.debug "refresh() is called"
-	def commands = []
-	commands << zwave.switchMultilevelV1.switchMultilevelGet().format()
-	if (getDataValue("MSR") == null) {
-		commands << zwave.manufacturerSpecificV1.manufacturerSpecificGet().format()
-	}
-	delayBetween(commands,100)
+	zwave.switchMultilevelV1.switchMultilevelGet().format()
 }
 
-void indicatorWhenOn() {
-	sendEvent(name: "indicatorStatus", value: "when on", displayed: false)
-	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()))
+def indicatorWhenOn() {
+	sendEvent(name: "indicatorStatus", value: "when on", display: false)
+	zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()
 }
 
-void indicatorWhenOff() {
-	sendEvent(name: "indicatorStatus", value: "when off", displayed: false)
-	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 3, size: 1).format()))
+def indicatorWhenOff() {
+	sendEvent(name: "indicatorStatus", value: "when off", display: false)
+	zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 3, size: 1).format()
 }
 
-void indicatorNever() {
-	sendEvent(name: "indicatorStatus", value: "never", displayed: false)
-	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 3, size: 1).format()))
+def indicatorNever() {
+	sendEvent(name: "indicatorStatus", value: "never", display: false)
+	zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 3, size: 1).format()
 }
 
 def invertSwitch(invert=true) {

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

@@ -1,72 +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.
- *
- *	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-rgbw-controller.src/fibaro-rgbw-controller.groovy

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

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

@@ -1,456 +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.
- *
- */
-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"
-        fingerprint mfr:"010F", prod:"0C02", model:"1002"
-    }
-    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/fidure-thermostat.src/fidure-thermostat.groovy

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

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

@@ -1,7 +1,7 @@
 /**
  *  GE Link Bulb
  *
- *  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:
@@ -36,73 +36,155 @@
  *				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", manufacturer: "GE_Appliances", model: "ZLL Light", deviceJoinName: "GE Link Bulb"
-        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0019", manufacturer: "GE", model: "SoftWhite", deviceJoinName: "GE Link Soft White Bulb"
-        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0019", manufacturer: "GE", model: "Daylight", deviceJoinName: "GE Link Daylight Bulb"
-    }
+		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,1000", outClusters: "0019"
+	}
 
 	// 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.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-        main "switch"
-        details(["switch", "refresh"])
-    }
+	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)
 
-    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) {
-    def resultMap = zigbee.getEvent(description)
-    if (resultMap) {
-        if (resultMap.name != "level" || resultMap.value != 0) {  // Ignore level reports of 0 sent when bulb turns off
-            sendEvent(resultMap)
+	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
         }
     }
-    else {
-        log.debug "DID NOT PARSE MESSAGE for description : $description"
-        log.debug zigbee.parseDescriptionAsMap(description)
+
+    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
+        }
     }
+
+    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() {
-    def refreshCmds = [
-        "st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {${state?.dOnOff ?: '0000'}}", "delay 2000"
+
+    [
+	"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'}}"
     ]
 
-    return refreshCmds + zigbee.onOffRefresh() + zigbee.levelRefresh()
 }
 
 def updated() {
@@ -188,60 +270,109 @@ def updated() {
 }
 
 def on() {
-    zigbee.on()
+	state.lvl = "00"
+    state.trigger = "on/off"
+
+    // log.debug "on()"
+	sendEvent(name: "switch", value: "on")
+	"st cmd 0x${device.deviceNetworkId} 1 6 1 {}"
 }
 
 def off() {
-    zigbee.off()
+	state.lvl = "00"
+    state.trigger = "on/off"
+
+    // log.debug "off()"
+	sendEvent(name: "switch", value: "off")
+	"st cmd 0x${device.deviceNetworkId} 1 6 0 {}"
 }
 
 def refresh() {
-    def refreshCmds = [
-        "st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {${state?.dOnOff ?: '0000'}}", "delay 2000"
-    ]
 
-    return refreshCmds + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig()
+    [
+	"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'}}"
+    ]
+    poll()
+
 }
 
 def setLevel(value) {
-    def cmd
-    def delayForRefresh = 500
+
+    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}"
+
     if (dimRate && (state?.rate != null)) {
-        def computedRate = convertRateValue(state.rate)
-        cmd = zigbee.setLevel(value, computedRate)
-        delayForRefresh += computedRate * 100       //converting tenth of second to milliseconds
+    	cmds << "st cmd 0x${device.deviceNetworkId} 1 8 4 {${level} ${state.rate}}"
     }
     else {
-        cmd = zigbee.setLevel(value, 20)
-        delayForRefresh += 2000
+    	cmds << "st cmd 0x${device.deviceNetworkId} 1 8 4 {${level} 1500}"
     }
-    cmd + ["delay $delayForRefresh"] + zigbee.levelRefresh()
-}
 
-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
+    log.debug cmds
+    cmds
 }
 
 def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    return zigbee.onOffConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
+
+	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
 }
+
+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

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

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

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

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

@@ -1,126 +0,0 @@
-/**
- *  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

@@ -1,81 +0,0 @@
-/**
- *  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,12 +80,19 @@ 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 = cmd.encapsulatedCommand([0x31: 1, 0x84: 2, 0x60: 1, 0x85: 1, 0x70: 1])
+	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])
+	}
 	return encapsulated ? zwaveEvent(encapsulated) : null
 }
 

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

@@ -1,175 +0,0 @@
-/**
- *  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"
-		capability "Health Check"
-		capability "Light"
-
-		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.color", key: "COLOR_CONTROL") {
-				attributeState "color", action:"setAdjustedColor"
-			}
-		}
-
-		standardTile("reset", "device.reset", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:"Reset To White", action:"reset", icon:"st.lights.philips.hue-single"
-		}
-
-		standardTile("refresh", "device.refresh", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-
-		main(["rich-control"])
-		details(["rich-control", "reset", "refresh"])
-	}
-}
-
-void installed() {
-	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}")
-}
-
-// 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)
-}
-
-void off() {
-	log.trace parent.off(this)
-}
-
-void setLevel(percent) {
-    log.debug "Executing 'setLevel'"
-    if (verifyPercent(percent)) {
-	    log.trace parent.setLevel(this, percent)
-    }
-}
-
-void setSaturation(percent) {
-    log.debug "Executing 'setSaturation'"
-    if (verifyPercent(percent)) {
-	    log.trace parent.setSaturation(this, percent)
-    }
-}
-
-void setHue(percent) {
-    log.debug "Executing 'setHue'"
-    if (verifyPercent(percent)) {
-	    log.trace parent.setHue(this, percent)
-    }
-}
-
-void setColor(value) {
-    def events = []
-    def validValues = [:]
-
-    if (verifyPercent(value.hue)) {
-        validValues.hue = value.hue
-    }
-    if (verifyPercent(value.saturation)) {
-        validValues.saturation = value.saturation
-    }
-    if (value.hex != null) {
-        if (value.hex ==~ /^\#([A-Fa-f0-9]){6}$/) {
-            validValues.hex = value.hex
-        } else {
-            log.warn "$value.hex is not a valid color"
-        }
-    }
-    if (verifyPercent(value.level)) {
-        validValues.level = value.level
-    }
-    if (value.switch == "off" || (value.level != null && value.level <= 0)) {
-        validValues.switch = "off"
-    } else {
-        validValues.switch = "on"
-    }
-    if (!validValues.isEmpty()) {
-	    log.trace parent.setColor(this, validValues)
-    }
-}
-
-void reset() {
-    log.debug "Executing 'reset'"
-	def value = [hue:20, saturation:2]
-	setAdjustedColor(value)
-}
-
-void setAdjustedColor(value) {
-    if (value) {
-        log.trace "setAdjustedColor: ${value}"
-        def adjusted = value + [:]
-        // Needed because color picker always sends 100
-        adjusted.level = null
-	    setColor(adjusted)
-    } else {
-        log.warn "Invalid color input $value"
-    }
-}
-
-void refresh() {
-    log.debug "Executing 'refresh'"
-    parent.manualRefresh()
-}
-
-
-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

@@ -7,15 +7,8 @@
 metadata {
 	// Automatically generated. Make future change here.
 	definition (name: "Hue Bridge", namespace: "smartthings", author: "SmartThings") {
-		capability "Health Check"
-
+		attribute "serialNumber", "string"
 		attribute "networkAddress", "string"
-		// Used to indicate if bridge is reachable or not, i.e. is the bridge connected to the network
-		// Possible values "Online" or "Offline"
-		attribute "status", "string"
-		// Id is the number on the back of the hub, Hue uses last six digits of Mac address
-		// This is also used in the Hue application as ID
-		attribute "idNumber", "string"
 	}
 
 	simulator {
@@ -24,30 +17,28 @@ metadata {
 
 	tiles(scale: 2) {
      	multiAttributeTile(name:"rich-control"){
-			tileAttribute ("device.status", key: "PRIMARY_CONTROL") {
-				attributeState "Offline", label: '${currentValue}', action: "", icon: "st.Lighting.light99-hue", backgroundColor: "#ffffff"
-	            attributeState "Online", label: '${currentValue}', action: "", icon: "st.Lighting.light99-hue", backgroundColor: "#79b821"
-			}
-			}
-		valueTile("doNotRemove", "v", decoration: "flat", height: 2, width: 6, inactiveLabel: false) {
-			state "default", label:'If removed, Hue lights will not work properly'
+			tileAttribute ("device.switch", 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("idNumber", "device.idNumber", decoration: "flat", height: 2, width: 6, inactiveLabel: false) {
-			state "default", label:'ID: ${currentValue}'
+		valueTile("serialNumber", "device.serialNumber", decoration: "flat", height: 1, width: 2, inactiveLabel: false) {
+			state "default", label:'SN: ${currentValue}'
 		}
-		valueTile("networkAddress", "device.networkAddress", decoration: "flat", height: 2, width: 6, inactiveLabel: false) {
-			state "default", label:'IP: ${currentValue}'
+		valueTile("networkAddress", "device.networkAddress", decoration: "flat", height: 2, width: 4, inactiveLabel: false) {
+			state "default", label:'${currentValue}', height: 1, width: 2, inactiveLabel: false
 		}
 
-		main (["rich-control"])
-		details(["rich-control", "doNotRemove", "idNumber", "networkAddress"])
+		main (["icon"])
+		details(["rich-control", "networkAddress"])
 	}
 }
 
-void installed() {
-	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}")
-}
-
 // parse events into attributes
 def parse(description) {
 	log.debug "Parsing '${description}'"
@@ -68,7 +59,7 @@ def parse(description) {
 			log.trace "HUE BRIDGE, GENERATING EVENT: $map.name: $map.value"
 			results << createEvent(name: "${map.name}", value: "${map.value}")
 		} else {
-			log.trace "Parsing description"
+        	log.trace "Parsing description"
 			def msg = parseLanMessage(description)
 			if (msg.body) {
 				def contentType = msg.headers["Content-Type"]
@@ -76,14 +67,17 @@ def parse(description) {
 					def bulbs = new groovy.json.JsonSlurper().parseText(msg.body)
 					if (bulbs.state) {
 						log.info "Bridge response: $msg.body"
+					} else {
+						// Sending Bulbs List to parent"
+                        if (parent.state.inBulbDiscovery)
+                        	log.info parent.bulbListHandler(device.hub.id, msg.body)
 					}
-				} else if (contentType?.contains("xml")) {
+				}
+				else if (contentType?.contains("xml")) {
 					log.debug "HUE BRIDGE ALREADY PRESENT"
-					parent.hubVerification(device.hub.id, msg.body)
 				}
 			}
 		}
 	}
 	results
 }
-

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

@@ -1,11 +1,9 @@
+
 /**
  *  Hue Bulb
  *
- *  Philips Hue Type "Extended Color Light"
- *
  *  Author: SmartThings
  */
-
 // for the UI
 metadata {
 	// Automatically generated. Make future change here.
@@ -13,16 +11,13 @@ metadata {
 		capability "Switch Level"
 		capability "Actuator"
 		capability "Color Control"
-		capability "Color Temperature"
 		capability "Switch"
 		capability "Refresh"
 		capability "Sensor"
-		capability "Health Check"
-		capability "Light"
 
 		command "setAdjustedColor"
-        command "reset"
-        command "refresh"
+                command "reset"        
+                command "refresh"
 	}
 
 	simulator {
@@ -30,7 +25,7 @@ metadata {
 	}
 
 	tiles (scale: 2){
-		multiAttributeTile(name:"rich-control", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+		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"
@@ -38,49 +33,34 @@ 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", range:"(0..100)"
-            }
+				attributeState "level", action:"switch level.setLevel"
+			}
 			tileAttribute ("device.color", key: "COLOR_CONTROL") {
 				attributeState "color", action:"setAdjustedColor"
 			}
 		}
 
-    controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2000..6500)") {
-        state "colorTemperature", action:"color temperature.setColorTemperature"
-    }
-
-    valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-        state "colorTemperature", label: 'WHITES'
-    }
-
-		standardTile("reset", "device.reset", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:"Reset To White", action:"reset", icon:"st.lights.philips.hue-single"
+		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.refresh", height: 2, width: 2, 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"
 		}
-
-		main(["rich-control"])
-		details(["rich-control", "colorTempSliderControl", "colorTemp", "reset", "refresh"])
 	}
-}
 
-void installed() {
-	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}")
+	main(["switch"])
+	details(["switch", "levelSliderControl", "rgbSelector", "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}")
 	}
@@ -88,104 +68,91 @@ def parse(description) {
 }
 
 // handle commands
-void on() {
+def on() {
 	log.trace parent.on(this)
+	sendEvent(name: "switch", value: "on")
 }
 
-void off() {
+def off() {
 	log.trace parent.off(this)
+	sendEvent(name: "switch", value: "off")
 }
 
-void setLevel(percent) {
-    log.debug "Executing 'setLevel'"
-    if (verifyPercent(percent)) {
-	    log.trace parent.setLevel(this, percent)
-    }
+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)
 }
 
-void setSaturation(percent) {
-    log.debug "Executing 'setSaturation'"
-    if (verifyPercent(percent)) {
-	    log.trace parent.setSaturation(this, percent)
-    }
+def setLevel(percent) {
+	log.debug "Executing 'setLevel'"
+	parent.setLevel(this, percent)
+	sendEvent(name: "level", value: percent)
 }
 
-void setHue(percent) {
-    log.debug "Executing 'setHue'"
-    if (verifyPercent(percent)) {
-	    log.trace parent.setHue(this, percent)
-    }
+def setSaturation(percent) {
+	log.debug "Executing 'setSaturation'"
+	parent.setSaturation(this, percent)
+	sendEvent(name: "saturation", value: percent)
 }
 
-void setColor(value) {
-    def events = []
-    def validValues = [:]
-
-    if (verifyPercent(value.hue)) {
-        validValues.hue = value.hue
-    }
-    if (verifyPercent(value.saturation)) {
-        validValues.saturation = value.saturation
-    }
-    if (value.hex != null) {
-        if (value.hex ==~ /^\#([A-Fa-f0-9]){6}$/) {
-            validValues.hex = value.hex
-        } else {
-            log.warn "$value.hex is not a valid color"
-        }
-    }
-    if (verifyPercent(value.level)) {
-        validValues.level = value.level
-    }
-    if (value.switch == "off" || (value.level != null && value.level <= 0)) {
-        validValues.switch = "off"
-    } else {
-        validValues.switch = "on"
-    }
-    if (!validValues.isEmpty()) {
-	    log.trace parent.setColor(this, validValues)
-    }
+def setHue(percent) {
+	log.debug "Executing 'setHue'"
+	parent.setHue(this, percent)
+	sendEvent(name: "hue", value: percent)
 }
 
-void reset() {
-    log.debug "Executing 'reset'"
-	setColorTemperature(4000)
+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 setAdjustedColor(value) {
-    if (value) {
+def reset() {
+	log.debug "Executing 'reset'"
+    def value = [level:100, hex:"#90C638", saturation:56, hue:23]
+    setAdjustedColor(value)
+	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)
-    } else {
-        log.warn "Invalid color input $value"
+        adjusted.level = null 
+        setColor(adjusted)
     }
 }
 
-void setColorTemperature(value) {
-    if (value) {
-        log.trace "setColorTemperature: ${value}k"
-	    log.trace parent.setColorTemperature(this, value)
-    } else {
-        log.warn "Invalid color temperature $value"
-    }
+def refresh() {
+	log.debug "Executing 'refresh'"
+	parent.manualRefresh()
 }
 
-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-lux-bulb.src/hue-lux-bulb.groovy

@@ -1,8 +1,6 @@
 /**
  *  Hue Lux Bulb
  *
- *  Philips Hue Type "Dimmable Light"
- *
  *  Author: SmartThings
  */
 // for the UI
@@ -14,16 +12,14 @@ metadata {
 		capability "Switch"
 		capability "Refresh"
 		capability "Sensor"
-		capability "Health Check"
-		capability "Light"
-
-        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,23 +31,29 @@ metadata {
             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}%'
+			}
         }
-
+    
+		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, decoration: "flat", width: 2, height: 2) {
+           
+        standardTile("refresh", "device.switch", inactiveLabel: false, height: 2, width: 2, decoration: "flat") {
             state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
+        }        
 
-        main(["rich-control"])
+        main(["switch"])
         details(["rich-control", "refresh"])
-    }
-}
-
-void installed() {
-	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}")
+    }    
 }
 
 // parse events into attributes
@@ -72,25 +74,23 @@ def parse(description) {
 }
 
 // handle commands
-void on() {
-	log.trace parent.on(this)
+def on() {
+	parent.on(this)
+	sendEvent(name: "switch", value: "on")
 }
 
-void off() {
-	log.trace parent.off(this)
+def off() {
+	parent.off(this)
+	sendEvent(name: "switch", value: "off")
 }
 
-void setLevel(percent) {
+def setLevel(percent) {
 	log.debug "Executing 'setLevel'"
-    if (percent != null && percent >= 0 && percent <= 100) {
-		parent.setLevel(this, percent)
-	} else {
-    	log.warn "$percent is not 0-100"
-    }
+	parent.setLevel(this, percent)
+	sendEvent(name: "level", value: percent)
 }
 
-void refresh() {
+def refresh() {
 	log.debug "Executing 'refresh'"
 	parent.manualRefresh()
 }
-

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

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

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

@@ -39,7 +39,7 @@ metadata {
 }
 
 def generatePresenceEvent(boolean present) {
-	log.info "Life360 generatePresenceEvent($present)"
+	log.debug "Here in generatePresenceEvent!"
 	def value = formatValue(present)
 	def linkText = getLinkText(device)
 	def descriptionText = formatDescriptionText(linkText, present)

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

@@ -11,67 +11,66 @@ metadata {
 		capability "Color Temperature"
 		capability "Switch"
 		capability "Switch Level" // brightness
+		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
-		capability "Health Check"
 	}
 
 	simulator {
-
+		// TODO: define status and reply messages here
 	}
 
-	tiles(scale: 2) {
-		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
-			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"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}'
-			}
+	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"
 		}
-
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
-
 		valueTile("null", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:''
 		}
 
-		controlTile("colorTempSliderControl", "device.colorTemperature", "slider", height: 2, width: 4, inactiveLabel: false, range:"(2700..9000)") {
-			state "colorTemp", action:"color temperature.setColorTemperature"
+		controlTile("rgbSelector", "device.color", "color", height: 3, width: 3, inactiveLabel: false) {
+			state "color", action:"setColor"
 		}
 
-		valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", height: 2, width: 2) {
+		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)") {
+			state "colorTemp", action:"color temperature.setColorTemperature"
+		}
+		valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat") {
 			state "colorTemp", label: '${currentValue}K'
 		}
 
-		main "switch"
-		details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
+		main(["switch"])
+		details(["switch", "refresh", "level", "levelSliderControl", "rgbSelector", "colorTempSliderControl", "colorTemp"])
 	}
 }
 
-void installed() {
-	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"cloud\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device?.hub?.hardwareID}\"}")
+// parse events into attributes
+def parse(String description) {
+	if (description == 'updated') {
+		return // don't poll when config settings is being updated as it may time out
+	}
+	poll()
 }
 
 // handle commands
 def setHue(percentage) {
 	log.debug "setHue ${percentage}"
 	parent.logErrors(logObject: log) {
-		def resp = parent.apiPUT("/lights/${selector()}/state", [color: "hue:${percentage * 3.6}", power: "on"])
+		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", [color: "hue:${percentage * 3.6}"])
 		if (resp.status < 300) {
 			sendEvent(name: "hue", value: percentage)
 			sendEvent(name: "switch", value: "on")
@@ -79,13 +78,12 @@ 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/${selector()}/state", [color: "saturation:${percentage / 100}", power: "on"])
+		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", [color: "saturation:${percentage / 100}"])
 		if (resp.status < 300) {
 			sendEvent(name: "saturation", value: percentage)
 			sendEvent(name: "switch", value: "on")
@@ -93,7 +91,6 @@ def setSaturation(percentage) {
 			log.error("Bad setSaturation result: [${resp.status}] ${resp.data}")
 		}
 	}
-	return []
 }
 
 def setColor(Map color) {
@@ -117,17 +114,15 @@ def setColor(Map color) {
 		}
 	}
 	parent.logErrors(logObject:log) {
-		def resp = parent.apiPUT("/lights/${selector()}/state", [color: attrs.join(" "), power: "on"])
+		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", [color: attrs.join(" ")])
 		if (resp.status < 300) {
-			if (color.hex)
-				sendEvent(name: "color", value: 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) {
@@ -136,25 +131,24 @@ def setLevel(percentage) {
 		percentage = 1 // clamp to 1%
 	}
 	if (percentage == 0) {
+		sendEvent(name: "level", value: 0) // Otherwise the level value tile does not update
 		return off() // if the brightness is set to 0, just turn it off
 	}
 	parent.logErrors(logObject:log) {
-		def resp = parent.apiPUT("/lights/${selector()}/state", ["brightness": percentage / 100, "power": "on"])
+		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", ["color": "brightness:${percentage / 100}"])
 		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/${selector()}/state", [color: "kelvin:${kelvin}", power: "on"])
+		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", [color: "kelvin:${kelvin}"])
 		if (resp.status < 300) {
 			sendEvent(name: "colorTemperature", value: kelvin)
 			sendEvent(name: "color", value: "#ffffff")
@@ -164,68 +158,46 @@ def setColorTemperature(kelvin) {
 		}
 
 	}
-	return []
 }
 
 def on() {
 	log.debug "Device setOn"
 	parent.logErrors() {
-		if (parent.apiPUT("/lights/${selector()}/state", [power: "on"]) != null) {
+		if (parent.apiPUT("/lights/${device.deviceNetworkId}/power", [state: "on"]) != null) {
 			sendEvent(name: "switch", value: "on")
 		}
 	}
-	return []
 }
 
 def off() {
 	log.debug "Device setOff"
 	parent.logErrors() {
-		if (parent.apiPUT("/lights/${selector()}/state", [power: "off"]) != null) {
+		if (parent.apiPUT("/lights/${device.deviceNetworkId}/power", [state: "off"]) != null) {
 			sendEvent(name: "switch", value: "off")
 		}
 	}
+}
+
+def poll() {
+	log.debug "Executing 'poll' for ${device} ${this} ${device.deviceNetworkId}"
+	def resp = parent.apiGET("/lights/${device.deviceNetworkId}")
+	if (resp.status != 200) {
+		log.error("Unexpected result in poll(): [${resp.status}] ${resp.data}")
+		return []
+	}
+	def data = resp.data
+
+	sendEvent(name: "level", value: sprintf("%.1f", (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: "saturation", value: data.color.saturation * 100)
+	sendEvent(name: "colorTemperature", value: data.color.kelvin)
+
 	return []
 }
 
 def refresh() {
 	log.debug "Executing 'refresh'"
-	
-	def resp = parent.apiGET("/lights/${selector()}")
-	if (resp.status == 404) {
-		state.online = false
-		sendEvent(name: "DeviceWatch-DeviceStatusUpdate", value: "offline", displayed: false)
- 		log.warn "$device is Offline"
-		return []
-	} else if (resp.status != 200) {
-		log.error("Unexpected result in refresh(): [${resp.status}] ${resp.data}")
-		return []
-	}
-	def data = resp.data[0]
-	log.debug("Data: ${data}")
-
-	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.power)
-	sendEvent(name: "color", value: colorUtil.hslToHex((data.color.hue / 3.6) as int, (data.color.saturation * 100) as int))
-	sendEvent(name: "hue", value: data.color.hue / 3.6)
-	sendEvent(name: "saturation", value: data.color.saturation * 100)
-	sendEvent(name: "colorTemperature", value: data.color.kelvin)
-	sendEvent(name: "model", value: data.product.name)
-
-	if (data.connected) {
-		sendEvent(name: "DeviceWatch-DeviceStatus", value: "online", displayed: false)
-		log.debug "$device is Online"
-	} else {
-		sendEvent(name: "DeviceWatch-DeviceStatus", value: "offline", displayed: false)
-		log.warn "$device is Offline"
-}
-}
-
-def selector() {
-	if (device.deviceNetworkId.contains(":")) {
-		return device.deviceNetworkId
-	} else {
-		return "id:${device.deviceNetworkId}"
-	}
+	poll()
 }

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

@@ -10,52 +10,55 @@ metadata {
 		capability "Color Temperature"
 		capability "Switch"
 		capability "Switch Level" // brightness
+		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
-		capability "Health Check"
 	}
 
 	simulator {
-
+		// TODO: define status and reply messages here
 	}
 
-	tiles(scale: 2) {
-		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
-			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"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"
-			}
+	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"
 		}
-
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
-
 		valueTile("null", "device.switch", inactiveLabel: false, decoration: "flat") {
 			state "default", label:''
 		}
 
-		controlTile("colorTempSliderControl", "device.colorTemperature", "slider", height: 2, width: 4, inactiveLabel: false, range:"(2700..9000)") {
-			state "colorTemp", action:"color temperature.setColorTemperature"
+		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}%'
 		}
 
-		valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", height: 2, width: 2) {
+		controlTile("colorTempSliderControl", "device.colorTemperature", "slider", height: 1, width: 2, inactiveLabel: false, range:"(2700..6500)") {
+			state "colorTemp", action:"color temperature.setColorTemperature"
+		}
+		valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat") {
 			state "colorTemp", label: '${currentValue}K'
 		}
 
-		main "switch"
-		details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
+		main(["switch"])
+		details(["switch", "refresh", "level", "levelSliderControl", "colorTempSliderControl", "colorTemp"])
 	}
 }
 
-void installed() {
-	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"cloud\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device?.hub?.hardwareID}\"}")
+// parse events into attributes
+def parse(String description) {
+	if (description == 'updated') {
+		return // don't poll when config settings is being updated as it may time out
+	}
+	poll()
 }
 
 // handle commands
@@ -65,25 +68,24 @@ def setLevel(percentage) {
 		percentage = 1 // clamp to 1%
 	}
 	if (percentage == 0) {
+		sendEvent(name: "level", value: 0) // Otherwise the level value tile does not update
 		return off() // if the brightness is set to 0, just turn it off
 	}
 	parent.logErrors(logObject:log) {
-		def resp = parent.apiPUT("/lights/${selector()}/state", [brightness: percentage / 100, power: "on"])
+		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", ["color": "brightness:${percentage / 100}"])
 		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/${selector()}/state", [color: "kelvin:${kelvin}", power: "on"])
+		def resp = parent.apiPUT("/lights/${device.deviceNetworkId}/color", [color: "kelvin:${kelvin}"])
 		if (resp.status < 300) {
 			sendEvent(name: "colorTemperature", value: kelvin)
 			sendEvent(name: "color", value: "#ffffff")
@@ -93,64 +95,43 @@ 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/${selector()}/state", [power: "on"]) != null) {
+		if (parent.apiPUT("/lights/${device.deviceNetworkId}/power", [state: "on"]) != null) {
 			sendEvent(name: "switch", value: "on")
 		}
 	}
-	return []
 }
 
 def off() {
 	log.debug "Device setOff"
 	parent.logErrors() {
-		if (parent.apiPUT("/lights/${selector()}/state", [power: "off"]) != null) {
+		if (parent.apiPUT("/lights/${device.deviceNetworkId}/power", [state: "off"]) != null) {
 			sendEvent(name: "switch", value: "off")
 		}
 	}
+}
+
+def poll() {
+	log.debug "Executing 'poll' for ${device} ${this} ${device.deviceNetworkId}"
+	def resp = parent.apiGET("/lights/${device.deviceNetworkId}")
+	if (resp.status != 200) {
+		log.error("Unexpected result in poll(): [${resp.status}] ${resp.data}")
+		return []
+	}
+	def data = resp.data
+
+	sendEvent(name: "level", value: sprintf("%f", (data.brightness ?: 1) * 100))
+	sendEvent(name: "switch", value: data.connected ? data.power : "unreachable")
+	sendEvent(name: "colorTemperature", value: data.color.kelvin)
+
 	return []
 }
 
 def refresh() {
 	log.debug "Executing 'refresh'"
-	
-	def resp = parent.apiGET("/lights/${selector()}")
-	if (resp.status == 404) {
-		state.online = false
-		sendEvent(name: "DeviceWatch-DeviceStatusUpdate", value: "offline", displayed: false)
-		log.warn "$device is Offline"
-		return []
-	} else if (resp.status != 200) {
-		log.error("Unexpected result in refresh(): [${resp.status}] ${resp.data}")
-		return []
-	}
-	def data = resp.data[0]
-
-	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.power)
-	sendEvent(name: "colorTemperature", value: data.color.kelvin)
-	sendEvent(name: "model", value: data.product.name)
-
-	if (data.connected) {
-		sendEvent(name: "DeviceWatch-DeviceStatus", value: "online", displayed: false)
-		log.debug "$device is Online"
-	} else {
-		sendEvent(name: "DeviceWatch-DeviceStatus", value: "offline", displayed: false)
-		log.warn "$device is Offline"
-	}
-}
-
-def selector() {
-	if (device.deviceNetworkId.contains(":")) {
-		return device.deviceNetworkId
-	} else {
-		return "id:${device.deviceNetworkId}"
-	}
+	poll()
 }

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

@@ -1,22 +0,0 @@
-#  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.
-# 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,19 +1,16 @@
-/*
- *  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.
+ *
  */
- 
 metadata {
 	definition (name: "Mobile Presence", namespace: "smartthings", author: "SmartThings") {
 		capability "Presence Sensor"
@@ -28,7 +25,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:"#ebeef2")
+			state("not present", labelIcon:"st.presence.tile.mobile-not-present", backgroundColor:"#ffffff")
 		}
 		main "presence"
 		details "presence"
@@ -44,7 +41,6 @@ def parse(String description) {
 	def isStateChange = isStateChange(device, name, value)
 
 	def results = [
-    	translatable: true,
 		name: name,
 		value: value,
 		unit: null,
@@ -76,8 +72,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
 	}
 }
@@ -88,4 +84,4 @@ private getState(String value) {
 		case "not present": return "left"
 		default: return value
 	}
-}
+}

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

@@ -43,8 +43,8 @@ def parse(String description) {
 }
 
 def push() {
-	sendEvent(name: "switch", value: "on", isStateChange: true, displayed: false)
-	sendEvent(name: "switch", value: "off", isStateChange: true, displayed: false)
+	sendEvent(name: "switch", value: "on", isStateChange: true, display: false)
+	sendEvent(name: "switch", value: "off", isStateChange: true, display: false)
 	sendEvent(name: "momentary", value: "pushed", isStateChange: true)
 }
 

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

@@ -13,7 +13,6 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
 
 metadata {
 	definition (name: "NYCE Motion Sensor", namespace: "smartthings", author: "SmartThings") {
@@ -144,14 +143,51 @@ private Map parseReportAttributeMessage(String description) {
  
 
 private Map parseIasMessage(String description) {
-	ZoneStatus zs = zigbee.parseZoneStatus(description)
-	Map resultMap = [:]
+    List parsedMsg = description.split(' ')
+    String msgCode = parsedMsg[2]
+    
+    Map resultMap = [:]
+    switch(msgCode) {
+        case '0x0030': // Closed/No Motion/Dry
+            log.debug 'no motion'
+            resultMap.name = 'motion'
+            resultMap.value = 'inactive'
+            break
 
-	resultMap.name = 'motion'
-	resultMap.value = zs.isAlarm2Set() ? 'active' : 'inactive'
-	log.debug(zs.isAlarm2Set() ? 'motion' : 'no motion')
+        case '0x0032': // Open/Motion/Wet
+            log.debug 'motion'
+            resultMap.name = 'motion'
+            resultMap.value = 'active'
+            break
 
-	return resultMap
+        case '0x0032': // Tamper Alarm
+        	log.debug 'motion with tamper alarm'
+            resultMap.name = 'motion'
+            resultMap.value = 'active'
+            break
+
+        case '0x0033': // Battery Alarm
+            break
+
+        case '0x0034': // Supervision Report
+        	log.debug 'no motion with tamper alarm'
+            resultMap.name = 'motion'
+            resultMap.value = 'inactive'
+            break
+
+        case '0x0035': // Restore Report
+            break
+
+        case '0x0036': // Trouble/Failure
+        	log.debug 'motion with failure alarm'
+            resultMap.name = 'motion'
+            resultMap.value = 'active'
+            break
+
+        case '0x0038': // Test Mode
+            break
+    }
+    return resultMap
 }
 
 def refresh()

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

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

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

@@ -1,41 +0,0 @@
-# Nyce Door/Window Sensor (Open/Close Sensor)
-
-Cloud Execution
-
-Works with:
-
-* [NYCE Door/Window Sensor NCZ-3011](https://support.smartthings.com/hc/en-us/articles/204576764-NYCE-Door-Window-Sensor)
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health](#device-health)
-* [Battery](#battery-specification)
-* [Troubleshooting](#troubleshooting)
-
-## Capabilities
-
-* **Configuration** - _configure()_ command called when device is installed or device preferences updated
-* **Contact Sensor** - can detect contact (with possible values - open/closed)
-* **Battery** - defines device uses a battery
-* **Refresh** - _refresh()_ command for status updates
-* **Health Check** - indicates ability to get device health notifications
-
-## Device Health
-
-Nyce Door/Window sensor with reporting interval of 5 min.
-SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
- 
-* __12min__ checkInterval
-
-
-## Battery Specification
-
-One 3V CR2032 battery required.
-
-## Troubleshooting
-
-If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the sensor is out of range.
-Pairing needs to be tried again by placing the sensor closer to the hub.
-Instructions related to pairing, resetting and removing the sensor from SmartThings can be found in the following link:
-* [Nyce Door/Window Sensor](https://support.smartthings.com/hc/en-us/articles/204576764-NYCE-Door-Window-Sensor)

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

@@ -13,32 +13,27 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-
-import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
-
-
+ 
 metadata {
 	definition (name: "NYCE Open/Closed Sensor", namespace: "smartthings", author: "NYCE") {
-		capability "Battery"
+    	capability "Battery"
 		capability "Configuration"
-		capability "Contact Sensor"
+        capability "Contact Sensor"
 		capability "Refresh"
-		capability "Health Check"
-
-		command "enrollResponse"
-
-
-		fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3010", deviceJoinName: "NYCE Door Hinge Sensor"
+        
+        command "enrollResponse"
+ 
+ 
 		fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3011", deviceJoinName: "NYCE Door/Window Sensor"
-		fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3011", deviceJoinName: "NYCE Door/Window Sensor"
-		fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3014", deviceJoinName: "NYCE Tilt Sensor"
-		fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3014", deviceJoinName: "NYCE Tilt Sensor"
+        fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3011", deviceJoinName: "NYCE Door/Window Sensor"
+        fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3014", deviceJoinName: "NYCE Tilt Sensor"
+        fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3014", deviceJoinName: "NYCE Tilt Sensor"
 	}
-
+ 
 	simulator {
-
+ 
 	}
-
+ 
 	tiles {
 		standardTile("contact", "device.contact", width: 2, height: 2) {
 			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
@@ -223,33 +218,40 @@ private Map parseReportAttributeMessage(String description) {
 }
 
 private List parseIasMessage(String description) {
-	ZoneStatus zs = zigbee.parseZoneStatus(description)
-	log.debug "parseIasMessage: $description"
+	List parsedMsg = description.split(" ")
+	String msgCode = parsedMsg[2]
 
 	List resultListMap = []
 	Map resultMap_battery = [:]
 	Map resultMap_battery_state = [:]
 	Map resultMap_sensor = [:]
 
-	resultMap_sensor.name = "contact"
-	resultMap_sensor.value = zs.isAlarm1Set() ? "open" : "closed"
+	// Relevant bit field definitions from ZigBee spec
+	def BATTERY_BIT = ( 1 << 3 )
+	def TROUBLE_BIT = ( 1 << 6 )
+	def SENSOR_BIT = ( 1 << 0 )		// it's ALARM1 bit from the ZCL spec
+
+	// Convert hex string to integer
+	def zoneStatus = Integer.parseInt(msgCode[-4..-1],16)
+
+	log.debug "parseIasMessage: zoneStatus: ${zoneStatus}"
 
 	// Check each relevant bit, create map for it, and add to list
-	log.debug "parseIasMessage: Battery Status ${zs.battery}"
-	log.debug "parseIasMessage: Trouble Status ${zs.trouble}"
-	log.debug "parseIasMessage: Sensor Status ${zs.alarm1}"
+	log.debug "parseIasMessage: Battery Status ${zoneStatus & BATTERY_BIT}"
+	log.debug "parseIasMessage: Trouble Status ${zoneStatus & TROUBLE_BIT}"
+	log.debug "parseIasMessage: Sensor Status ${zoneStatus & SENSOR_BIT}"
 
 	/* 	Comment out this path to check the battery state to avoid overwriting the
 		battery value (Change log #2), but keep these conditions for later use
 	 resultMap_battery_state.name = "battery_state"
-	 if (zs.isTroubleSet()) {
+	 if (zoneStatus & TROUBLE_BIT) {
 		 resultMap_battery_state.value = "failed"
 
 		 resultMap_battery.name = "battery"
 		 resultMap_battery.value = 0
 	 }
 	 else {
-		 if (zs.isBatterySet()) {
+		 if (zoneStatus & BATTERY_BIT) {
 			 resultMap_battery_state.value = "low"
 
 			 // to generate low battery notification by the platform
@@ -267,6 +269,9 @@ private List parseIasMessage(String description) {
 	 }
 	*/
 
+	resultMap_sensor.name = "contact"
+	resultMap_sensor.value = (zoneStatus & SENSOR_BIT) ? "open" : "closed"
+
 	resultListMap << resultMap_battery_state
 	resultListMap << resultMap_battery
 	resultListMap << resultMap_sensor
@@ -274,28 +279,23 @@ private List parseIasMessage(String description) {
 	return resultListMap
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	return zigbee.readAttribute(0x001, 0x0020) // Read the Battery Level
-}
-
 def configure() {
-	// Device-Watch allows 2 check-in misses from device
-	sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-
 	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 
-	def enrollCmds = [
+	def configCmds = [
+			//battery reporting and heartbeat
+			"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 1 {${device.zigbeeId}} {}", "delay 200",
+			"zcl global send-me-a-report 1 0x20 0x20 600 3600 {01}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500",
+
+
 			// Writes CIE attribute on end device to direct reports to the hub's EUID
 			"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
 			"send 0x${device.deviceNetworkId} 1 1", "delay 500",
 	]
 
 	log.debug "configure: Write IAS CIE"
-	// battery minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
-	return enrollCmds + zigbee.batteryConfig(30, 300) + refresh() // send refresh cmds as part of config
+	return configCmds
 }
 
 def enrollResponse() {
@@ -340,8 +340,7 @@ Integer convertHexToInt(hex) {
 
 def refresh() {
 	log.debug "Refreshing Battery"
-	def refreshCmds = [
+	[
 			"st rattr 0x${device.deviceNetworkId} ${endpointId} 1 0x20", "delay 200"
 	]
-	return refreshCmds + enrollResponse()
 }

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

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

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

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

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

@@ -0,0 +1,262 @@
+/*
+    Osram Tunable White 60 A19 bulb
+
+    Osram bulbs have a firmware issue causing it to forget its dimming level when turned off (via commands). Handling
+    that issue by using state variables
+*/
+
+metadata {
+    definition (name: "OSRAM LIGHTIFY LED Tunable White 60W", namespace: "smartthings", author: "SmartThings") {
+
+        capability "Color Temperature"
+        capability "Actuator"
+        capability "Switch"
+        capability "Switch Level"
+        capability "Configuration"
+        capability "Refresh"
+        capability "Sensor"
+
+        attribute "colorName", "string"
+
+        // 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"
+
+    }
+
+    // simulator metadata
+    simulator {
+        // status messages
+        status "on": "on/off: 1"
+        status "off": "on/off: 0"
+
+        // reply messages
+        reply "zcl on-off on": "on/off: 1"
+        reply "zcl on-off off": "on/off: 0"
+    }
+
+    // UI tile definitions
+    tiles {
+        standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+            state "on", label: '${name}', action: "switch.off", icon: "st.switches.light.on", backgroundColor: "#79b821"
+            state "off", label: '${name}', action: "switch.on", icon: "st.switches.light.off", backgroundColor: "#ffffff"
+        }
+        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+
+        controlTile("colorTempSliderControl", "device.colorTemperature", "slider", height: 1, width: 2, inactiveLabel: false, range:"(2700..6500)") {
+            state "colorTemperature", action:"color temperature.setColorTemperature"
+        }
+        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat") {
+            state "colorTemperature", label: '${currentValue} K'
+        }
+        valueTile("colorName", "device.colorName", inactiveLabel: false, decoration: "flat") {
+            state "colorName", label: '${currentValue}'
+        }
+
+
+        controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false, range:"(0..100)") {
+            state "level", action:"switch level.setLevel"
+        }
+        valueTile("level", "device.level", inactiveLabel: false, decoration: "flat") {
+            state "level", label: 'Level ${currentValue}%'
+        }
+
+
+        main(["switch"])
+        details(["switch", "refresh", "colorName", "levelSliderControl", "level", "colorTempSliderControl", "colorTemp"])
+    }
+}
+
+// Parse incoming device messages to generate events
+def parse(String description) {
+    //log.trace description
+
+    // save heartbeat (i.e. last time we got a message from device)
+    state.heartbeat = Calendar.getInstance().getTimeInMillis()
+
+    if (description?.startsWith("catchall:")) {
+        if(description?.endsWith("0100") ||description?.endsWith("1001") || description?.matches("on/off\\s*:\\s*1"))
+        {
+            def result = createEvent(name: "switch", value: "on")
+            log.debug "Parse returned ${result?.descriptionText}"
+            return result
+        }
+        else if(description?.endsWith("0000") || description?.endsWith("1000") || description?.matches("on/off\\s*:\\s*0"))
+        {
+            def result = createEvent(name: "switch", value: "off")
+            log.debug "Parse returned ${result?.descriptionText}"
+            return result
+        }
+
+    }
+    else if (description?.startsWith("read attr -")) {
+        def descMap = parseDescriptionAsMap(description)
+        log.trace "descMap : $descMap"
+
+        if (descMap.cluster == "0300") {
+            log.debug descMap.value
+            def tempInMired = convertHexToInt(descMap.value)
+            def tempInKelvin = Math.round(1000000/tempInMired)
+            log.trace "temp in kelvin: $tempInKelvin"
+            sendEvent(name: "colorTemperature", value: tempInKelvin, displayed:false)
+        }
+        else if(descMap.cluster == "0008"){
+            def dimmerValue = Math.round(convertHexToInt(descMap.value) * 100 / 255)
+            log.debug "dimmer value is $dimmerValue"
+            sendEvent(name: "level", value: dimmerValue)
+        }
+    }
+    else {
+        def name = description?.startsWith("on/off: ") ? "switch" : null
+        def value = name == "switch" ? (description?.endsWith(" 1") ? "on" : "off") : null
+        def result = createEvent(name: name, value: value)
+        log.debug "Parse returned ${result?.descriptionText}"
+        return result
+    }
+}
+
+def on() {
+    log.debug "on()"
+    sendEvent(name: "switch", value: "on")
+    setLevel(state?.levelValue)
+}
+
+def off() {
+    log.debug "off()"
+    sendEvent(name: "switch", value: "off")
+    "st cmd 0x${device.deviceNetworkId} ${endpointId} 6 0 {}"
+}
+
+def refresh() {
+    sendEvent(name: "heartbeat", value: "alive", displayed:false)
+    [
+            "st rattr 0x${device.deviceNetworkId} ${endpointId} 6 0", "delay 500",
+            "st rattr 0x${device.deviceNetworkId} ${endpointId} 8 0", "delay 500",
+            "st rattr 0x${device.deviceNetworkId} ${endpointId} 0x0300 7"
+    ]
+
+}
+
+def configure() {
+    state.levelValue = 100
+    log.debug "Configuring Reporting and Bindings."
+    def configCmds = [
+            "zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0x0300 {${device.zigbeeId}} {}", "delay 500"
+    ]
+    return onOffConfig() + levelConfig() + configCmds + refresh() // send refresh cmds as part of config
+}
+
+def onOffConfig() {
+    [
+            "zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 6 {${device.zigbeeId}} {}", "delay 200",
+            "zcl global send-me-a-report 6 0 0x10 0 300 {01}",
+            "send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500"
+    ]
+}
+
+//level config for devices with min reporting interval as 5 seconds and reporting interval if no activity as 1hour (3600s)
+//min level change is 01
+def levelConfig() {
+    [
+            "zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 8 {${device.zigbeeId}} {}", "delay 200",
+            "zcl global send-me-a-report 8 0 0x20 5 3600 {01}",
+            "send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500"
+    ]
+}
+
+def setColorTemperature(value) {
+    if(value<101){
+        value = (value*38) + 2700		//Calculation of mapping 0-100 to 2700-6500
+    }
+
+    def tempInMired = Math.round(1000000/value)
+    def finalHex = swapEndianHex(hex(tempInMired, 4))
+    def genericName = getGenericName(value)
+    log.debug "generic name is : $genericName"
+
+    def cmds = []
+    sendEvent(name: "colorTemperature", value: value, displayed:false)
+    sendEvent(name: "colorName", value: genericName)
+
+    cmds << "st cmd 0x${device.deviceNetworkId} ${endpointId} 0x0300 0x0a {${finalHex} 2000}"
+
+    cmds
+}
+
+def parseDescriptionAsMap(description) {
+    (description - "read attr - ").split(",").inject([:]) { map, param ->
+        def nameAndValue = param.split(":")
+        map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
+    }
+}
+
+def setLevel(value) {
+    state.levelValue = (value==null) ? 100 : 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")
+    }
+
+    sendEvent(name: "level", value: state.levelValue)
+    def level = hex(state.levelValue * 254 / 100)
+    cmds << "st cmd 0x${device.deviceNetworkId} ${endpointId} 8 4 {${level} 0000}"
+
+    //log.debug cmds
+    cmds
+}
+
+//Naming based on the wiki article here: http://en.wikipedia.org/wiki/Color_temperature
+private getGenericName(value){
+    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 <= 6500){
+        genericName = "Daylight"
+    }
+
+    genericName
+}
+
+private getEndpointId() {
+    new BigInteger(device.endpointId, 16).toString()
+}
+
+private hex(value, width=2) {
+    def s = new BigInteger(Math.round(value).toString()).toString(16)
+    while (s.size() < width) {
+        s = "0" + s
+    }
+    s
+}
+
+private String swapEndianHex(String hex) {
+    reverseArray(hex.decodeHex()).encodeHex()
+}
+
+private Integer convertHexToInt(hex) {
+    Integer.parseInt(hex,16)
+}
+
+//Need to reverse array of size 2
+private byte[] reverseArray(byte[] array) {
+    byte tmp;
+    tmp = array[1];
+    array[1] = array[0];
+    array[0] = tmp;
+    return array
+}

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

@@ -0,0 +1,235 @@
+/**
+ *  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-dimming-outlet.src/smartpower-dimming-outlet.groovy

@@ -69,35 +69,283 @@ metadata {
 def parse(String description) {
 	log.debug "description is $description"
 
-	def event = zigbee.getEvent(description)
-	if (!event) {
-		log.warn "DID NOT PARSE MESSAGE for description : $description"
-		log.debug zigbee.parseDescriptionAsMap(description)
-	} else if (event.name == "power") {
-		/*
-			Dividing by 10 as the Divisor is 10000 and unit is kW for the device. Simplifying to 10 power level is an integer.
-		*/
-		event.value = event.value / 10
+	def finalResult = isKnownDescription(description)
+	if (finalResult != "false") {
+		log.info finalResult
+		if (finalResult.type == "update") {
+			log.info "$device updates: ${finalResult.value}"
+		}
+		else if (finalResult.type == "power") {
+			def powerValue = (finalResult.value as Integer)/10
+			sendEvent(name: "power", value: powerValue)
+
+			/*
+				Dividing by 10 as the Divisor is 10000 and unit is kW for the device. AttrId: 0302 and 0300. Simplifying to 10
+
+				power level is an integer. The exact power level with correct units needs to be handled in the device type
+				to account for the different Divisor value (AttrId: 0302) and POWER Unit (AttrId: 0300). CLUSTER for simple metering is 0702
+			*/
+		}
+		else {
+			sendEvent(name: finalResult.type, value: finalResult.value)
+		}
+	}
+	else {
+		log.warn "DID NOT PARSE MESSAGE for description : $description"
+		log.debug parseDescriptionAsMap(description)
 	}
-	return event
 }
 
-def setLevel(value) {
-	zigbee.setLevel(value)
+// Commands to device
+def zigbeeCommand(cluster, attribute){
+	"st cmd 0x${device.deviceNetworkId} ${endpointId} ${cluster} ${attribute} {}"
 }
 
 def off() {
-	zigbee.off()
+	zigbeeCommand("6", "0")
 }
 
 def on() {
-	zigbee.on()
+	zigbeeCommand("6", "1")
+}
+
+def setLevel(value) {
+	value = value as Integer
+	if (value == 0) {
+		off()
+	}
+	else {
+		if (device.latestValue("switch") == "off") {
+			sendEvent(name: "switch", value: "on")
+		}
+		sendEvent(name: "level", value: value)
+		setLevelWithRate(value, "0000")		//value is between 0 to 100
+	}
 }
 
 def refresh() {
-	zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.electricMeasurementPowerRefresh()
+	[
+			"st rattr 0x${device.deviceNetworkId} ${endpointId} 6 0", "delay 500",
+			"st rattr 0x${device.deviceNetworkId} ${endpointId} 8 0", "delay 500",
+			"st rattr 0x${device.deviceNetworkId} ${endpointId} 0x0B04 0x050B", "delay 500"
+	]
+
 }
 
 def configure() {
-	refresh() + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.electricMeasurementPowerConfig()
+	onOffConfig() + levelConfig() + powerConfig() + refresh()
+}
+
+
+private getEndpointId() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+private hex(value, width=2) {
+	def s = new BigInteger(Math.round(value).toString()).toString(16)
+	while (s.size() < width) {
+		s = "0" + s
+	}
+	s
+}
+
+private String swapEndianHex(String hex) {
+	reverseArray(hex.decodeHex()).encodeHex()
+}
+
+private Integer convertHexToInt(hex) {
+	Integer.parseInt(hex,16)
+}
+
+//Need to reverse array of size 2
+private byte[] reverseArray(byte[] array) {
+	byte tmp;
+	tmp = array[1];
+	array[1] = array[0];
+	array[0] = tmp;
+	return array
+}
+
+def parseDescriptionAsMap(description) {
+	if (description?.startsWith("read attr -")) {
+		(description - "read attr - ").split(",").inject([:]) { map, param ->
+			def nameAndValue = param.split(":")
+			map += [(nameAndValue[0].trim()): nameAndValue[1].trim()]
+		}
+	}
+	else if (description?.startsWith("catchall: ")) {
+		def seg = (description - "catchall: ").split(" ")
+		def zigbeeMap = [:]
+		zigbeeMap += [raw: (description - "catchall: ")]
+		zigbeeMap += [profileId: seg[0]]
+		zigbeeMap += [clusterId: seg[1]]
+		zigbeeMap += [sourceEndpoint: seg[2]]
+		zigbeeMap += [destinationEndpoint: seg[3]]
+		zigbeeMap += [options: seg[4]]
+		zigbeeMap += [messageType: seg[5]]
+		zigbeeMap += [dni: seg[6]]
+		zigbeeMap += [isClusterSpecific: Short.valueOf(seg[7], 16) != 0]
+		zigbeeMap += [isManufacturerSpecific: Short.valueOf(seg[8], 16) != 0]
+		zigbeeMap += [manufacturerId: seg[9]]
+		zigbeeMap += [command: seg[10]]
+		zigbeeMap += [direction: seg[11]]
+		zigbeeMap += [data: seg.size() > 12 ? seg[12].split("").findAll { it }.collate(2).collect {
+			it.join('')
+		} : []]
+
+		zigbeeMap
+	}
+}
+
+def isKnownDescription(description) {
+	if ((description?.startsWith("catchall:")) || (description?.startsWith("read attr -"))) {
+		def descMap = parseDescriptionAsMap(description)
+		if (descMap.cluster == "0006" || descMap.clusterId == "0006") {
+			isDescriptionOnOff(descMap)
+		}
+		else if (descMap.cluster == "0008" || descMap.clusterId == "0008"){
+			isDescriptionLevel(descMap)
+		}
+		else if (descMap.cluster == "0B04" || descMap.clusterId == "0B04"){
+			isDescriptionPower(descMap)
+		}
+	}
+	else if(description?.startsWith("on/off:")) {
+		def switchValue = description?.endsWith("1") ? "on" : "off"
+		return	[type: "switch", value : switchValue]
+	}
+	else {
+		return "false"
+	}
+}
+
+def isDescriptionOnOff(descMap) {
+	def switchValue = "undefined"
+	if (descMap.cluster == "0006") {				//cluster info from read attr
+		value = descMap.value
+		if (value == "01"){
+			switchValue = "on"
+		}
+		else if (value == "00"){
+			switchValue = "off"
+		}
+	}
+	else if (descMap.clusterId == "0006") {
+		//cluster info from catch all
+		//command 0B is Default response and the last two bytes are [on/off][success]. on/off=00, success=00
+		//command 01 is Read attr response. the last two bytes are [datatype][value]. boolean datatype=10; on/off value = 01/00
+		if ((descMap.command=="0B" && descMap.raw.endsWith("0100")) || (descMap.command=="01" && descMap.raw.endsWith("1001"))){
+			switchValue = "on"
+		}
+		else if ((descMap.command=="0B" && descMap.raw.endsWith("0000")) || (descMap.command=="01" && descMap.raw.endsWith("1000"))){
+			switchValue = "off"
+		}
+		else if(descMap.command=="07"){
+			return	[type: "update", value : "switch (0006) capability configured successfully"]
+		}
+	}
+
+	if (switchValue != "undefined"){
+		return	[type: "switch", value : switchValue]
+	}
+	else {
+		return "false"
+	}
+
+}
+
+//@return - false or "success" or level [0-100]
+def isDescriptionLevel(descMap) {
+	def dimmerValue = -1
+	if (descMap.cluster == "0008"){
+		//TODO: the message returned with catchall is command 0B with clusterId 0008. That is just a confirmation message
+		def value = convertHexToInt(descMap.value)
+		dimmerValue = Math.round(value * 100 / 255)
+		if(dimmerValue==0 && value > 0) {
+			dimmerValue = 1						//handling for non-zero hex value less than 3
+		}
+	}
+	else if(descMap.clusterId == "0008") {
+		if(descMap.command=="0B"){
+			return	[type: "update", value : "level updated successfully"]					//device updating the level change was successful. no value sent.
+		}
+		else if(descMap.command=="07"){
+			return	[type: "update", value : "level (0008) capability configured successfully"]
+		}
+	}
+
+	if (dimmerValue != -1){
+		return	[type: "level", value : dimmerValue]
+
+	}
+	else {
+		return "false"
+	}
+}
+
+def isDescriptionPower(descMap) {
+	def powerValue = "undefined"
+	if (descMap.cluster == "0B04") {
+		if (descMap.attrId == "050b") {
+			if(descMap.value!="ffff")
+				powerValue = convertHexToInt(descMap.value)
+		}
+	}
+	else if (descMap.clusterId == "0B04") {
+		if(descMap.command=="07"){
+			return	[type: "update", value : "power (0B04) capability configured successfully"]
+		}
+	}
+
+	if (powerValue != "undefined"){
+		return	[type: "power", value : powerValue]
+	}
+	else {
+		return "false"
+	}
+}
+
+
+def onOffConfig() {
+	[
+			"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 6 {${device.zigbeeId}} {}", "delay 200",
+			"zcl global send-me-a-report 6 0 0x10 0 600 {01}",
+			"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500"
+	]
+}
+
+//level config for devices with min reporting interval as 5 seconds and reporting interval if no activity as 1hour (3600s)
+//min level change is 01
+def levelConfig() {
+	[
+			"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 8 {${device.zigbeeId}} {}", "delay 200",
+			"zcl global send-me-a-report 8 0 0x20 5 3600 {01}",
+			"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500"
+	]
+}
+
+//power config for devices with min reporting interval as 1 seconds and reporting interval if no activity as 10min (600s)
+//min change in value is 05
+def powerConfig() {
+	[
+		"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 0x0B04 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 0x0B04 0x050B 0x29 1 600 {05 00}",				//The send-me-a-report is custom to the attribute type for CentraLite
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
+	]
+}
+
+def setLevelWithRate(level, rate) {
+	if(rate == null){
+		rate = "0000"
+	}
+	level = convertToHexString(level * 255 / 100) 				//Converting the 0-100 range to 0-FF range in hex
+	"st cmd 0x${device.deviceNetworkId} ${endpointId} 8 4 {$level $rate}"
+}
+
+String convertToHexString(value, width=2) {
+	def s = new BigInteger(Math.round(value).toString()).toString(16)
+	while (s.size() < width) {
+		s = "0" + s
+	}
+	s
 }

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

@@ -5,7 +5,7 @@ metadata {
 		capability "Switch"
 		capability "Sensor"
 
-		fingerprint profileId: "0104", inClusters: "0006, 0004, 0003, 0000, 0005", outClusters: "0019", manufacturer: "Compacta International, Ltd", model: "ZBMPlug15", deviceJoinName: "SmartPower Outlet V1"
+		fingerprint profileId: "0104", inClusters: "0000,0003,0006", outClusters: "0019"
 	}
 
 	// simulator metadata
@@ -47,21 +47,9 @@ def parse(String description) {
 
 // Commands to device
 def on() {
-	[
-			'zcl on-off on',
-			'delay 200',
-			"send 0x${zigbee.deviceNetworkId} 0x01 0x${zigbee.endpointId}",
-			'delay 2000'
-
-	]
-
+	'zcl on-off on'
 }
 
 def off() {
-	[
-			'zcl on-off off',
-			'delay 200',
-			"send 0x${zigbee.deviceNetworkId} 0x01 0x${zigbee.endpointId}",
-			'delay 2000'
-	]
+	'zcl on-off off'
 }

devicetypes/smartthings/smartpower-outlet.src/.st-ignore

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

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

@@ -1,39 +0,0 @@
-# SmartPower Outlet
-
-Local Execution on V2 Hubs
-
-Works with: 
-
-* [Samsung SmartPower Outlet](https://shop.smartthings.com/#!/products/smartpower-outlet)
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health](#device-health)
-
-## Capabilities
-
-* **Configuration** - _configure()_ command called when device is installed or device preferences updated
-* **Actuator** - represents that a Device has commands
-* **Switch** - can detect state (possible values: on/off)
-* **Refresh** - _refresh()_ command for status updates
-* **Power Meter** - detects power meter for device in either w or kw.
-* **Health Check** - indicates ability to get device health notifications
-* **Sensor** - detects sensor events
-
-## Device Health
-
-SmartPower outlet with reporting interval of 5 mins
-SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
-
-* V1, TV, HubV2 AppEngine < 1.5.1 - __21min__ checkInterval
-* HubV2 AppEngine 1.5.1 - __12min__ checkInterval
-
-## Troubleshooting
-
-If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the device is out of range.
-Pairing needs to be tried again by placing the device closer to the hub.
-Instructions related to pairing, resetting and removing the device from SmartThings can be found in the following links
-for the different models:
-* [SmartPower Outlet Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/201084854-SmartPower-Outlet)
-* [Samsung SmartThings Outlet Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/205957620)

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

@@ -1,26 +0,0 @@
-#  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.
-# 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,32 +1,36 @@
-/*
- *  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.
+ *
+ *	SmartPower Outlet (CentraLite)
+ *
+ *	Author: SmartThings
+ *	Date: 2015-08-23
  */
 metadata {
 	// Automatically generated. Make future change here.
-	definition(name: "SmartPower Outlet", namespace: "smartthings", author: "SmartThings") {
+	definition (name: "SmartPower Outlet", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
 		capability "Switch"
 		capability "Power Meter"
 		capability "Configuration"
 		capability "Refresh"
 		capability "Sensor"
-		capability "Health Check"
 
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3200", deviceJoinName: "Outlet"
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3200-Sgb", deviceJoinName: "Outlet"
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "4257050-RZHAC", deviceJoinName: "Outlet"
+		// indicates that device keeps track of heartbeat (in state.heartbeat)
+		attribute "heartbeat", "string"
+
+		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite",  model: "3200", deviceJoinName: "Outlet"
+		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite",  model: "3200-Sgb", deviceJoinName: "Outlet"
+		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite",  model: "4257050-RZHAC", deviceJoinName: "Outlet"
 		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019"
 	}
 
@@ -44,32 +48,32 @@ metadata {
 	preferences {
 		section {
 			image(name: 'educationalcontent', multiple: true, images: [
-					"http://cdn.device-gse.smartthings.com/Outlet/US/OutletUS1.jpg",
-					"http://cdn.device-gse.smartthings.com/Outlet/US/OutletUS2.jpg"
-			])
+				"http://cdn.device-gse.smartthings.com/Outlet/US/OutletUS1.jpg",
+				"http://cdn.device-gse.smartthings.com/Outlet/US/OutletUS2.jpg"
+				])
 		}
 	}
 
 	// 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: '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"
+		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'
+			tileAttribute ("power", key: "SECONDARY_CONTROL") {
+				attributeState "power", label:'${currentValue} W'
 			}
 		}
 
 		standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label: '', action: "refresh.refresh", icon: "st.secondary.refresh"
+			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 
 		main "switch"
-		details(["switch", "refresh"])
+		details(["switch","refresh"])
 	}
 }
 
@@ -77,34 +81,38 @@ metadata {
 def parse(String description) {
 	log.debug "description is $description"
 
-	def event = zigbee.getEvent(description)
+	// save heartbeat (i.e. last time we got a message from device)
+	state.heartbeat = Calendar.getInstance().getTimeInMillis()
 
-	if (event) {
-		if (event.name == "power") {
-			event.value = event.value / 10
-			event.descriptionText = '{{ device.displayName }} power is {{ value }} Watts'
-			event.translatable = true
-		} else if (event.name == "switch") {
-			def descriptionText = event.value == "on" ? '{{ device.displayName }} is On' : '{{ device.displayName }} is Off'
-			event = createEvent(name: event.name, value: event.value, descriptionText: descriptionText, translatable: true)
+	def finalResult = zigbee.getKnownDescription(description)
+
+	//TODO: Remove this after getKnownDescription can parse it automatically
+	if (!finalResult && description!="updated")
+		finalResult = getPowerDescription(zigbee.parseDescriptionAsMap(description))
+
+	if (finalResult) {
+		log.info finalResult
+		if (finalResult.type == "update") {
+			log.info "$device updates: ${finalResult.value}"
 		}
-	} else {
-		def cluster = zigbee.parse(description)
+		else if (finalResult.type == "power") {
+			def powerValue = (finalResult.value as Integer)/10
+			sendEvent(name: "power", value: powerValue)
+			/*
+				Dividing by 10 as the Divisor is 10000 and unit is kW for the device. AttrId: 0302 and 0300. Simplifying to 10
 
-		if (cluster && cluster.clusterId == 0x0006 && cluster.command == 0x07) {
-			if (cluster.data[0] == 0x00) {
-				log.debug "ON/OFF REPORTING CONFIG RESPONSE: " + cluster
-				event = createEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-			} else {
-				log.warn "ON/OFF REPORTING CONFIG FAILED- error code:${cluster.data[0]}"
-				event = null
-			}
-		} else {
-			log.warn "DID NOT PARSE MESSAGE for description : $description"
-			log.debug "${cluster}"
+				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)
 		}
 	}
-	return event
+	else {
+		log.warn "DID NOT PARSE MESSAGE for description : $description"
+		log.debug zigbee.parseDescriptionAsMap(description)
+	}
 }
 
 def off() {
@@ -114,23 +122,49 @@ def off() {
 def on() {
 	zigbee.on()
 }
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	return zigbee.onOffRefresh()
-}
 
 def refresh() {
-	zigbee.onOffRefresh() + zigbee.electricMeasurementPowerRefresh()
+	sendEvent(name: "heartbeat", value: "alive", displayed:false)
+	zigbee.onOffRefresh() + zigbee.refreshData("0x0B04", "0x050B")
 }
 
 def configure() {
-	// Device-Watch allows 2 check-in misses from device + ping (plus 1 min lag time)
-	// enrolls with default periodic reporting until newer 5 min interval is confirmed
-	sendEvent(name: "checkInterval", value: 2 * 10 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-
-	// OnOff minReportTime 0 seconds, maxReportTime 5 min. Reporting interval if no activity
-	refresh() + zigbee.onOffConfig(0, 300) + zigbee.electricMeasurementPowerConfig()
+	zigbee.onOffConfig() + powerConfig() + refresh()
 }
 
+//power config for devices with min reporting interval as 1 seconds and reporting interval if no activity as 10min (600s)
+//min change in value is 01
+def powerConfig() {
+	[
+		"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 0x0B04 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 0x0B04 0x050B 0x29 1 600 {05 00}",				//The send-me-a-report is custom to the attribute type for CentraLite
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
+	]
+}
+
+private getEndpointId() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+//TODO: Remove this after getKnownDescription can parse it automatically
+def getPowerDescription(descMap) {
+	def powerValue = "undefined"
+	if (descMap.cluster == "0B04") {
+		if (descMap.attrId == "050b") {
+			if(descMap.value!="ffff")
+				powerValue = zigbee.convertHexToInt(descMap.value)
+		}
+	}
+	else if (descMap.clusterId == "0B04") {
+		if(descMap.command=="07"){
+			return	[type: "update", value : "power (0B04) capability configured successfully"]
+		}
+	}
+
+	if (powerValue != "undefined"){
+		return	[type: "power", value : powerValue]
+	}
+	else {
+		return [:]
+	}
+}

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

@@ -79,14 +79,14 @@ metadata {
 	}
     
 	preferences {
-		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
+		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
 	}    
 }
 
 def parse(String description) {
 	log.debug "parse($description)"
-	def results = [:]
+	def results = null
 
 	if (!isSupportedDescription(description) || zigbee.isZoneType19(description)) {
 		// Ignore this in favor of orientation-based state

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

@@ -88,8 +88,8 @@ metadata {
 	}
 
 	preferences {
-		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
+		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
 	}
 }
 

devicetypes/smartthings/smartsense-moisture-sensor.src/.st-ignore

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

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

@@ -1,45 +0,0 @@
-# Smartsense Moisture Sensor
-
-Local Execution on V2 Hubs
-
-Works with: 
-
-* [Samsung SmartThings Moisture Sensor](https://shop.smartthings.com/#!/products/samsung-smartthings-water-leak-sensor)
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health](#device-health)
-* [Battery](#battery-specification)
-
-## Capabilities
-
-* **Configuration** - _configure()_ command called when device is installed or device preferences updated
-* **Battery** - defines device uses a battery
-* **Refresh** - _refresh()_ command for status updates
-* **Temperature Measurement** - defines device measures current temperature
-* **Water Sensor** - can detect presence of water (dry or wet)
-* **Health Check** - indicates ability to get device health notifications
-
-## Device Health
-
-SmartSense Moisture sensor with reporting interval of 5 mins.
-SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
-
-* V1, TV, HubV2 AppEngine < 1.5.1 - __121min__ checkInterval
-* HubV2 AppEngine 1.5.1 - __12min__ checkInterval
-
-## Battery Specification
-
-One CR2 3V battery required.
-
-## Troubleshooting
-
-If the sensor doesn't pair when trying from the SmartThings mobile app, it is possible that the sensor is out of range.
-Pairing needs to be tried again by placing the sensor closer to the hub.
-Instructions related to pairing, resetting and removing the different sensors from SmartThings can be found in the following links
-for the different models:
-* [SmartSense Moisture Sensor Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/202847044-SmartSense-Moisture-Sensor)
-* [Samsung SmartThings Water Leak Sensor Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/205957630)
-Other troubleshooting tips are listed as follows:
-* [Troubleshooting: Samsung SmartThings Water Leak Sensor won’t pair after removing pull-tab](https://support.smartthings.com/hc/en-us/articles/204966616-Troubleshooting-Samsung-SmartThings-device-won-t-pair-after-removing-pull-tab)

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

@@ -1,35 +0,0 @@
-#  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.
-# 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,206 +1,332 @@
-/*
- *  Copyright 2016 SmartThings
+/**
+ *  SmartSense Moisture Sensor
  *
- *  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:
+ *  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:
  *
  *      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.
+ *
  */
-import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
-
-
 metadata {
-	definition(name: "SmartSense Moisture Sensor", namespace: "smartthings", author: "SmartThings") {
+	definition (name: "SmartSense Moisture Sensor",namespace: "smartthings", author: "SmartThings") {
 		capability "Configuration"
 		capability "Battery"
 		capability "Refresh"
 		capability "Temperature Measurement"
 		capability "Water Sensor"
-		capability "Health Check"
-		capability "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,0020,0402,0500,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3315-L", deviceJoinName: "Iris Smart Water Sensor"
-		fingerprint inClusters: "0000,0001,0003,000F,0020,0402,0500", outClusters: "0019", manufacturer: "SmartThings", model: "moisturev4", deviceJoinName: "Water Leak Sensor"
+		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"
+
 	}
-
+ 
 	simulator {
-
+ 
 	}
 
 	preferences {
 		section {
 			image(name: 'educationalcontent', multiple: true, images: [
-					"http://cdn.device-gse.smartthings.com/Moisture/Moisture1.png",
-					"http://cdn.device-gse.smartthings.com/Moisture/Moisture2.png",
-					"http://cdn.device-gse.smartthings.com/Moisture/Moisture3.png"
-			])
+				"http://cdn.device-gse.smartthings.com/Moisture/Moisture1.png",
+				"http://cdn.device-gse.smartthings.com/Moisture/Moisture2.png",
+				"http://cdn.device-gse.smartthings.com/Moisture/Moisture3.png"
+				])
 		}
 		section {
-			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
+			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
 		}
 	}
-
+ 
 	tiles(scale: 2) {
-		multiAttributeTile(name: "water", type: "generic", width: 6, height: 4) {
-			tileAttribute("device.water", key: "PRIMARY_CONTROL") {
-				attributeState "dry", label: "Dry", icon: "st.alarm.water.dry", backgroundColor: "#ffffff"
-				attributeState "wet", label: "Wet", icon: "st.alarm.water.wet", backgroundColor: "#53a7c0"
+		multiAttributeTile(name:"water", type: "generic", width: 6, height: 4){
+			tileAttribute ("device.water", key: "PRIMARY_CONTROL") {
+				attributeState "dry", label: "Dry", icon:"st.alarm.water.dry", backgroundColor:"#ffffff"
+				attributeState "wet", label: "Wet", icon:"st.alarm.water.wet", backgroundColor:"#53a7c0"
 			}
 		}
 		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"]
-					]
+			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: ""
+			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"
+			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 
-		main(["water", "temperature"])
+		main (["water", "temperature"])
 		details(["water", "temperature", "battery", "refresh"])
 	}
 }
-
+ 
 def parse(String description) {
 	log.debug "description: $description"
 
-	// getEvent will handle temperature and humidity
-	Map map = zigbee.getEvent(description)
-	if (!map) {
-		if (description?.startsWith('zone status')) {
-			map = parseIasMessage(description)
-		} else {
-			Map descMap = zigbee.parseDescriptionAsMap(description)
-			if (descMap.clusterInt == 0x0001 && descMap.commandInt != 0x07 && descMap?.value) {
-				map = getBatteryResult(Integer.parseInt(descMap.value, 16))
-			} else if (descMap?.clusterInt == zigbee.TEMPERATURE_MEASUREMENT_CLUSTER && descMap.commandInt == 0x07) {
-				if (descMap.data[0] == "00") {
-					log.debug "TEMP REPORTING CONFIG RESPONSE: $descMap"
-					sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-				} else {
-					log.warn "TEMP REPORTING CONFIG FAILED- error code: ${descMap.data[0]}"
-				}
-			}
-		}
+	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)
+    }
+ 
 	log.debug "Parse returned $map"
-	def result = map ? createEvent(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
+}
+ 
+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
 
-	if (description?.startsWith('enroll request')) {
-		List cmds = zigbee.enrollResponse()
-		log.debug "enroll response: ${cmds}"
-		result = cmds?.collect { new physicalgraph.device.HubAction(it) }
+            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
+        }
+    }
+
+    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 Map parseReportAttributeMessage(String description) {
+	Map descMap = (description - "read attr - ").split(",").inject([:]) { map, param ->
+		def nameAndValue = param.split(":")
+		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
 	}
-	return result
+	log.debug "Desc Map: $descMap"
+ 
+	Map resultMap = [:]
+	if (descMap.cluster == "0402" && descMap.attrId == "0000") {
+		def value = getTemperature(descMap.value)
+		resultMap = getTemperatureResult(value)
+	}
+	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: ')) {
+		def value = zigbee.parseHATemperatureValue(description, "temperature: ", getTemperatureScale())
+		resultMap = getTemperatureResult(value)
+	}
+	return resultMap
 }
 
 private Map parseIasMessage(String description) {
-	ZoneStatus zs = zigbee.parseZoneStatus(description)
+    List parsedMsg = description.split(' ')
+    String msgCode = parsedMsg[2]
+    
+    Map resultMap = [:]
+    switch(msgCode) {
+        case '0x0020': // Closed/No Motion/Dry
+        	resultMap = getMoistureResult('dry')
+            break
 
-	return zs.isAlarm1Set() ? getMoistureResult('wet') : getMoistureResult('dry')
+        case '0x0021': // Open/Motion/Wet
+        	resultMap = getMoistureResult('wet')
+            break
+
+        case '0x0022': // Tamper Alarm
+            break
+
+        case '0x0023': // Battery Alarm
+            break
+
+        case '0x0024': // Supervision Report
+        	 log.debug 'dry with tamper alarm'
+        	resultMap = getMoistureResult('dry')
+            break
+
+        case '0x0025': // Restore Report
+        	log.debug 'water with tamper alarm'
+        	resultMap = getMoistureResult('wet')
+            break
+
+        case '0x0026': // Trouble/Failure
+            break
+
+        case '0x0028': // Test Mode
+            break
+    }
+    return resultMap
+}
+
+def getTemperature(value) {
+	def celsius = Integer.parseInt(value, 16).shortValue() / 100
+	if(getTemperatureScale() == "C"){
+		return celsius
+	} else {
+		return celsiusToFahrenheit(celsius) as Integer
+	}
 }
 
 private Map getBatteryResult(rawValue) {
-	log.debug "Battery rawValue = ${rawValue}"
+	log.debug 'Battery'
 	def linkText = getLinkText(device)
-
-	def result = [:]
-
+    
+    def result = [
+    	name: 'battery'
+    ]
+    
 	def volts = rawValue / 10
-
-	if (!(rawValue == 0 || rawValue == 255)) {
-		result.name = 'battery'
-		result.translatable = true
-		result.descriptionText = "{{ device.displayName }} battery was {{ 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
-
-			if (volts < minVolts)
-				volts = minVolts
-			else if (volts > maxVolts)
-				volts = maxVolts
-			def pct = batteryMap[volts]
-			result.value = pct
-		} else {
-			def minVolts = 2.1
-			def maxVolts = 3.0
-			def pct = (volts - minVolts) / (maxVolts - minVolts)
-			def roundedPct = Math.round(pct * 100)
-			if (roundedPct <= 0)
-				roundedPct = 1
-			result.value = Math.min(100, roundedPct)
-		}
-
+	def descriptionText
+	if (volts > 3.5) {
+		result.descriptionText = "${linkText} battery has too much power (${volts} 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}%"
 	}
 
 	return result
 }
 
-private Map getMoistureResult(value) {
-	log.debug "water"
-	def descriptionText
-	if (value == "wet")
-		descriptionText = '{{ device.displayName }} is wet'
-	else
-		descriptionText = '{{ device.displayName }} is dry'
+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}"
 	return [
-			name           : 'water',
-			value          : value,
-			descriptionText: descriptionText,
-			translatable   : true
+		name: 'temperature',
+		value: value,
+		descriptionText: descriptionText
 	]
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	return zigbee.readAttribute(0x001, 0x0020) // Read the Battery Level
+private Map getMoistureResult(value) {
+	log.debug 'water'
+	String descriptionText = "${device.displayName} is ${value}"
+	return [
+		name: 'water',
+		value: value,
+		descriptionText: descriptionText
+	]
 }
 
 def refresh() {
 	log.debug "Refreshing Temperature and Battery"
-	def refreshCmds = zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
-			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020)
+	def refreshCmds = [
+        "st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+		"st rattr 0x${device.deviceNetworkId} 1 1 0x20", "delay 200"
+	]
 
-	return refreshCmds + zigbee.enrollResponse()
+	return refreshCmds + enrollResponse()
 }
 
 def configure() {
-	// Device-Watch allows 2 check-in misses from device + ping (plus 1 min lag time)
-	// enrolls with default periodic reporting until newer 5 min interval is confirmed
-	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
+	log.debug "Configuring Reporting, IAS CIE, and Bindings."
+	def configCmds = [	
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 500",
 
-	// temperature minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
-	// battery minReport 30 seconds, maxReportTime 6 hrs by default
-	return refresh() + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) // send refresh cmds as part of config
+		"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",
+
+		"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"
+	]
+    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() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+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/smartthings/smartsense-moisture.src/smartsense-moisture.groovy

@@ -16,7 +16,6 @@ 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"
@@ -40,29 +39,17 @@ metadata {
 				attributeState "wet", label: "Wet", icon:"st.alarm.water.wet", backgroundColor:"#53a7c0"
 			}
 		}
-		standardTile("temperatureState", "device.temperature", width: 2, height: 2) {
+		standardTile("temperature", "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", "temperatureState"])
-		details(["water", "temperatureState", "temperature", "battery"])
+
+		main (["water", "temperature"])
+		details(["water", "temperature", "battery"])
 	}
 }
 
@@ -128,7 +115,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 = "temperatureState"
+		map.name = "temperature"
 		if(cmd.zwaveAlarmEvent == 1) { map.value = "overheated"}
 		if(cmd.zwaveAlarmEvent == 2) { map.value = "overheated"}
 		if(cmd.zwaveAlarmEvent == 3) { map.value = "changing temperature rapidly"}
@@ -142,30 +129,17 @@ def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd)
 	map
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd)
+def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd)
 {
 	def map = [:]
-	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.name = "water"
+	map.value = cmd.value ? "wet" : "dry"
+	map.descriptionText = "${device.displayName} is ${map.value}"
 	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/.st-ignore

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

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

@@ -1,47 +0,0 @@
-# Smartsense Motion Sensor
-
-Local Execution on V2 Hubs
-
-Works with: 
-
-* [Samsung SmartThings Motion Sensor](https://shop.smartthings.com/#!/products/samsung-smartthings-motion-sensor)
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health](#device-health)
-* [Battery](#battery-specification)
-
-## Capabilities
-
-* **Configuration** - _configure()_ command called when device is installed or device preferences updated
-* **Motion Sensor** - can detect motion
-* **Battery** - defines device uses a battery
-* **Refresh** - _refresh()_ command for status updates
-* **Health Check** - indicates ability to get device health notifications
-
-## Device Health
-
-SmartSense Motion sensor with reporting interval of 5 mins.
-SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
-
-* V1, TV, HubV2 AppEngine < 1.5.1 - __121min__ checkInterval
-* HubV2 AppEngine 1.5.1 - __12min__ checkInterval
-
-
-## Battery Specification
-
-One CR2477 (for Samsung SmartThings Motion Sensor) / CR123A (SmartSense Motion Sensor) 3V battery is required.
-
-## Troubleshooting
-
-If the device doesn't pair when trying from the SmartThings mobile app, it is possible that the sensor is out of range.
-Pairing needs to be tried again by placing the sensor closer to the hub.
-Instructions related to pairing, resetting and removing the different motion sensors from SmartThings can be found in the following links
-for the different models:
-* [SmartSense Motion Sensor (original model) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/200903280-SmartSense-Motion-Sensor-original-model-)
-* [SmartSense Motion Sensor (2014 model) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/203077520-SmartSense-Motion-Sensor-2014-model-)
-* [Samsung SmartThings Motion Sensor (2015 model) Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/205957580-Samsung-SmartThings-Motion-Sensor-2015-model-)
-Other troubleshooting tips are listed as follows:
-* [Troubleshooting: Samsung SmartThings Motion Sensor is stuck showing "Motion Detected" or "No Motion"](https://support.smartthings.com/hc/en-us/articles/200961130-Troubleshooting-Samsung-SmartThings-Motion-Sensor-is-stuck-showing-Motion-Detected-or-No-Motion-)
-* [Troubleshooting: Samsung SmartThings Motion Sensor won’t pair after removing pull-tab](https://support.smartthings.com/hc/en-us/articles/204966616-Troubleshooting-Samsung-SmartThings-device-won-t-pair-after-removing-pull-tab)

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

@@ -1,33 +0,0 @@
-#  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.
-# 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,40 +1,34 @@
-/*
- *  Copyright 2016 SmartThings
+/**
+ *  SmartSense Motion/Temp Sensor
  *
- *  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:
+ *  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:
  *
  *      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.
+ *
  */
-import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
-
 
 metadata {
-	definition(name: "SmartSense Motion Sensor", namespace: "smartthings", author: "SmartThings") {
+	definition (name: "SmartSense Motion Sensor", namespace: "smartthings", author: "SmartThings") {
 		capability "Motion Sensor"
 		capability "Configuration"
 		capability "Battery"
-		capability "Temperature Measurement"
+        capability "Temperature Measurement"
 		capability "Refresh"
-		capability "Health Check"
-		capability "Sensor"
-
-		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: "3326-L", deviceJoinName: "Iris Motion Sensor"
-		fingerprint inClusters: "0000,0001,0003,000F,0020,0402,0500", outClusters: "0019", manufacturer: "SmartThings", model: "motionv4", deviceJoinName: "Motion Sensor"
+        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"
 	}
 
 	simulator {
@@ -45,42 +39,42 @@ metadata {
 	preferences {
 		section {
 			image(name: 'educationalcontent', multiple: true, images: [
-					"http://cdn.device-gse.smartthings.com/Motion/Motion1.jpg",
-					"http://cdn.device-gse.smartthings.com/Motion/Motion2.jpg",
-					"http://cdn.device-gse.smartthings.com/Motion/Motion3.jpg"
-			])
+				"http://cdn.device-gse.smartthings.com/Motion/Motion1.jpg",
+				"http://cdn.device-gse.smartthings.com/Motion/Motion2.jpg",
+				"http://cdn.device-gse.smartthings.com/Motion/Motion3.jpg"
+				])
 		}
 		section {
-			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
+			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
 		}
 	}
 
 	tiles(scale: 2) {
-		multiAttributeTile(name: "motion", type: "generic", width: 6, height: 4) {
-			tileAttribute("device.motion", key: "PRIMARY_CONTROL") {
-				attributeState "active", label: 'motion', icon: "st.motion.motion.active", backgroundColor: "#53a7c0"
-				attributeState "inactive", label: 'no motion', icon: "st.motion.motion.inactive", backgroundColor: "#ffffff"
+		multiAttributeTile(name:"motion", type: "generic", width: 6, height: 4){
+			tileAttribute ("device.motion", key: "PRIMARY_CONTROL") {
+				attributeState "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
+				attributeState "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
 			}
 		}
 		valueTile("temperature", "device.temperature", width: 2, height: 2) {
-			state("temperature", label: '${currentValue}°', unit: "F",
-					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"]
-					]
+			state("temperature", label:'${currentValue}°', unit:"F",
+				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: ""
+			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"
+			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 
 		main(["motion", "temperature"])
@@ -90,119 +84,272 @@ metadata {
 
 def parse(String description) {
 	log.debug "description: $description"
-	Map map = zigbee.getEvent(description)
-	if (!map) {
-		if (description?.startsWith('zone status')) {
-			map = parseIasMessage(description)
-		} else {
-			Map descMap = zigbee.parseDescriptionAsMap(description)
-			if (descMap?.clusterInt == 0x0001 && descMap.commandInt != 0x07 && descMap?.value) {
-				map = getBatteryResult(Integer.parseInt(descMap.value, 16))
-			} else if (descMap?.clusterInt == zigbee.TEMPERATURE_MEASUREMENT_CLUSTER && descMap.commandInt == 0x07) {
-				if (descMap.data[0] == "00") {
-					log.debug "TEMP REPORTING CONFIG RESPONSE: $descMap"
-					sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-				} else {
-					log.warn "TEMP REPORTING CONFIG FAILED- error code: ${descMap.data[0]}"
-				}
-			} else if (descMap.clusterInt == 0x0406 && descMap.attrInt == 0x0000) {
-				def value = descMap.value.endsWith("01") ? "active" : "inactive"
-				log.warn "Doing a read attr motion event"
-				resultMap = getMotionResult(value)
-			}
-		}
+    
+	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)
+    }
+ 
 	log.debug "Parse returned $map"
-	def result = map ? createEvent(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 = zigbee.enrollResponse()
-		log.debug "enroll response: ${cmds}"
-		result = cmds?.collect { new physicalgraph.device.HubAction(it) }
+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
+
+            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
+        }
+    }
+
+    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 Map parseReportAttributeMessage(String description) {
+	Map descMap = (description - "read attr - ").split(",").inject([:]) { map, param ->
+		def nameAndValue = param.split(":")
+		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
 	}
-	return result
+	log.debug "Desc Map: $descMap"
+ 
+	Map resultMap = [:]
+	if (descMap.cluster == "0402" && descMap.attrId == "0000") {
+		def value = getTemperature(descMap.value)
+		resultMap = getTemperatureResult(value)
+	}
+	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)
+    } 
+ 
+	return resultMap
+}
+ 
+private Map parseCustomMessage(String description) {
+	Map resultMap = [:]
+	if (description?.startsWith('temperature: ')) {
+		def value = zigbee.parseHATemperatureValue(description, "temperature: ", getTemperatureScale())
+		resultMap = getTemperatureResult(value)
+	}
+	return resultMap
 }
 
 private Map parseIasMessage(String description) {
-	ZoneStatus zs = zigbee.parseZoneStatus(description)
+    List parsedMsg = description.split(' ')
+    String msgCode = parsedMsg[2]
+    
+    Map resultMap = [:]
+    switch(msgCode) {
+        case '0x0020': // Closed/No Motion/Dry
+        	resultMap = getMotionResult('inactive')
+            break
 
-	// Some sensor models that use this DTH use alarm1 and some use alarm2 to signify motion
-	return (zs.isAlarm1Set() || zs.isAlarm2Set()) ? getMotionResult('active') : getMotionResult('inactive')
+        case '0x0021': // Open/Motion/Wet
+        	resultMap = getMotionResult('active')
+            break
+
+        case '0x0022': // Tamper Alarm
+        	log.debug 'motion with tamper alarm'
+        	resultMap = getMotionResult('active')
+            break
+
+        case '0x0023': // Battery Alarm
+            break
+
+        case '0x0024': // Supervision Report
+        	log.debug 'no motion with tamper alarm'
+        	resultMap = getMotionResult('inactive')
+            break
+
+        case '0x0025': // Restore Report
+            break
+
+        case '0x0026': // Trouble/Failure
+        	log.debug 'motion with failure alarm'
+        	resultMap = getMotionResult('active')
+            break
+
+        case '0x0028': // Test Mode
+            break
+    }
+    return resultMap
+}
+
+def getTemperature(value) {
+	def celsius = Integer.parseInt(value, 16).shortValue() / 100
+	if(getTemperatureScale() == "C"){
+		return celsius
+	} else {
+		return celsiusToFahrenheit(celsius) as Integer
+	}
 }
 
 private Map getBatteryResult(rawValue) {
-	log.debug "Battery rawValue = ${rawValue}"
+	log.debug 'Battery'
 	def linkText = getLinkText(device)
 
-	def result = [:]
+	log.debug rawValue
+
+	def result = [
+		name: 'battery',
+		value: '--'
+	]
 
 	def volts = rawValue / 10
+	def descriptionText
 
-	if (!(rawValue == 0 || rawValue == 255)) {
-		result.name = 'battery'
-		result.translatable = true
-		result.descriptionText = "{{ device.displayName }} battery was {{ 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
-
-			if (volts < minVolts)
-				volts = minVolts
-			else if (volts > maxVolts)
-				volts = maxVolts
-			def pct = batteryMap[volts]
-			result.value = pct
-		} else {
+	if (rawValue == 0) {}
+	else {
+		if (volts > 3.5) {
+			result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
+		}
+		else if (volts > 0){
 			def minVolts = 2.1
 			def maxVolts = 3.0
 			def pct = (volts - minVolts) / (maxVolts - minVolts)
-			def roundedPct = Math.round(pct * 100)
-			if (roundedPct <= 0)
-				roundedPct = 1
-			result.value = Math.min(100, roundedPct)
+			result.value = Math.min(100, (int) pct * 100)
+			result.descriptionText = "${linkText} battery was ${result.value}%"
 		}
 	}
 
 	return result
 }
 
+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}"
+	return [
+		name: 'temperature',
+		value: value,
+		descriptionText: descriptionText
+	]
+}
+
 private Map getMotionResult(value) {
 	log.debug 'motion'
-	String descriptionText = value == 'active' ? "{{ device.displayName }} detected motion" : "{{ device.displayName }} motion has stopped"
+	String linkText = getLinkText(device)
+	String descriptionText = value == 'active' ? "${linkText} detected motion" : "${linkText} motion has stopped"
 	return [
-			name           : 'motion',
-			value          : value,
-			descriptionText: descriptionText,
-			translatable   : true
+		name: 'motion',
+		value: value,
+		descriptionText: descriptionText
 	]
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	return zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) // Read the Battery Level
-}
-
 def refresh() {
 	log.debug "refresh called"
+	def refreshCmds = [
+		"st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+		"st rattr 0x${device.deviceNetworkId} 1 1 0x20", "delay 200"
+	]
 
-	def refreshCmds = zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) +
-			zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000)
-
-	return refreshCmds + zigbee.enrollResponse()
+	return refreshCmds + enrollResponse()
 }
 
 def configure() {
-	// Device-Watch allows 2 check-in misses from device + ping (plus 1 min lag time)
-	// enrolls with default periodic reporting until newer 5 min interval is confirmed
-	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
+	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
+	log.debug "Configuring Reporting, IAS CIE, and Bindings."
 
-	// temperature minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
-	// battery minReport 30 seconds, maxReportTime 6 hrs by default
-	return refresh() + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) // send refresh cmds as part of config
+	def configCmds = [
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 1 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}",		//checkin time 6 hrs
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0x402 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 0x402 0 0x29 300 3600 {6400}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
+	]
+	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() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+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/smartthings/smartsense-motion-temp-sensor.src/smartsense-motion-temp-sensor.groovy

@@ -0,0 +1,346 @@
+/**
+ *  SmartSense Motion/Temp Sensor
+ *
+ *  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:
+ *
+ *      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: "SmartSense Motion/Temp Sensor", namespace: "smartthings", author: "SmartThings") {
+		capability "Motion Sensor"
+		capability "Configuration"
+		capability "Battery"
+        capability "Temperature Measurement"
+		capability "Refresh"
+		capability "Sensor"
+        
+        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 {
+		status "active": "zone report :: type: 19 value: 0031"
+		status "inactive": "zone report :: type: 19 value: 0030"
+	}
+
+	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
+	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name:"motion", type: "generic", width: 6, height: 4){
+			tileAttribute ("device.motion", key: "PRIMARY_CONTROL") {
+				attributeState "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
+				attributeState "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
+			}
+		}
+		valueTile("temperature", "device.temperature", width: 2, height: 2) {
+			state("temperature", label:'${currentValue}°', unit:"F",
+				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:""
+		}
+		standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+
+		main(["motion", "temperature"])
+		details(["motion", "temperature", "battery", "refresh"])
+	}
+}
+
+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: ')) {
+		map = parseCustomMessage(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
+}
+
+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
+
+            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
+        }
+    }
+
+    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 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)
+		resultMap = getTemperatureResult(value)
+	}
+	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)
+    } 
+ 
+	return resultMap
+}
+ 
+private Map parseCustomMessage(String description) {
+	Map resultMap = [:]
+	if (description?.startsWith('temperature: ')) {
+		def value = zigbee.parseHATemperatureValue(description, "temperature: ", getTemperatureScale())
+		resultMap = getTemperatureResult(value)
+	}
+	return resultMap
+}
+
+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
+
+        case '0x0021': // Open/Motion/Wet
+        	resultMap = getMotionResult('active')
+            break
+
+        case '0x0022': // Tamper Alarm
+        	log.debug 'motion with tamper alarm'
+        	resultMap = getMotionResult('active')
+            break
+
+        case '0x0023': // Battery Alarm
+            break
+
+        case '0x0024': // Supervision Report
+        	log.debug 'no motion with tamper alarm'
+        	resultMap = getMotionResult('inactive')
+            break
+
+        case '0x0025': // Restore Report
+            break
+
+        case '0x0026': // Trouble/Failure
+        	log.debug 'motion with failure alarm'
+        	resultMap = getMotionResult('active')
+            break
+
+        case '0x0028': // Test Mode
+            break
+    }
+    return resultMap
+}
+
+def getTemperature(value) {
+	def celsius = Integer.parseInt(value, 16).shortValue() / 100
+	if(getTemperatureScale() == "C"){
+		return celsius
+	} else {
+		return celsiusToFahrenheit(celsius) as Integer
+	}
+}
+
+private Map getBatteryResult(rawValue) {
+	log.debug 'Battery'
+	def linkText = getLinkText(device)
+
+	log.debug rawValue
+
+	def result = [
+		name: 'battery',
+		value: '--'
+	]
+
+	def volts = rawValue / 10
+	def descriptionText
+
+	if (rawValue == 0) {}
+	else {
+		if (volts > 3.5) {
+			result.descriptionText = "${linkText} battery has too much power (${volts} 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}%"
+		}
+	}
+
+	return result
+}
+
+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}"
+	return [
+		name: 'temperature',
+		value: value,
+		descriptionText: descriptionText
+	]
+}
+
+private Map getMotionResult(value) {
+	log.debug 'motion'
+	String linkText = getLinkText(device)
+	String descriptionText = value == 'active' ? "${linkText} detected motion" : "${linkText} motion has stopped"
+	return [
+		name: 'motion',
+		value: value,
+		descriptionText: descriptionText
+	]
+}
+
+def refresh() {
+	log.debug "refresh called"
+	def refreshCmds = [
+		"st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+		"st rattr 0x${device.deviceNetworkId} 1 1 0x20", "delay 200"
+	]
+
+	return refreshCmds + enrollResponse()
+}
+
+def configure() {
+	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
+	log.debug "Configuring Reporting, IAS CIE, and Bindings."
+
+	def configCmds = [
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 1 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}",		//checkin time 6 hrs
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0x402 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 0x402 0 0x29 30 3600 {6400}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
+	]
+    return configCmds + refresh() // send refresh cmds as part of config
+}
+
+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() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+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/smartthings/smartsense-motion.src/smartsense-motion.groovy

@@ -44,7 +44,7 @@ metadata {
 }
 
 def parse(String description) {
-	def results = [:]
+	def results
 	if (isZoneType19(description) || !isSupportedDescription(description)) {
 		results = parseBasicMessage(description)
 	}
@@ -57,24 +57,21 @@ def parse(String description) {
 
 private Map parseBasicMessage(description) {
 	def name = parseName(description)
-	def results = [:]
-	if (name != null) {
-		def value = parseValue(description)
-		def linkText = getLinkText(device)
-		def descriptionText = parseDescriptionText(linkText, value, description)
-		def handlerName = value
-		def isStateChange = isStateChange(device, name, value)
+	def value = parseValue(description)
+	def linkText = getLinkText(device)
+	def descriptionText = parseDescriptionText(linkText, value, description)
+	def handlerName = value
+	def isStateChange = isStateChange(device, name, value)
 
-		results = [
-				name           : name,
-				value          : value,
-				linkText       : linkText,
-				descriptionText: descriptionText,
-				handlerName    : handlerName,
-				isStateChange  : isStateChange,
-				displayed      : displayed(description, isStateChange)
-		]
-	}
+	def results = [
+		name: name,
+		value: value,
+		linkText: linkText,
+		descriptionText: descriptionText,
+		handlerName: handlerName,
+		isStateChange: isStateChange,
+		displayed: displayed(description, isStateChange)
+	]
 	log.debug "Parse returned $results.descriptionText"
 	return results
 }

devicetypes/smartthings/smartsense-multi-sensor.src/.st-ignore

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

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

@@ -1,46 +0,0 @@
-# Smartsense Multi Sensor
-
-Local Execution on V2 Hubs
-
-Works with: 
-
-* [Samsung SmartThings Multi Sensor](https://shop.smartthings.com/#!/products/smartsense-multi)
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health](#device-health)
-* [Battery](#battery-specification)
-
-## Capabilities
-
-* **Three Axis** - monitors the state of a single axis
-* **Configuration** - _configure()_ command called when device is installed or device preferences updated
-* **Battery** - defines device uses a battery
-* **Sensor** - detects sensor events
-* **Contact Sensor** - can detect contact (possible values: open,closed)
-* **Acceleration Sensor** - allows for acceleration detection.
-* **Refresh** - _refresh()_ command for status updates
-* **Temperature Measurement** - defines device measures current temperature
-* **Health Check** - indicates ability to get device health notifications
-
-## Device Health
-
-SmartSense Multi sensor with reporting interval of 5 mins.
-SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
-
-* V1, TV, HubV2 AppEngine < 1.5.1 - __121min__ checkInterval
-* HubV2 AppEngine 1.5.1 - __12min__ checkInterval
-
-## Battery Specification
-
-One CR2450 (for Samsung SmartThings Multipurpose Sensor) battery / Two AAAA (for SmartSense Multi Sensor) batteries required.
-
-## Troubleshooting
-
-If the sensor doesn't pair when trying from the SmartThings mobile app, it is possible that the sensor is out of range.
-Pairing needs to be tried again by placing the sensor closer to the hub.
-Other troubleshooting tips are listed as follows:
-* [Troubleshooting: Samsung SmartThings Multipurpose Sensor is stuck on "open" or "closed"](https://support.smartthings.com/hc/en-us/articles/200955940-Troubleshooting-Samsung-SmartThings-Multipurpose-Sensor-is-stuck-on-open-or-closed-)
-* [Troubleshooting: Temperature reading for the Samsung SmartThings Multipurpose Sensor is off](https://support.smartthings.com/hc/en-us/articles/200756845-Troubleshooting-Temperature-reading-for-the-Samsung-SmartThings-Multipurpose-Sensor-is-off)
-* [Troubleshooting: Samsung SmartThings Multipurpose Sensor won’t pair after removing pull-tab](https://support.smartthings.com/hc/en-us/articles/204966616-Troubleshooting-Samsung-SmartThings-device-won-t-pair-after-removing-pull-tab)

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

@@ -1,41 +0,0 @@
-#  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.
-# 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,44 +1,40 @@
-/*
- *  Copyright 2016 SmartThings
+/**
+ *  SmartSense Multi
  *
- *  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:
+ *  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.
+ *  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 physicalgraph.zigbee.clusters.iaszone.ZoneStatus
-import physicalgraph.zigbee.zcl.DataType
 
-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 "Contact Sensor"
-		capability "Acceleration Sensor"
-		capability "Refresh"
-		capability "Temperature Measurement"
-		capability "Health Check"
-
-		command "enrollResponse"
-		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05,FC02", outClusters: "0019", manufacturer: "CentraLite", model: "3320"
+ 		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,000F,0020,0402,0500,FC02", outClusters: "0019", manufacturer: "SmartThings", model: "multiv4", deviceJoinName: "Multipurpose Sensor"
+        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05,FC02", outClusters: "0019", manufacturer: "CentraLite", model: "3321-S", deviceJoinName: "Multipurpose Sensor"
 
 		attribute "status", "string"
-	}
+ 	}
 
-	simulator {
+ 	simulator {
 		status "open": "zone report :: type: 19 value: 0031"
 		status "closed": "zone report :: type: 19 value: 0030"
 
@@ -55,299 +51,209 @@ metadata {
 		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",
-					"http://cdn.device-gse.smartthings.com/Multi/Multi2.jpg",
-					"http://cdn.device-gse.smartthings.com/Multi/Multi3.jpg",
-					"http://cdn.device-gse.smartthings.com/Multi/Multi4.jpg"
-			])
+				"http://cdn.device-gse.smartthings.com/Multi/Multi1.jpg",
+				"http://cdn.device-gse.smartthings.com/Multi/Multi2.jpg",
+				"http://cdn.device-gse.smartthings.com/Multi/Multi3.jpg",
+				"http://cdn.device-gse.smartthings.com/Multi/Multi4.jpg"
+				])
 		}
 		section {
-			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
-		}
+ 			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?", description: "Tap to set", options: ["Yes", "No"], defaultValue: "No", required: false, displayDuringSetup: false)
+ 			input("garageSensor", "enum", title: "Do you want to use this sensor on a garage door?", 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: '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"
+		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 "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: 'Open', icon: "st.contact.contact.open", backgroundColor: "#ffa81e")
-			state("closed", label: 'Closed', icon: "st.contact.contact.closed", backgroundColor: "#79b821")
+			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
+			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
 		}
 		standardTile("acceleration", "device.acceleration", width: 2, height: 2) {
-			state("active", label: 'Active', icon: "st.motion.acceleration.active", backgroundColor: "#53a7c0")
-			state("inactive", label: 'Inactive', icon: "st.motion.acceleration.inactive", backgroundColor: "#ffffff")
+			state("active", label:'${name}', icon:"st.motion.acceleration.active", backgroundColor:"#53a7c0")
+			state("inactive", label:'${name}', icon:"st.motion.acceleration.inactive", backgroundColor:"#ffffff")
 		}
 		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"]
-					]
+			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("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"
+			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"
+ 		}
 
 
 		main(["status", "acceleration", "temperature"])
-		details(["status", "acceleration", "temperature", "battery", "refresh"])
+		details(["status", "acceleration", "temperature", "3axis", "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 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
 }
 
-def parse(String description) {
-	def maps = []
-	maps << zigbee.getEvent(description)
-	if (!maps[0]) {
-		maps = []
-		if (description?.startsWith('zone status')) {
-			maps += parseIasMessage(description)
-		} else {
-			Map descMap = zigbee.parseDescriptionAsMap(description)
-			if (descMap?.clusterInt == 0x0001 && descMap.commandInt != 0x07 && descMap?.value) {
-				maps << getBatteryResult(Integer.parseInt(descMap.value, 16))
-			} else if (descMap?.clusterInt == zigbee.TEMPERATURE_MEASUREMENT_CLUSTER && descMap.commandInt == 0x07) {
-				if (descMap.data[0] == "00") {
-					log.debug "TEMP REPORTING CONFIG RESPONSE: $descMap"
-					sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-				} else {
-					log.warn "TEMP REPORTING CONFIG FAILED- error code: ${descMap.data[0]}"
-				}
-			} else {
+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()]
+	}
+    
+    Map resultMap = [:]
+	if (descMap.cluster == "0402" && descMap.attrId == "0000") {
+		def value = getTemperature(descMap.value)
+		resultMap = getTemperatureResult(value)
+	}
+	else if (descMap.cluster == "FC02" && descMap.attrId == "0010") {
+  		resultMap = getAccelerationResult(descMap.value)
+	}
+    else if (descMap.cluster == "FC02" && descMap.attrId == "0012") {
+  		resultMap = parseAxis(descMap.value)
+	}
+	else if (descMap.cluster == "0001" && descMap.attrId == "0020") {
+		resultMap = getBatteryResult(Integer.parseInt(descMap.value, 16))
+	}
 
-				maps += handleAcceleration(descMap)
+	return resultMap
+}
+
+private Map parseCustomMessage(String description) {
+	Map resultMap = [:]
+	if (description?.startsWith('temperature: ')) {
+		def value = zigbee.parseHATemperatureValue(description, "temperature: ", getTemperatureScale())
+		resultMap = getTemperatureResult(value)
+	}
+	return resultMap
+}
+
+private Map parseIasMessage(String description) {
+	List parsedMsg = description.split(' ')
+	String msgCode = parsedMsg[2]
+
+	Map resultMap = [:]
+	switch(msgCode) {
+        case '0x0020': // Closed/No Motion/Dry
+			if (garageSensor != "Yes"){
+				resultMap = getContactResult('closed')
 			}
-		}
-	} else if (maps[0].name == "temperature") {
-		def map = maps[0]
-		if (tempOffset) {
-			map.value = (int) map.value + (int) tempOffset
-		}
-		map.descriptionText = temperatureScale == 'C' ? '{{ device.displayName }} was {{ value }}°C' : '{{ device.displayName }} was {{ value }}°F'
-		map.translatable = true
-	}
+        break
 
-	def result = maps.inject([]) {acc, it ->
-		if (it) {
-			acc << createEvent(it)
-		}
-	}
-	if (description?.startsWith('enroll request')) {
-		List cmds = zigbee.enrollResponse()
-		log.debug "enroll response: ${cmds}"
-		result = cmds?.collect { new physicalgraph.device.HubAction(it) }
-	}
-	return result
-}
+        case '0x0021': // Open/Motion/Wet
+			if (garageSensor != "Yes"){
+				resultMap = getContactResult('open')
+			}
+        break
 
-private List<Map> handleAcceleration(descMap) {
-	def result = []
-	if (descMap.clusterInt == 0xFC02 && descMap.attrInt == 0x0010) {
-		def value = descMap.value == "01" ? "active" : "inactive"
-		log.debug "Acceleration $value"
-		result << [
-				name           : "acceleration",
-				value          : value,
-				descriptionText: "{{ device.displayName }} was $value",
-				isStateChange  : isStateChange(device, "acceleration", value),
-				translatable   : true
-		]
+        case '0x0022': // Tamper Alarm
+        break
 
-		if (descMap.additionalAttrs) {
-			result += parseAxis(descMap.additionalAttrs)
-		}
-	} else if (descMap.clusterInt == 0xFC02 && descMap.attrInt == 0x0012) {
-		def addAttrs = descMap.additionalAttrs
-		addAttrs << ["attrInt": descMap.attrInt, "value": descMap.value]
-		result += parseAxis(addAttrs)
-	}
-	return result
-}
+        case '0x0023': // Battery Alarm
+        break
 
-private List<Map> parseAxis(List<Map> attrData) {
-	def results = []
-	def x = hexToSignedInt(attrData.find { it.attrInt == 0x0012 }?.value)
-	def y = hexToSignedInt(attrData.find { it.attrInt == 0x0013 }?.value)
-	def z = hexToSignedInt(attrData.find { it.attrInt == 0x0014 }?.value)
+        case '0x0024': // Supervision Report
+			if (garageSensor != "Yes"){
+				resultMap = getContactResult('closed')
+			}
+        break
 
-	def xyzResults = [:]
-	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
-	}
+        case '0x0025': // Restore Report
+			if (garageSensor != "Yes"){
+				resultMap = getContactResult('open')
+			}
+        break
 
-	log.debug "parseAxis -- ${xyzResults}"
+        case '0x0026': // Trouble/Failure
+        break
 
-	if (garageSensor == "Yes")
-		results += garageEvent(xyzResults.z)
-
-	def value = "${xyzResults.x},${xyzResults.y},${xyzResults.z}"
-	results << [
-			name           : "threeAxis",
-			value          : value,
-			linkText       : getLinkText(device),
-			descriptionText: "${getLinkText(device)} was ${value}",
-			handlerName    : name,
-			isStateChange  : isStateChange(device, "threeAxis", value),
-			displayed      : false
-	]
-	results
-}
-
-private List<Map> parseIasMessage(String description) {
-	ZoneStatus zs = zigbee.parseZoneStatus(description)
-	List<Map> results = []
-
-	if (garageSensor != "Yes") {
-		def value = zs.isAlarm1Set() ? 'open' : 'closed'
-		log.debug "Contact: ${device.displayName} value = ${value}"
-		def descriptionText = value == 'open' ? '{{ device.displayName }} was opened' : '{{ device.displayName }} was closed'
-		results << [name: 'contact', value: value, descriptionText: descriptionText, displayed: false, translatable: true]
-		results << [name: 'status', value: value, descriptionText: descriptionText, translatable: true]
-	}
-
-	return results
-}
-
-private Map getBatteryResult(rawValue) {
-	log.debug "Battery rawValue = ${rawValue}"
-
-	def result = [:]
-
-	def volts = rawValue / 10
-
-	if (!(rawValue == 0 || rawValue == 255)) {
-		result.name = 'battery'
-		result.translatable = true
-		result.descriptionText = "{{ device.displayName }} battery was {{ 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
-
-			if (volts < minVolts)
-				volts = minVolts
-			else if (volts > maxVolts)
-				volts = maxVolts
-			def pct = batteryMap[volts]
-			result.value = pct
-		} else {
-			def minVolts = 2.1
-			def maxVolts = 3.0
-			def pct = (volts - minVolts) / (maxVolts - minVolts)
-			def roundedPct = Math.round(pct * 100)
-			if (roundedPct <= 0)
-				roundedPct = 1
-			result.value = Math.min(100, roundedPct)
-		}
-	}
-
-	return result
-}
-
-List<Map> garageEvent(zValue) {
-	List<Map> results = []
-	def absValue = zValue.abs()
-	def contactValue = null
-	def garageValue = null
-	if (absValue > 900) {
-		contactValue = 'closed'
-		garageValue = 'garage-closed'
-	} else if (absValue < 100) {
-		contactValue = 'open'
-		garageValue = 'garage-open'
-	}
-	if (contactValue != null) {
-		def descriptionText = contactValue == 'open' ? '{{ device.displayName }} was opened' : '{{ device.displayName }} was closed'
-		results << [name: 'contact', value: contactValue, descriptionText: descriptionText, displayed: false, translatable: true]
-		results << [name: 'status', value: garageValue, descriptionText: descriptionText, translatable: true]
-	}
-	results
-}
-
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	return zigbee.readAttribute(0x001, 0x0020) // Read the Battery Level
-}
-
-def refresh() {
-	log.debug "Refreshing Values "
-
-	def refreshCmds = zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
-			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) +
-			zigbee.readAttribute(0xFC02, 0x0010, [mfgCode: manufacturerCode]) +
-			zigbee.enrollResponse()
-
-	return refreshCmds
-}
-
-def configure() {
-	// Device-Watch allows 2 check-in misses from device + ping (plus 1 min lag time)
-	// enrolls with default periodic reporting until newer 5 min interval is confirmed
-	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-
-	log.debug "Configuring Reporting"
-	def configCmds = []
-
-	if (device.getDataValue("manufacturer") == "SmartThings") {
-		log.debug "Refreshing Values for manufacturer: SmartThings "
-		/* These values of Motion Threshold Multiplier(0x01) and Motion Threshold (0x0276)
-            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.
-        */
-		configCmds += zigbee.writeAttribute(0xFC02, 0x0000, 0x20, 0x01, [mfgCode: manufacturerCode])
-		configCmds += zigbee.writeAttribute(0xFC02, 0x0002, 0x21, 0x0276, [mfgCode: manufacturerCode])
-	} else {
-		// Write a motion threshold of 2 * .063g = .126g
-		// Currently due to a Centralite firmware issue, this will cause a read attribute response that
-		// indicates acceleration even when there isn't.
-		configCmds += zigbee.writeAttribute(0xFC02, 0x0000, 0x20, 0x02, [mfgCode: manufacturerCode])
-	}
-
-	// temperature minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
-	// battery minReport 30 seconds, maxReportTime 6 hrs by default
-	configCmds += zigbee.batteryConfig() +
-			zigbee.temperatureConfig(30, 300) +
-			zigbee.configureReporting(0xFC02, 0x0010, DataType.BITMAP8, 10, 3600, 0x01, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0012, DataType.INT16, 1, 3600, 0x0001, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0013, DataType.INT16, 1, 3600, 0x0001, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0014, DataType.INT16, 1, 3600, 0x0001, [mfgCode: manufacturerCode])
-
-	return refresh() + configCmds
+        case '0x0028': // Test Mode
+        break
+    }
+    return resultMap
 }
 
 def updated() {
@@ -356,33 +262,286 @@ 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, translatable: true)
-		} else if (device.latestValue("status") == "closed") {
-			sendEvent(name: 'status', value: 'garage-closed', descriptionText: descriptionText, translatable: true)
+			sendEvent(name: 'status', value: 'garage-open', descriptionText: descriptionText)
 		}
-	} else {
+		else if (device.latestValue("status") == "closed") {
+			sendEvent(name: 'status', value: 'garage-closed', descriptionText: descriptionText)
+		}
+	}
+	else {
 		def descriptionText = "Updating device to open/close sensor"
 		if (device.latestValue("status") == "garage-open") {
-			sendEvent(name: 'status', value: 'open', descriptionText: descriptionText, translatable: true)
-		} else if (device.latestValue("status") == "garage-closed") {
-			sendEvent(name: 'status', value: 'closed', descriptionText: descriptionText, translatable: true)
+			sendEvent(name: 'status', value: 'open', descriptionText: descriptionText)
+		}
+		else if (device.latestValue("status") == "garage-closed") {
+			sendEvent(name: 'status', value: 'closed', descriptionText: descriptionText)
 		}
 	}
 }
 
-private hexToSignedInt(hexVal) {
-	def unsignedVal = hexToInt(hexVal)
-	unsignedVal > 32767 ? unsignedVal - 65536 : unsignedVal
+def getTemperature(value) {
+	def celsius = Integer.parseInt(value, 16).shortValue() / 100
+	if(getTemperatureScale() == "C"){
+		return celsius
+		} else {
+			return celsiusToFahrenheit(celsius) as Integer
+		}
+	}
+
+	private Map getBatteryResult(rawValue) {
+		log.debug "Battery"
+        log.debug rawValue
+		def linkText = getLinkText(device)
+
+		def result = [
+		name: 'battery',
+        value: '--'
+		]
+
+		def volts = rawValue / 10
+		def descriptionText
+        
+        if (rawValue == 255) {}
+        else {
+		
+        if (volts > 3.5) {
+			result.descriptionText = "${linkText} battery has too much power (${volts} 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}%"
+		}}
+
+		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
+		}
+		def descriptionText = "${linkText} was ${value}°${temperatureScale}"
+		return [
+		name: 'temperature',
+		value: value,
+		descriptionText: descriptionText
+		]
+	}
+
+	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 = "$linkText 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",
+
+		"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"
+		]
+
+		return refreshCmds + enrollResponse()
+	}
+
+	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
+		"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}",
+		"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}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code 0x104E",
+		"zcl global send-me-a-report 0xFC02 0x0012 0x29 1 3600 {01}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code 0x104E",
+		"zcl global send-me-a-report 0xFC02 0x0013 0x29 1 3600 {01}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code 0x104E",
+		"zcl global send-me-a-report 0xFC02 0x0014 0x29 1 3600 {01}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
+
+		]
+   
+   return configCmds + refresh()
 }
 
-private getManufacturerCode() {
-	if (device.getDataValue("manufacturer") == "SmartThings") {
-		return "0x110A"
-	} else {
-		return "0x104E"
+private getEndpointId() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+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 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)
+        }
+    }
+
+	getXyzResult(xyzResults, description)
+}
+
+def garageEvent(zValue) {
+	def absValue = zValue.abs()
+	def contactValue = null
+	def garageValue = null
+	if (absValue>900) {
+		contactValue = 'closed'
+		garageValue = 'garage-closed'
 	}
+	else if (absValue < 100) {
+		contactValue = 'open'
+		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)
+	}
+}
+
+private Map getXyzResult(results, description) {
+	def name = "threeAxis"
+	def value = "${results.x},${results.y},${results.z}"
+	def linkText = getLinkText(device)
+	def descriptionText = "$linkText was $value"
+	def isStateChange = isStateChange(device, name, value)
+
+	[
+		name: name,
+		value: value,
+		unit: null,
+		linkText: linkText,
+		descriptionText: descriptionText,
+		handlerName: name,
+		isStateChange: isStateChange,
+		displayed: false
+	]
 }
 
 private hexToInt(value) {
 	new BigInteger(value, 16)
 }
+
+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/smartthings/smartsense-multi.src/smartsense-multi.groovy

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

@@ -0,0 +1,360 @@
+/**
+ *  SmartSense Open/Closed Accelerometer Sensor
+ *
+ *  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:
+ *
+ *      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: "SmartSense Open/Closed Accelerometer Sensor", namespace: "smartthings", author: "SmartThings") {
+ 		capability "Battery"
+ 		capability "Configuration"
+ 		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"
+ 	}
+
+ 	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 "tempOffset", "number", title: "Temperature Offset", description: "Adjust temperature by this many degrees", range: "*..*", displayDuringSetup: false
+ 	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name:"contact", type: "generic", width: 6, height: 4){
+			tileAttribute ("device.contact", 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"
+			}
+		}
+		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")
+		}
+		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", 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"
+		}
+
+		main (["contact", "acceleration", "temperature"])
+		details(["contact", "acceleration", "temperature", "battery", "refresh"])
+	}
+ }
+
+ 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: ')) {
+ 		map = parseCustomMessage(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
+ }
+
+ 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
+
+ 			case 0xFC02:
+ 			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 int getHumidity(value) {
+	return Math.round(Double.parseDouble(value))
+}
+
+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)
+		resultMap = getTemperatureResult(value)
+	}
+	else if (descMap.cluster == "FC02" && descMap.attrId == "0002") {
+		Integer.parseInt(descMap.value,8)
+	}
+	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: ')) {
+		def value = zigbee.parseHATemperatureValue(description, "temperature: ", getTemperatureScale())
+		resultMap = getTemperatureResult(value)
+	}
+	return resultMap
+}
+
+private Map parseIasMessage(String description) {
+	List parsedMsg = description.split(' ')
+	String msgCode = parsedMsg[2]
+
+	Map resultMap = [:]
+	switch(msgCode) {
+        case '0x0020': // Closed/No Motion/Dry
+        resultMap = getContactResult('closed')
+        break
+
+        case '0x0021': // Open/Motion/Wet
+        resultMap = getContactResult('open')
+        break
+
+        case '0x0022': // Tamper Alarm
+        break
+
+        case '0x0023': // Battery Alarm
+        break
+
+        case '0x0024': // Supervision Report
+        resultMap = getContactResult('closed')
+        break
+
+        case '0x0025': // Restore Report
+        resultMap = getContactResult('open')
+        break
+
+        case '0x0026': // Trouble/Failure
+        break
+
+        case '0x0028': // Test Mode
+        break
+    }
+    return resultMap
+}
+
+def getTemperature(value) {
+	def celsius = Integer.parseInt(value, 16).shortValue() / 100
+	if(getTemperatureScale() == "C"){
+		return celsius
+		} else {
+			return celsiusToFahrenheit(celsius) as Integer
+		}
+	}
+
+	private Map getBatteryResult(rawValue) {
+		log.debug 'Battery'
+		def linkText = getLinkText(device)
+
+		def result = [
+		name: 'battery'
+		]
+
+		def volts = rawValue / 10
+		def descriptionText
+		if (volts > 3.5) {
+			result.descriptionText = "${linkText} battery has too much power (${volts} 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}%"
+		}
+
+		return result
+	}
+
+	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}"
+		return [
+		name: 'temperature',
+		value: value,
+		descriptionText: descriptionText
+		]
+	}
+
+	private Map getContactResult(value) {
+		log.debug 'Contact Status'
+		def linkText = getLinkText(device)
+		def descriptionText = "${linkText} was ${value == 'open' ? 'opened' : 'closed'}"
+		return [
+		name: 'contact',
+		value: value,
+		descriptionText: descriptionText
+		]
+	}
+
+	private getAccelerationResult(numValue) {
+		def name = "acceleration"
+		def value = numValue.endsWith("1") ? "active" : "inactive"
+		//def linkText = getLinkText(device)
+		def descriptionText = "$linkText was $value"
+		def isStateChange = isStateChange(device, name, value)
+		[
+			name: name,
+			value: value,
+			//unit: null,
+			//linkText: linkText,
+			descriptionText: descriptionText,
+			//handlerName: value,
+			isStateChange: isStateChange
+		//	displayed: displayed(description, isStateChange)
+		]
+	}
+
+	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 0xFC02 2", "delay 200",
+		"st rattr 0x${device.deviceNetworkId} 1 1 0x20", "delay 200"
+
+		]
+
+		return refreshCmds + enrollResponse()
+	}
+
+def configure() {
+
+	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
+	log.debug "Configuring Reporting, IAS CIE, and Bindings."
+	def configCmds = [
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 1 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}",		//checkin time 6 hrs
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"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 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0xFC02 {${device.zigbeeId}} {}", "delay 500",
+		"zcl global send-me-a-report 0xFC02 2 0x18 30 3600 {01}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
+	]
+	return configCmds + refresh() // send refresh cmds as part of config
+}
+
+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() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+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/smartthings/smartsense-open-closed-sensor.src/.st-ignore

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

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

@@ -1,42 +0,0 @@
-# Smartsense Open/Closed Sensor
-
-Local Execution on V2 Hubs
-
-Works with: 
-
-* [Samsung SmartThings Open/Closed Sensor](https://shop.smartthings.com/#!/packs/smartsense-open-closed-sensor/)
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health](#device-health)
-* [Battery](#battery-specification)
-
-## Capabilities
-
-* **Configuration** - _configure()_ command called when device is installed or device preferences updated
-* **Battery** - defines device uses a battery
-* **Contact Sensor** - can detect contact (possible values: open,closed)
-* **Refresh** - _refresh()_ command for status updates
-* **Temperature Measurement** - defines device measures current temperature
-* **Health Check** - indicates ability to get device health notifications
-* **Sensor** - detects sensor events
-
-## Device Health
-
-SmartSense Open Closed sensor with reporting interval of 5 mins.
-SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
-
-* V1, TV, HubV2 AppEngine < 1.5.1 - __121min__ checkInterval
-* HubV2 AppEngine 1.5.1 - __12min__ checkInterval
-
-## Battery Specification
-
-One CR2 3V battery required.
-
-## Troubleshooting
-
-If the sensor doesn't pair when trying from the SmartThings mobile app, it is possible that the sensor is out of range.
-Pairing needs to be tried again by placing the sensor closer to the hub.
-Instructions related to pairing, resetting and removing the sensor from SmartThings can be found in the following link:
-* [SmartSense Open/Closed Sensor Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/202836844-SmartSense-Open-Closed-Sensor)

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

@@ -13,163 +13,317 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-import physicalgraph.zigbee.clusters.iaszone.ZoneStatus
-
+ 
 metadata {
-	definition(name: "SmartSense Open/Closed Sensor", namespace: "smartthings", author: "SmartThings") {
-		capability "Battery"
+	definition (name: "SmartSense Open/Closed Sensor", namespace: "smartthings", author: "SmartThings") {
+    	capability "Battery"
 		capability "Configuration"
-		capability "Contact Sensor"
+        capability "Contact Sensor"
 		capability "Refresh"
 		capability "Temperature Measurement"
-		capability "Health Check"
-		capability "Sensor"
-
-		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,0020,0402,0500,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3320-L", deviceJoinName: "Iris Contact Sensor"
+        fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3300"
 	}
-
+ 
 	simulator {
-
+ 
 	}
 
 	preferences {
-		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
+		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
 	}
-
+ 
 	tiles(scale: 2) {
-		multiAttributeTile(name: "contact", type: "generic", width: 6, height: 4) {
-			tileAttribute("device.contact", 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"
+		multiAttributeTile(name:"contact", type: "generic", width: 6, height: 4){
+			tileAttribute ("device.contact", 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"
 			}
 		}
 
 		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"]
-					]
+			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: ""
+			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"
+			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 
-		main(["contact", "temperature"])
-		details(["contact", "temperature", "battery", "refresh"])
+		main (["contact", "temperature"])
+		details(["contact","temperature","battery","refresh"])
 	}
 }
-
+ 
 def parse(String description) {
 	log.debug "description: $description"
-
-	Map map = zigbee.getEvent(description)
-	if (!map) {
-		if (description?.startsWith('zone status')) {
-			map = parseIasMessage(description)
-		} else {
-			Map descMap = zigbee.parseDescriptionAsMap(description)
-			if (descMap?.clusterInt == 0x0001 && descMap.commandInt != 0x07 && descMap?.value) {
-				map = getBatteryResult(Integer.parseInt(descMap.value, 16))
-			} else if (descMap?.clusterInt == zigbee.TEMPERATURE_MEASUREMENT_CLUSTER && descMap.commandInt == 0x07) {
-				if (descMap.data[0] == "00") {
-					log.debug "TEMP REPORTING CONFIG RESPONSE: $descMap"
-					sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-				} else {
-					log.warn "TEMP REPORTING CONFIG FAILED- error code: ${descMap.data[0]}"
-				}
-			}
-		}
+    
+	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)
+    }
+ 
 	log.debug "Parse returned $map"
-	def result = map ? createEvent(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
+}
+ 
+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
 
-	if (description?.startsWith('enroll request')) {
-		List cmds = zigbee.enrollResponse()
-		log.debug "enroll response: ${cmds}"
-		result = cmds?.collect { new physicalgraph.device.HubAction(it) }
-	}
-	return result
+            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 int getHumidity(value) {
+    return Math.round(Double.parseDouble(value))
+}
+ 
+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)
+		resultMap = getTemperatureResult(value)
+	}
+	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: ')) {
+		def value = zigbee.parseHATemperatureValue(description, "temperature: ", getTemperatureScale())
+		resultMap = getTemperatureResult(value)
+	}
+	return resultMap
+}
 
 private Map parseIasMessage(String description) {
-	ZoneStatus zs = zigbee.parseZoneStatus(description)
-	return zs.isAlarm1Set() ? getContactResult('open') : getContactResult('closed')
+    List parsedMsg = description.split(' ')
+    String msgCode = parsedMsg[2]
+    
+    Map resultMap = [:]
+    switch(msgCode) {
+        case '0x0020': // Closed/No Motion/Dry
+        	resultMap = getContactResult('closed')
+            break
+
+        case '0x0021': // Open/Motion/Wet
+        	resultMap = getContactResult('open')
+            break
+
+        case '0x0022': // Tamper Alarm
+            break
+
+        case '0x0023': // Battery Alarm
+            break
+
+        case '0x0024': // Supervision Report
+        	resultMap = getContactResult('closed')
+            break
+
+        case '0x0025': // Restore Report
+        	resultMap = getContactResult('open')
+            break
+
+        case '0x0026': // Trouble/Failure
+            break
+
+        case '0x0028': // Test Mode
+            break
+    }
+    return resultMap
+}
+ 
+def getTemperature(value) {
+	def celsius = Integer.parseInt(value, 16).shortValue() / 100
+	if(getTemperatureScale() == "C"){
+		return celsius
+	} else {
+		return celsiusToFahrenheit(celsius) as Integer
+	}
 }
 
 private Map getBatteryResult(rawValue) {
 	log.debug 'Battery'
 	def linkText = getLinkText(device)
-
-    def result = [:]
-
+    
+    def result = [
+    	name: 'battery'
+    ]
+    
 	def volts = rawValue / 10
-	if (!(rawValue == 0 || rawValue == 255)) {
+	def descriptionText
+	if (volts > 3.5) {
+		result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
+	}
+	else {
 		def minVolts = 2.1
-		def maxVolts = 3.0
+    	def maxVolts = 3.0
 		def pct = (volts - minVolts) / (maxVolts - minVolts)
-		def roundedPct = Math.round(pct * 100)
-		if (roundedPct <= 0)
-			roundedPct = 1
-		result.value = Math.min(100, roundedPct)
+		result.value = Math.min(100, (int) pct * 100)
 		result.descriptionText = "${linkText} battery was ${result.value}%"
-		result.name = 'battery'
 	}
 
 	return result
 }
 
+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}"
+	return [
+		name: 'temperature',
+		value: value,
+		descriptionText: descriptionText
+	]
+}
+
 private Map getContactResult(value) {
 	log.debug 'Contact Status'
 	def linkText = getLinkText(device)
 	def descriptionText = "${linkText} was ${value == 'open' ? 'opened' : 'closed'}"
 	return [
-			name           : 'contact',
-			value          : value,
-			descriptionText: descriptionText
+		name: 'contact',
+		value: value,
+		descriptionText: descriptionText
 	]
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	return zigbee.readAttribute(0x001, 0x0020) // Read the Battery Level
-}
-
 def refresh() {
 	log.debug "Refreshing Temperature and Battery"
-	def refreshCmds = zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
-			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020)
+	def refreshCmds = [
+        "st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+		"st rattr 0x${device.deviceNetworkId} 1 1 0x20", "delay 200"
+	]
 
-	return refreshCmds + zigbee.enrollResponse()
+	return refreshCmds + enrollResponse()
 }
 
 def configure() {
-	// Device-Watch allows 2 check-in misses from device + ping (plus 1 min lag time)
-	// enrolls with default periodic reporting until newer 5 min interval is confirmed
-	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 
+	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting, IAS CIE, and Bindings."
+	def configCmds = [
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 500",
 
-	// temperature minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
-	// battery minReport 30 seconds, maxReportTime 6 hrs by default
-	return refresh() + zigbee.batteryConfig() + zigbee.temperatureConfig(30, 300) // send refresh cmds as part of config
+		"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",
+
+		"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"
+	]
+    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() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+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/smartthings/smartsense-temp-humidity-sensor.src/.st-ignore

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

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

@@ -1,42 +0,0 @@
-# SmartSense Temp/Humidity Sensor
-
-Local Execution on V2 Hubs
-
-Works with: 
-
-* [Samsung SmartSense Temp/Humidity Sensor](https://shop.smartthings.com/#!/products/smartsense-temp-humidity-sensor)
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health](#device-health)
-* [Battery](#battery-specification)
-
-## Capabilities
-
-* **Configuration** - _configure()_ command called when device is installed or device preferences updated
-* **Battery** - defines device uses a battery
-* **Relative Humidity Measurement** - defines device measures relative humidity
-* **Refresh** - _refresh()_ command for status updates
-* **Temperature Measurement** - defines device measures current temperature
-* **Health Check** - indicates ability to get device health notifications
-* **Sensor** - detects sensor events
-
-## Device Health
-
-SmartSense Temp/Humidity Sensor with reporting interval of 5 mins.
-SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
-
-* V1, TV, HubV2 AppEngine < 1.5.1 - __121min__ checkInterval
-* HubV2 AppEngine 1.5.1 - __12min__ checkIntervalr 5 min interval is confirmed
-
-## Battery Specification
-
-One CR2 battery is required.
-
-## Troubleshooting
-
-If the sensor doesn't pair when trying from the SmartThings mobile app, it is possible that the sensor is out of range.
-Pairing needs to be tried by placing the sensor closer to the hub.
-Instructions related to pairing, resetting and removing the sensor from SmartThings can be found in the following link:
-* [Troubleshooting Tips](https://support.smartthings.com/hc/en-us/articles/203040294)

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

@@ -13,17 +13,13 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-import physicalgraph.zigbee.zcl.DataType
-
 metadata {
-	definition(name: "SmartSense Temp/Humidity Sensor", namespace: "smartthings", author: "SmartThings") {
+	definition (name: "SmartSense Temp/Humidity Sensor",namespace: "smartthings", author: "SmartThings") {
 		capability "Configuration"
 		capability "Battery"
 		capability "Refresh"
 		capability "Temperature Measurement"
 		capability "Relative Humidity Measurement"
-		capability "Health Check"
-		capability "Sensor"
 
 		fingerprint endpointId: "01", inClusters: "0001,0003,0020,0402,0B05,FC45", outClusters: "0019,0003"
 	}
@@ -33,37 +29,37 @@ metadata {
 		status 'H 45': 'catchall: 0104 FC45 01 01 0140 00 D9B9 00 04 C2DF 0A 01 0000218911'
 		status 'H 57': 'catchall: 0104 FC45 01 01 0140 00 4E55 00 04 C2DF 0A 01 0000211316'
 		status 'H 53': 'catchall: 0104 FC45 01 01 0140 00 20CD 00 04 C2DF 0A 01 0000219814'
-		status 'H 43': 'read attr - raw: BF7601FC450C00000021A410, dni: BF76, endpoint: 01, cluster: FC45, size: 0C, attrId: 0000, result: success, encoding: 21, value: 10a4'
+		status 'H 43':  'read attr - raw: BF7601FC450C00000021A410, dni: BF76, endpoint: 01, cluster: FC45, size: 0C, attrId: 0000, result: success, encoding: 21, value: 10a4'
 	}
 
 	preferences {
-		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
+		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
 	}
 
 	tiles(scale: 2) {
-		multiAttributeTile(name: "temperature", type: "generic", width: 6, height: 4) {
-			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
-				attributeState "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"]
-						]
+		multiAttributeTile(name:"temperature", type: "generic", width: 6, height: 4){
+			tileAttribute ("device.temperature", key: "PRIMARY_CONTROL") {
+				attributeState "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", inactiveLabel: false, width: 2, height: 2) {
-			state "humidity", label: '${currentValue}% humidity', unit: ""
+			state "humidity", label:'${currentValue}% humidity', unit:""
 		}
 		valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false, width: 2, height: 2) {
-			state "battery", label: '${currentValue}% battery'
+			state "battery", label:'${currentValue}% battery'
 		}
 		standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", action: "refresh.refresh", icon: "st.secondary.refresh"
+			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
 		}
 
 		main "temperature", "humidity"
@@ -74,75 +70,222 @@ metadata {
 def parse(String description) {
 	log.debug "description: $description"
 
-	// getEvent will handle temperature and humidity
-	Map map = zigbee.getEvent(description)
-	if (!map) {
-		Map descMap = zigbee.parseDescriptionAsMap(description)
-		if (descMap.clusterInt == 0x0001 && descMap.commandInt != 0x07 && descMap?.value) {
-			map = getBatteryResult(Integer.parseInt(descMap.value, 16))
-		} else if (descMap?.clusterInt == zigbee.TEMPERATURE_MEASUREMENT_CLUSTER && descMap.commandInt == 0x07) {
-			if (descMap.data[0] == "00") {
-				log.debug "TEMP REPORTING CONFIG RESPONSE: $descMap"
-				sendEvent(name: "checkInterval", value: 60 * 12, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-			} else {
-				log.warn "TEMP REPORTING CONFIG FAILED- error code: ${descMap.data[0]}"
-			}
-		}
+	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 "Parse returned $map"
-	return map ? createEvent(map) : [:]
+	return map ? createEvent(map) : null
+}
+
+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
+
+            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 0xFC45:
+                String pctStr = cluster.data[-1, -2].collect { Integer.toHexString(it) }.join('')
+                String display = Math.round(Integer.valueOf(pctStr, 16) / 100)
+                resultMap = getHumidityResult(display)
+                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 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)
+		resultMap = getTemperatureResult(value)
+	}
+	else if (descMap.cluster == "0001" && descMap.attrId == "0020") {
+		resultMap = getBatteryResult(Integer.parseInt(descMap.value, 16))
+	}
+	else if (descMap.cluster == "FC45" && descMap.attrId == "0000") {
+		def value = getReportAttributeHumidity(descMap.value)
+		resultMap = getHumidityResult(value)
+	}
+
+	return resultMap
+}
+
+def getReportAttributeHumidity(String value) {
+    def humidity = null
+    if (value?.trim()) {
+        try {
+        	// value is hex with no decimal
+            def pct = Integer.parseInt(value.trim(), 16) / 100
+            humidity = String.format('%.0f', pct)
+        } catch(NumberFormatException nfe) {
+            log.debug "Error converting $value to humidity"
+        }
+    }
+    return humidity
+}
+
+private Map parseCustomMessage(String description) {
+	Map resultMap = [:]
+	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
+}
+
+def getTemperature(value) {
+	def celsius = Integer.parseInt(value, 16).shortValue() / 100
+	if(getTemperatureScale() == "C"){
+		return celsius
+	} else {
+		return celsiusToFahrenheit(celsius) as Integer
+	}
 }
 
 private Map getBatteryResult(rawValue) {
 	log.debug 'Battery'
 	def linkText = getLinkText(device)
 
-  def result = [:]
+    def result = [
+    	name: 'battery'
+    ]
 
 	def volts = rawValue / 10
-	if (!(rawValue == 0 || rawValue == 255)) {
+	def descriptionText
+	if (volts > 3.5) {
+		result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
+	}
+	else {
 		def minVolts = 2.1
-		def maxVolts = 3.0
+    	def maxVolts = 3.0
 		def pct = (volts - minVolts) / (maxVolts - minVolts)
-		def roundedPct = Math.round(pct * 100)
-		if (roundedPct <= 0)
-			roundedPct = 1
-		result.value = Math.min(100, roundedPct)
+		result.value = Math.min(100, (int) pct * 100)
 		result.descriptionText = "${linkText} battery was ${result.value}%"
-		result.name = 'battery'
-
 	}
 
 	return result
 }
 
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	return zigbee.readAttribute(0x0001, 0x0020) // Read the Battery Level
+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}"
+	return [
+		name: 'temperature',
+		value: value,
+		descriptionText: descriptionText
+	]
 }
 
-def refresh() {
+private Map getHumidityResult(value) {
+	log.debug 'Humidity'
+	return [
+		name: 'humidity',
+		value: value,
+		unit: '%'
+	]
+}
+
+def refresh()
+{
 	log.debug "refresh temperature, humidity, and battery"
-	return zigbee.readAttribute(0xFC45, 0x0000, ["mfgCode": 0x104E]) +   // New firmware
-			zigbee.readAttribute(0xFC45, 0x0000, ["mfgCode": 0xC2DF]) +   // Original firmware
-			zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
-			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) +
-			zigbee.configureReporting(0xFC45, 0x0000, DataType.INT16, 30, 3600, 100) +
-			zigbee.batteryConfig() +
-			zigbee.temperatureConfig(30, 300)
+	[
+
+		"zcl mfg-code 0xC2DF", "delay 1000",
+		"zcl global read 0xFC45 0", "delay 1000",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 1000",
+        "st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+        "st rattr 0x${device.deviceNetworkId} 1 1 0x20"
+
+	]
 }
 
 def configure() {
-	// Device-Watch allows 2 check-in misses from device + ping (plus 1 min lag time)
-	// enrolls with default periodic reporting until newer 5 min interval is confirmed
-	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 1 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 
 	log.debug "Configuring Reporting and Bindings."
+	def configCmds = [
+		"zdo bind 0x${device.deviceNetworkId} 1 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",
 
-	// temperature minReportTime 30 seconds, maxReportTime 5 min. Reporting interval if no activity
-	// battery minReport 30 seconds, maxReportTime 6 hrs by default
-	return refresh()
+		"zdo bind 0x${device.deviceNetworkId} 1 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",
+
+		"zdo bind 0x${device.deviceNetworkId} 1 1 0xFC45 {${device.zigbeeId}} {}", "delay 500",
+		"zcl global send-me-a-report 0xFC45 0 0x29 30 3600 {6400}",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 500"
+	]
+	return configCmds + refresh() // send refresh cmds as part of config
+}
+
+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/smartthings/smartsense-virtual-open-closed.src/smartsense-virtual-open-closed.groovy

@@ -45,8 +45,8 @@ metadata {
 	}
     
 	preferences {
-		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
+		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
 	}    
 
 	tiles {