Modifying 'Laundry Monitor Using Power Meter'

.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,514 +0,0 @@
-// keen home smart vent
-// http://www.keenhome.io
-// SmartThings Device Handler v1.0.0
-
-metadata {
-    definition (name: "Keen Home Smart Vent", namespace: "Keen Home", author: "Keen Home") {
-        capability "Switch Level"
-        capability "Switch"
-        capability "Configuration"
-        capability "Refresh"
-        capability "Sensor"
-        capability "Temperature Measurement"
-        capability "Battery"
-
-        command "getLevel"
-        command "getOnOff"
-        command "getPressure"
-        command "getBattery"
-        command "getTemperature"
-        command "setZigBeeIdTile"
-        command "clearObstruction"
-
-        fingerprint endpoint: "1",
-        profileId: "0104",
-        inClusters: "0000,0001,0003,0004,0005,0006,0008,0020,0402,0403,0B05,FC01,FC02",
-        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"
-    }
-
-    // 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"
-        }
-        controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false) {
-            state "level", action:"switch level.setLevel"
-        }
-        standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat") {
-            state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-        valueTile("temperature", "device.temperature", inactiveLabel: 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("battery", "device.battery", inactiveLabel: false, decoration: "flat") {
-            state "battery", label: 'Battery \n${currentValue}%', backgroundColor:"#ffffff"
-        }
-        valueTile("zigbeeId", "device.zigbeeId", inactiveLabel: true, decoration: "flat") {
-            state "serial", label:'${currentValue}', backgroundColor:"#ffffff"
-        }
-        main "switch"
-        details(["switch","refresh","temperature","levelSliderControl","battery"])
-    }
-}
-
-/**** PARSE METHODS ****/
-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)
-    }
-    else if (description?.startsWith('on/off: ')) {
-        map = parseOnOffMessage(description)
-    }
-
-    log.debug "Parse returned $map"
-    return map ? createEvent(map) : null
-}
-
-private Map parseCatchAllMessage(String description) {
-    log.debug "parseCatchAllMessage"
-
-    def cluster = zigbee.parse(description)
-    log.debug "cluster: ${cluster}"
-    if (shouldProcessMessage(cluster)) {
-        log.debug "processing message"
-        switch(cluster.clusterId) {
-            case 0x0001:
-                return makeBatteryResult(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 = convertTemperatureHex(temp)
-                return makeTemperatureResult(value)
-                break
-
-            case 0x0006:
-                return makeOnOffResult(cluster.data[-1])
-                break
-        }
-    }
-
-    return [:]
-}
-
-private boolean shouldProcessMessage(cluster) {
-    // 0x0B is default response indicating message got through
-    // 0x07 is bind message
-    if (cluster.profileId != 0x0104 ||
-        cluster.command == 0x0B ||
-        cluster.command == 0x07 ||
-        (cluster.data.size() > 0 && cluster.data.first() == 0x3e)) {
-        return false
-    }
-
-    return true
-}
-
-private Map parseReportAttributeMessage(String description) {
-    log.debug "parseReportAttributeMessage"
-
-    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"
-
-    if (descMap.cluster == "0006" && descMap.attrId == "0000") {
-        return makeOnOffResult(Int.parseInt(descMap.value));
-    }
-    else if (descMap.cluster == "0008" && descMap.attrId == "0000") {
-        return makeLevelResult(descMap.value)
-    }
-    else if (descMap.cluster == "0402" && descMap.attrId == "0000") {
-        def value = convertTemperatureHex(descMap.value)
-        return makeTemperatureResult(value)
-    }
-    else if (descMap.cluster == "0001" && descMap.attrId == "0021") {
-        return makeBatteryResult(Integer.parseInt(descMap.value, 16))
-    }
-    else if (descMap.cluster == "0403" && descMap.attrId == "0020") {
-        return makePressureResult(Integer.parseInt(descMap.value, 16))
-    }
-    else if (descMap.cluster == "0000" && descMap.attrId == "0006") {
-        return makeSerialResult(new String(descMap.value.decodeHex()))
-    }
-
-    // shouldn't get here
-    return [:]
-}
-
-private Map parseCustomMessage(String description) {
-    Map resultMap = [:]
-    if (description?.startsWith('temperature: ')) {
-        // log.debug "${description}"
-        // def value = zigbee.parseHATemperatureValue(description, "temperature: ", getTemperatureScale())
-        // log.debug "split: " + description.split(": ")
-        def value = Double.parseDouble(description.split(": ")[1])
-        // log.debug "${value}"
-        resultMap = makeTemperatureResult(convertTemperature(value))
-    }
-    return resultMap
-}
-
-private Map parseOnOffMessage(String description) {
-    Map resultMap = [:]
-    if (description?.startsWith('on/off: ')) {
-        def value = Integer.parseInt(description - "on/off: ")
-        resultMap = makeOnOffResult(value)
-    }
-    return resultMap
-}
-
-private Map makeOnOffResult(rawValue) {
-    log.debug "makeOnOffResult: ${rawValue}"
-    def linkText = getLinkText(device)
-    def value = rawValue == 1 ? "on" : "off"
-    return [
-        name: "switch",
-        value: value,
-        descriptionText: "${linkText} is ${value}"
-    ]
-}
-
-private Map makeLevelResult(rawValue) {
-    def linkText = getLinkText(device)
-    def value = Integer.parseInt(rawValue, 16)
-    def rangeMax = 254
-
-    // catch obstruction level
-    if (value == 255) {
-        log.debug "${linkText} is obstructed"
-        // Just return here. Once the vent is power cycled
-        // it will go back to the previous level before obstruction.
-        // Therefore, no need to update level on the display.
-        return [
-            name: "switch",
-            value: "obstructed",
-            descriptionText: "${linkText} is obstructed. Please power cycle."
-        ]
-    }
-
-    value = Math.floor(value / rangeMax * 100)
-
-    return [
-        name: "level",
-        value: value,
-        descriptionText: "${linkText} level is ${value}%"
-    ]
-}
-
-private Map makePressureResult(rawValue) {
-    log.debug 'makePressureResut'
-    def linkText = getLinkText(device)
-
-    def pascals = rawValue / 10
-    def result = [
-        name: 'pressure',
-        descriptionText: "${linkText} pressure is ${pascals}Pa",
-        value: pascals
-    ]
-
-    return result
-}
-
-private Map makeBatteryResult(rawValue) {
-    // log.debug 'makeBatteryResult'
-    def linkText = getLinkText(device)
-
-    // log.debug
-    [
-        name: 'battery',
-        value: rawValue,
-        descriptionText: "${linkText} battery is at ${rawValue}%"
-    ]
-}
-
-private Map makeTemperatureResult(value) {
-    // log.debug 'makeTemperatureResult'
-    def linkText = getLinkText(device)
-
-    // log.debug "tempOffset: ${tempOffset}"
-    if (tempOffset) {
-        def offset = tempOffset as int
-        // log.debug "offset: ${offset}"
-        def v = value as int
-        // log.debug "v: ${v}"
-        value = v + offset
-        // log.debug "value: ${value}"
-    }
-
-    return [
-        name: 'temperature',
-        value: "" + value,
-        descriptionText: "${linkText} is ${value}°${temperatureScale}",
-        unit: temperatureScale
-    ]
-}
-
-/**** HELPER METHODS ****/
-private def convertTemperatureHex(value) {
-    // log.debug "convertTemperatureHex(${value})"
-    def celsius = Integer.parseInt(value, 16).shortValue() / 100
-    // log.debug "celsius: ${celsius}"
-
-    return convertTemperature(celsius)
-}
-
-private def convertTemperature(celsius) {
-    // log.debug "convertTemperature()"
-
-    if(getTemperatureScale() == "C"){
-        return celsius
-    } else {
-        def fahrenheit = Math.round(celsiusToFahrenheit(celsius) * 100) /100
-        // log.debug "converted to F: ${fahrenheit}"
-        return fahrenheit
-    }
-}
-
-private def makeSerialResult(serial) {
-    log.debug "makeSerialResult: " + serial
-
-    def linkText = getLinkText(device)
-    sendEvent([
-        name: "serial",
-        value: serial,
-        descriptionText: "${linkText} has serial ${serial}" ])
-    return [
-        name: "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 on() {
-    def linkText = getLinkText(device)
-    log.debug "open ${linkText}"
-
-    // only change the state if the vent is not obstructed
-    if (device.currentValue("switch") == "obstructed") {
-        log.error("cannot open because ${linkText} is obstructed")
-        return
-    }
-
-    sendEvent(makeOnOffResult(1))
-    "st cmd 0x${device.deviceNetworkId} 1 6 1 {}"
-}
-
-def off() {
-    def linkText = getLinkText(device)
-    log.debug "close ${linkText}"
-
-    // only change the state if the vent is not obstructed
-    if (device.currentValue("switch") == "obstructed") {
-        log.error("cannot close because ${linkText} is obstructed")
-        return
-    }
-
-    sendEvent(makeOnOffResult(0))
-    "st cmd 0x${device.deviceNetworkId} 1 6 0 {}"
-}
-
-def clearObstruction() {
-    def linkText = getLinkText(device)
-    log.debug "attempting to clear ${linkText} obstruction"
-
-    sendEvent([
-        name: "switch",
-        value: "clearing",
-        descriptionText: "${linkText} is clearing obstruction"
-    ])
-
-    // send a move command to ensure level attribute gets reset for old, buggy firmware
-    // then send a reset to factory defaults
-    // finally re-configure to ensure reports and binding is still properly set after the rtfd
-    [
-        makeLevelCommand(device.currentValue("level")), "delay 500",
-        "st cmd 0x${device.deviceNetworkId} 1 0 0 {}", "delay 5000"
-    ] + configure()
-}
-
-def setLevel(value) {
-    log.debug "setting level: ${value}"
-    def linkText = getLinkText(device)
-
-    // only change the level if the vent is not obstructed
-    def currentState = device.currentValue("switch")
-
-    if (currentState == "obstructed") {
-        log.error("cannot set level because ${linkText} is obstructed")
-        return
-    }
-
-    sendEvent(name: "level", value: value)
-    if (value > 0) {
-        sendEvent(name: "switch", value: "on", descriptionText: "${linkText} is on by setting a level")
-    }
-    else {
-        sendEvent(name: "switch", value: "off", descriptionText: "${linkText} is off by setting level to 0")
-    }
-
-    makeLevelCommand(value)
-}
-
-def getOnOff() {
-    log.debug "getOnOff()"
-
-    // disallow on/off updates while vent is obstructed
-    if (device.currentValue("switch") == "obstructed") {
-        log.error("cannot update open/close status because ${getLinkText(device)} is obstructed")
-        return []
-    }
-
-    ["st rattr 0x${device.deviceNetworkId} 1 0x0006 0"]
-}
-
-def getPressure() {
-    log.debug "getPressure()"
-
-    // using a Keen Home specific attribute in the pressure measurement cluster
-    [
-        "zcl mfg-code 0x115B", "delay 200",
-        "zcl global read 0x0403 0x20", "delay 200",
-        "send 0x${device.deviceNetworkId} 1 1", "delay 200"
-    ]
-}
-
-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 []
-    }
-
-    ["st rattr 0x${device.deviceNetworkId} 1 0x0008 0x0000"]
-}
-
-def getTemperature() {
-    log.debug "getTemperature()"
-
-    ["st rattr 0x${device.deviceNetworkId} 1 0x0402 0"]
-}
-
-def getBattery() {
-    log.debug "getBattery()"
-
-    ["st rattr 0x${device.deviceNetworkId} 1 0x0001 0x0021"]
-}
-
-def setZigBeeIdTile() {
-    log.debug "setZigBeeIdTile() - ${device.zigbeeId}"
-
-    def linkText = getLinkText(device)
-
-    sendEvent([
-        name: "zigbeeId",
-        value: device.zigbeeId,
-        descriptionText: "${linkText} has zigbeeId ${device.zigbeeId}" ])
-    return [
-        name: "zigbeeId",
-        value: device.zigbeeId,
-        descriptionText: "${linkText} has zigbeeId ${device.zigbeeId}" ]
-}
-
-def refresh() {
-    getOnOff() +
-    getLevel() +
-    getTemperature() +
-    getPressure() +
-    getBattery()
-}
-
-def configure() {
-    log.debug "CONFIGURE"
-
-    // get ZigBee ID by hidden tile because that's the only way we can do it
-    setZigBeeIdTile()
-
-    def configCmds = [
-        // bind reporting clusters to hub
-        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0006 {${device.zigbeeId}} {}", "delay 500",
-        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0008 {${device.zigbeeId}} {}", "delay 500",
-        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0402 {${device.zigbeeId}} {}", "delay 500",
-        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0403 {${device.zigbeeId}} {}", "delay 500",
-        "zdo bind 0x${device.deviceNetworkId} 1 1 0x0001 {${device.zigbeeId}} {}", "delay 500"
-
-        // configure report commands
-        // zcl global send-me-a-report [cluster] [attr] [type] [min-interval] [max-interval] [min-change]
-
-        // report with these parameters is preconfigured in firmware, can be overridden here
-        // vent on/off state - type: boolean, change: 1
-        // "zcl global send-me-a-report 6 0 0x10 5 60 {01}", "delay 200",
-        // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-
-        // report with these parameters is preconfigured in firmware, can be overridden here
-        // vent level - type: int8u, change: 1
-        // "zcl global send-me-a-report 8 0 0x20 5 60 {01}", "delay 200",
-        // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-
-        // report with these parameters is preconfigured in firmware, can be overridden here
-        // temperature - type: int16s, change: 0xA = 10 = 0.1C
-        // "zcl global send-me-a-report 0x0402 0 0x29 60 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",
-
-        // report with these parameters is preconfigured in firmware, can be overridden here
-        // battery - type: int8u, change: 1
-        // "zcl global send-me-a-report 1 0x21 0x20 60 3600 {01}", "delay 200",
-        // "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-    ]
-
-    return configCmds + refresh()
-}

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-home-energy-meter-c3.src/aeon-home-energy-meter-c3.groovy

@@ -56,7 +56,7 @@ metadata {
 			state "configure", label: '', action: "configuration.configure", icon: "st.secondary.configure"
 		}
 
-		graphTile(name: "powerGraph", attribute: "device.power")
+		PLATFORM_graphTile(name: "powerGraph", attribute: "device.power")
 
 		main(["power", "energy"])
 		details(["powerGraph", "power", "energy", "reset", "refresh", "configure"])
@@ -68,8 +68,16 @@ metadata {
 // ========================================================
 
 preferences {
-	input name: "graphPrecision", type: "enum", title: "Graph Precision", description: "Daily", required: true, options: graphPrecisionOptions(), defaultValue: "Daily"
-	input name: "graphType", type: "enum", title: "Graph Type", description: "line", required: false, options: graphTypeOptions()
+	input name: "graphPrecision", type: "enum", title: "Graph Precision", description: "Daily", required: true, options: PLATFORM_graphPrecisionOptions(), defaultValue: "Daily"
+	input name: "graphType", type: "enum", title: "Graph Type", description: selectedGraphType(), required: false, options: PLATFORM_graphTypeOptions()
+}
+
+def selectedGraphPrecision() {
+	graphPrecision ?: "Daily"
+}
+
+def selectedGraphType() {
+	graphType ?: "line"
 }
 
 // ========================================================
@@ -83,6 +91,22 @@ mappings {
 			GET: "renderGraph"
 		]
 	}
+	path("/graphDataSizes") { // for testing. remove before publishing
+		action:
+		[
+			GET: "graphDataSizes"
+		]
+	}
+}
+
+def graphDataSizes() { // for testing. remove before publishing
+	state.findAll { k, v -> k.startsWith("measure.") }.inject([:]) { attributes, attributeData ->
+		attributes[attributeData.key] = attributeData.value.inject([:]) { dateTypes, dateTypeData ->
+			dateTypes[dateTypeData.key] = dateTypeData.value.size()
+			dateTypes
+		}
+		attributes
+	}
 }
 
 // ========================================================
@@ -97,7 +121,8 @@ def parse(String description) {
 	}
 	log.debug "Parse returned ${result?.descriptionText}"
 
-	storeGraphData(result.name, result.value)
+	PLATFORM_migrateGraphDataIfNeeded()
+	PLATFORM_storeData(result.name, result.value)
 
 	return result
 }
@@ -151,15 +176,535 @@ def configure() {
 
 def renderGraph() {
 
-	def data = fetchGraphData(params.attribute)
+	def data = PLATFORM_fetchGraphData(params.attribute)
 
 	def totalData = data*.runningSum
 
 	def xValues = data*.unixTime
 
 	def yValues = [
-		Total: [color: "#49a201", data: totalData]
+		Total: [color: "#49a201", data: totalData, type: selectedGraphType()]
 	]
 
-	renderGraph(attribute: params.attribute, xValues: xValues, yValues: yValues, focus: "Total", label: "Watts")
+	PLATFORM_renderGraph(attribute: params.attribute, xValues: xValues, yValues: yValues, focus: "Total", label: "Watts")
+}
+
+// TODO: // ========================================================
+// TODO: // PLATFORM CODE !!! DO NOT ALTER !!!
+// TODO: // ========================================================
+
+// ========================================================
+// PLATFORM TILES
+// ========================================================
+
+def PLATFORM_graphTile(Map tileParams) {
+	def cleanAttribute = tileParams.attribute - "device." - "capability."
+	htmlTile([name: tileParams.name, attribute: tileParams.attribute, action: "graph/${cleanAttribute}", width: 3, height: 2] + tileParams)
+}
+
+// ========================================================
+// PLATFORM GRAPH RENDERING
+// ========================================================
+
+private PLATFORM_graphTypeOptions() {
+	[
+		"line", // DEFAULT
+		"spline",
+		"step",
+		"area",
+		"area-spline",
+		"area-step",
+		"bar",
+		"scatter",
+		"pie",
+		"donut",
+		"gauge",
+	]
+}
+
+private PLATFORM_renderGraph(graphParams) {
+
+	String attribute = graphParams.attribute
+	List xValues = graphParams.xValues
+	Map yValues = graphParams.yValues
+	String focus = graphParams.focus ?: ""
+	String label = graphParams.label ?: ""
+
+	/*
+	def xValues = [1, 2]
+
+	def yValues = [
+			High: [type: "spline", data: [5, 6], color: "#bc2323"],
+			Low: [type: "spline", data: [0, 1], color: "#153591"]
+	]
+
+	Available type values:
+	line 	// DEFAULT
+	spline
+	step
+	area
+	area-spline
+	area-step
+	bar
+	scatter
+	pie
+	donut
+	gauge
+
+*/
+
+	def graphData = PLATFORM_buildGraphData(xValues, yValues, label)
+
+	def legendData = yValues*.key
+	def focusJS = focus ? "chart.focus('${focus}')" : "// focus not specified"
+	def flowColumn = focus ?: yValues ? yValues.keySet().first() : null
+
+	def htmlTitle = "${(device.label ?: device.name)} ${attribute.capitalize()} Graph"
+	renderHTML(htmlTitle) { html ->
+		html.head {
+			"""
+			<!-- Load c3.css -->
+			<link href="https://www.dropbox.com/s/m6ptp72cw4nx0sp/c3.css?dl=1" rel="stylesheet" type="text/css">
+
+			<!-- Load d3.js and c3.js -->
+			<script src="https://www.dropbox.com/s/9x22jyfu5qyacpp/d3.v3.min.js?dl=1" charset="utf-8"></script>
+			<script src="https://www.dropbox.com/s/to7dtcn403l7mza/c3.js?dl=1"></script>
+
+			<script>
+			function getDocumentHeight() {
+				var body = document.body;
+				var html = document.documentElement;
+
+				return html.clientHeight;
+			}
+			function getDocumentWidth() {
+				var body = document.body;
+				var html = document.documentElement;
+
+				return html.clientWidth;
+			}
+			</script>
+
+			<style>
+				.legend {
+					position: absolute;
+					width: 80%;
+					padding-left: 15%;
+					z-index: 999;
+					padding-top: 5px;
+				}
+				.legend span {
+					width: ${100 / yValues.size()}%;
+					display: inline-block;
+					text-align: center;
+					cursor: pointer;
+					color: white;
+				}
+			</style>
+			"""
+		}
+		html.body {
+			"""
+			<div class="legend"></div>
+			<div id="chart" style="max-height: 120px; position: relative;"></div>
+
+			<script>
+
+			// Generate the chart
+			var chart = c3.generate(${graphData as grails.converters.JSON});
+
+			// Resize the chart to the size of the device tile
+			chart.resize({height:getDocumentHeight(), width:getDocumentWidth()});
+
+			// Focus data if specified
+			${focusJS}
+
+			// Update the chart when ${attribute} events are received
+			function ${attribute}(evt) {
+				var newValue = ['${flowColumn}'];
+				newValue.push(evt.value);
+
+				var newX = ['x'];
+				newX.push(evt.unixTime);
+
+				chart.flow({
+					columns: [
+						newX,
+						newValue
+					]
+				});
+			}
+
+			// Build the custom legend
+			d3.select('.legend').selectAll('span')
+    		.data(${legendData as grails.converters.JSON})
+  			.enter().append('span')
+    		.attr('data-id', function (id) { return id; })
+    		.html(function (id) { return id; })
+    		.each(function (id) {
+        	d3.select(this).style('background-color', chart.color(id));
+    		})
+    		.on('mouseover', function (id) {
+     	   chart.focus(id);
+    		})
+    		.on('mouseout', function (id) {
+        	chart.revert();
+    		})
+    		.on('click', function (id) {
+        	chart.toggle(id);
+    		});
+
+			</script>
+			"""
+		}
+	}
+}
+
+private PLATFORM_buildGraphData(List xValues, Map yValues, String label = "") {
+
+	/*
+	def xValues = [1, 2]
+
+	def yValues = [
+			High: [type: "spline", data: [5, 6], color: "#bc2323"],
+			Low: [type: "spline", data: [0, 1], color: "#153591"]
+	]
+	*/
+
+	[
+		interaction: [
+			enabled: false
+		],
+		bindto     : '#chart',
+		padding    : [
+			left  : 30,
+			right : 30,
+			bottom: 0,
+			top   : 0
+		],
+		legend     : [
+			show: false,
+//			hide    : false,//(yValues.keySet().size() < 2),
+//			position: 'inset',
+//            inset: [
+//            	anchor: "top-right"
+//            ],
+//            item: [
+//            	onclick: "do nothing" // (yValues.keySet().size() > 1) ? null : "do nothing"
+//            ]
+		],
+		data       : [
+			x      : "x",
+			columns: [(["x"] + xValues)] + yValues.collect { k, v -> [k] + v.data },
+			types  : yValues.inject([:]) { total, current -> total[current.key] = current.value.type; return total },
+			colors : yValues.inject([:]) { total, current -> total[current.key] = current.value.color; return total }
+		],
+		axis       : [
+			x: [
+				type: 'timeseries',
+				tick: [
+					centered: true,
+					culling : [max: 7],
+					fit     : true,
+					format  : PLATFORM_getGraphDateFormat()
+//				format: PLATFORM_getGraphDateFormatFunction() // throws securityException when trying to escape javascript
+				]
+			],
+			y: [
+				label  : label,
+				padding: [
+					top: 50
+				]
+			]
+		]
+	]
+}
+
+private PLATFORM_getGraphDateFormat(dateType = selectedGraphPrecision()) {
+	// https://github.com/mbostock/d3/wiki/Time-Formatting
+	def graphDateFormat
+	switch (dateType) {
+		case "Live":
+			graphDateFormat = "%I:%M" // hour (12-hour clock) as a decimal number [00,12] // AM or PM
+			break
+		case "Hourly":
+			graphDateFormat = "%I %p" // hour (12-hour clock) as a decimal number [00,12] // AM or PM
+			break
+		case "Daily":
+			graphDateFormat = "%a" // abbreviated weekday name
+			break
+		case "Monthly":
+			graphDateFormat = "%b" // abbreviated month name
+			break
+		case "Annually":
+			graphDateFormat = "%y" // year without century as a decimal number [00,99]
+			break
+	}
+	graphDateFormat
+}
+
+private String PLATFORM_getGraphDateFormatFunction(dateType = selectedGraphPrecision()) {
+	def graphDateFunction = "function(date) { return date; }"
+	switch (dateType) {
+		case "Live":
+			graphDateFunction = """
+			function(date) {
+			 return.getMinutes();
+			}
+			"""
+			break;
+		case "Hourly":
+			graphDateFunction = """ function(date) {
+			  var hour = date.getHours();
+			  if (hour == 0) {
+			   return String(/12 am/).substring(1).slice(0,-1);
+			  } else if (hour > 12) {
+			   return hour -12 + String(/ pm/).substring(1).slice(0,-1);
+			  } else {
+			   return hour + String(/ am/).substring(1).slice(0,-1);
+			  }
+			 }"""
+			break
+		case "Daily":
+			graphDateFunction = """ function(date) {
+			  var day = date.getDay();
+			  switch(day) {
+			   case 0: return String(/Sun/).substring(1).slice(0,-1);
+			   case 1: return String(/Mon/).substring(1).slice(0,-1);
+			   case 2: return String(/Tue/).substring(1).slice(0,-1);
+			   case 3: return String(/Wed/).substring(1).slice(0,-1);
+			   case 4: return String(/Thu/).substring(1).slice(0,-1);
+			   case 5: return String(/Fri/).substring(1).slice(0,-1);
+			   case 6: return String(/Sat/).substring(1).slice(0,-1);
+			  }
+			 }"""
+			break
+		case "Monthly":
+			graphDateFunction = """ function(date) {
+			  var month = date.getMonth();
+			  switch(month) {
+			   case 0: return String(/Jan/).substring(1).slice(0,-1);
+			   case 1: return String(/Feb/).substring(1).slice(0,-1);
+			   case 2: return String(/Mar/).substring(1).slice(0,-1);
+			   case 3: return String(/Apr/).substring(1).slice(0,-1);
+			   case 4: return String(/May/).substring(1).slice(0,-1);
+			   case 5: return String(/Jun/).substring(1).slice(0,-1);
+			   case 6: return String(/Jul/).substring(1).slice(0,-1);
+			   case 7: return String(/Aug/).substring(1).slice(0,-1);
+			   case 8: return String(/Sep/).substring(1).slice(0,-1);
+			   case 9: return String(/Oct/).substring(1).slice(0,-1);
+			   case 10: return String(/Nov/).substring(1).slice(0,-1);
+			   case 11: return String(/Dec/).substring(1).slice(0,-1);
+			  }
+			 }"""
+			break
+		case "Annually":
+			graphDateFunction = """
+			function(date) {
+			 return.getFullYear();
+			}
+			"""
+			break
+	}
+	groovy.json.StringEscapeUtils.escapeJavaScript(graphDateFunction)
+}
+
+private jsEscapeString(str = "") {
+	"String(/${str}/).substring(1).slice(0,-1);"
+}
+
+private PLATFORM_fetchGraphData(attribute) {
+
+	log.debug "PLATFORM_fetchGraphData(${attribute})"
+
+	/*
+	[
+		[
+			dateString: "2014-12-1",
+			unixTime: 1421931600000,
+			min: 0,
+			max: 10,
+			average: 5
+		],
+		...
+	]
+	*/
+
+	def attributeBucket = state["measure.${attribute}"] ?: [:]
+	def dateType = selectedGraphPrecision()
+	attributeBucket[dateType]
+}
+
+// ========================================================
+// PLATFORM DATA STORAGE
+// ========================================================
+
+private PLATFORM_graphPrecisionOptions() { ["Live", "Hourly", "Daily", "Monthly", "Annually"] }
+
+private PLATFORM_storeData(attribute, value) {
+	PLATFORM_graphPrecisionOptions().each { dateType ->
+		PLATFORM_addDataToBucket(attribute, value, dateType)
+	}
+}
+
+/*
+[
+	Hourly: [
+		[
+			dateString: "2014-12-1",
+			unixTime: 1421931600000,
+			min: 0,
+			max: 10,
+			average: 5
+		],
+		...
+	],
+	...
+]
+*/
+
+private PLATFORM_addDataToBucket(attribute, value, dateType) {
+
+	def numberValue = value.toBigDecimal()
+
+	def attributeKey = "measure.${attribute}"
+	def attributeBucket = state[attributeKey] ?: [:]
+
+	def dateTypeBucket = attributeBucket[dateType] ?: []
+
+	def now = new Date()
+	def itemDateString = now.format("PLATFORM_get${dateType}Format"())
+	def item = dateTypeBucket.find { it.dateString == itemDateString }
+
+	if (!item) {
+		// no entry for this data point yet, fill with initial values
+		item = [:]
+		item.average = numberValue
+		item.runningSum = numberValue
+		item.runningCount = 1
+		item.min = numberValue
+		item.max = numberValue
+		item.unixTime = now.getTime()
+		item.dateString = itemDateString
+
+		// add the new data point
+		dateTypeBucket << item
+
+		// clear out old data points
+		def old = PLATFORM_getOldDateString(dateType)
+		if (old) { // annual data never gets cleared
+			dateTypeBucket.findAll { it.unixTime < old }.each { dateTypeBucket.remove(it) }
+		}
+
+		// limit the size of the bucket. Live data can stack up fast
+		def sizeLimit = 25
+		if (dateTypeBucket.size() > sizeLimit) {
+			dateTypeBucket = dateTypeBucket[-sizeLimit..-1]
+		}
+
+	} else {
+		//re-calculate average/min/max for this bucket
+		item.runningSum = (item.runningSum.toBigDecimal()) + numberValue
+		item.runningCount = item.runningCount.toInteger() + 1
+		item.average = item.runningSum.toBigDecimal() / item.runningCount.toInteger()
+
+		if (item.min == null) {
+			item.min = numberValue
+		} else if (numberValue < item.min.toBigDecimal()) {
+			item.min = numberValue
+		}
+		if (item.max == null) {
+			item.max = numberValue
+		} else if (numberValue > item.max.toBigDecimal()) {
+			item.max = numberValue
+		}
+	}
+
+	attributeBucket[dateType] = dateTypeBucket
+	state[attributeKey] = attributeBucket
+}
+
+private PLATFORM_getOldDateString(dateType) {
+	def now = new Date()
+	def date
+	switch (dateType) {
+		case "Live":
+			date = now.getTime() - 60 * 60 * 1000 // 1h * 60m * 60s * 1000ms // 1 hour
+			break
+		case "Hourly":
+			date = (now - 1).getTime()
+			break
+		case "Daily":
+			date = (now - 10).getTime()
+			break
+		case "Monthly":
+			date = (now - 30).getTime()
+			break
+		case "Annually":
+			break
+	}
+	date
+}
+
+private PLATFORM_getLiveFormat() { "HH:mm:ss" }
+
+private PLATFORM_getHourlyFormat() { "yyyy-MM-dd'T'HH" }
+
+private PLATFORM_getDailyFormat() { "yyyy-MM-dd" }
+
+private PLATFORM_getMonthlyFormat() { "yyyy-MM" }
+
+private PLATFORM_getAnnuallyFormat() { "yyyy" }
+
+// ========================================================
+// PLATFORM GRAPH DATA MIGRATION
+// ========================================================
+
+private PLATFORM_migrateGraphDataIfNeeded() {
+	if (!state.hasMigratedOldGraphData) {
+		def acceptableKeys = PLATFORM_graphPrecisionOptions()
+		def needsMigration = state.findAll { k, v -> v.keySet().findAll { !acceptableKeys.contains(it) } }.keySet()
+		needsMigration.each { PLATFORM_migrateGraphData(it) }
+		state.hasMigratedOldGraphData = true
+	}
+}
+
+private PLATFORM_migrateGraphData(attribute) {
+
+	log.trace "about to migrate ${attribute}"
+
+	def attributeBucket = state[attribute] ?: [:]
+	def migratedAttributeBucket = [:]
+
+	attributeBucket.findAll { k, v -> !PLATFORM_graphPrecisionOptions().contains(k) }.each { oldDateString, oldItem ->
+
+		def dateType = oldDateString.contains('T') ? "Hourly" : PLATFORM_graphPrecisionOptions().find {
+			"PLATFORM_get${it}Format"().size() == oldDateString.size()
+		}
+
+		def dateTypeFormat = "PLATFORM_get${dateType}Format"()
+
+		def newBucket = attributeBucket[dateType] ?: []
+/*
+		def existingNewItem = newBucket.find { it.dateString == oldDateString }
+		if (existingNewItem) {
+			newBucket.remove(existingNewItem)
+		}
+*/
+
+		def newItem = [
+			min         : oldItem.min,
+			max         : oldItem.max,
+			average     : oldItem.average,
+			runningSum  : oldItem.runningSum,
+			runningCount: oldItem.runningCount,
+			dateString  : oldDateString,
+			unixTime    : new Date().parse(dateTypeFormat, oldDateString).getTime()
+		]
+
+		newBucket << newItem
+		migratedAttributeBucket[dateType] = newBucket
+	}
+
+	state[attribute] = migratedAttributeBucket
 }

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/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){
+			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",
@@ -152,37 +153,31 @@ def refresh()
 //}
 
 def getTemperature(value) {
-	if (value != null) {
-		def celsius = Integer.parseInt(value, 16) / 100
-		if (getTemperatureScale() == "C") {
-			return celsius
-		} else {
-			return Math.round(celsiusToFahrenheit(celsius))
-		}
+	def celsius = Integer.parseInt(value, 16) / 100
+	if(getTemperatureScale() == "C"){
+		return celsius
+	} else {
+		return celsiusToFahrenheit(celsius) as Integer
 	}
 }
 
 def setHeatingSetpoint(degrees) {
-	if (degrees != null) {
-		def temperatureScale = getTemperatureScale()
-
-		def degreesInteger = Math.round(degrees)
-		log.debug "setHeatingSetpoint({$degreesInteger} ${temperatureScale})"
-		sendEvent("name": "heatingSetpoint", "value": degreesInteger, "unit": temperatureScale)
-
-		def celsius = (getTemperatureScale() == "C") ? degreesInteger : (fahrenheitToCelsius(degreesInteger) as Double).round(2)
-		"st wattr 0x${device.deviceNetworkId} 1 0x201 0x12 0x29 {" + hex(celsius * 100) + "}"
-	}
+	def temperatureScale = getTemperatureScale()
+	
+	def degreesInteger = degrees as Integer
+	log.debug "setHeatingSetpoint({$degreesInteger} ${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) + "}"
 }
 
 def setCoolingSetpoint(degrees) {
-	if (degrees != null) {
-		def degreesInteger = Math.round(degrees)
-		log.debug "setCoolingSetpoint({$degreesInteger} ${temperatureScale})"
-		sendEvent("name": "coolingSetpoint", "value": degreesInteger, "unit": temperatureScale)
-		def celsius = (getTemperatureScale() == "C") ? degreesInteger : (fahrenheitToCelsius(degreesInteger) as Double).round(2)
-		"st wattr 0x${device.deviceNetworkId} 1 0x201 0x11 0x29 {" + hex(celsius * 100) + "}"
-	}
+	def degreesInteger = degrees as Integer
+	log.debug "setCoolingSetpoint({$degreesInteger} ${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) + "}"
 }
 
 def modes() {

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,100 +13,194 @@
  *  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 "Light"
+		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()
+
+	String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+	log.debug "Confuguring 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,13 +20,8 @@ metadata {
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
-		capability "Health Check"
-		capability "Light"
 
-		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 {
@@ -47,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") {
@@ -64,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

@@ -1,887 +0,0 @@
-/**
- *	Fidure Thermostat, Based on ZigBee thermostat (SmartThings)
- *
- *	Author: Fidure
- *	Date: 2014-12-13
- *  Updated: 2015-08-26
- */
-metadata {
-	// Automatically generated. Make future change here.
-	definition (name: "Fidure Thermostat", namespace: "smartthings", author: "SmartThings") {
-
-        capability "Actuator"
-		capability "Temperature Measurement"
-		capability "Thermostat"
-		capability "Configuration"
-		capability "Refresh"
-		capability "Sensor"
-        capability "Polling"
-
-		attribute "displayTemperature","number"
-		attribute "displaySetpoint", "string"
-		command 	"raiseSetpoint"
-		command 	"lowerSetpoint"
-		attribute "upButtonState", "string"
-		attribute "downButtonState", "string"
-
-		attribute "runningMode", "string"
-    	attribute "lockLevel", "string"
-
-		command "setThermostatTime"
-  		command "lock"
-
- 		attribute "prorgammingOperation", "number"
-  		attribute "prorgammingOperationDisplay", "string"
-  		command   "Program"
-
-  		attribute "setpointHold", "string"
-		attribute "setpointHoldDisplay", "string"
-		command "Hold"
-  		attribute "holdExpiary", "string"
-
-		attribute "lastTimeSync", "string"
-
-		attribute "thermostatOperatingState", "string"
-
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0201,0204,0B05", outClusters: "000A, 0019"
-
-	}
-
-	// simulator metadata
-	simulator { }
-  // pref
-     preferences {
-
-		input ("hold_time", "enum", title: "Default Hold Time in Hours",
-        description: "Default Hold Duration in hours",
-        range: "1..24", options: ["No Hold", "2 Hours", "4 Hours", "8 Hours", "12 Hours", "1 Day"],
-        displayDuringSetup: false)
-        input ("sync_clock", "boolean", title: "Synchronize Thermostat Clock Automatically?", options: ["Yes","No"])
-        input ("lock_level", "enum", title: "Thermostat Screen Lock Level", options: ["Full","Mode Only", "Setpoint"])
- 	}
-
-	tiles {
-		valueTile("temperature", "displayTemperature", width: 2, height: 2) {
-			state("temperature", label:'${currentValue}°', unit:"F",
-				backgroundColors:[
-        [value: 0, color: "#153591"],
-				[value: 7, color: "#1e9cbb"],
-				[value: 15, color: "#90d2a7"],
-				[value: 23, color: "#44b621"],
-				[value: 29, color: "#f1d801"],
-				[value: 35, color: "#d04e00"],
-				[value: 36, color: "#bc2323"],
-									// fahrenheit range
-				[value: 37, color: "#153591"],
-				[value: 44, color: "#1e9cbb"],
-				[value: 59, color: "#90d2a7"],
-				[value: 74, color: "#44b621"],
-				[value: 84, color: "#f1d801"],
-				[value: 95, color: "#d04e00"],
-				[value: 96, color: "#bc2323"]
-        ]
-			)
-		}
-		standardTile("mode", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
-			state "off",   action:"thermostat.setThermostatMode", icon:"st.thermostat.heating-cooling-off"
-			state "cool",  action:"thermostat.setThermostatMode", icon:"st.thermostat.cool"
-			state "heat",  action:"thermostat.setThermostatMode", icon:"st.thermostat.heat"
-			state "auto",  action:"thermostat.setThermostatMode", icon:"st.thermostat.auto"
-		}
-
-		standardTile("fanMode", "device.thermostatFanMode", inactiveLabel: false, decoration: "flat") {
-			state "fanAuto", label:'${name}', action:"thermostat.setThermostatFanMode"
-			state "fanOn", label:'${name}', action:"thermostat.setThermostatFanMode"
-		}
-
-    standardTile("hvacStatus", "thermostatOperatingState", inactiveLabel: false, decoration: "flat") {
-				state "Resting",  label: 'Resting'
-				state "Heating",  icon:"st.thermostat.heating"
-				state "Cooling",  icon:"st.thermostat.cooling"
-		}
-
-
-    standardTile("lock", "lockLevel", inactiveLabel: false, decoration: "flat") {
-        state "Unlocked",   action:"lock", label:'${name}'
-        state "Mode Only",  action:"lock", label:'${name}'
-        state "Setpoint",   action:"lock", label:'${name}'
-        state "Full",  action:"lock", label:'${name}'
-    }
-
-		controlTile("heatSliderControl", "device.heatingSetpoint", "slider", height: 1, width: 2, inactiveLabel: false, range: "$min..$max") {
-			state "setHeatingSetpoint", action:"thermostat.setHeatingSetpoint", backgroundColor:"#d04e00"
-		}
-		valueTile("heatingSetpoint", "device.heatingSetpoint", inactiveLabel: false, decoration: "flat") {
-			state "heat", label:'${currentValue}° heat', unit:"F", backgroundColor:"#ffffff"
-		}
-		controlTile("coolSliderControl", "device.coolingSetpoint", "slider", height: 1, width: 2, inactiveLabel: false, range: "$min..$max") {
-			state "setCoolingSetpoint", action:"thermostat.setCoolingSetpoint", backgroundColor: "#1e9cbb"
-		}
-		valueTile("coolingSetpoint", "device.coolingSetpoint", inactiveLabel: false, decoration: "flat") {
-			state "cool", label:'${currentValue}° cool', unit:"F", backgroundColor:"#ffffff"
-		}
-		standardTile("refresh", "device.temperature", inactiveLabel: false, decoration: "flat") {
-			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-		standardTile("configure", "device.configure", inactiveLabel: false, decoration: "flat") {
-			state "configure", label:'', action:"configuration.configure", icon:"st.secondary.configure"
-		}
-
-        valueTile("scheduleText", "prorgammingOperation", inactiveLabel: false, decoration: "flat", width: 2) {
-        	state "default", label: 'Schedule'
-    	}
-    	valueTile("schedule", "prorgammingOperationDisplay", inactiveLabel: false, decoration: "flat") {
-        	state "default", action:"Program", label: '${currentValue}'
-    	}
-
-    	valueTile("hold", "setpointHoldDisplay", inactiveLabel: false, decoration: "flat", width: 3) {
-            state "setpointHold", action:"Hold", label: '${currentValue}'
-		}
-
-		valueTile("setpoint", "displaySetpoint", width: 2, height: 2)
-		{
-			state("displaySetpoint", label: '${currentValue}°',
-				backgroundColor: "#919191")
-		}
-
-		standardTile("upButton", "upButtonState", decoration: "flat", inactiveLabel: false) {
-			state "normal", action:"raiseSetpoint", backgroundColor:"#919191", icon:"st.thermostat.thermostat-up"
-			state "pressed", action:"raiseSetpoint", backgroundColor:"#ff0000", icon:"st.thermostat.thermostat-up"
-		}
-		standardTile("downButton", "downButtonState", decoration: "flat", inactiveLabel: false) {
-			state "normal", action:"lowerSetpoint", backgroundColor:"#919191", icon:"st.thermostat.thermostat-down"
-			state "pressed", action:"lowerSetpoint", backgroundColor:"#ff9191", icon:"st.thermostat.thermostat-down"
-		}
-
-
-		main "temperature"
-		details([ "temperature", "mode", "hvacStatus","setpoint","upButton","downButton","scheduleText", "schedule", "hold",
-        "heatSliderControl", "heatingSetpoint","coolSliderControl", "coolingSetpoint", "lock", "refresh", "configure"])
-	}
-}
-
-def getMin() {
-	try
-	{
-	if (getTemperatureScale() == "C")
-	 	return 10
-	else
-		return 50
-	} catch (all)
-	{
-		return 10
-	}
-}
-
-def getMax() {
-	try {
-		if (getTemperatureScale() == "C")
-		return 30
-	else
-		return 86
-	} catch (all)
-	{
-		return 86
-	}
-}
-
-// parse events into attributes
-def parse(String description) {
-	log.debug "Parse description $description"
-	def result = []
-
-	if (description?.startsWith("read attr -")) {
-
-		//TODO: Parse RAW strings for multiple attributes
-		def descMap = parseDescriptionAsMap(description)
-		log.debug "Desc Map: $descMap"
-		for ( atMap in descMap.attrs)
-		{
-			def map = [:]
-
-		  if (descMap.cluster == "0201")
-			{
-				//log.trace "attribute: ${atMap.attrId} "
-                switch(atMap.attrId.toLowerCase())
-				{
-	            case "0000":
-	  						map.name = "temperature"
-	  						map.value = getTemperature(atMap.value)
-								result += createEvent("name":"displayTemperature", "value": getDisplayTemperature(atMap.value))
-	  					break;
-	            case "0005":
-	            //log.debug "hex time: ${descMap.value}"
-	            	if (atMap.encoding ==  "23")
-	                {
-	            	    	map.name = "holdExpiary"
-	                  	map.value = "${convertToTime(atMap.value).getTime()}"
-	                    //log.trace "HOLD EXPIRY: ${atMap.value} is ${map.value}"
-	                    updateHoldLabel("HoldExp", "${map.value}")
-	  				}
-	            break;
-	  				  case "0011":
-	  						map.name = "coolingSetpoint"
-	  						map.value = getDisplayTemperature(atMap.value)
-								updateSetpoint(map.name,map.value)
-	  					break;
-	  					case "0012":
-	  						map.name = "heatingSetpoint"
-	  						map.value = getDisplayTemperature(atMap.value)
-								updateSetpoint(map.name,map.value)
-	  					break;
-	  					case "001c":
-                        	map.name = "thermostatMode"
-	  						map.value = getModeMap()[atMap.value]
-							updateSetpoint(map.name,map.value)
-	  					break;
-							case "001e":   //running mode enum8
-			          			map.name = "runningMode"
-								map.value = getModeMap()[atMap.value]
-								updateSetpoint(map.name,map.value)
-							break;
-	            case "0023":   // setpoint hold enum8
-	            map.name = "setpointHold"
-	            map.value = getHoldMap()[atMap.value]
-	            updateHoldLabel("Hold", map.value)
-	            break;
-	            case "0024":   // hold duration int16u
-	            map.name = "setpointHoldDuration"
-	            map.value = Integer.parseInt("${atMap.value}", 16)
-
-	            break;
-	            case "0025":   // thermostat programming operation bitmap8
-	  					map.name = "prorgammingOperation"
-	                      def val = getProgrammingMap()[Integer.parseInt("${atMap.value}", 16) & 0x01]
-	  					result += createEvent("name":"prorgammingOperationDisplay", "value": val)
-	            map.value = atMap.value
-	  					break;
-	            case "0029":
-								// relay state
-	              map.name = "thermostatOperatingState"
-	              map.value = getThermostatOperatingState(atMap.value)
-	            break;
-	      }
-	    } else if (descMap.cluster == "0204")
-	    {
-	      if (atMap.attrId == "0001")
-	      {
-	  			map.name = "lockLevel"
-                map.value = getLockMap()[atMap.value]
-	      }
-	    }
-
-		 if (map) {
-            result += createEvent(map)
- 	 	 }
-	  }
-  }
-
-	log.debug "Parse returned $result"
-	return result
-}
-
-def parseDescriptionAsMap(description) {
-  def map = (description - "read attr - ").split(",").inject([:]) { map, param ->
-  def nameAndValue = param.split(":")
-  map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
-  }
-
-    def attrId = map.get('attrId')
-    def encoding = map.get('encoding')
-    def value = map.get('value')
-    def result = map.get('result')
-    def list = [];
-
-  if (getDataLengthByType(map.get('encoding')) < map.get('value').length()) {
-    def raw = map.get('raw')
-
-    def size = Long.parseLong(''+ map.get('size'), 16)
-    def index = 12;
-    def len
-	
-    //log.trace "processing multi attributes"
-    while((index-12) < size) {
-       attrId = flipHexStringEndianness(raw[index..(index+3)])
-       index+= 4;
-       if (result == "success")
-       index+=2;
-       encoding = raw[index..(index+1)]
-       index+= 2;
-       len =getDataLengthByType(encoding)
-       value = flipHexStringEndianness(raw[index..(index+len-1)])
-       index+=len;
-       list += ['attrId': "$attrId", 'encoding':"$encoding", 'value': "$value"]
-    }
-  }
-  else 
-    list += ['attrId': "$attrId", 'encoding': "$encoding", 'value': "$value"]
-  
-  map.remove('value')
-  map.remove('encoding')
-  map.remove('attrId')
-  map += ['attrs' : list ]
-}
-
-def flipHexStringEndianness(s)
-{
-  s = s.reverse()
-  def sb = new StringBuilder()
-  for (int i=0; i < s.length() -1; i+=2)
-   sb.append(s.charAt(i+1)).append(s.charAt(i))
-  sb
-}
-
-def getDataLengthByType(t)
-{
-	// number of bytes in each static data type
-	 def map = ["08":1,	"09":2,	"0a":3,	"0b":4,	"0c":5,	"0d":6,	"0e":7,	"0f":8,	"10":1,	"18":1,	"19":2,	"1a":3,	"1b":4,
-	 "1c":5,"1d":6,	"1e":7,	"1f":8,	"20":1,	"21":2,	"22":3,	"23":4,	"24":5,	"25":6,	"26":7,	"27":8,	"28":1,	"29":2,
-	 "2a":3,	"2b":4,	"2c":5,	"2d":6,	"2e":7,	"2f":8,	"30":1,	"31":2,	"38":2,	"39":4,	"40":8,	"e0":4,	"e1":4,	"e2":4,
-	 "e8":2,	"e9":2,	"ea":4,	"f0":8,	"f1":16]
-
-	// return number of hex chars
-	 return map.get(t) * 2
-}
-
-
-def getProgrammingMap() { [
-	0:"Off",
-	1:"On"
-]}
-
-def getModeMap() { [
-	"00":"off",
-	"01":"auto",
-	"03":"cool",
-	"04":"heat"
-]}
-
-def getFanModeMap() { [
-	"04":"fanOn",
-	"05":"fanAuto"
-]}
-
-def getHoldMap()
-{[
-	"00":"Off",
-	"01":"On"
-]}
-
-
-def updateSetpoint(attrib, val)
-{
-	def cool = device.currentState("coolingSetpoint")?.value
-	def heat = device.currentState("heatingSetpoint")?.value
-	def runningMode = device.currentState("runningMode")?.value
-	def mode = device.currentState("thermostatMode")?.value
-
-	def value = '--';
-
-
-	if ("heat"  == mode && heat != null)
-		value = heat;
-	else if ("cool"  == mode && cool != null)
-		value = cool;
-    else if ("auto" == mode && runningMode == "cool" && cool != null)
-    	value = cool;
-    else if ("auto" == mode && runningMode == "heat" && heat != null)
-    	value = heat;
-
-	sendEvent("name":"displaySetpoint", "value": value)
-}
-
-def raiseSetpoint()
-{
-	sendEvent("name":"upButtonState", "value": "pressed")
-	sendEvent("name":"upButtonState", "value": "normal")
-	adjustSetpoint(5)
-}
-
-def lowerSetpoint()
-{
-	sendEvent("name":"downButtonState", "value": "pressed")
-	sendEvent("name":"downButtonState", "value": "normal")
-	adjustSetpoint(-5)
-}
-
-def adjustSetpoint(value)
-{
-	def runningMode = device.currentState("runningMode")?.value
-	def mode = device.currentState("thermostatMode")?.value
-
-		//default to both heat and cool
-    def modeData = 0x02
-
-    if ("heat" == mode || "heat" == runningMode)
-    		modeData = "00"
-    else if ("cool" == mode || "cool" == runningMode)
-    	modeData = "01"
-
-    def amountData = String.format("%02X", value)[-2..-1]
-
-
-	"st cmd 0x${device.deviceNetworkId} 1 0x201 0 {" + modeData + " " + amountData + "}"
-
-}
-
-
-def getDisplayTemperature(value)
-{
-	def t = Integer.parseInt("$value", 16);
-
-
-	if (getTemperatureScale() == "C") {
-		t = (((t + 4) / 10) as Integer) / 10;
-	} else {
-		t = ((10 *celsiusToFahrenheit(t/100)) as Integer)/ 10;
-	}
-
-
-	return t;
-}
-
-def updateHoldLabel(attr, value)
-{
-	def currentHold = (device?.currentState("setpointHold")?.value)?: "..."
-
-    def holdExp = device?.currentState("holdExpiary")?.value
-		holdExp = holdExp?: "${(new Date()).getTime()}"
-
-	if ("Hold" == attr)
-    {
-    	currentHold = value
-    }
-
-	    if ("HoldExp" == attr)
-		{
-			holdExp = value
-		}
-		boolean past = ( (new Date(holdExp.toLong()).getTime())  < (new Date().getTime()))
-
-		if ("HoldExp" == attr)
-		{
-  			if (!past)
-				currentHold = "On"
-            else
-				currentHold = "Off"
-    }
-
-	def holdString = (currentHold == "On")?
-			( (past)? "Is On" : "Ends ${compareWithNow(holdExp.toLong())}") :
-			((currentHold == "Off")? " is Off" : " ...")
-
-    sendEvent("name":"setpointHoldDisplay", "value": "Hold ${holdString}")
-}
-
-def getSetPointHoldDuration()
-{
-	def holdTime = 0
-
-    if (settings.hold_time?.contains("Hours"))
-    {
-    	holdTime = Integer.parseInt(settings.hold_time[0..1].trim())
-    }
-    else if (settings.hold_time?.contains("Day"))
-    {
-    	holdTime = Integer.parseInt(settings.hold_time[0..1].trim()) * 24
-    }
-
-    def currentHoldDuration = device.currentState("setpointHoldDuration")?.value
-
-
-    if (Short.parseShort('0'+ (currentHoldDuration?: 0)) != (holdTime * 60))
-    {
-    	[
-        	"st wattr 0x${device.deviceNetworkId} 1 0x201 0x24 0x21 {" +
-            String.format("%04X", ((holdTime * 60) as Short))  // switch to zigbee endian
-
-            + "}", "delay 100",
-			"st rattr 0x${device.deviceNetworkId} 1 0x201 0x24", "delay 200",
-		]
-
-    } else
-    {
-    	[]
-    }
-
-}
-
-def Hold()
-{
-	def currentHold = device.currentState("setpointHold")?.value
-
-	def next = (currentHold == "On") ? "00" : "01"
-	def nextHold = getHoldMap()[next]
-
-	sendEvent("name":"setpointHold", "value":nextHold)
-
-	// set the duration first if it's changed
-
-    [
-    "st wattr 0x${device.deviceNetworkId} 1 0x201 0x23 0x30 {$next}", "delay 100" ,
-
-    "raw 0x201 {04 21 11 00 00 05 00 }","delay 200",      // hold expiry time
-  	"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-    ] + getSetPointHoldDuration()
-}
-
-def compareWithNow(d)
-{
-	long mins = (new Date(d)).getTime() - (new Date()).getTime()
-
-	mins /= 1000 * 60;
-
-    log.trace "mins: ${mins}"
-
-    boolean past = (mins < 0)
-    def ret = (past)? "" : "in "
-
-    if (past)
-    	mins *= -1;
-
-    float t = 0;
-	// minutes
-	if (mins < 60)
-	{
-			ret +=  (mins as Integer) + " min" + ((mins > 1)? 's' : '')
-	}else if (mins < 1440)
-	{
-		t = ( Math.round((14 + mins)/30) as Integer) / 2
-        ret += t + " hr" +  ((t > 1)? 's' : '')
-	} else
-    {
-		t = (Math.round((359 + mins)/720) as Integer) / 2
-        ret +=  t + " day" + ((t > 1)? 's' : '')
-	}
-    ret += (past)? " ago": ""
-
-    log.trace "ret: ${ret}"
-
-    ret
-}
-
-def convertToTime(data)
-{
-	def time = Integer.parseInt("$data", 16) as long;
-    time *= 1000;
-    time += 946684800000; // 481418694
-    time -= location.timeZone.getRawOffset() + location.timeZone.getDSTSavings();
-
-    def d = new Date(time);
-
-	//log.trace "converted $data to Time $d"
-	return d;
-}
-
-def Program()
-{
-   	def currentSched = device.currentState("prorgammingOperation")?.value
-
-    def next = Integer.parseInt(currentSched?: "00", 16);
-    if ( (next & 0x01) == 0x01)
-    	next = next & 0xfe;
-    else
-    	next = next | 0x01;
-
-	def nextSched = getProgrammingMap()[next & 0x01]
-
-    "st wattr 0x${device.deviceNetworkId} 1 0x201 0x25 0x18 {$next}"
-
-}
-
-
-def getThermostatOperatingState(value)
-{
-	String[] m = [ "heating", "cooling", "fan", "Heat2", "Cool2", "Fan2", "Fan3"]
-	String desc = 'idle'
-		value = Integer.parseInt(''+value, 16)
-
-		// only check for 1-stage  for A1730
-	for ( i in 0..2 ) {
-		if (value & 1 << i)
-			desc = m[i]
-	}
-
-	desc
-}
-
-def checkLastTimeSync(delay)
-{
-	def lastSync = device.currentState("lastTimeSync")?.value
-    if (!lastSync)
-    	lastSync = "${new Date(0)}"
-
-    if (settings.sync_clock ?: false && lastSync != new Date(0))
-    	{
-        	sendEvent("name":"lastTimeSync", "value":"${new Date(0)}")
-    	}
-
-
-
-	long duration = (new Date()).getTime() - (new Date(lastSync)).getTime()
-
-  //  log.debug "check Time: $lastSync duration: ${duration} settings.sync_clock: ${settings.sync_clock}"
-	if (duration > 86400000)
-		{
-			sendEvent("name":"lastTimeSync", "value":"${new Date()}")
-			return setThermostatTime()
-		}
-
-	return []
-}
-
-def readAttributesCommand(cluster, attribList)
-{
-	def attrString = ''
-
-	for ( val in attribList ) {
-    attrString += ' ' + String.format("%02X %02X", val & 0xff , (val >> 8) & 0xff)
-	}
-
-	//log.trace "list: " + attrString
-
-	["raw "+ cluster + " {00 00 00 $attrString}","delay 100",
-	"send 0x${device.deviceNetworkId} 1 1", "delay 100",
-	]
-}
-
-def refresh()
-{
-	log.debug "refresh called"
-     // log.trace "list: " +       readAttributesCommand(0x201, [0x1C,0x1E,0x23])
-      
-        readAttributesCommand(0x201, [0x00,0x11,0x12]) +
-        readAttributesCommand(0x201, [0x1C,0x1E,0x23]) +
-        readAttributesCommand(0x201, [0x24,0x25,0x29]) +
-        [
-	    "st rattr 0x${device.deviceNetworkId} 1 0x204 0x01", "delay 200",  // lock status
-        "raw 0x201 {04 21 11 00 00 05 00 }"                , "delay 500",  // hold expiary
-	    "send 0x${device.deviceNetworkId} 1 1"             , "delay 1500",
-		]  + checkLastTimeSync(2000)
-}
-
-
-
-
-def poll() {
-	log.trace "poll called"
-	refresh()
-}
-
-def getTemperature(value) {
-	def celsius = Integer.parseInt("$value", 16) / 100
-
-	if(getTemperatureScale() == "C"){
-		return celsius as Integer
-	} else {
-		return celsiusToFahrenheit(celsius) as Integer
-	}
-}
-
-def setHeatingSetpoint(degrees) {
-	def temperatureScale = getTemperatureScale()
-
-	def degreesInteger = degrees as Integer
-	sendEvent("name":"heatingSetpoint", "value":degreesInteger, "unit":temperatureScale)
-
-	def celsius = (getTemperatureScale() == "C") ? degreesInteger : (fahrenheitToCelsius(degreesInteger) as Double).round(2)
-	"st wattr 0x${device.deviceNetworkId} 1 0x201 0x12 0x29 {" + hex(celsius*100) + "}"
-
-}
-
-def setCoolingSetpoint(degrees) {
-	def degreesInteger = degrees as Integer
-	sendEvent("name":"coolingSetpoint", "value":degreesInteger, "unit":temperatureScale)
-	def celsius = (getTemperatureScale() == "C") ? degreesInteger : (fahrenheitToCelsius(degreesInteger) as Double).round(2)
-	"st wattr 0x${device.deviceNetworkId} 1 0x201 0x11 0x29 {" + hex(celsius*100) + "}"
-
-}
-
-def modes() {
-	["off", "heat", "cool"]
-}
-
-def setThermostatFanMode() {
-	def currentFanMode = device.currentState("thermostatFanMode")?.value
-	//log.debug "switching fan from current mode: $currentFanMode"
-	def returnCommand
-
-	switch (currentFanMode) {
-		case "fanAuto":
-			returnCommand = fanOn()
-			break
-		case "fanOn":
-			returnCommand = fanAuto()
-			break
-	}
-	if(!currentFanMode) { returnCommand = fanAuto() }
-	returnCommand
-}
-
-def setThermostatMode() {
-	def currentMode = device.currentState("thermostatMode")?.value
-	def modeOrder = modes()
-	def index = modeOrder.indexOf(currentMode)
-	def next = index >= 0 && index < modeOrder.size() - 1 ? modeOrder[index + 1] : modeOrder[0]
-
-	setThermostatMode(next)
-}
-
-def setThermostatMode(String next) {
-	def val = (getModeMap().find { it.value == next }?.key)?: "00"
-
-	// log.trace "mode changing to $next sending value: $val"
-    
-	sendEvent("name":"thermostatMode", "value":"$next")
-	["st wattr 0x${device.deviceNetworkId} 1 0x201 0x1C 0x30 {$val}"] +
-    refresh()
-}
-
-def setThermostatFanMode(String value) {
-	log.debug "setThermostatFanMode({$value})"
-	"$value"()
-}
-
-def off() {
-	setThermostatMode("off")
-}
-
-def cool() {
-	setThermostatMode("cool")}
-
-def heat() {
-	setThermostatMode("heat")
-}
-
-def auto() {
-	setThermostatMode("auto")
-}
-
-def on() {
-	fanOn()
-}
-
-def fanOn() {
-	 sendEvent("name":"thermostatFanMode", "value":"fanOn")
-	"st wattr 0x${device.deviceNetworkId} 1 0x202 0 0x30 {04}"
-}
-
-
-def fanAuto() {
-	 sendEvent("name":"thermostatFanMode", "value":"fanAuto")
-	"st wattr 0x${device.deviceNetworkId} 1 0x202 0 0x30 {05}"
-}
-
-def updated()
-{
-	def lastSync = device.currentState("lastTimeSync")?.value
-	if ((settings.sync_clock ?: false) == false)
-			{
-            	log.debug "resetting last sync time.  Used to be: $lastSync"
-                sendEvent("name":"lastTimeSync", "value":"${new Date(0)}")
-
-      }
-
-}
-
-def getLockMap()
-{[
-  "00":"Unlocked",
-  "01":"Mode Only",
-  "02":"Setpoint",
-  "03":"Full",
-  "04":"Full",
-  "05":"Full",
-
-]}
-def lock()
-{
-
-	def currentLock = device.currentState("lockLevel")?.value
-  def val = getLockMap().find { it.value == currentLock }?.key
-
-
-
-  //log.debug "current lock is: ${val}"
-
-  if (val == "00")
-      val = getLockMap().find { it.value == (settings.lock_level ?: "Full") }?.key
-  else
-      val = "00"
-
- "st rattr 0x${device.deviceNetworkId} 1 0x204 0x01"
-
-}
-
-
-def setThermostatTime()
-{
-
-  if ((settings.sync_clock ?: false))
-    {
-      log.debug "sync time is disabled, leaving"
-      return []
-    }
-
-
-  	Date date = new Date();
-  	String zone = location.timeZone.getRawOffset() + " DST " + location.timeZone.getDSTSavings();
-
-	long millis = date.getTime(); // Millis since Unix epoch
-  	millis -= 946684800000;  // adjust for ZigBee EPOCH
-  // adjust for time zone and DST offset
-	millis += location.timeZone.getRawOffset() + location.timeZone.getDSTSavings();
-	//convert to seconds
-	millis /= 1000;
-
-	// print to a string for hex capture
-  	String s = String.format("%08X", millis);
-	// hex capture for message format
-  	String data = " " + s.substring(6, 8) + " " + s.substring(4, 6) + " " + s.substring(2, 4)+ " " + s.substring(0, 2);
-
-	[
-  	"raw 0x201 {04 21 11 00 02 0f 00 23 ${data} }",
-  	"send 0x${device.deviceNetworkId} 1 ${endpointId}"
-  	]
-}
-
-def configure() {
-
- 	[
-			"zdo bind 0x${device.deviceNetworkId} 1 1 0x201 {${device.zigbeeId}} {}", "delay 500",
-
-            "zcl global send-me-a-report 0x201 0x0000 0x29 20 300 {19 00}",  // report temperature changes over 0.2C
-  		    "send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
-
-            "zcl global send-me-a-report 0x201 0x001C 0x30 10 305 { }",  // mode
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}","delay 500",
-
-            "zcl global send-me-a-report 0x201 0x0025 0x18 10 310 { 00 }",  // schedule on/off
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}","delay 500",
-
-            "zcl global send-me-a-report 0x201 0x001E 0x30 10 315 { 00 }",  // running mode
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}","delay 500",
-
-            "zcl global send-me-a-report 0x201 0x0011 0x29 10 320 {32 00}",  // cooling setpoint delta: 0.5C (0x3200 in little endian)
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}","delay 500",
-
-            "zcl global send-me-a-report 0x201 0x0012 0x29 10 320 {32 00}", // cooling setpoint delta: 0.5C (0x3200 in little endian)
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}","delay 500",
-
-            "zcl global send-me-a-report 0x201 0x0029 0x19 10 325 { 00 }", "delay 200",  // relay status
-			"send 0x${device.deviceNetworkId} 1 ${endpointId}","delay 500",
-
-            "zcl global send-me-a-report 0x201 0x0023 0x30 10 330 { 00 }", 		// hold
-            "send 0x${device.deviceNetworkId} 1 ${endpointId}","delay 1500",
-
-	] + refresh()
-}
-
-private hex(value) {
-	new BigInteger(Math.round(value).toString()).toString(16)
-}
-
-private getEndpointId()
-{
-	new BigInteger(device.endpointId, 16).toString()
-}

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

@@ -19,6 +19,7 @@ metadata {
 		capability "Sensor"
         
 		fingerprint deviceId: "0x1000", inClusters: "0x25,0x72,0x86,0x71,0x22,0x70"
+		fingerprint deviceId: "0x1006", inClusters: "0x25"
 	}
 
 	// simulator metadata

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,110 @@ 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
-    if (dimRate && (state?.rate != null)) {
-        def computedRate = convertRateValue(state.rate)
-        cmd = zigbee.setLevel(value, computedRate)
-        delayForRefresh += computedRate * 100       //converting tenth of second to milliseconds
+
+    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) {
+    	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()
+
+	String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+	log.debug "Confuguring 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,53 +7,36 @@
 metadata {
 	// Automatically generated. Make future change here.
 	definition (name: "Hue Bridge", namespace: "smartthings", author: "SmartThings") {
-		capability "Bridge"
-		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 {
 		// TODO: define status and reply messages here
 	}
 
-	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'
+	tiles {
+		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: 1, width: 2, inactiveLabel: false) {
+			state "default", label:'${currentValue}', height: 1, width: 2, inactiveLabel: false
 		}
 
-		main (["rich-control"])
-		details(["rich-control", "doNotRemove", "idNumber", "networkAddress"])
+		main (["icon"])
+		details(["networkAddress","serialNumber"])
 	}
 }
 
-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}'"
 	def results = []
 	def result = parent.parse(this, description)
+
 	if (result instanceof physicalgraph.device.HubAction){
 		log.trace "HUE BRIDGE HubAction received -- DOES THIS EVER HAPPEN?"
 		results << result
@@ -61,30 +44,35 @@ def parse(description) {
 		//do nothing
 		log.trace "HUE BRIDGE was updated"
 	} else {
+		log.trace "HUE BRIDGE, OTHER"
 		def map = description
 		if (description instanceof String)  {
 			map = stringToMap(description)
 		}
 		if (map?.name && map?.value) {
 			log.trace "HUE BRIDGE, GENERATING EVENT: $map.name: $map.value"
-			results << createEvent(name: "${map.name}", value: "${map.value}")
-		} else {
-			log.trace "Parsing description"
+			results << createEvent(name: "${map?.name}", value: "${map?.value}")
+		}
+		else {
+			log.trace "HUE BRIDGE, OTHER"
 			def msg = parseLanMessage(description)
 			if (msg.body) {
 				def contentType = msg.headers["Content-Type"]
 				if (contentType?.contains("json")) {
 					def bulbs = new groovy.json.JsonSlurper().parseText(msg.body)
 					if (bulbs.state) {
-						log.info "Bridge response: $msg.body"
+						log.warn "NOT PROCESSED: $msg.body"
 					}
-				} else if (contentType?.contains("xml")) {
-					log.debug "HUE BRIDGE ALREADY PRESENT"
-					parent.hubVerification(device.hub.id, msg.body)
+					else {
+						log.debug "HUE BRIDGE, GENERATING BULB LIST EVENT: $bulbs"
+                        sendEvent(name: "bulbList", value: device.hub.id, isStateChange: true, data: bulbs, displayed: false)
+					}
+				}
+				else if (contentType?.contains("xml")) {
+					log.debug "HUE BRIDGE, SWALLOWING BRIDGE DESCRIPTION RESPONSE -- BRIDGE ALREADY PRESENT"
 				}
 			}
 		}
 	}
 	results
 }
-

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

@@ -1,11 +1,8 @@
 /**
  *  Hue Bulb
  *
- *  Philips Hue Type "Extended Color Light"
- *
  *  Author: SmartThings
  */
-
 // for the UI
 metadata {
 	// Automatically generated. Make future change here.
@@ -13,15 +10,12 @@ 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 "reset"        
         command "refresh"
 	}
 
@@ -29,58 +23,52 @@ metadata {
 		// 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"
-			}
-		}
-
-    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("refresh", "device.refresh", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-
-		main(["rich-control"])
-		details(["rich-control", "colorTempSliderControl", "colorTemp", "reset", "refresh"])
+	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"
+		state "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff"
+	}
+	standardTile("reset", "device.reset", inactiveLabel: false, decoration: "flat") {
+		state "default", label:"Color Reset", action:"reset", icon:"st.lights.philips.hue-single"
+	}
+	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"
+	}
+	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}%'
+	}
+	controlTile("saturationSliderControl", "device.saturation", "slider", height: 1, width: 2, inactiveLabel: false) {
+		state "saturation", action:"color control.setSaturation"
+	}
+	valueTile("saturation", "device.saturation", inactiveLabel: false, decoration: "flat") {
+		state "saturation", label: 'Sat ${currentValue}    '
+	}
+	controlTile("hueSliderControl", "device.hue", "slider", height: 1, width: 2, inactiveLabel: false) {
+		state "hue", action:"color control.setHue"
+	}
+	valueTile("hue", "device.hue", inactiveLabel: false, decoration: "flat") {
+		state "hue", label: 'Hue ${currentValue}   '
 	}
-}
 
-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 +76,91 @@ def parse(description) {
 }
 
 // handle commands
-void on() {
-	log.trace parent.on(this)
+def on(transition = "4") {
+	log.trace parent.on(this,transition)
+	sendEvent(name: "switch", value: "on")
 }
 
-void off() {
-	log.trace parent.off(this)
+def off(transition = "4") {
+	log.trace parent.off(this,transition)
+	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,alert = "none",transition = 4) {
+	log.debug "setColor: ${value}, $this"
+	parent.setColor(this, value, alert, transition)
+	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,44 +12,31 @@ 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") {
-              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)"
-            }
-        }
+	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"
+		state "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff"
+	}
+	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: 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}%'
+	}
 
-        controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false, range:"(0..100)") {
-            state "level", action:"switch level.setLevel"
-        }
+	main(["switch"])
+	details(["switch", "levelSliderControl", "refresh"])
 
-        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-
-        main(["rich-control"])
-        details(["rich-control", "refresh"])
-    }
-}
-
-void installed() {
-	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"LAN\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device.hub.hardwareID}\"}")
 }
 
 // parse events into attributes
@@ -72,25 +57,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

@@ -1,232 +0,0 @@
-/**
- *  LIFX Color Bulb
- *
- *  Copyright 2015 LIFX
- *
- */
-metadata {
-	definition (name: "LIFX Color Bulb", namespace: "smartthings", author: "LIFX") {
-		capability "Actuator"
-		capability "Color Control"
-		capability "Color Temperature"
-		capability "Switch"
-		capability "Switch Level" // brightness
-		capability "Refresh"
-		capability "Sensor"
-		capability "Health Check"
-		capability "Light"
-	}
-
-	simulator {
-
-	}
-
-	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}'
-			}
-		}
-
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-
-		valueTile("null", "device.switch", inactiveLabel: false, decoration: "flat") {
-			state "default", label:''
-		}
-
-		controlTile("colorTempSliderControl", "device.colorTemperature", "slider", height: 2, width: 4, inactiveLabel: false, range:"(2700..9000)") {
-			state "colorTemp", action:"color temperature.setColorTemperature"
-		}
-
-		valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", height: 2, width: 2) {
-			state "colorTemp", label: '${currentValue}K'
-		}
-
-		main "switch"
-		details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
-	}
-}
-
-void installed() {
-	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"cloud\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device?.hub?.hardwareID}\"}")
-}
-
-// 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"])
-		if (resp.status < 300) {
-			sendEvent(name: "hue", value: percentage)
-			sendEvent(name: "switch", value: "on")
-		} else {
-			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"])
-		if (resp.status < 300) {
-			sendEvent(name: "saturation", value: percentage)
-			sendEvent(name: "switch", value: "on")
-		} else {
-			log.error("Bad setSaturation result: [${resp.status}] ${resp.data}")
-		}
-	}
-	return []
-}
-
-def setColor(Map color) {
-	log.debug "setColor ${color}"
-	def attrs = []
-	def events = []
-	color.each { key, value ->
-		switch (key) {
-			case "hue":
-				attrs << "hue:${value * 3.6}"
-				events << createEvent(name: "hue", value: value)
-				break
-			case "saturation":
-				attrs << "saturation:${value / 100}"
-				events << createEvent(name: "saturation", value: value)
-				break
-			case "colorTemperature":
-				attrs << "kelvin:${value}"
-				events << createEvent(name: "colorTemperature", value: value)
-				break
-		}
-	}
-	parent.logErrors(logObject:log) {
-		def resp = parent.apiPUT("/lights/${selector()}/state", [color: attrs.join(" "), power: "on"])
-		if (resp.status < 300) {
-			if (color.hex)
-				sendEvent(name: "color", value: color.hex)
-			sendEvent(name: "switch", value: "on")
-			events.each { sendEvent(it) }
-		} else {
-			log.error("Bad setColor result: [${resp.status}] ${resp.data}")
-		}
-	}
-	return []
-}
-
-def setLevel(percentage) {
-	log.debug "setLevel ${percentage}"
-	if (percentage < 1 && percentage > 0) {
-		percentage = 1 // clamp to 1%
-	}
-	if (percentage == 0) {
-		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"])
-		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"])
-		if (resp.status < 300) {
-			sendEvent(name: "colorTemperature", value: kelvin)
-			sendEvent(name: "color", value: "#ffffff")
-			sendEvent(name: "saturation", value: 0)
-		} else {
-			log.error("Bad setLevel result: [${resp.status}] ${resp.data}")
-		}
-
-	}
-	return []
-}
-
-def on() {
-	log.debug "Device setOn"
-	parent.logErrors() {
-		if (parent.apiPUT("/lights/${selector()}/state", [power: "on"]) != null) {
-			sendEvent(name: "switch", value: "on")
-		}
-	}
-	return []
-}
-
-def off() {
-	log.debug "Device setOff"
-	parent.logErrors() {
-		if (parent.apiPUT("/lights/${selector()}/state", [power: "off"]) != null) {
-			sendEvent(name: "switch", value: "off")
-		}
-	}
-	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}"
-	}
-}

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

@@ -1,157 +0,0 @@
-/**
- *  LIFX White Bulb
- *
- *  Copyright 2015 LIFX
- *
- */
-metadata {
-	definition (name: "LIFX White Bulb", namespace: "smartthings", author: "LIFX") {
-		capability "Actuator"
-		capability "Color Temperature"
-		capability "Switch"
-		capability "Switch Level" // brightness
-		capability "Refresh"
-		capability "Sensor"
-		capability "Health Check"
-		capability "Light"
-	}
-
-	simulator {
-
-	}
-
-	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"
-			}
-		}
-
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-
-		valueTile("null", "device.switch", inactiveLabel: false, decoration: "flat") {
-			state "default", label:''
-		}
-
-		controlTile("colorTempSliderControl", "device.colorTemperature", "slider", height: 2, width: 4, inactiveLabel: false, range:"(2700..9000)") {
-			state "colorTemp", action:"color temperature.setColorTemperature"
-		}
-
-		valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", height: 2, width: 2) {
-			state "colorTemp", label: '${currentValue}K'
-		}
-
-		main "switch"
-		details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
-	}
-}
-
-void installed() {
-	sendEvent(name: "DeviceWatch-Enroll", value: "{\"protocol\": \"cloud\", \"scheme\":\"untracked\", \"hubHardwareId\": \"${device?.hub?.hardwareID}\"}")
-}
-
-// handle commands
-def setLevel(percentage) {
-	log.debug "setLevel ${percentage}"
-	if (percentage < 1 && percentage > 0) {
-		percentage = 1 // clamp to 1%
-	}
-	if (percentage == 0) {
-		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"])
-		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"])
-		if (resp.status < 300) {
-			sendEvent(name: "colorTemperature", value: kelvin)
-			sendEvent(name: "color", value: "#ffffff")
-			sendEvent(name: "saturation", value: 0)
-			sendEvent(name: "switch", value: "on")
-		} else {
-			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) {
-			sendEvent(name: "switch", value: "on")
-		}
-	}
-	return []
-}
-
-def off() {
-	log.debug "Device setOff"
-	parent.logErrors() {
-		if (parent.apiPUT("/lights/${selector()}/state", [power: "off"]) != null) {
-			sendEvent(name: "switch", value: "off")
-		}
-	}
-	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}"
-	}
-}

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

@@ -36,7 +36,6 @@ metadata {
 		capability "Switch"
 		capability "Refresh"
 		capability "Contact Sensor"
-		capability "Light"
 
 		attribute "powered", "string"
 

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") {
@@ -25,8 +24,8 @@ metadata {
         command "enrollResponse"
 
 		fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3041"
-        fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3043", deviceJoinName: "NYCE Ceiling Motion Sensor"
-        fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3045", deviceJoinName: "NYCE Curtain Motion Sensor"
+        fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3043"
+        fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3045"
 	}
 
 	tiles {
@@ -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()
@@ -165,10 +201,10 @@ def refresh()
 
 def configure() {
 
-	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
-	log.debug "Configuring Reporting, IAS CIE, and Bindings."
+	String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+	log.debug "Confuguring Reporting, IAS CIE, and Bindings."
 	def configCmds = [
-    	"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+    	"zcl global write 0x500 0x10 0xf0 {${zigbeeId}}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
         
         "zcl global send-me-a-report 1 0x20 0x20 0x3600 0x3600 {01}", "delay 200",

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"
-		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"
+        
+        command "enrollResponse"
+ 
+ 
+		fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3011"
+        fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3011"
+        fingerprint inClusters: "0000,0001,0003,0406,0500,0020", manufacturer: "NYCE", model: "3014"
+        fingerprint inClusters: "0000,0001,0003,0500,0020", manufacturer: "NYCE", model: "3014"
 	}
-
+ 
 	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 zigbeeId = swapEndianHex(device.hub.zigbeeId)
+
+	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",
 
-	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 
-	def enrollCmds = [
 			// Writes CIE attribute on end device to direct reports to the hub's EUID
-			"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+			"zcl global write 0x500 0x10 0xf0 {${zigbeeId}}", "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/open-closed-sensor.src/open-closed-sensor.groovy

@@ -40,11 +40,14 @@ metadata {
 
 // Parse incoming device messages to generate events
 def parse(String description) {
-	def resMap
-	if (description.startsWith("zone")) {
-		resMap = createEvent(name: "contact", value: zigbee.parseZoneStatus(description).isAlarm1Set() ? "open" : "closed")
+	def name = null
+	def value = description
+	if (zigbee.isZoneType19(description)) {
+		name = "contact"
+		value = zigbee.translateStatusZoneType19(description) ? "open" : "closed"
 	}
 	
-	log.debug "Parse returned $resMap"
-	return resMap
+	def result = createEvent(name: name, value: value)
+	log.debug "Parse returned ${result?.descriptionText}"
+	return result
 }

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

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

@@ -24,7 +24,6 @@ metadata {
 		capability "Refresh"
 		capability "Actuator"
 		capability "Sensor"
-		capability "Outlet"
 
 		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "4257050-ZHAC"
 
@@ -42,7 +41,7 @@ metadata {
 	}
 
 	tiles(scale: 2) {
-		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
 				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
 				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
@@ -70,36 +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)
 
-	return event ? createEvent(event) : event
+			/*
+				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)
+	}
 }
 
-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") {
+			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() {
+	[
+			//Meter (Power) Reporting
+			"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 0x0B04 {${device.zigbeeId}} {}", "delay 200",
+			"zcl global send-me-a-report 0x0B04 0x050B 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/smartpower-outlet-v1.src/smartpower-outlet-v1.groovy

@@ -4,9 +4,8 @@ metadata {
 		capability "Actuator"
 		capability "Switch"
 		capability "Sensor"
-		capability "Outlet"
 
-		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
@@ -48,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,34 +1,22 @@
-/*
- *  Copyright 2016 SmartThings
+/**
+ *	CentraLite Switch
  *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
- *  use this file except in compliance with the License. You may obtain a copy
- *  of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- *  License for the specific language governing permissions and limitations
- *  under the License.
+ *	Author: SmartThings
+ *	Date: 2013-12-02
  */
 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"
-		capability "Light"
-		capability "Outlet"
 
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3200", deviceJoinName: "Outlet"
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "3200-Sgb", deviceJoinName: "Outlet"
-		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite", model: "4257050-RZHAC", deviceJoinName: "Outlet"
+		// 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"
 	}
 
@@ -43,95 +31,90 @@ metadata {
 		reply "zcl on-off off": "on/off: 0"
 	}
 
-	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"
-			])
-		}
-	}
-
 	// 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){
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
+				attributeState "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
 			}
-			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"])
 	}
 }
 
 // Parse incoming device messages to generate events
 def parse(String description) {
-	log.debug "description is $description"
+	log.debug "Parse description $description"
+	def name = null
+	def value = null
 
-	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") {
-			def value = (event.value as Integer) / 10
-			event = createEvent(name: event.name, value: value, descriptionText: '{{ device.displayName }} power is {{ value }} Watts', 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)
-		}
-	} else {
-		def cluster = zigbee.parse(description)
-
-		if (cluster && cluster.clusterId == 0x0006 && cluster.command == 0x07) {
-			if (cluster.data[0] == 0x00) {
-				log.debug "ON/OFF REPORTING CONFIG RESPONSE: " + cluster
-				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}"
+	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 if (descMap.cluster.equalsIgnoreCase("0B04") && descMap.attrId.equalsIgnoreCase("050b")) {
+			def reportValue = descMap.value
+			name = "power"
+			//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"
 	}
-	return event ? createEvent(event) : event
+
+	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() {
-	zigbee.off()
+	'zcl on-off off'
 }
 
-def on() {
-	zigbee.on()
-}
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-	return zigbee.onOffRefresh()
+def meter() {
+	"st rattr 0x${device.deviceNetworkId} 1 0xB04 0x50B"
 }
 
 def refresh() {
-	zigbee.onOffRefresh() + zigbee.electricMeasurementPowerRefresh()
+	sendEvent(name: "heartbeat", value: "alive", displayed:false)
+	[
+			"st rattr 0x${device.deviceNetworkId} 1 0xB04 0x50B"
+	]
 }
 
 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()
+	def configCmds = [
+			"zdo bind 0x${device.deviceNetworkId} 1 1 6 {${device.zigbeeId}} {}", "delay 200",
+			"zdo bind 0x${device.deviceNetworkId} 1 1 0xB04 {${device.zigbeeId}} {}", "delay 200"
+	]
+	return configCmds + refresh() // send refresh cmds as part of config
 }
-

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

@@ -79,16 +79,16 @@ 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) || description.startsWith("zone")) {
+	if (!isSupportedDescription(description) || zigbee.isZoneType19(description)) {
 		// Ignore this in favor of orientation-based state
 		// results = parseSingleMessage(description)
 	}

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
 	}
 }
 
@@ -117,7 +117,7 @@ def parse(String description) {
 	log.debug "parse($description)"
 	def results = null
 
-	if (!isSupportedDescription(description) || description.startsWith("zone")) {
+	if (!isSupportedDescription(description) || zigbee.isZoneType19(description)) {
 		// Ignore this in favor of orientation-based state
 		// results = parseSingleMessage(description)
 	}

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,324 @@
-/*
- *  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"
+ 
+ 
+		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "CentraLite",  model: "3315-S"
+	        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"
 
-		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"
 	}
-
+ 
 	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"
-			])
-		}
-		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", icon:"st.alarm.water.dry", backgroundColor:"#ffffff"
+				attributeState "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"]
-					]
+		valueTile("temperature", "device.temperature", inactiveLabel: 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("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() {
+def refresh()
+{
 	log.debug "Refreshing Temperature and Battery"
-	def refreshCmds = zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
-			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020)
+	[
+		
 
-	return refreshCmds + zigbee.enrollResponse()
+        "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])
 
-	// 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
+	String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+	log.debug "Confuguring Reporting, IAS CIE, and Bindings."
+	def configCmds = [	
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeId}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        
+        "zcl global send-me-a-report 1 0x20 0x20 300 0600 {01}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        
+        "zcl global send-me-a-report 0x402 0 0x29 300 3600 {6400}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        
+        
+		"zdo bind 0x${device.deviceNetworkId} 1 1 0x402 {${device.zigbeeId}} {}", "delay 500",
+		"zdo bind 0x${device.deviceNetworkId} 1 1 0x001 {${device.zigbeeId}} {}", "delay 1000",
+        
+        "raw 0x500 {01 23 00 00 00}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1000",
+	]
+    return configCmds + refresh() // send refresh cmds as part of config
+}
+
+def enrollResponse() {
+	log.debug "Sending enroll response"
+    [	
+    	
+	"raw 0x500 {01 23 00 00 00}", "delay 200",
+    "send 0x${device.deviceNetworkId} 1 1"
+        
+    ]
+}
+
+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"
@@ -36,33 +35,20 @@ metadata {
 	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"
+				attributeState "dry", icon:"st.alarm.water.dry", backgroundColor:"#ffffff"
+				attributeState "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 +114,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 +128,8 @@ def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd)
 	map
 }
 
-def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport 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
-}
-
-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"
+        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 {
@@ -43,44 +37,35 @@ 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"
-			])
-		}
-		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 +75,276 @@ 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 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()]
 	}
-	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
-
-	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 (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 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() {
+def refresh()
+{
 	log.debug "refresh called"
-
-	def refreshCmds = zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) +
-			zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000)
-
-	return refreshCmds + zigbee.enrollResponse()
+    [
+		"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])
 
-	// 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
+	String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+	log.debug "Confuguring Reporting, IAS CIE, and Bindings."
+	def configCmds = [
+    
+   		"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 0x402 {${device.zigbeeId}} {}", "delay 200",
+        "zcl global send-me-a-report 0x402 0 0x29 300 3600 {6400}",
+        "send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500",
+        
+        "zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 0x20 {${device.zigbeeId}} {}", "delay 200",
+        "zcl global send-me-a-report 1 0x20 0x20 300 3600 {01}", 
+        "send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 1500",
+
+		"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 0x001 {${device.zigbeeId}} {}", "delay 200",
+        "zcl global write 0x500 0x10 0xf0 {${zigbeeId}}", 
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}"
+        
+ 
+	]
+    return configCmds + enrollResponse() + refresh() // send refresh cmds as part of config
 }
+
+private getEndpointId() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+def enrollResponse() {
+	log.debug "Sending enroll response"
+    [	
+    	
+	"raw 0x500 {01 23 00 00 00}", "delay 200",
+    "send 0x${device.deviceNetworkId} 1 ${endpointId}"
+        
+    ]
+}
+
+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,340 @@
+/**
+ *  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"
+        
+        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 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))
+	}
+    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)
+    
+    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 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"
+    [
+		"st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+        "st rattr 0x${device.deviceNetworkId} 1 1 0x20"
+		
+	]
+}
+
+def configure() {
+
+	String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+	log.debug "Confuguring Reporting, IAS CIE, and Bindings."
+	def configCmds = [
+    	"zcl global write 0x500 0x10 0xf0 {${zigbeeId}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        
+        "zcl global send-me-a-report 1 0x20 0x20 300 3600 {01}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        
+        "zcl global send-me-a-report 0x402 0 0x29 300 3600 {6400}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        
+        
+		"zdo bind 0x${device.deviceNetworkId} 1 1 0x402 {${device.zigbeeId}} {}", "delay 200",
+		"zdo bind 0x${device.deviceNetworkId} 1 1 0x001 {${device.zigbeeId}} {}", "delay 1500",
+        
+        "raw 0x500 {01 23 00 00 00}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+	]
+    return configCmds + refresh() // send refresh cmds as part of config
+}
+
+def enrollResponse() {
+	log.debug "Sending enroll response"
+    [	
+    	
+	"raw 0x500 {01 23 00 00 00}", "delay 200",
+    "send 0x${device.deviceNetworkId} 1 1"
+        
+    ]
+}
+
+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,8 +44,8 @@ metadata {
 }
 
 def parse(String description) {
-	def results = [:]
-	if (description.startsWith("zone") || !isSupportedDescription(description)) {
+	def results
+	if (isZoneType19(description) || !isSupportedDescription(description)) {
 		results = parseBasicMessage(description)
 	}
 	else if (isMotionStatusMessage(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
 }
@@ -87,12 +84,16 @@ private String parseName(String description) {
 }
 
 private String parseValue(String description) {
-	def zs = zigbee.parseZoneStatus(description)
-	if (zs) {
-		zs.isAlarm1Set() ? "active" : "inactive"
-	} else {
-		description
+	if (isZoneType19(description)) {
+		if (translateStatusZoneType19(description)) {
+			return "active"
+		}
+		else {
+			return "inactive"
+		}
 	}
+
+	description
 }
 
 private parseDescriptionText(String linkText, String value, String description) {

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,39 @@
-/*
- *  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"
+       
+ 	}
 
-		attribute "status", "string"
-	}
-
-	simulator {
+ 	simulator {
 		status "open": "zone report :: type: 19 value: 0031"
 		status "closed": "zone report :: type: 19 value: 0030"
 
@@ -55,334 +50,436 @@ 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 {
-		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"
-			])
-		}
-		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
-		}
-		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)
-		}
-	}
+ 	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: "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:"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("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")
-		}
+
 		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"])
+		main(["contact", "acceleration", "temperature"])
+		details(["contact", "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)
+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()]
+	}
+    
+    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))
+	}
+
+	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 {
-			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 {
-
-				maps += handleAcceleration(descMap)
-			}
-		}
-	} 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
-	}
-
-	def result = maps.inject([]) {acc, it ->
-		if (it) {
-			acc << createEvent(it)
+			return celsiusToFahrenheit(celsius) as Integer
 		}
 	}
-	if (description?.startsWith('enroll request')) {
-		List cmds = zigbee.enrollResponse()
-		log.debug "enroll response: ${cmds}"
-		result = cmds?.collect { new physicalgraph.device.HubAction(it) }
-	}
-	return result
-}
 
-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
+	private Map getBatteryResult(rawValue) {
+		log.debug "Battery"
+        log.debug rawValue
+		def linkText = getLinkText(device)
+
+		def result = [
+		name: 'battery',
+        value: '--'
 		]
 
-		if (descMap.additionalAttrs) {
-			result += parseAxis(descMap.additionalAttrs)
+		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 if (descMap.clusterInt == 0xFC02 && descMap.attrInt == 0x0012) {
-		def addAttrs = descMap.additionalAttrs
-		addAttrs << ["attrInt": descMap.attrInt, "value": descMap.value]
-		result += parseAxis(addAttrs)
-	}
-	return result
-}
-
-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)
-
-	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
-	}
-
-	log.debug "parseAxis -- ${xyzResults}"
-
-	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 {
+		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)
+			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
+		]
 	}
 
-	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])
+	private Map getContactResult(value) {
+		log.debug "Contact"
+		def linkText = getLinkText(device)
+		def descriptionText = "${linkText} was ${value == 'open' ? 'opened' : 'closed'}"
+		return [
+		name: 'contact',
+		value: value,
+		descriptionText: descriptionText
+		]
 	}
 
-	// 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
-}
-
-def updated() {
-	log.debug "updated called"
-	log.info "garage value : $garageSensor"
-	if (garageSensor == "Yes") {
-		def descriptionText = "Updating device to garage sensor"
-		if (device.latestValue("status") == "open") {
-			sendEvent(name: 'status', value: 'garage-open', descriptionText: descriptionText, translatable: true)
-		} else if (device.latestValue("status") == "closed") {
-			sendEvent(name: 'status', value: 'garage-closed', descriptionText: descriptionText, translatable: true)
-		}
-	} else {
-		def descriptionText = "Updating device to open/close sensor"
-		if (device.latestValue("status") == "garage-open") {
-			sendEvent(name: 'status', value: 'open', descriptionText: descriptionText, translatable: true)
-		} else if (device.latestValue("status") == "garage-closed") {
-			sendEvent(name: 'status', value: 'closed', descriptionText: descriptionText, translatable: true)
-		}
+	private getAccelerationResult(numValue) {
+		log.debug "Acceleration"
+        def name = "acceleration"
+		def value = numValue.endsWith("1") ? "active" : "inactive"
+		//def linkText = getLinkText(device)
+		def descriptionText = "was $value"
+		def isStateChange = isStateChange(device, name, value)
+		[
+			name: name,
+			value: value,
+			descriptionText: descriptionText,
+			isStateChange: isStateChange
+		]
 	}
-}
 
-private hexToSignedInt(hexVal) {
-	def unsignedVal = hexToInt(hexVal)
-	unsignedVal > 32767 ? unsignedVal - 65536 : unsignedVal
-}
+	def refresh()
+	{
+		log.debug "Refreshing Values "
+		[
+        
+        /* 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",
+        
+        "zcl mfg-code 0x104E", "delay 200",
+        "zcl global read 0xFC02 0x0000", "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",
 
-private getManufacturerCode() {
-	if (device.getDataValue("manufacturer") == "SmartThings") {
-		return "0x110A"
-	} else {
-		return "0x104E"
+        "zcl mfg-code 0x104E", "delay 200",
+        "zcl global read 0xFC02 0x0010", "delay 100",
+        "send 0x${device.deviceNetworkId} 1 1","delay 400",
+        
+        "zcl mfg-code 0x104E", "delay 200",
+        "zcl global read 0xFC02 0x0012", "delay 100",
+        "send 0x${device.deviceNetworkId} 1 1","delay 400",
+        
+        "zcl mfg-code 0x104E", "delay 200",
+        "zcl global read 0xFC02 0x0013", "delay 100",
+        "send 0x${device.deviceNetworkId} 1 1","delay 400",
+        
+        "zcl mfg-code 0x104E", "delay 200",
+        "zcl global read 0xFC02 0x0014", "delay 100",
+        "send 0x${device.deviceNetworkId} 1 1"
+
+		] 
 	}
+
+	def configure() {
+
+		String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+		log.debug "Configuring Reporting"
+		
+        def configCmds = [
+        
+        "zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 1 {${device.zigbeeId}} {}", "delay 200",
+        "zcl global write 0x500 0x10 0xf0 {${zigbeeId}}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 0x20 {${device.zigbeeId}} {}", "delay 200",
+        "zcl global send-me-a-report 1 0x20 0x20 600 3600 {01}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 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",
+
+		"zdo bind 0x${device.deviceNetworkId} 1 ${endpointId} 0xFC02 {${device.zigbeeId}} {}", "delay 200",
+		"zcl mfg-code 0x104E", 
+        "zcl global send-me-a-report 0xFC02 0x0010 0x18 300 3600 {01}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+        
+        "zcl mfg-code 0x104E", 
+        "zcl global send-me-a-report 0xFC02 0x0012 0x29 300 3600 {01}",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+        
+        "zcl mfg-code 0x104E", 
+        "zcl global send-me-a-report 0xFC02 0x0013 0x29 300 3600 {01}", 
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+        
+        "zcl mfg-code 0x104E", 
+        "zcl global send-me-a-report 0xFC02 0x0014 0x29 300 3600 {01}", 
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
+
+		]
+   
+   return configCmds + refresh()
+}
+
+private getEndpointId() {
+	new BigInteger(device.endpointId, 16).toString()
+}
+
+def enrollResponse() {
+	log.debug "Sending enroll response"
+	[
+
+	"raw 0x500 {01 23 00 00 00}", "delay 200",
+	"send 0x${device.deviceNetworkId} 1 1"
+
+	]
+}
+
+
+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}"
+        }
+    }
+
+	getXyzResult(xyzResults, description)
+}
+
+
+
+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,19 +72,22 @@ 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"])
 	}
 }
 
 def parse(String description) {
 	def results
 
-	if (!isSupportedDescription(description) || description.startsWith("zone")) {
+	if (!isSupportedDescription(description) || zigbee.isZoneType19(description)) {
 		results = parseSingleMessage(description)
 	}
 	else if (description == 'updated') {
@@ -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"
@@ -488,7 +463,12 @@ private String parseValue(String description) {
 	if (!isSupportedDescription(description)) {
 		return description
 	}
-	return zigbee.parseZoneStatus(description)?.isAlarm1Set() ? "open" : "closed"
+	else if (zigbee.translateStatusZoneType19(description)) {
+		return "open"
+	}
+	else {
+		return "closed"
+	}
 }
 
 private parseDescriptionText(String linkText, String value, String description) {

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

@@ -0,0 +1,353 @@
+/**
+ *  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 "
+		[
+
+		"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"
+
+		]
+	}
+
+	def configure() {
+
+		String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+		log.debug "Confuguring Reporting, IAS CIE, and Bindings."
+		def configCmds = [
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeId}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+
+		"zcl global send-me-a-report 1 0x20 0x20 600 3600 {01}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+
+		"zcl global send-me-a-report 0x402 0 0x29 300 3600 {6400}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+
+		"zcl global send-me-a-report 0xFC02 2 0x18 300 3600 {01}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+
+		"zdo bind 0x${device.deviceNetworkId} 1 1 0xFC02 {${device.zigbeeId}} {}", "delay 500",
+		"zdo bind 0x${device.deviceNetworkId} 1 1 0x402 {${device.zigbeeId}} {}", "delay 500",
+		"zdo bind 0x${device.deviceNetworkId} 1 1 1 {${device.zigbeeId}} {}"
+
+		]
+    return configCmds + refresh() // send refresh cmds as part of config
+}
+
+def enrollResponse() {
+	log.debug "Sending enroll response"
+	[
+
+	"raw 0x500 {01 23 00 00 00}", "delay 200",
+	"send 0x${device.deviceNetworkId} 1 1"
+
+	]
+}
+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,316 @@
  *  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() {
+def refresh()
+{
 	log.debug "Refreshing Temperature and Battery"
-	def refreshCmds = zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
-			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020)
+	[
+    
+        "st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+		"st rattr 0x${device.deviceNetworkId} 1 1 0x20"
 
-	return refreshCmds + zigbee.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])
 
-	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
+	String zigbeeId = swapEndianHex(device.hub.zigbeeId)
+	log.debug "Confuguring Reporting, IAS CIE, and Bindings."
+	def configCmds = [
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeId}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        
+        "zcl global send-me-a-report 1 0x20 0x20 600 3600 {01}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        
+        "zcl global send-me-a-report 0x402 0 0x29 300 3600 {6400}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        
+        
+        //"raw 0x500 {01 23 00 00 00}", "delay 200",
+        //"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+        
+        
+		"zdo bind 0x${device.deviceNetworkId} 1 1 0x402 {${device.zigbeeId}} {}", "delay 500",
+		"zdo bind 0x${device.deviceNetworkId} 1 1 1 {${device.zigbeeId}} {}"
+	]
+    return configCmds + refresh() // send refresh cmds as part of config
+}
+
+def enrollResponse() {
+	log.debug "Sending enroll response"
+    [	
+    	
+	"raw 0x500 {01 23 00 00 00}", "delay 200",
+    "send 0x${device.deviceNetworkId} 1 1"
+        
+    ]
+}
+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-presence.src/smartsense-presence.groovy

@@ -12,7 +12,7 @@
  *
  */
 metadata {
-	definition (name: "Arrival Sensor", namespace: "smartthings", author: "SmartThings") {
+	definition (name: "SmartSense Presence", namespace: "smartthings", author: "SmartThings") {
 		capability "Tone"
 		capability "Actuator"
 		capability "Signal Strength"
@@ -31,19 +31,10 @@ metadata {
 		status "battery": "battery: 27, batteryDivisor: 0A, rssi: 100, lqi: 64"
 	}
 
-	preferences {
-		section {
-			image(name: 'educationalcontent', multiple: true, images: [
-				"http://cdn.device-gse.smartthings.com/Arrival/Arrival1.jpg",
-				"http://cdn.device-gse.smartthings.com/Arrival/Arrival2.jpg"
-				])
-		}
-	}
-
 	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 +78,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}"
 	]
 }