MSA-933: 스마트싱작업 테스트해보는중입니다

build.gradle

@@ -1,18 +1,15 @@
 import java.nio.charset.StandardCharsets
 import java.nio.file.Paths
-import com.smartthings.deployment.slack.FileUpload
-import com.smartthings.deployment.slack.Message
 
 apply plugin: 'groovy'
 apply plugin: 'smartthings-executable-deployment'
-apply plugin: 'smartthings-slack'
+apply plugin: 'smartthings-hipchat'
 
 buildscript {
     dependencies {
-        classpath "com.smartthings.deployment:executable-deployment-scripts:1.0.8"
+        classpath "com.smartthings.deployment:executable-deployment-scripts:1.0.3"
     }
     repositories {
-        mavenLocal()
         jcenter()
         maven {
             credentials {
@@ -32,43 +29,7 @@ repositories {
 dependencies {
 }
 
-slackSendMessage {
-    String branch = project.hasProperty('branch') ? project.property('branch') : 'unknown'
-    String token = project.hasProperty('slackToken') ? project.property('slackToken') : null
-    String webhookUrl = project.hasProperty('slackWebhookUrl') ? project.property('slackWebhookUrl') : null
-    String channel = project.hasProperty('slackChannel') ? project.property('slackChannel') : null
-    String drinks = 'https://dl.dropboxusercontent.com/s/m1z5mpd3c83lwev/minion_beer.jpeg?dl=0'
-    String wolverine = 'https://dl.dropboxusercontent.com/s/4lbjqzvm2v033u9/minion_wolverine.jpg?dl=0'
-    String beach = 'https://dl.dropboxusercontent.com/s/rqrfgxk53gfng69/minion_beach.png?dl=0'
-    String iconUrl
-    String color
-    String messageText
-    String username
-    switch (branch) {
-        case 'master':
-            username = 'Hickory'
-            iconUrl = wolverine
-            color = '#35D0F2'
-            messageText = 'Began deployment of _SmartThingsPublic[master]_ branch to the _Dev_ environments.'
-            break
-        case 'staging':
-            username = 'Dickory'
-            iconUrl = beach
-            color = '#FFDE20'
-            messageText = 'Began deployment of _SmartThingsPublic[staging]_ branch to the _Staging_ environments.'
-            break
-        case 'production':
-            username = 'Dock'
-            iconUrl = drinks
-            color = '#FF1D23'
-            messageText = 'Began deployment of _SmartThingsPublic[production]_ branch to the _Prod_ environments.'
-            break
-        default:
-            username = 'Hickory'
-            iconUrl = wolverine
-            color = '#35D0F2'
-            messageText = "Began deployment of an _SmartThingsPublic[${branch}]_ branch.  Have no idea what's going on."
-    }
+hipchatShareFile {
     List<String> archives = []
     File rootDir = new File("${project.buildDir}/archives")
     if (rootDir.exists()) {
@@ -81,25 +42,16 @@ slackSendMessage {
             }
         }
     }
-    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
-    )
+    // Set task properties
+    data = archives.join('\n').getBytes(StandardCharsets.UTF_8)
+    fileName = 'deployment-notes.txt'
+    contentType = 'text/html'
+}
+
+hipchatSendNotification {
+    String branch = project.hasProperty('branch') ? project.property('branch') : 'unknown'
+    message = "Began executable deploy of SmartThingsPublic(${branch})."
+    color = branch == 'master' ? 'yellow' : 'red'
+    notify = true
 }

circle.yml

@@ -15,11 +15,13 @@ 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
+      - ./gradlew deployArchives -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD -Ps3BucketName=$S3_BUCKET_NAME_PREPROD_DEV
+      - ./gradlew hipchatSendNotification -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD -Pbranch=$CIRCLE_BRANCH
+      - ./gradlew hipchatShareFile -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD
 
   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
+      - ./gradlew deployArchives -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD -Ps3BucketName=$S3_BUCKET_NAME_PREPROD_STAGING
+      - ./gradlew hipchatSendNotification -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD -Pbranch=$CIRCLE_BRANCH
+      - ./gradlew hipchatShareFile -PsmartThingsArtifactoryUserName=$ARTIFACTORY_USERNAME -PsmartThingsArtifactoryPassword=$ARTIFACTORY_PASSWORD

devicetypes/-/test.src/test.groovy

@@ -0,0 +1,93 @@
+/**
+ *  TEST
+ *
+ *  Copyright 2016 박춘영
+ *
+ *  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: "TEST", namespace: "스마트보안", author: "박춘영") {
+		capability "Button"
+		capability "Samsung TV"
+	}
+
+	simulator {
+		// TODO: define status and reply messages here
+	}
+
+	tiles {
+		// TODO: define your main and details tiles here
+	}
+}
+
+// parse events into attributes
+def parse(String description) {
+	log.debug "Parsing '${description}'"
+	// TODO: handle 'button' attribute
+	// TODO: handle 'volume' attribute
+	// TODO: handle 'mute' attribute
+	// TODO: handle 'pictureMode' attribute
+	// TODO: handle 'soundMode' attribute
+	// TODO: handle 'switch' attribute
+	// TODO: handle 'messageButton' attribute
+
+}
+
+// handle commands
+def volumeUp() {
+	log.debug "Executing 'volumeUp'"
+	// TODO: handle 'volumeUp' command
+}
+
+def volumeDown() {
+	log.debug "Executing 'volumeDown'"
+	// TODO: handle 'volumeDown' command
+}
+
+def setVolume() {
+	log.debug "Executing 'setVolume'"
+	// TODO: handle 'setVolume' command
+}
+
+def mute() {
+	log.debug "Executing 'mute'"
+	// TODO: handle 'mute' command
+}
+
+def unmute() {
+	log.debug "Executing 'unmute'"
+	// TODO: handle 'unmute' command
+}
+
+def setPictureMode() {
+	log.debug "Executing 'setPictureMode'"
+	// TODO: handle 'setPictureMode' command
+}
+
+def setSoundMode() {
+	log.debug "Executing 'setSoundMode'"
+	// TODO: handle 'setSoundMode' command
+}
+
+def on() {
+	log.debug "Executing 'on'"
+	// TODO: handle 'on' command
+}
+
+def off() {
+	log.debug "Executing 'off'"
+	// TODO: handle 'off' command
+}
+
+def showMessage() {
+	log.debug "Executing 'showMessage'"
+	// TODO: handle 'showMessage' command
+}

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/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,281 +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", icon:"st.motion.motion.inactive", backgroundColor:"#79b821")
-            	attributeState("active", icon:"st.motion.motion.active", backgroundColor:"#ffa81e")   
-            }
-            
-            tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
-				attributeState("active", label:'tamper active', backgroundColor:"#53a7c0")
-				attributeState("inactive", label:'tamper inactive', backgroundColor:"#ffffff")
-			}  
-        }
-        
-        valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {
-			state "temperature", label:'${currentValue}°',
-			backgroundColors:[
-				[value: 31, color: "#153591"],
-				[value: 44, color: "#1e9cbb"],
-				[value: 59, color: "#90d2a7"],
-				[value: 74, color: "#44b621"],
-				[value: 84, color: "#f1d801"],
-				[value: 95, color: "#d04e00"],
-				[value: 96, color: "#bc2323"]
-			]
-		}
-        
-        valueTile("illuminance", "device.illuminance", inactiveLabel: false, width: 2, height: 2) {
-			state "luminosity", label:'${currentValue} ${unit}', unit:"lux"
-		}
-        
-        valueTile("battery", "device.battery", inactiveLabel: false, width: 2, height: 2, decoration: "flat") {
-            state "battery", label:'${currentValue}% battery', unit:""
-        }
-        
-        main "FGMS"
-        details(["FGMS","battery","temperature","illuminance"])
-    }
-}
-
-// parse events into attributes
-def parse(String description) {
-	log.debug "Parsing '${description}'"        
-    def result = []
-    
-    if (description.startsWith("Err 106")) {
-		if (state.sec) {
-			result = createEvent(descriptionText:description, displayed:false)
-		} else {
-			result = createEvent(
-				descriptionText: "FGK failed to complete the network security key exchange. If you are unable to receive data from it, you must remove it from your network and add it again.",
-				eventType: "ALERT",
-				name: "secureInclusion",
-				value: "failed",
-				displayed: true,
-			)
-		}
-	} else if (description == "updated") {
-		return null
-	} else {
-    	def cmd = zwave.parse(description, [0x31: 5, 0x56: 1, 0x71: 3, 0x72: 2, 0x80: 1, 0x84: 2, 0x85: 2, 0x86: 1, 0x98: 1])
-    
-    	if (cmd) {
-    		log.debug "Parsed '${cmd}'"
-        	zwaveEvent(cmd)
-    	}
-    }
-}
-
-//security
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
-	def encapsulatedCommand = cmd.encapsulatedCommand([0x71: 3, 0x84: 2, 0x85: 2, 0x86: 1, 0x98: 1])
-	if (encapsulatedCommand) {
-		return zwaveEvent(encapsulatedCommand)
-	} else {
-		log.warn "Unable to extract encapsulated cmd from $cmd"
-		createEvent(descriptionText: cmd.toString())
-	}
-}
-
-//crc16
-def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd)
-{
-    def versions = [0x31: 5, 0x71: 3, 0x72: 2, 0x80: 1, 0x84: 2, 0x85: 2, 0x86: 1]
-	def version = versions[cmd.commandClass as Integer]
-	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
-	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
-	if (!encapsulatedCommand) {
-		log.debug "Could not extract command from $cmd"
-	} else {
-		zwaveEvent(encapsulatedCommand)
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd) {
-	def map = [ displayed: true ]
-    switch (cmd.sensorType) {
-    	case 1:
-        	map.name = "temperature"
-            map.unit = cmd.scale == 1 ? "F" : "C"
-            map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, map.unit, cmd.precision)
-            break
-    	case 3:
-        	map.name = "illuminance"
-            map.value = cmd.scaledSensorValue.toInteger().toString()
-            map.unit = "lux"
-            break
-    }
-
-	createEvent(map)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
-	def map = [:]
-    if (cmd.notificationType == 7) {
-    	switch (cmd.event) {
-        	case 0:
-            	if (cmd.eventParameter[0] == 3) {
-            		map.name = "tamper"
-                    map.value = "inactive"
-                    map.descriptionText = "${device.displayName}: tamper alarm has been deactivated"
-            	}
-            	if (cmd.eventParameter[0] == 8) {
-                	map.name = "motion"
-                    map.value = "inactive"
-                    map.descriptionText = "${device.displayName}: motion has stopped"
-                }
-        		break
-                
-        	case 3:
-            	map.name = "tamper"
-                map.value = "active"
-                map.descriptionText = "${device.displayName}: tamper alarm activated"
-            	break
-                
-            case 8:
-                map.name = "motion"
-                map.value = "active"
-                map.descriptionText = "${device.displayName}: motion detected"
-                break
-        }
-    }
-    
-    createEvent(map)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
-	def map = [:]
-	map.name = "battery"
-	map.value = cmd.batteryLevel == 255 ? 1 : cmd.batteryLevel.toString()
-	map.unit = "%"
-	map.displayed = true
-	createEvent(map)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd)
-{
-	def event = createEvent(descriptionText: "${device.displayName} woke up", displayed: false)
-    def cmds = []
-    cmds << encap(zwave.batteryV1.batteryGet())
-    cmds << "delay 500"
-    cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0))
-    cmds << "delay 500"
-    cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 3, scale: 1))     
-    cmds << "delay 1200"
-    cmds << encap(zwave.wakeUpV1.wakeUpNoMoreInformation())
-    [event, response(cmds)]
-    
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) { 
-	log.debug "manufacturerId:   ${cmd.manufacturerId}"
-    log.debug "manufacturerName: ${cmd.manufacturerName}"
-    log.debug "productId:        ${cmd.productId}"
-    log.debug "productTypeId:    ${cmd.productTypeId}"
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.DeviceSpecificReport cmd) { 
-	log.debug "deviceIdData:                ${cmd.deviceIdData}"
-    log.debug "deviceIdDataFormat:          ${cmd.deviceIdDataFormat}"
-    log.debug "deviceIdDataLengthIndicator: ${cmd.deviceIdDataLengthIndicator}"
-    log.debug "deviceIdType:                ${cmd.deviceIdType}"
-    
-    if (cmd.deviceIdType == 1 && cmd.deviceIdDataFormat == 1) {//serial number in binary format
-		String serialNumber = "h'"
-        
-        cmd.deviceIdData.each{ data ->
-        	serialNumber += "${String.format("%02X", data)}"
-        }
-        
-        updateDataValue("serialNumber", serialNumber)
-        log.debug "${device.displayName} - serial number: ${serialNumber}"
-    }
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {	
-    updateDataValue("version", "${cmd.applicationVersion}.${cmd.applicationSubVersion}")
-    log.debug "applicationVersion:      ${cmd.applicationVersion}"
-    log.debug "applicationSubVersion:   ${cmd.applicationSubVersion}"
-    log.debug "zWaveLibraryType:        ${cmd.zWaveLibraryType}"
-    log.debug "zWaveProtocolVersion:    ${cmd.zWaveProtocolVersion}"
-    log.debug "zWaveProtocolSubVersion: ${cmd.zWaveProtocolSubVersion}"
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLocallyNotification cmd) {
-	log.info "${device.displayName}: received command: $cmd - device has reset itself"
-}
-
-def configure() {
-	log.debug "Executing 'configure'"
-    
-    def cmds = []
-    
-    cmds += zwave.wakeUpV2.wakeUpIntervalSet(seconds: 7200, nodeid: zwaveHubNodeId)//FGMS' default wake up interval
-    cmds += zwave.manufacturerSpecificV2.manufacturerSpecificGet()
-    cmds += zwave.manufacturerSpecificV2.deviceSpecificGet()
-    cmds += zwave.versionV1.versionGet()
-    cmds += zwave.associationV2.associationSet(groupingIdentifier:1, nodeId:[zwaveHubNodeId])
-    cmds += zwave.batteryV1.batteryGet()
-    cmds += zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0)
-    cmds += zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 3, scale: 1)
-    cmds += zwave.wakeUpV2.wakeUpNoMoreInformation()
-    
-    encapSequence(cmds, 500)
-}
-
-private secure(physicalgraph.zwave.Command cmd) {
-	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
-}
-
-private crc16(physicalgraph.zwave.Command cmd) {
-	//zwave.crc16encapV1.crc16Encap().encapsulate(cmd).format()
-    "5601${cmd.format()}0000"
-}
-
-private encapSequence(commands, delay=200) {
-	delayBetween(commands.collect{ encap(it) }, delay)
-}
-
-private encap(physicalgraph.zwave.Command cmd) {
-	def secureClasses = [0x20, 0x30, 0x5A, 0x70, 0x71, 0x84, 0x85, 0x8E, 0x9C]
-
-	//todo: check if secure inclusion was successful
-    //if not do not send security-encapsulated command
-	if (secureClasses.find{ it == cmd.commandClassId }) {
-    	secure(cmd)
-    } else {
-    	crc16(cmd)
-    }
-}

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

@@ -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/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-multisensor-6.src/aeon-multisensor-6.groovy

@@ -22,14 +22,12 @@ metadata {
 		capability "Configuration"
 		capability "Sensor"
 		capability "Battery"
-		capability "Health Check"
 
 		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 {
@@ -328,9 +326,6 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 }
 
 def configure() {
-	// allow device user configured or default 16 min to check in; double the periodic reporting interval
-	sendEvent(name: "checkInterval", value: 2* (timeOptionValueMap[reportInterval] ?: (2*8*60)), displayed: false)
-
 	// 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 = []
@@ -357,7 +352,7 @@ def configure() {
 									motionSensitivity == "minimum" ? 0 : 64)
 
 	//5. report every x minutes (threshold reports don't work on battery power, default 8 mins)
-	request << zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: timeOptionValueMap[reportInterval] ?: (8*60)) //association group 1
+	request << zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: timeOptionValueMap[reportInterval] ?: 8*60) //association group 1
 
 	request << zwave.configurationV1.configurationSet(parameterNumber: 112, size: 4, scaledConfigurationValue: 6*60*60)  //association group 2
 

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

@@ -20,9 +20,6 @@ metadata {
 		capability "Configuration"
 		capability "Sensor"
 		capability "Battery"
-		capability "Health Check"
-
-		command "configureAfterSecure"
 
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x86,0x72,0x59,0x85,0x73,0x71,0x84,0x80,0x30,0x31,0x70,0x98,0x7A", outClusters:"0x5A"
 	}
@@ -248,8 +245,6 @@ def configureAfterSecure() {
 def configure() {
 	// log.debug "configure()"
     //["delay 30000"] + secure(zwave.securityV1.securityCommandsSupportedGet())
-	// allow device 16 min to check in; double the periodic reporting interval
-	sendEvent(name: "checkInterval", value: 2*8*60, displayed: false)
 }
 
 private setConfigured() {

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

@@ -20,7 +20,6 @@ metadata {
 		capability "Illuminance Measurement"
 		capability "Sensor"
 		capability "Battery"
-		capability "Health Check"
 
 		fingerprint deviceId: "0x2001", inClusters: "0x30,0x31,0x80,0x84,0x70,0x85,0x72,0x86"
 	}
@@ -181,9 +180,6 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 }
 
 def configure() {
-	// allow device 10 min to check in; double the periodic reporting interval
-	sendEvent(name: "checkInterval", value: 2*5*60, displayed: false)
-
 	delayBetween([
 		// send binary sensor report instead of basic set for motion
 		zwave.configurationV1.configurationSet(parameterNumber: 5, size: 1, scaledConfigurationValue: 2).format(),

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

@@ -11,7 +11,6 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
- 
 metadata {
     definition (name: "Arrival Sensor HA", namespace: "smartthings", author: "SmartThings") {
         capability "Tone"
@@ -33,7 +32,7 @@ metadata {
                 ])
         }
         section {
-            input "checkInterval", "enum", title: "Presence timeout (minutes)", description: "Tap to set",
+            input "checkInterval", "enum", title: "Presence timeout (minutes)",
                     defaultValue:"2", options: ["2", "3", "5"], displayDuringSetup: false
         }
     }
@@ -83,6 +82,7 @@ def parse(String description) {
 
 private handleReportAttributeMessage(String description) {
     def descMap = zigbee.parseDescriptionAsMap(description)
+
     if (descMap.clusterInt == 0x0001 && descMap.attrInt == 0x0020) {
         handleBatteryEvent(Integer.parseInt(descMap.value, 16))
     }
@@ -94,7 +94,6 @@ private handleReportAttributeMessage(String description) {
  * @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)"
     }
@@ -108,17 +107,15 @@ private handleBatteryEvent(volts) {
             volts = minVolts
         else if (volts > maxVolts)
             volts = maxVolts
-        def value = batteryMap[volts]
-        if (value != null) {
+        def pct = batteryMap[volts]
+        if (pct != null) {
             def linkText = getLinkText(device)
-            descriptionText = '{{ linkText }} battery was {{ value }}'
             def eventMap = [
                 name: 'battery',
-                value: value,
-                descriptionText: descriptionText,
-                translatable: true
+                value: pct,
+                descriptionText: "${linkText} battery was ${pct}%"
             ]
-            log.debug "Creating battery event for voltage=${volts/10}V: ${linkText} ${eventMap.name} is ${eventMap.value}%"
+            log.debug "Creating battery event for voltage=${volts/10}V: ${eventMap}"
             sendEvent(eventMap)
         }
     }
@@ -134,19 +131,13 @@ private handlePresenceEvent(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
+        descriptionText: "${linkText} has ${present ? 'arrived' : 'left'}",
     ]
-    log.debug "Creating presence event: ${device.displayName} ${eventMap.name} is ${eventMap.value}"
+    log.debug "Creating presence event: ${eventMap}"
     sendEvent(eventMap)
 }
 
@@ -167,4 +158,4 @@ def checkPresenceCallback() {
     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/bose-soundtouch.src/bose-soundtouch.groovy

@@ -64,10 +64,8 @@ metadata {
     }
 
     standardTile("switch", "device.switch", width: 1, height: 1, canChangeIcon: true) {
-        state "on", label: '${name}', action: "switch.off", icon: "st.Electronics.electronics16", backgroundColor: "#79b821", nextState:"turningOff"
-        state "turningOff", label:'TURNING OFF', icon:"st.Electronics.electronics16", backgroundColor:"#ffffff"
-        state "off", label: '${name}', action: "switch.on", icon: "st.Electronics.electronics16", backgroundColor: "#ffffff", nextState:"turningOn"
-        state "turningOn", label:'TURNING ON', icon:"st.Electronics.electronics16", backgroundColor:"#79b821"
+        state "off", label: '${name}', action: "switch.on", icon: "st.Electronics.electronics16", backgroundColor: "#ffffff"
+        state "on", label: '${name}', action: "switch.off", icon: "st.Electronics.electronics16", backgroundColor: "#79b821"
     }
     valueTile("1", "device.station1", decoration: "flat", canChangeIcon: false) {
         state "station1", label:'${currentValue}', action:"preset1"
@@ -749,16 +747,8 @@ def cb_boseSetInput(xml, input) {
  */
 def boseSetPowerState(boolean enable) {
     log.info "boseSetPowerState(${enable})"
-    // Fix to get faster update of power status back from speaker after sending on/off
-    // Instead of queuing the command to be sent after the refresh send it directly via sendHubCommand
-    // Note: This is a temporary hack that should be replaced by a re-design of the
-    // DTH to use sendHubCommand for all commands
-    sendHubCommand(bosePOST("/key", "<key state=\"press\" sender=\"Gabbo\">POWER</key>")) 
-    sendHubCommand(bosePOST("/key", "<key state=\"release\" sender=\"Gabbo\">POWER</key>"))
-    sendHubCommand(boseGET("/now_playing"))
-    if (enable) {
-        queueCallback('nowPlaying', "cb_boseConfirmPowerOn", 5)
-    }
+    queueCallback('nowPlaying', "cb_boseSetPowerState", enable ? "POWERON" : "POWEROFF")
+    return boseRefreshNowPlaying()
 }
 
 /**
@@ -797,11 +787,10 @@ def cb_boseSetPowerState(xml, state) {
  */
 def cb_boseConfirmPowerOn(xml, tries) {
     def result = []
-    def attempt = tries as Integer
-    log.warn "boseConfirmPowerOn() attempt #$attempt"
-    if (xml.attributes()['source'] == "STANDBY" && attempt > 0) {
+    log.warn "boseConfirmPowerOn() attempt #" + tries
+    if (xml.attributes()['source'] == "STANDBY" && tries > 0) {
         result << boseRefreshNowPlaying()
-        queueCallback('nowPlaying', "cb_boseConfirmPowerOn", attempt-1)
+        queueCallback('nowPlaying', "cb_boseConfirmPowerOn", tries-1)
     }
     return result
 }

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

@@ -13,13 +13,12 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-
+ 
 metadata {
     definition (name: "Cree Bulb", namespace: "smartthings", author: "SmartThings") {
 
         capability "Actuator"
         capability "Configuration"
-        capability "Polling"
         capability "Refresh"
         capability "Switch"
         capability "Switch Level"
@@ -89,10 +88,6 @@ def refresh() {
     zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig() + zigbee.levelConfig()
 }
 
-def poll() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh()
-}
-
 def configure() {
     log.debug "Configuring Reporting and Bindings."
     zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()

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

@@ -21,9 +21,7 @@ metadata {
 		capability "Refresh"
 		capability "Sensor"
 
-		fingerprint mfr:"0063", prod:"4457", deviceJoinName: "Z-Wave Wall Dimmer"
-		fingerprint mfr:"0063", prod:"4944", deviceJoinName: "Z-Wave Wall Dimmer"
-		fingerprint mfr:"0063", prod:"5044", deviceJoinName: "Z-Wave Plug-In Dimmer"
+		fingerprint inClusters: "0x26"
 	}
 
 	simulator {
@@ -44,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") {
@@ -76,28 +70,11 @@ metadata {
 		}
 
 		main(["switch"])
-		details(["switch", "level", "refresh"])
+		details(["switch", "level", "indicator", "refresh"])
 
 	}
 }
 
-def updated(){
-  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") {
@@ -161,7 +138,6 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
 	log.debug "productTypeId:    ${cmd.productTypeId}"
 	def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
 	updateDataValue("MSR", msr)
-	updateDataValue("manufacturer", cmd.manufacturerName)
 	createEvent([descriptionText: "$device.displayName MSR: $msr", isStateChange: false])
 }
 
@@ -225,19 +201,19 @@ def refresh() {
 	delayBetween(commands,100)
 }
 
-void indicatorWhenOn() {
-	sendEvent(name: "indicatorStatus", value: "when on", display: false)
-	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()))
+def indicatorWhenOn() {
+	sendEvent(name: "indicatorStatus", value: "when on")
+	zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()
 }
 
-void indicatorWhenOff() {
-	sendEvent(name: "indicatorStatus", value: "when off", display: false)
-	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 3, size: 1).format()))
+def indicatorWhenOff() {
+	sendEvent(name: "indicatorStatus", value: "when off")
+	zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 3, size: 1).format()
 }
 
-void indicatorNever() {
-	sendEvent(name: "indicatorStatus", value: "never", display: false)
-	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 3, size: 1).format()))
+def indicatorNever() {
+	sendEvent(name: "indicatorStatus", value: "never")
+	zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 3, size: 1).format()
 }
 
 def invertSwitch(invert=true) {
@@ -247,4 +223,4 @@ def invertSwitch(invert=true) {
 	else {
 		zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 4, size: 1).format()
 	}
-}
+}

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

@@ -20,6 +20,7 @@ metadata {
 		capability "Temperature Measurement"
 		capability "Motion Sensor"
 		capability "Refresh"
+		capability "Polling"
 	}
 
 	tiles {
@@ -67,6 +68,6 @@ def refresh() {
 
 void poll() {
 	log.debug "Executing 'poll' using parent SmartApp"
-	parent.pollChild()
+	parent.pollChild(this)
 
 }

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

@@ -20,6 +20,7 @@ metadata {
 		capability "Actuator"
 		capability "Thermostat"
 		capability "Temperature Measurement"
+		capability "Polling"
 		capability "Sensor"
 		capability "Refresh"
 		capability "Relative Humidity Measurement"
@@ -133,7 +134,9 @@ def refresh() {
 
 void poll() {
 	log.debug "Executing 'poll' using parent SmartApp"
-	parent.pollChild()
+
+	def results = parent.pollChild(this)
+	generateEvent(results) //parse received message from parent
 }
 
 def generateEvent(Map results) {
@@ -379,16 +382,12 @@ def getDataByName(String name) {
 	state[name] ?: device.getDataValue(name)
 }
 
-def setThermostatMode(String mode) {
-	log.debug "setThermostatMode($mode)"
-	mode = mode.toLowerCase()
-	switchToMode(mode)
+def setThermostatMode(String value) {
+	log.debug "setThermostatMode({$value})"
 }
 
-def setThermostatFanMode(String mode) {
-	log.debug "setThermostatFanMode($mode)"
-	mode = mode.toLowerCase()
-	switchToFanMode(mode)
+def setThermostatFanMode(String value) {
+	log.debug "setThermostatFanMode({$value})"
 }
 
 def generateModeEvent(mode) {

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

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

devicetypes/smartthings/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"
-    }
+	}
 
 	// 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" && state.trigger == "setLevel") || resultMap.name != "level") {  //doing this to account for weird level reporting bug with GE Link Bulbs
-            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 500"
+
+    [
+	"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,63 +270,109 @@ def updated() {
 }
 
 def on() {
+	state.lvl = "00"
     state.trigger = "on/off"
-    zigbee.on()
+
+    // log.debug "on()"
+	sendEvent(name: "switch", value: "on")
+	"st cmd 0x${device.deviceNetworkId} 1 6 1 {}"
 }
 
 def off() {
+	state.lvl = "00"
     state.trigger = "on/off"
-    zigbee.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 500"
-    ]
 
-    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 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"
-    def cmd
-    def delayForRefresh = 500
+    state.lvl = "${level}"
+
     if (dimRate && (state?.rate != null)) {
-        def computedRate = convertRateValue(state.rate)
-        cmd = zigbee.setLevel(value, computedRate)
-        delayForRefresh += computedRate * 100       //converting tenth of second to milliseconds
+    	cmds << "st cmd 0x${device.deviceNetworkId} 1 8 4 {${level} ${state.rate}}"
     }
     else {
-        cmd = zigbee.setLevel(value, 20)
-        delayForRefresh += 2000
+    	cmds << "st cmd 0x${device.deviceNetworkId} 1 8 4 {${level} 1500}"
     }
-    cmd + ["delay $delayForRefresh"] + zigbee.levelRefresh()
-}
 
-int convertRateValue(rate) {
-    int convertedRate = 0
-    switch (rate)
-    {
-        case "0000":
-            convertedRate = 0
-            break
-
-        case "1500":
-            convertedRate = 20      //0015 hex in int is 2.1
-            break
-
-        case "2500":
-            convertedRate = 35      //0025 hex in int is 3.7
-            break
-
-        case "3500":
-            convertedRate = 50      //0035 hex in int is 5.1
-            break
-    }
-    convertedRate
+    log.debug cmds
+    cmds
 }
 
 def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    return zigbee.onOffConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
+
+	log.debug "Configuring Reporting and Bindings."
+	def configCmds = [
+
+        //Switch Reporting
+        "zcl global send-me-a-report 6 0 0x10 0 3600 {01}", "delay 500",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1000",
+
+        //Level Control Reporting
+        "zcl global send-me-a-report 8 0 0x20 5 3600 {0010}", "delay 200",
+        "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
+
+        "zdo bind 0x${device.deviceNetworkId} 1 1 6 {${device.zigbeeId}} {}", "delay 1000",
+		"zdo bind 0x${device.deviceNetworkId} 1 1 8 {${device.zigbeeId}} {}", "delay 500",
+	]
+    return configCmds + refresh() // send refresh cmds as part of config
 }
+
+private hex(value, width=2) {
+	def s = new BigInteger(Math.round(value).toString()).toString(16)
+	while (s.size() < width) {
+		s = "0" + s
+	}
+	s
+}
+
+private Integer convertHexToInt(hex) {
+	Integer.parseInt(hex,16)
+}
+
+private String swapEndianHex(String hex) {
+    reverseArray(hex.decodeHex()).encodeHex()
+}
+
+private byte[] reverseArray(byte[] array) {
+    int i = 0;
+    int j = array.length - 1;
+    byte tmp;
+    while (j > i) {
+        tmp = array[j];
+        array[j] = array[i];
+        array[i] = tmp;
+        j--;
+        i++;
+    }
+    return array
+}

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

@@ -1,224 +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"
-
-		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 Color", action:"reset", icon:"st.lights.philips.hue-single"
-		}
-
-		standardTile("refresh", "device.refresh", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-
-		main(["rich-control"])
-		details(["rich-control", "colorTempSliderControl", "colorTemp", "reset", "refresh"])
-	}
-}
-
-// parse events into attributes
-def parse(description) {
-	log.debug "parse() - $description"
-	def results = []
-
-	def map = description
-	if (description instanceof String)  {
-		log.debug "Hue Bulb stringToMap - ${map}"
-		map = stringToMap(description)
-	}
-
-	if (map?.name && map?.value) {
-		results << createEvent(name: "${map?.name}", value: "${map?.value}")
-	}
-	results
-}
-
-// handle commands
-void on() {
-	log.trace parent.on(this)
-	sendEvent(name: "switch", value: "on")
-}
-
-void off() {
-	log.trace parent.off(this)
-	sendEvent(name: "switch", value: "off")
-}
-
-void nextLevel() {
-	def level = device.latestValue("level") as Integer ?: 0
-	if (level <= 100) {
-		level = Math.min(25 * (Math.round(level / 25) + 1), 100) as Integer
-	}
-	else {
-		level = 25
-	}
-	setLevel(level)
-}
-
-void setLevel(percent) {
-    log.debug "Executing 'setLevel'"
-    if (verifyPercent(percent)) {
-        parent.setLevel(this, percent)
-        sendEvent(name: "level", value: percent, descriptionText: "Level has changed to ${percent}%")
-        sendEvent(name: "switch", value: "on")
-    }
-}
-
-void setSaturation(percent) {
-    log.debug "Executing 'setSaturation'"
-    if (verifyPercent(percent)) {
-        parent.setSaturation(this, percent)
-        sendEvent(name: "saturation", value: percent, displayed: false)
-    }
-}
-
-void setHue(percent) {
-    log.debug "Executing 'setHue'"
-    if (verifyPercent(percent)) {
-        parent.setHue(this, percent)
-        sendEvent(name: "hue", value: percent, displayed: false)
-    }
-}
-
-void setColor(value) {
-    log.debug "setColor: ${value}, $this"
-    def events = []
-    def validValues = [:]
-
-    if (verifyPercent(value.hue)) {
-        events << createEvent(name: "hue", value: value.hue, displayed: false)
-        validValues.hue = value.hue
-    }
-    if (verifyPercent(value.saturation)) {
-        events << createEvent(name: "saturation", value: value.saturation, displayed: false)
-        validValues.saturation = value.saturation
-    }
-    if (value.hex != null) {
-        if (value.hex ==~ /^\#([A-Fa-f0-9]){6}$/) {
-            events << createEvent(name: "color", value: value.hex)
-            validValues.hex = value.hex
-        } else {
-            log.warn "$value.hex is not a valid color"
-        }
-    }
-    if (verifyPercent(value.level)) {
-        events << createEvent(name: "level", value: value.level, descriptionText: "Level has changed to ${value.level}%")
-        validValues.level = value.level
-    }
-    if (value.switch == "off" || (value.level != null && value.level <= 0)) {
-        events << createEvent(name: "switch", value: "off")
-        validValues.switch = "off"
-    } else {
-        events << createEvent(name: "switch", value: "on")
-        validValues.switch = "on"
-    }
-    if (!events.isEmpty()) {
-        parent.setColor(this, validValues)
-    }
-    events.each {
-        sendEvent(it)
-    }
-}
-
-void reset() {
-    log.debug "Executing 'reset'"
-    def value = [level:100, saturation:56, hue:23]
-    setAdjustedColor(value)
-    parent.poll()
-}
-
-void setAdjustedColor(value) {
-    if (value) {
-        log.trace "setAdjustedColor: ${value}"
-        def adjusted = value + [:]
-        adjusted.hue = adjustOutgoingHue(value.hue)
-        // Needed because color picker always sends 100
-        adjusted.level = null
-        setColor(adjusted)
-    } else {
-        log.warn "Invalid color input"
-    }
-}
-
-void setColorTemperature(value) {
-    if (value) {
-        log.trace "setColorTemperature: ${value}k"
-        parent.setColorTemperature(this, value)
-        sendEvent(name: "colorTemperature", value: value)
-        sendEvent(name: "switch", value: "on")
-    } else {
-        log.warn "Invalid color temperature"
-    }
-}
-
-void refresh() {
-    log.debug "Executing 'refresh'"
-    parent.manualRefresh()
-}
-
-def adjustOutgoingHue(percent) {
-	def adjusted = percent
-	if (percent > 31) {
-		if (percent < 63.0) {
-			adjusted = percent + (7 * (percent -30 ) / 32)
-		}
-		else if (percent < 73.0) {
-			adjusted = 69 + (5 * (percent - 62) / 10)
-		}
-		else {
-			adjusted = percent + (2 * (100 - percent) / 28)
-		}
-	}
-	log.info "percent: $percent, adjusted: $adjusted"
-	adjusted
-}
-
-def verifyPercent(percent) {
-    if (percent == null)
-        return false
-    else if (percent >= 0 && percent <= 100) {
-        return true
-    } else {
-        log.warn "$percent is not 0-100"
-        return false
-    }
-}

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

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

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

@@ -1,11 +1,8 @@
 /**
  *  Hue Bulb
  *
- *  Philips Hue Type "Extended Color Light"
- *
  *  Author: SmartThings
  */
-
 // for the UI
 metadata {
 	// Automatically generated. Make future change here.
@@ -38,15 +35,24 @@ metadata {
 			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
 				attributeState "level", action:"switch level.setLevel", range:"(0..100)"
             }
+            tileAttribute ("device.level", key: "SECONDARY_CONTROL") {
+	            attributeState "level", label: 'Level ${currentValue}%'
+			}
 			tileAttribute ("device.color", key: "COLOR_CONTROL") {
 				attributeState "color", action:"setAdjustedColor"
 			}
 		}
 
+		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+			state "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+			state "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+			state "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+			state "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+		}
+
         controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2000..6500)") {
             state "colorTemperature", action:"color temperature.setColorTemperature"
         }
-
         valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
             state "colorTemperature", label: '${currentValue} K'
         }
@@ -54,12 +60,29 @@ metadata {
 		standardTile("reset", "device.reset", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
 			state "default", label:"Reset Color", action:"reset", icon:"st.lights.philips.hue-single"
 		}
-
-		standardTile("refresh", "device.refresh", height: 2, width: 2, inactiveLabel: false, decoration: "flat") {
+		standardTile("refresh", "device.switch", height: 2, width: 2, 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("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}   '
+		}
 
-		main(["rich-control"])
+		main(["switch"])
 		details(["rich-control", "colorTempSliderControl", "colorTemp", "reset", "refresh"])
 	}
 }
@@ -68,13 +91,11 @@ metadata {
 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}")
 	}
@@ -104,104 +125,62 @@ void nextLevel() {
 }
 
 void setLevel(percent) {
-    log.debug "Executing 'setLevel'"
-    if (verifyPercent(percent)) {
-        parent.setLevel(this, percent)
-        sendEvent(name: "level", value: percent, descriptionText: "Level has changed to ${percent}%")
-        sendEvent(name: "switch", value: "on")
-    }
+	log.debug "Executing 'setLevel'"
+	parent.setLevel(this, percent)
+	sendEvent(name: "level", value: percent)
 }
 
 void setSaturation(percent) {
-    log.debug "Executing 'setSaturation'"
-    if (verifyPercent(percent)) {
-        parent.setSaturation(this, percent)
-        sendEvent(name: "saturation", value: percent, displayed: false)
-    }
+	log.debug "Executing 'setSaturation'"
+	parent.setSaturation(this, percent)
+	sendEvent(name: "saturation", value: percent)
 }
 
 void setHue(percent) {
-    log.debug "Executing 'setHue'"
-    if (verifyPercent(percent)) {
-        parent.setHue(this, percent)
-        sendEvent(name: "hue", value: percent, displayed: false)
-    }
+	log.debug "Executing 'setHue'"
+	parent.setHue(this, percent)
+	sendEvent(name: "hue", value: percent)
 }
 
 void setColor(value) {
-    log.debug "setColor: ${value}, $this"
-    def events = []
-    def validValues = [:]
-
-    if (verifyPercent(value.hue)) {
-        events << createEvent(name: "hue", value: value.hue, displayed: false)
-        validValues.hue = value.hue
-    }
-    if (verifyPercent(value.saturation)) {
-        events << createEvent(name: "saturation", value: value.saturation, displayed: false)
-        validValues.saturation = value.saturation
-    }
-    if (value.hex != null) {
-        if (value.hex ==~ /^\#([A-Fa-f0-9]){6}$/) {
-            events << createEvent(name: "color", value: value.hex)
-            validValues.hex = value.hex
-        } else {
-            log.warn "$value.hex is not a valid color"
-        }
-    }
-    if (verifyPercent(value.level)) {
-        events << createEvent(name: "level", value: value.level, descriptionText: "Level has changed to ${value.level}%")
-        validValues.level = value.level
-    }
-    if (value.switch == "off" || (value.level != null && value.level <= 0)) {
-        events << createEvent(name: "switch", value: "off")
-        validValues.switch = "off"
-    } else {
-        events << createEvent(name: "switch", value: "on")
-        validValues.switch = "on"
-    }
-    if (!events.isEmpty()) {
-        parent.setColor(this, validValues)
-    }
-    events.each {
-        sendEvent(it)
-    }
+	log.debug "setColor: ${value}, $this"
+	parent.setColor(this, value)
+	if (value.hue) { sendEvent(name: "hue", value: value.hue)}
+	if (value.saturation) { sendEvent(name: "saturation", value: value.saturation)}
+	if (value.hex) { sendEvent(name: "color", value: value.hex)}
+	if (value.level) { sendEvent(name: "level", value: value.level)}
+	if (value.switch) { sendEvent(name: "switch", value: value.switch)}
 }
 
 void reset() {
-    log.debug "Executing 'reset'"
-    def value = [level:100, saturation:56, hue:23]
+	log.debug "Executing 'reset'"
+    def value = [level:100, hex:"#90C638", saturation:56, hue:23]
     setAdjustedColor(value)
-    parent.poll()
+	parent.poll()
 }
 
 void setAdjustedColor(value) {
-    if (value) {
+	if (value) {
         log.trace "setAdjustedColor: ${value}"
         def adjusted = value + [:]
         adjusted.hue = adjustOutgoingHue(value.hue)
         // Needed because color picker always sends 100
         adjusted.level = null
         setColor(adjusted)
-    } else {
-        log.warn "Invalid color input"
     }
 }
 
 void setColorTemperature(value) {
-    if (value) {
+	if (value) {
         log.trace "setColorTemperature: ${value}k"
         parent.setColorTemperature(this, value)
         sendEvent(name: "colorTemperature", value: value)
-        sendEvent(name: "switch", value: "on")
-    } else {
-        log.warn "Invalid color temperature"
-    }
+	}
 }
 
 void refresh() {
-    log.debug "Executing 'refresh'"
-    parent.manualRefresh()
+	log.debug "Executing 'refresh'"
+	parent.manualRefresh()
 }
 
 def adjustOutgoingHue(percent) {
@@ -220,14 +199,3 @@ def adjustOutgoingHue(percent) {
 	log.info "percent: $percent, adjusted: $adjusted"
 	adjusted
 }
-
-def verifyPercent(percent) {
-    if (percent == null)
-        return false
-    else if (percent >= 0 && percent <= 100) {
-        return true
-    } else {
-        log.warn "$percent is not 0-100"
-        return false
-    }
-}

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

@@ -1,8 +1,6 @@
 /**
  *  Hue Lux Bulb
  *
- *  Philips Hue Type "Dimmable Light"
- *
  *  Author: SmartThings
  */
 // for the UI
@@ -11,6 +9,7 @@ metadata {
 	definition (name: "Hue Lux Bulb", namespace: "smartthings", author: "SmartThings") {
 		capability "Switch Level"
 		capability "Actuator"
+		capability "Color Temperature"
 		capability "Switch"
 		capability "Refresh"
 		capability "Sensor"
@@ -33,18 +32,35 @@ metadata {
             tileAttribute ("device.level", key: "SLIDER_CONTROL") {
               attributeState "level", action:"switch level.setLevel", range:"(0..100)"
             }
+            tileAttribute ("device.level", key: "SECONDARY_CONTROL") {
+	            attributeState "level", label: 'Level ${currentValue}%'
+			}
+        }
+
+		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+			state "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+			state "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+			state "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+			state "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
         }
 
         controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false, range:"(0..100)") {
             state "level", action:"switch level.setLevel"
         }
 
-        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+        controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2000..6500)") {
+            state "colorTemperature", action:"color temperature.setColorTemperature"
+        }
+        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "colorTemperature", label: '${currentValue} K'
+        }
+
+        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
             state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
         }
 
-        main(["rich-control"])
-        details(["rich-control", "refresh"])
+        main(["switch"])
+        details(["rich-control", "colorTempSliderControl", "colorTemp", "refresh"])
     }
 }
 
@@ -67,24 +83,27 @@ def parse(description) {
 
 // handle commands
 void on() {
-	log.trace parent.on(this)
+	parent.on(this)
 	sendEvent(name: "switch", value: "on")
 }
 
 void off() {
-	log.trace parent.off(this)
+	parent.off(this)
 	sendEvent(name: "switch", value: "off")
 }
 
 void setLevel(percent) {
 	log.debug "Executing 'setLevel'"
-    if (percent != null && percent >= 0 && percent <= 100) {
-		parent.setLevel(this, percent)
-		sendEvent(name: "level", value: percent)
-		sendEvent(name: "switch", value: "on")
-	} else {
-    	log.warn "$percent is not 0-100"
-    }
+	parent.setLevel(this, percent)
+	sendEvent(name: "level", value: percent)
+}
+
+void setColorTemperature(value) {
+	if (value) {
+        log.trace "setColorTemperature: ${value}k"
+        parent.setColorTemperature(this, value)
+        sendEvent(name: "colorTemperature", value: value)
+	}
 }
 
 void refresh() {

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"
-
-        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:"(2000..6500)") {
-            state "colorTemperature", action:"color temperature.setColorTemperature"
-        }
-
-        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "colorTemperature", label: '${currentValue} K'
-        }
-
-        standardTile("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"])
-    }
-}
-
-// 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)
-    sendEvent(name: "switch", value: "on")
-}
-
-void off() {
-    log.trace parent.off(this)
-    sendEvent(name: "switch", value: "off")
-}
-
-void setLevel(percent) {
-    log.debug "Executing 'setLevel'"
-    if (percent != null && percent >= 0 && percent <= 100) {
-        parent.setLevel(this, percent)
-        sendEvent(name: "level", value: percent)
-        sendEvent(name: "switch", value: "on")
-    } else {
-        log.warn "$percent is not 0-100"
-    }
-}
-
-void setColorTemperature(value) {
-    if (value) {
-        log.trace "setColorTemperature: ${value}k"
-        parent.setColorTemperature(this, value)
-        sendEvent(name: "colorTemperature", value: value)
-        sendEvent(name: "switch", value: "on")
-    } else {
-        log.warn "Invalid color temperature"
-    }
-}
-
-void refresh() {
-    log.debug "Executing 'refresh'"
-    parent.manualRefresh()
-}
-

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

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

@@ -24,7 +24,6 @@ metadata {
         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"

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

@@ -19,6 +19,11 @@ metadata {
         capability "Sensor"
 
         attribute "colorName", "string"
+
+        // indicates that device keeps track of heartbeat (in state.heartbeat)
+        attribute "heartbeat", "string"
+        
+
     }
 
     // simulator metadata
@@ -70,6 +75,9 @@ metadata {
 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"))
         {
@@ -124,6 +132,7 @@ def off() {
 }
 
 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",

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,29 +1,32 @@
-/*
- *  Copyright 2016 SmartThings
+/**
+ *  Copyright 2015 SmartThings
  *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
- *  use this file except in compliance with the License. You may obtain a copy
- *  of the License at:
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- *  License for the specific language governing permissions and limitations
- *  under the License.
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ *	SmartPower Outlet (CentraLite)
+ *
+ *	Author: SmartThings
+ *	Date: 2015-08-23
  */
-
 metadata {
 	// Automatically generated. Make future change here.
-	definition (name: "SmartPower Outlet", namespace: "smartthings", author: "SmartThings", category: "C1") {
+	definition (name: "SmartPower Outlet", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
 		capability "Switch"
 		capability "Power Meter"
 		capability "Configuration"
 		capability "Refresh"
 		capability "Sensor"
-		capability "Health Check"
+
+		// indicates that device keeps track of heartbeat (in state.heartbeat)
+		attribute "heartbeat", "string"
 
 		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite",  model: "3200", deviceJoinName: "Outlet"
 		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0B04,0B05", outClusters: "0019", manufacturer: "CentraLite",  model: "3200-Sgb", deviceJoinName: "Outlet"
@@ -55,10 +58,10 @@ metadata {
 	tiles(scale: 2) {
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
 			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label: '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"
+				attributeState "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821", nextState: "turningOff"
+				attributeState "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "turningOn"
+				attributeState "turningOn", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821", nextState: "turningOff"
+				attributeState "turningOff", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "turningOn"
 			}
 			tileAttribute ("power", key: "SECONDARY_CONTROL") {
 				attributeState "power", label:'${currentValue} W'
@@ -78,6 +81,9 @@ metadata {
 def parse(String description) {
 	log.debug "description is $description"
 
+	// save heartbeat (i.e. last time we got a message from device)
+	state.heartbeat = Calendar.getInstance().getTimeInMillis()
+
 	def finalResult = zigbee.getKnownDescription(description)
 
 	//TODO: Remove this after getKnownDescription can parse it automatically
@@ -85,22 +91,22 @@ def parse(String description) {
 		finalResult = getPowerDescription(zigbee.parseDescriptionAsMap(description))
 
 	if (finalResult) {
-		log.info "final result = $finalResult"
+		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, descriptionText: '{{ device.displayName }} power is {{ value }} Watts', translatable: true )
+			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 {
-			def descriptionText = finalResult.value == "on" ? '{{ device.displayName }} is On' : '{{ device.displayName }} is Off'
-			sendEvent(name: finalResult.type, value: finalResult.value, descriptionText: descriptionText, translatable: true)
+			sendEvent(name: finalResult.type, value: finalResult.value)
 		}
 	}
 	else {
@@ -118,11 +124,11 @@ def on() {
 }
 
 def refresh() {
+	sendEvent(name: "heartbeat", value: "alive", displayed:false)
 	zigbee.onOffRefresh() + zigbee.refreshData("0x0B04", "0x050B")
 }
 
 def configure() {
-	sendEvent(name: "checkInterval", value: 1200, displayed: false)
 	zigbee.onOffConfig() + powerConfig() + refresh()
 }
 

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

@@ -1,35 +1,14 @@
-#  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=누수
+
+# Generated on Wed Feb 24 14:28:26 CST 2016 by dylan
+'''Adjust temperature by this many degrees'''.ko=몇 도씩 온도를 조절하십시오
+'''Degrees'''.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=기준 온도를 원하는대로 몇 도 올리거나 내려서 설정할 수 있습니다. 
+'''battery'''.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 }}%
-#==============================================================================
+'''{{ device.displayName }} battery was {{ value }}'''.ko={{ device.displayName }} 배터리가 {{ value }}였습니다
+'''{{ device.displayName }} is {{ value | translate }}'''.ko={{ device.displayName }}이(가) {{ value | translate }}입니다
+'''{{ device.displayName }} was {{ value }}°C'''.ko={{ device.displayName }}이(가) {{ value }}°C였습니다
+'''{{ device.displayName }} was {{ value }}°F'''.ko={{ device.displayName }}이(가) {{ value }}°F였습니다

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

@@ -1,27 +1,25 @@
-/*
- *  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.
+ *
  */
-
 metadata {
-	definition (name: "SmartSense Moisture Sensor",namespace: "smartthings", author: "SmartThings", category: "C2") {
+	definition (name: "SmartSense Moisture Sensor",namespace: "smartthings", author: "SmartThings") {
 		capability "Configuration"
 		capability "Battery"
 		capability "Refresh"
 		capability "Temperature Measurement"
 		capability "Water Sensor"
-		capability "Health Check"
 
 		command "enrollResponse"
 
@@ -45,7 +43,7 @@ metadata {
 				])
 		}
 		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 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
 		}
 	}
@@ -118,16 +116,16 @@ private Map parseCatchAllMessage(String description) {
 				resultMap = getBatteryResult(cluster.data.last())
 				break
 
-            case 0x0402:
-                // temp is last 2 data values. reverse to swap endian
-                String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
-                def value = getTemperature(temp)
-                resultMap = getTemperatureResult(value)
-                break
-        }
-    }
+			case 0x0402:
+				// temp is last 2 data values. reverse to swap endian
+				String temp = cluster.data[-2..-1].reverse().collect { cluster.hex1(it) }.join()
+				def value = getTemperature(temp)
+				resultMap = getTemperatureResult(value)
+				break
+		}
+	}
 
-    return resultMap
+	return resultMap
 }
 
 private boolean shouldProcessMessage(cluster) {
@@ -222,8 +220,7 @@ private Map getBatteryResult(rawValue) {
 
 	def result = [
 		name: 'battery',
-		value: '--',
-		translatable: true
+		value: '--'
 	]
 
 	def volts = rawValue / 10
@@ -231,7 +228,7 @@ private Map getBatteryResult(rawValue) {
 	if (rawValue == 0 || rawValue == 255) {}
 	else {
 		if (volts > 3.5) {
-			result.descriptionText = "{{ device.displayName }} battery has too much power: (> 3.5) volts."
+			result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
 		}
 		else {
 			if (device.getDataValue("manufacturer") == "SmartThings") {
@@ -248,16 +245,15 @@ private Map getBatteryResult(rawValue) {
 				def pct = batteryMap[volts]
 				if (pct != null) {
 					result.value = pct
-					result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+					result.descriptionText = "${linkText} battery was ${result.value}%"
 				}
 			}
 			else {
 				def minVolts = 2.1
 				def maxVolts = 3.0
 				def pct = (volts - minVolts) / (maxVolts - minVolts)
-				def roundedPct = Math.round(pct * 100)
-				result.value = Math.min(100, roundedPct)
-				result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+				result.value = Math.min(100, (int) pct * 100)
+				result.descriptionText = "${linkText} battery was ${result.value}%"
 			}
 		}
 	}
@@ -267,37 +263,27 @@ private Map getBatteryResult(rawValue) {
 
 private Map getTemperatureResult(value) {
 	log.debug 'TEMP'
+	def linkText = getLinkText(device)
 	if (tempOffset) {
 		def offset = tempOffset as int
 		def v = value as int
 		value = v + offset
 	}
-    def descriptionText
-    if ( temperatureScale == 'C' )
-    	descriptionText = '{{ device.displayName }} was {{ value }}°C'
-    else
-    	descriptionText = '{{ device.displayName }} was {{ value }}°F'
-
+	def descriptionText = "${linkText} was ${value}°${temperatureScale}"
 	return [
 		name: 'temperature',
 		value: value,
-		descriptionText: descriptionText,
-        translatable: true
+		descriptionText: descriptionText
 	]
 }
 
 private Map getMoistureResult(value) {
-	log.debug "water"
-    def descriptionText
-    if ( value == "wet" )
-    	descriptionText = '{{ device.displayName }} is wet'
-    else
-    	descriptionText = '{{ device.displayName }} is dry'
+	log.debug 'water'
+	String descriptionText = "${device.displayName} is ${value}"
 	return [
 		name: 'water',
 		value: value,
-		descriptionText: descriptionText,
-        translatable: true
+		descriptionText: descriptionText
 	]
 }
 
@@ -312,8 +298,6 @@ def refresh() {
 }
 
 def configure() {
-	sendEvent(name: "checkInterval", value: 7200, displayed: false)
-
 	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting, IAS CIE, and Bindings."
 	def configCmds = [

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,30 +0,0 @@
-# Smartsense Motion Sensor
-
-
-
-Works with: 
-
-* [Samsung SmartThings Motion Sensor](https://shop.smartthings.com/#!/products/samsung-smartthings-motion-sensor)
-
-## Table of contents
-
-* [Capabilities](#capabilities)
-* [Health]($health)
-
-## 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
-
-A Category C2 motion sensor that has 120min check-in interval
-
-
-
-
-
-

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

@@ -1,33 +1,13 @@
-#  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=온도
+
+# Generated on Wed Feb 24 14:28:26 CST 2016 by dylan
 '''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였습니다
+'''Degrees'''.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=기준 온도를 원하는대로 몇 도 올리거나 내려서 설정할 수 있습니다. 
+'''battery'''.ko=배터리
 '''{{ device.displayName }} battery has too much power: (> 3.5) volts.'''.ko={{ device.displayName }} 배터리 전력이 너무 높습니다(3.5볼트 초과).
-'''{{ device.displayName }} battery was {{ value }}%'''.ko={{ device.displayName }}의 남은 배터리 {{ value }}%
-#==============================================================================
+'''{{ device.displayName }} battery was {{ value }}'''.ko={{ device.displayName }} 배터리가 {{ value }}였습니다
+'''{{ 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였습니다

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

@@ -1,27 +1,26 @@
-/*
- *  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.
+ *
  */
 
 metadata {
-	definition (name: "SmartSense Motion Sensor", namespace: "smartthings", author: "SmartThings", category: "C2") {
+	definition (name: "SmartSense Motion Sensor", namespace: "smartthings", author: "SmartThings") {
 		capability "Motion Sensor"
 		capability "Configuration"
 		capability "Battery"
 		capability "Temperature Measurement"
 		capability "Refresh"
-		capability "Health Check"
 
 		command "enrollResponse"
 
@@ -48,7 +47,7 @@ metadata {
 				])
 		}
 		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 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
 		}
 	}
@@ -237,8 +236,7 @@ private Map getBatteryResult(rawValue) {
 
 	def result = [
 		name: 'battery',
-		value: '--',
-		translatable: true
+		value: '--'
 	]
 
 	def volts = rawValue / 10
@@ -246,7 +244,7 @@ private Map getBatteryResult(rawValue) {
 	if (rawValue == 0 || rawValue == 255) {}
 	else {
 		if (volts > 3.5) {
-			result.descriptionText = "{{ device.displayName }} battery has too much power: (> 3.5) volts."
+			result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
 		}
 		else {
 			if (device.getDataValue("manufacturer") == "SmartThings") {
@@ -263,17 +261,15 @@ private Map getBatteryResult(rawValue) {
 				def pct = batteryMap[volts]
 				if (pct != null) {
 					result.value = pct
-                    def value = pct
-					result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+					result.descriptionText = "${linkText} battery was ${result.value}%"
 				}
 			}
 			else {
 				def minVolts = 2.1
 				def maxVolts = 3.0
 				def pct = (volts - minVolts) / (maxVolts - minVolts)
-				def roundedPct = Math.round(pct * 100)
-				result.value = Math.min(100, roundedPct)
-				result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+				result.value = Math.min(100, (int) pct * 100)
+				result.descriptionText = "${linkText} battery was ${result.value}%"
 			}
 		}
 	}
@@ -283,33 +279,28 @@ private Map getBatteryResult(rawValue) {
 
 private Map getTemperatureResult(value) {
 	log.debug 'TEMP'
+	def linkText = getLinkText(device)
 	if (tempOffset) {
 		def offset = tempOffset as int
 		def v = value as int
 		value = v + offset
 	}
-    def descriptionText
-    if ( temperatureScale == 'C' )
-    	descriptionText = '{{ device.displayName }} was {{ value }}°C'
-    else
-    	descriptionText = '{{ device.displayName }} was {{ value }}°F'
-
+	def descriptionText = "${linkText} was ${value}°${temperatureScale}"
 	return [
 		name: 'temperature',
 		value: value,
-		descriptionText: descriptionText,
-        translatable: true
+		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
+		descriptionText: descriptionText
 	]
 }
 
@@ -324,8 +315,6 @@ def refresh() {
 }
 
 def configure() {
-	sendEvent(name: "checkInterval", value: 7200, displayed: false)
-
 	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting, IAS CIE, and Bindings."
 

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

@@ -24,7 +24,7 @@ metadata {
         capability "Temperature Measurement"
 		capability "Refresh"
 		capability "Sensor"
-
+        
         command "enrollResponse"
 
 	}
@@ -73,7 +73,7 @@ metadata {
 
 def parse(String description) {
 	log.debug "description: $description"
-
+    
 	Map map = [:]
 	if (description?.startsWith('catchall:')) {
 		map = parseCatchAllMessage(description)
@@ -87,10 +87,10 @@ def parse(String 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}"
@@ -128,7 +128,7 @@ private Map parseCatchAllMessage(String description) {
 private boolean shouldProcessMessage(cluster) {
     // 0x0B is default response indicating message got through
     // 0x07 is bind message
-    boolean ignoredMessage = cluster.profileId != 0x0104 ||
+    boolean ignoredMessage = cluster.profileId != 0x0104 || 
         cluster.command == 0x0B ||
         cluster.command == 0x07 ||
         (cluster.data.size() > 0 && cluster.data.first() == 0x3e)
@@ -141,7 +141,7 @@ private Map parseReportAttributeMessage(String description) {
 		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
 	}
 	log.debug "Desc Map: $descMap"
-
+ 
 	Map resultMap = [:]
 	if (descMap.cluster == "0402" && descMap.attrId == "0000") {
 		def value = getTemperature(descMap.value)
@@ -153,11 +153,11 @@ private Map parseReportAttributeMessage(String description) {
     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: ')) {
@@ -170,7 +170,7 @@ private Map parseCustomMessage(String description) {
 private Map parseIasMessage(String description) {
     List parsedMsg = description.split(' ')
     String msgCode = parsedMsg[2]
-
+    
     Map resultMap = [:]
     switch(msgCode) {
         case '0x0020': // Closed/No Motion/Dry
@@ -240,8 +240,7 @@ private Map getBatteryResult(rawValue) {
 			def minVolts = 2.1
 			def maxVolts = 3.0
 			def pct = (volts - minVolts) / (maxVolts - minVolts)
-			def roundedPct = Math.round(pct * 100)
-			result.value = Math.min(100, roundedPct)
+			result.value = Math.min(100, (int) pct * 100)
 			result.descriptionText = "${linkText} battery was ${result.value}%"
 		}
 	}

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

@@ -1,41 +1,20 @@
-#  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=예
+
+# Generated on Wed Feb 24 14:28:26 CST 2016 by dylan
+'''Adjust temperature by this many degrees'''.ko=몇 도씩 온도를 조절하십시오
+'''Degrees'''.ko=온도
+'''Do you want to use this sensor on a garage door?'''.ko=차고 문의 센서 사용 설정하기
 '''No'''.ko=아니요
-'''battery'''.ko=배터리
+'''Tap to set'''.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}% 배터리
+'''Yes'''.ko=예
+'''{{ device.displayName }} status was closed'''.ko={{ device.displayName }}은(는) 닫힌 상태입니다
+'''{{ device.displayName }} status was opened'''.ko={{ device.displayName }}은(는) 열린 상태입니다
+'''{{ device.displayName }} was active'''.ko={{ device.displayName }}이(가) 활성화되었습니다
+'''{{ device.displayName }} was closed'''.ko={{ device.displayName }}이(가) 닫혔습니다
+'''{{ device.displayName }} was inactive'''.ko={{ device.displayName }}이(가) 비활성화되었습니다
+'''{{ device.displayName }} was opened'''.ko={{ device.displayName }}이(가) 열렸습니다
+'''{{ device.displayName }} was {{ value }}°C'''.ko={{ device.displayName }}이(가) {{ value }}°C였습니다
+'''{{ device.displayName }} was {{ value }}°F'''.ko={{ device.displayName }}이(가) {{ value }}°F였습니다

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

@@ -1,21 +1,21 @@
-/*
- *  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.
+ *
  */
 
 metadata {
-	definition (name: "SmartSense Multi Sensor", namespace: "smartthings", author: "SmartThings", category: "C2") {
+	definition (name: "SmartSense Multi Sensor", namespace: "smartthings", author: "SmartThings") {
 
 		capability "Three Axis"
 		capability "Battery"
@@ -25,7 +25,6 @@ metadata {
  		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"
@@ -63,30 +62,30 @@ metadata {
 				])
 		}
 		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 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)
+			input("garageSensor", "enum", title: "Do you want to use this sensor on a garage door?", options: ["Yes", "No"], defaultValue: "No", required: false, displayDuringSetup: false)
 		}
 	}
 
 	tiles(scale: 2) {
 		multiAttributeTile(name:"status", type: "generic", width: 6, height: 4){
 			tileAttribute ("device.status", key: "PRIMARY_CONTROL") {
-				attributeState "open", label:'Open', icon:"st.contact.contact.open", backgroundColor:"#ffa81e"
-				attributeState "closed", label:'Closed', icon:"st.contact.contact.closed", backgroundColor:"#79b821"
+				attributeState "open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e"
+				attributeState "closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821"
 				attributeState "garage-open", label:'Open', icon:"st.doors.garage.garage-open", backgroundColor:"#ffa81e"
 				attributeState "garage-closed", label:'Closed', icon:"st.doors.garage.garage-closed", backgroundColor:"#79b821"
 			}
 		}
 		standardTile("contact", "device.contact", width: 2, height: 2) {
-			state("open", label:'Open', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
-			state("closed", label:'Closed', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
+			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
+			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
 		}
 		standardTile("acceleration", "device.acceleration", width: 2, height: 2) {
-			state("active", label:'Active', icon:"st.motion.acceleration.active", backgroundColor:"#53a7c0")
-			state("inactive", label:'Inactive', icon:"st.motion.acceleration.inactive", backgroundColor:"#ffffff")
+			state("active", label:'${name}', icon:"st.motion.acceleration.active", backgroundColor:"#53a7c0")
+			state("inactive", label:'${name}', icon:"st.motion.acceleration.inactive", backgroundColor:"#ffffff")
 		}
 		valueTile("temperature", "device.temperature", width: 2, height: 2) {
 			state("temperature", label:'${currentValue}°',
@@ -274,19 +273,19 @@ def updated() {
 	if (garageSensor == "Yes") {
 		def descriptionText = "Updating device to garage sensor"
 		if (device.latestValue("status") == "open") {
-			sendEvent(name: 'status', value: 'garage-open', descriptionText: descriptionText, translatable: true)
+			sendEvent(name: 'status', value: 'garage-open', descriptionText: descriptionText)
 		}
 		else if (device.latestValue("status") == "closed") {
-			sendEvent(name: 'status', value: 'garage-closed', descriptionText: descriptionText, translatable: true)
+			sendEvent(name: 'status', value: 'garage-closed', descriptionText: descriptionText)
 		}
 	}
 	else {
 		def descriptionText = "Updating device to open/close sensor"
 		if (device.latestValue("status") == "garage-open") {
-			sendEvent(name: 'status', value: 'open', descriptionText: descriptionText, translatable: true)
+			sendEvent(name: 'status', value: 'open', descriptionText: descriptionText)
 		}
 		else if (device.latestValue("status") == "garage-closed") {
-			sendEvent(name: 'status', value: 'closed', descriptionText: descriptionText, translatable: true)
+			sendEvent(name: 'status', value: 'closed', descriptionText: descriptionText)
 		}
 	}
 }
@@ -302,11 +301,11 @@ def getTemperature(value) {
 
 private Map getBatteryResult(rawValue) {
 	log.debug "Battery rawValue = ${rawValue}"
+	def linkText = getLinkText(device)
 
 	def result = [
 		name: 'battery',
-		value: '--',
-		translatable: true
+		value: '--'
 	]
 
 	def volts = rawValue / 10
@@ -314,7 +313,7 @@ private Map getBatteryResult(rawValue) {
 	if (rawValue == 0 || rawValue == 255) {}
 	else {
 		if (volts > 3.5) {
-			result.descriptionText = "{{ device.displayName }} battery has too much power: (> 3.5) volts."
+			result.descriptionText = "${linkText} battery has too much power (${volts} volts)."
 		}
 		else {
 			if (device.getDataValue("manufacturer") == "SmartThings") {
@@ -331,16 +330,15 @@ private Map getBatteryResult(rawValue) {
 				def pct = batteryMap[volts]
 				if (pct != null) {
 					result.value = pct
-					result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+					result.descriptionText = "${linkText} battery was ${result.value}%"
 				}
 			}
 			else {
 				def minVolts = 2.1
 				def maxVolts = 3.0
 				def pct = (volts - minVolts) / (maxVolts - minVolts)
-				def roundedPct = Math.round(pct * 100)
-				result.value = Math.min(100, roundedPct)
-				result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+				result.value = Math.min(100, (int) pct * 100)
+				result.descriptionText = "${linkText} battery was ${result.value}%"
 			}
 		}
 	}
@@ -350,50 +348,40 @@ private Map getBatteryResult(rawValue) {
 
 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 = temperatureScale == 'C' ? '{{ device.displayName }} was {{ value }}°C':
-			'{{ device.displayName }} was {{ value }}°F'
-
+	def descriptionText = "${linkText} was ${value}°${temperatureScale}"
 	return [
 	name: 'temperature',
 	value: value,
-	descriptionText: descriptionText,
-    translatable: true
+	descriptionText: descriptionText
 	]
 }
 
 private Map getContactResult(value) {
-	log.debug "Contact: ${device.displayName} value = ${value}"
-	def descriptionText = value == 'open' ? '{{ device.displayName }} was opened' : '{{ device.displayName }} was closed'
-	sendEvent(name: 'contact', value: value, descriptionText: descriptionText, displayed: false, translatable: true)
-	sendEvent(name: 'status', value: value, descriptionText: descriptionText, translatable: true)
+	log.debug "Contact"
+	def linkText = getLinkText(device)
+	def descriptionText = "${linkText} was ${value == 'open' ? 'opened' : 'closed'}"
+	sendEvent(name: 'contact', value: value, descriptionText: descriptionText, displayed:false)
+	sendEvent(name: 'status', value: value, descriptionText: descriptionText)
 }
 
 private getAccelerationResult(numValue) {
 	log.debug "Acceleration"
 	def name = "acceleration"
-    def value
-    def descriptionText
-
-	if ( numValue.endsWith("1") ) {
-    	value = "active"
-        descriptionText = '{{ device.displayName }} was active'
-    } else {
-    	value = "inactive"
-        descriptionText = '{{ device.displayName }} was inactive'
-    }
-
+	def value = numValue.endsWith("1") ? "active" : "inactive"
+	def linkText = getLinkText(device)
+	def descriptionText = "$linkText was $value"
 	def isStateChange = isStateChange(device, name, value)
-	return [
+	[
 		name: name,
 		value: value,
 		descriptionText: descriptionText,
-		isStateChange: isStateChange,
-		translatable: true
+		isStateChange: isStateChange
 	]
 }
 
@@ -404,37 +392,76 @@ def refresh() {
 
 	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.
-        */
-		refreshCmds += zigbee.writeAttribute(0xFC02, 0x0000, 0x20, 0x01, [mfgCode: manufacturerCode])
-		refreshCmds += zigbee.writeAttribute(0xFC02, 0x0002, 0x21, 0x0276, [mfgCode: manufacturerCode])
+		refreshCmds = refreshCmds + [
+			/* These values of Motion Threshold Multiplier(01) and Motion Threshold (7602)
+				seem to be giving pretty accurate results for the XYZ co-ordinates for this manufacturer.
+				Separating these out in a separate if-else because I do not want to touch Centralite part
+				as of now.
+			*/
+
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 0 0x20 {01}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 2 0x21 {7602}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+		]
 	} else {
-		refreshCmds += zigbee.writeAttribute(0xFC02, 0x0000, 0x20, 0x02, [mfgCode: manufacturerCode])
+		refreshCmds = refreshCmds + [
+			/* sensitivity - default value (8) */
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 0 0x20 {02}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+		]
 	}
 
 	//Common refresh commands
-	refreshCmds += zigbee.readAttribute(0x0402, 0x0000) +
-			zigbee.readAttribute(0x0001, 0x0020) +
-			zigbee.readAttribute(0xFC02, 0x0010, [mfgCode: manufacturerCode])
+	refreshCmds = refreshCmds + [
+		"st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+		"st rattr 0x${device.deviceNetworkId} 1 1 0x20", "delay 200",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global read 0xFC02 0x0010",
+		"send 0x${device.deviceNetworkId} 1 1","delay 400"
+	]
 
 	return refreshCmds + enrollResponse()
 }
 
 def configure() {
-	sendEvent(name: "checkInterval", value: 7200, displayed: false)
-
+	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting"
 
-	def configCmds = enrollResponse() +
-			zigbee.batteryConfig() +
-			zigbee.temperatureConfig() +
-			zigbee.configureReporting(0xFC02, 0x0010, 0x18, 10, 3600, 0x01, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0012, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0013, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0014, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode])
+	def configCmds = [
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 1 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}", "delay 200",		//checkin time 6 hrs
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0x402 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 0x402 0 0x29 30 3600 {6400}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0xFC02 {${device.zigbeeId}} {}", "delay 200",
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0010 0x18 10 3600 {01}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0012 0x29 1 3600 {01}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0013 0x29 1 3600 {01}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0014 0x29 1 3600 {01}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
+		]
 
 	return configCmds + refresh()
 }
@@ -501,9 +528,10 @@ def garageEvent(zValue) {
 		garageValue = 'garage-open'
 	}
 	if (contactValue != null){
-		def descriptionText = contactValue == 'open' ? '{{ device.displayName }} was opened' :'{{ device.displayName }} was closed'
-		sendEvent(name: 'contact', value: contactValue, descriptionText: descriptionText, displayed:false, translatable: true)
-		sendEvent(name: 'status', value: garageValue, descriptionText: descriptionText, translatable: true)
+		def linkText = getLinkText(device)
+		def descriptionText = "${linkText} was ${contactValue == 'open' ? 'opened' : 'closed'}"
+		sendEvent(name: 'contact', value: contactValue, descriptionText: descriptionText, displayed:false)
+		sendEvent(name: 'status', value: garageValue, descriptionText: descriptionText)
 	}
 }
 

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

@@ -22,8 +22,6 @@ metadata {
 		capability "Battery"
 
 		fingerprint profileId: "FC01", deviceId: "0139"
-
-		attribute "status", "string"
 	}
 
 	simulator {
@@ -101,7 +99,7 @@ def parse(String description) {
 
 }
 
-private List parseSingleMessage(description) {
+private Map parseSingleMessage(description) {
 
 	def name = parseName(description)
 	def value = parseValue(description)
@@ -110,9 +108,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 +117,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 +190,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 +269,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 +277,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 +308,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 +333,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 +352,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 +373,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 +404,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 +449,6 @@ private Boolean isOrientationMessage(String description) {
 	description ==~ /x:.*y:.*z:.*rssi:.*lqi:.*/
 }
 
-//Note: Not using this method anymore
 private String parseName(String description) {
 	if (isSupportedDescription(description)) {
 		return "contact"

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

@@ -16,16 +16,15 @@
 //DEPRECATED - Using the smartsense-multi-sensor.groovy DTH for this device. Users need to be moved before deleting this DTH
 
  metadata {
- 	definition (name: "SmartSense Open/Closed Accelerometer Sensor", namespace: "smartthings", author: "SmartThings", category: "C2") {
+ 	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"
-		capability "Health Check"
+ 		command "enrollResponse"
 
-		command "enrollResponse"
  	}
 
  	simulator {
@@ -234,8 +233,7 @@ def getTemperature(value) {
 			def minVolts = 2.1
 			def maxVolts = 3.0
 			def pct = (volts - minVolts) / (maxVolts - minVolts)
-			def roundedPct = Math.round(pct * 100)
-			result.value = Math.min(100, roundedPct)
+			result.value = Math.min(100, (int) pct * 100)
 			result.descriptionText = "${linkText} battery was ${result.value}%"
 		}
 
@@ -301,7 +299,6 @@ def getTemperature(value) {
 	}
 
 def configure() {
-	sendEvent(name: "checkInterval", value: 7200, displayed: false)
 
 	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting, IAS CIE, and Bindings."

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

@@ -13,34 +13,32 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-
+ 
 metadata {
-	definition (name: "SmartSense Open/Closed Sensor", namespace: "smartthings", author: "SmartThings", category: "C2") {
+	definition (name: "SmartSense Open/Closed Sensor", namespace: "smartthings", author: "SmartThings") {
 		capability "Battery"
 		capability "Configuration"
 		capability "Contact Sensor"
 		capability "Refresh"
 		capability "Temperature Measurement"
-		capability "Health Check"
-		capability "Sensor"
-
+        
 		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"
 	}
-
+ 
 	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
 	}
-
+ 
 	tiles(scale: 2) {
 		multiAttributeTile(name:"contact", type: "generic", width: 6, height: 4){
 			tileAttribute ("device.contact", key: "PRIMARY_CONTROL") {
@@ -73,10 +71,10 @@ metadata {
 		details(["contact","temperature","battery","refresh"])
 	}
 }
-
+ 
 def parse(String description) {
 	log.debug "description: $description"
-
+    
 	Map map = [:]
 	if (description?.startsWith('catchall:')) {
 		map = parseCatchAllMessage(description)
@@ -90,10 +88,10 @@ def parse(String 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}"
@@ -101,7 +99,7 @@ def parse(String description) {
     }
     return result
 }
-
+ 
 private Map parseCatchAllMessage(String description) {
     Map resultMap = [:]
     def cluster = zigbee.parse(description)
@@ -127,7 +125,7 @@ private Map parseCatchAllMessage(String description) {
 private boolean shouldProcessMessage(cluster) {
     // 0x0B is default response indicating message got through
     // 0x07 is bind message
-    boolean ignoredMessage = cluster.profileId != 0x0104 ||
+    boolean ignoredMessage = cluster.profileId != 0x0104 || 
         cluster.command == 0x0B ||
         cluster.command == 0x07 ||
         (cluster.data.size() > 0 && cluster.data.first() == 0x3e)
@@ -137,14 +135,14 @@ private boolean shouldProcessMessage(cluster) {
 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)
@@ -153,10 +151,10 @@ private Map parseReportAttributeMessage(String description) {
 	else if (descMap.cluster == "0001" && descMap.attrId == "0020") {
 		resultMap = getBatteryResult(Integer.parseInt(descMap.value, 16))
 	}
-
+ 
 	return resultMap
 }
-
+ 
 private Map parseCustomMessage(String description) {
 	Map resultMap = [:]
 	if (description?.startsWith('temperature: ')) {
@@ -169,7 +167,7 @@ private Map parseCustomMessage(String description) {
 private Map parseIasMessage(String description) {
     List parsedMsg = description.split(' ')
     String msgCode = parsedMsg[2]
-
+    
     Map resultMap = [:]
     switch(msgCode) {
         case '0x0020': // Closed/No Motion/Dry
@@ -202,7 +200,7 @@ private Map parseIasMessage(String description) {
     }
     return resultMap
 }
-
+ 
 def getTemperature(value) {
 	def celsius = Integer.parseInt(value, 16).shortValue() / 100
 	if(getTemperatureScale() == "C"){
@@ -215,11 +213,11 @@ def getTemperature(value) {
 private Map getBatteryResult(rawValue) {
 	log.debug 'Battery'
 	def linkText = getLinkText(device)
-
+    
     def result = [
     	name: 'battery'
     ]
-
+    
 	def volts = rawValue / 10
 	def descriptionText
     if (rawValue == 0 || rawValue == 255) {}
@@ -230,8 +228,7 @@ private Map getBatteryResult(rawValue) {
 		def minVolts = 2.1
     	def maxVolts = 3.0
 		def pct = (volts - minVolts) / (maxVolts - minVolts)
-		def roundedPct = Math.round(pct * 100)
-		result.value = Math.min(100, roundedPct)
+		result.value = Math.min(100, (int) pct * 100)
 		result.descriptionText = "${linkText} battery was ${result.value}%"
 	}
 
@@ -276,7 +273,6 @@ def refresh() {
 }
 
 def configure() {
-	sendEvent(name: "checkInterval", value: 7200, displayed: false)
 
 	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting, IAS CIE, and Bindings."

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

@@ -14,13 +14,12 @@
  *
  */
 metadata {
-	definition (name: "SmartSense Temp/Humidity Sensor",namespace: "smartthings", author: "SmartThings", category: "C2") {
+	definition (name: "SmartSense Temp/Humidity Sensor",namespace: "smartthings", author: "SmartThings") {
 		capability "Configuration"
 		capability "Battery"
 		capability "Refresh"
 		capability "Temperature Measurement"
 		capability "Relative Humidity Measurement"
-		capability "Health Check"
 
 		fingerprint endpointId: "01", inClusters: "0001,0003,0020,0402,0B05,FC45", outClusters: "0019,0003"
 	}
@@ -205,8 +204,7 @@ private Map getBatteryResult(rawValue) {
 		def minVolts = 2.1
     	def maxVolts = 3.0
 		def pct = (volts - minVolts) / (maxVolts - minVolts)
-		def roundedPct = Math.round(pct * 100)
-		result.value = Math.min(100, roundedPct)
+		result.value = Math.min(100, (int) pct * 100)
 		result.descriptionText = "${linkText} battery was ${result.value}%"
 	}
 
@@ -253,7 +251,6 @@ def refresh()
 }
 
 def configure() {
-	sendEvent(name: "checkInterval", value: 7200, displayed: false)
 
 	log.debug "Configuring Reporting and Bindings."
 	def configCmds = [

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

@@ -32,15 +32,14 @@ metadata {
 				attributeState("default", label:'${currentValue}', unit:"dF")
 			}
 			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
-				attributeState("VALUE_UP", action: "tempUp")
-				attributeState("VALUE_DOWN", action: "tempDown")
+				attributeState("default", action: "setTemperature")
 			}
 			tileAttribute("device.humidity", key: "SECONDARY_CONTROL") {
 				attributeState("default", label:'${currentValue}%', unit:"%")
 			}
 			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
 				attributeState("idle", backgroundColor:"#44b621")
-				attributeState("heating", backgroundColor:"#ea5462")
+				attributeState("heating", backgroundColor:"#ffa81e")
 				attributeState("cooling", backgroundColor:"#269bd2")
 			}
 			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {

devicetypes/smartthings/tile-ux/README.md

@@ -1,42 +0,0 @@
-# Device Tiles Examples and Reference
-
-This package contains examples of Device tiles, organized by tile type.
-
-## Purpose
-
-Each Device Handler shows example usages of a specific tile, and is meant to represent the variety of permutations that a tile can be configured.
-
-The various tiles can be used by QA to test tiles on all supported mobile devices, and by developers as a reference implementation.
-
-## Installation
-
-1. Self-publish the Device Handlers in this package.
-2. Self-publish the Device Tile Controller SmartApp. The SmartApp can be found [here](https://github.com/SmartThingsCommunity/SmartThingsPublic/blob/master/smartapps/smartthings/tile-ux/device-tile-controller.src/device-tile-controller.groovy).
-3. Install the SmartApp from the Marketplace, under "My Apps".
-4. Select the simulated devices you want to install and press "Done".
-
-The simulated devices can then be found in the "Things" view of "My Home" in the mobile app.
-You may wish to create a new room for these simulated devices for easy access.
-
-## Usage
-
-Each simulated device can be interacted with like other devices.
-You can use the mobile app to interact with the tiles to see how they look and behave.
-
-## Troubleshooting
-
-If you get an error when installing the simulated devices using the controller SmartApp, ensure that you have published all the Device Handlers for yourself.
-Also check live logging to see if there is a specific tile that is causing installation issues.
-
-## FAQ
-
-*Question: A tile isn't behaving as expected. What should I do?*
-
-QA should create a JIRA ticket for any issues or inconsistencies of tiles across devices.
-
-Developers may file a support ticket, and reference the specific tile and issue observed.
-
-*Question: I'd like to contribute an example tile usage that would be helpful for testing and reference purposes. Can I do that?*
-
-We recommend that you open an issue in the SmartThingsPublic repository describing the example tile and usage.
-That way we can discuss with you the proposed change, and then if appropriate you can create a PR associated to the issue.

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

@@ -1,225 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (
-		name: "carouselDeviceTile",
-		namespace: "smartthings/tile-ux",
-		author: "SmartThings") {
-
-		capability "Thermostat"
-		capability "Relative Humidity Measurement"
-
-		command "tempUp"
-		command "tempDown"
-		command "heatUp"
-		command "heatDown"
-		command "coolUp"
-		command "coolDown"
-		command "setTemperature", ["number"]
-	}
-
-	tiles(scale: 2) {
-		multiAttributeTile(name:"thermostatMulti", type:"thermostat", width:6, height:4) {
-			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
-				attributeState("default", label:'${currentValue}', unit:"dF")
-			}
-			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
-				attributeState("default", action: "setTemperature")
-			}
-			tileAttribute("device.humidity", key: "SECONDARY_CONTROL") {
-				attributeState("default", label:'${currentValue}%', unit:"%")
-			}
-			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
-				attributeState("idle", backgroundColor:"#44b621")
-				attributeState("heating", backgroundColor:"#ffa81e")
-				attributeState("cooling", backgroundColor:"#269bd2")
-			}
-			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {
-				attributeState("off", label:'${name}')
-				attributeState("heat", label:'${name}')
-				attributeState("cool", label:'${name}')
-				attributeState("auto", label:'${name}')
-			}
-			tileAttribute("device.heatingSetpoint", key: "HEATING_SETPOINT") {
-				attributeState("default", label:'${currentValue}', unit:"dF")
-			}
-			tileAttribute("device.coolingSetpoint", key: "COOLING_SETPOINT") {
-				attributeState("default", label:'${currentValue}', unit:"dF")
-			}
-		}
-
-		main("thermostatMulti")
-		details([
-			"thermostatMulti"
-		])
-	}
-}
-
-def installed() {
-	sendEvent(name: "temperature", value: 72, unit: "F")
-	sendEvent(name: "heatingSetpoint", value: 70, unit: "F")
-	sendEvent(name: "thermostatSetpoint", value: 70, unit: "F")
-	sendEvent(name: "coolingSetpoint", value: 76, unit: "F")
-	sendEvent(name: "thermostatMode", value: "off")
-	sendEvent(name: "thermostatFanMode", value: "fanAuto")
-	sendEvent(name: "thermostatOperatingState", value: "idle")
-	sendEvent(name: "humidity", value: 53, unit: "%")
-}
-
-def parse(String description) {
-}
-
-def evaluate(temp, heatingSetpoint, coolingSetpoint) {
-	log.debug "evaluate($temp, $heatingSetpoint, $coolingSetpoint"
-	def threshold = 1.0
-	def current = device.currentValue("thermostatOperatingState")
-	def mode = device.currentValue("thermostatMode")
-
-	def heating = false
-	def cooling = false
-	def idle = false
-	if (mode in ["heat","emergency heat","auto"]) {
-		if (heatingSetpoint - temp >= threshold) {
-			heating = true
-			sendEvent(name: "thermostatOperatingState", value: "heating")
-		}
-		else if (temp - heatingSetpoint >= threshold) {
-			idle = true
-		}
-		sendEvent(name: "thermostatSetpoint", value: heatingSetpoint)
-	}
-	if (mode in ["cool","auto"]) {
-		if (temp - coolingSetpoint >= threshold) {
-			cooling = true
-			sendEvent(name: "thermostatOperatingState", value: "cooling")
-		}
-		else if (coolingSetpoint - temp >= threshold && !heating) {
-			idle = true
-		}
-		sendEvent(name: "thermostatSetpoint", value: coolingSetpoint)
-	}
-	else {
-		sendEvent(name: "thermostatSetpoint", value: heatingSetpoint)
-	}
-	if (idle && !heating && !cooling) {
-		sendEvent(name: "thermostatOperatingState", value: "idle")
-	}
-}
-
-def setHeatingSetpoint(Double degreesF) {
-	log.debug "setHeatingSetpoint($degreesF)"
-	sendEvent(name: "heatingSetpoint", value: degreesF)
-	evaluate(device.currentValue("temperature"), degreesF, device.currentValue("coolingSetpoint"))
-}
-
-def setCoolingSetpoint(Double degreesF) {
-	log.debug "setCoolingSetpoint($degreesF)"
-	sendEvent(name: "coolingSetpoint", value: degreesF)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), degreesF)
-}
-
-def setThermostatMode(String value) {
-	sendEvent(name: "thermostatMode", value: value)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def setThermostatFanMode(String value) {
-	sendEvent(name: "thermostatFanMode", value: value)
-}
-
-def off() {
-	sendEvent(name: "thermostatMode", value: "off")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def heat() {
-	sendEvent(name: "thermostatMode", value: "heat")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def auto() {
-	sendEvent(name: "thermostatMode", value: "auto")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def emergencyHeat() {
-	sendEvent(name: "thermostatMode", value: "emergency heat")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def cool() {
-	sendEvent(name: "thermostatMode", value: "cool")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def fanOn() {
-	sendEvent(name: "thermostatFanMode", value: "fanOn")
-}
-
-def fanAuto() {
-	sendEvent(name: "thermostatFanMode", value: "fanAuto")
-}
-
-def fanCirculate() {
-	sendEvent(name: "thermostatFanMode", value: "fanCirculate")
-}
-
-def tempUp() {
-	def ts = device.currentState("temperature")
-	def value = ts ? ts.integerValue + 1 : 72
-	sendEvent(name:"temperature", value: value)
-	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def tempDown() {
-	def ts = device.currentState("temperature")
-	def value = ts ? ts.integerValue - 1 : 72
-	sendEvent(name:"temperature", value: value)
-	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def setTemperature(value) {
-	def ts = device.currentState("temperature")
-	sendEvent(name:"temperature", value: value)
-	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def heatUp() {
-	def ts = device.currentState("heatingSetpoint")
-	def value = ts ? ts.integerValue + 1 : 68
-	sendEvent(name:"heatingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), value, device.currentValue("coolingSetpoint"))
-}
-
-def heatDown() {
-	def ts = device.currentState("heatingSetpoint")
-	def value = ts ? ts.integerValue - 1 : 68
-	sendEvent(name:"heatingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), value, device.currentValue("coolingSetpoint"))
-}
-
-
-def coolUp() {
-	def ts = device.currentState("coolingSetpoint")
-	def value = ts ? ts.integerValue + 1 : 76
-	sendEvent(name:"coolingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), value)
-}
-
-def coolDown() {
-	def ts = device.currentState("coolingSetpoint")
-	def value = ts ? ts.integerValue - 1 : 76
-	sendEvent(name:"coolingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), value)
-}

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

@@ -1,59 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (
-		name: "colorWheelDeviceTile",
-		namespace: "smartthings/tile-ux",
-		author: "SmartThings") {
-
-		capability "Color Control"
-	}
-
-	tiles(scale: 2) {
-		valueTile("currentColor", "device.color") {
-			state "color", label: '${currentValue}', defaultState: true
-		}
-
-		controlTile("rgbSelector", "device.color", "color", height: 6, width: 6, inactiveLabel: false) {
-			state "color", action: "color control.setColor"
-		}
-
-		main("currentColor")
-		details([
-			"rgbSelector"
-		])
-	}
-}
-
-// parse events into attributes
-def parse(String description) {
-	log.debug "Parsing '${description}'"
-}
-
-def setColor(value) {
-	log.debug "setting color: $value"
-    if (value.hex) { sendEvent(name: "color", value: value.hex) }
-    if (value.hue) { sendEvent(name: "hue", value: value.hue) }
-    if (value.saturation) { sendEvent(name: "saturation", value: value.saturation) }
-}
-
-def setSaturation(percent) {
-	log.debug "Executing 'setSaturation'"
-	sendEvent(name: "saturation", value: percent)
-}
-
-def setHue(percent) {
-	log.debug "Executing 'setHue'"
-	sendEvent(name: "hue", value: percent)
-}

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

@@ -1,63 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (
-		name: "presenceDeviceTile",
-		namespace: "smartthings/tile-ux",
-		author: "SmartThings") {
-
-		capability "Presence Sensor"
-
-		command "arrived"
-		command "departed"
-	}
-
-	tiles(scale: 2) {
-		// You only get a presence tile view when the size is 3x3 otherwise it's a value tile
-		standardTile("presence", "device.presence", width: 3, height: 3, canChangeBackground: true) {
-			state("present", labelIcon:"st.presence.tile.mobile-present", backgroundColor:"#53a7c0")
-			state("not present", labelIcon:"st.presence.tile.mobile-not-present", backgroundColor:"#ebeef2")
-		}
-
-		standardTile("notPresentBtn", "device.fake", width: 3, height: 3, decoration: "flat") {
-			state("not present", label:'not present', backgroundColor:"#ffffff", action:"departed")
-		}
-
-		standardTile("presentBtn", "device.fake", width: 3, height: 3, decoration: "flat") {
-			state("present", label:'present', backgroundColor:"#53a7c0", action:"arrived")
-		}
-
-		main("presence")
-		details([
-			"presence", "presenceControl", "notPresentBtn", "presentBtn"
-		])
-	}
-}
-
-def installed() {
-	sendEvent(name: "presence", value: "present")
-}
-
-def parse(String description) {
-}
-
-def arrived() {
-	log.trace "Executing 'arrived'"
-	sendEvent(name: "presence", value: "present")
-}
-
-def departed() {
-	log.trace "Executing 'arrived'"
-	sendEvent(name: "presence", value: "not present")
-}

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

@@ -1,75 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (
-		name: "sliderDeviceTile",
-		namespace: "smartthings/tile-ux",
-		author: "SmartThings") {
-
-		capability "Switch Level"
-		command "setRangedLevel", ["number"]
-	}
-
-	tiles(scale: 2) {
-		controlTile("tinySlider", "device.level", "slider", height: 2, width: 2, inactiveLabel: false) {
-			state "level", action:"switch level.setLevel"
-		}
-
-		controlTile("mediumSlider", "device.level", "slider", height: 2, width: 4, inactiveLabel: false) {
-			state "level", action:"switch level.setLevel"
-		}
-
-		controlTile("largeSlider", "device.level", "slider", decoration: "flat", height: 2, width: 6, inactiveLabel: false) {
-			state "level", action:"switch level.setLevel"
-		}
-
-		controlTile("rangeSlider", "device.rangedLevel", "slider", height: 2, width: 4, range: "(20..80)") {
-			state "level", action:"setRangedLevel"
-		}
-
-		valueTile("rangeValue", "device.rangedLevel", height: 2, width: 2) {
-			state "range", label:'${currentValue}', defaultState: true
-		}
-
-		controlTile("rangeSliderConstrained", "device.rangedLevel", "slider", height: 2, width: 4, range: "(40..60)") {
-			state "level", action:"setRangedLevel"
-		}
-
-		main("rangeValue")
-		details([
-			"tinySlider", "mediumSlider",
-			"largeSlider",
-			"rangeSlider", "rangeValue",
-			"rangeSliderConstrained"
-		])
-	}
-}
-
-def installed() {
-	sendEvent(name: "level", value: 63)
-	sendEvent(name: "rangedLevel", value: 47)
-}
-
-def parse(String description) {
-}
-
-def setLevel(value) {
-	log.debug "setting level to $value"
-	sendEvent(name:"level", value:value)
-}
-
-def setRangedLevel(value) {
-	log.debug "setting ranged level to $value"
-	sendEvent(name:"rangedLevel", value:value)
-}

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

@@ -1,121 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (
-		name: "standardDeviceTile",
-		namespace: "smartthings/tile-ux",
-		author: "SmartThings") {
-
-		capability "Switch"
-	}
-
-	tiles(scale: 2) {
-		// standard tile with actions
-		standardTile("actionRings", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "off", label: '${currentValue}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
-			state "on", label: '${currentValue}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
-		}
-
-		// standard flat tile with actions
-		standardTile("actionFlat", "device.switch", width: 2, height: 2, canChangeIcon: true, decoration: "flat") {
-			state "off", label: '${currentValue}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
-			state "on", label: '${currentValue}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
-		}
-
-		// standard flat tile without actions
-		standardTile("noActionFlat", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "off", label: '${currentValue}',icon: "st.switches.switch.off", backgroundColor: "#ffffff"
-			state "on", label: '${currentValue}', icon: "st.switches.switch.on", backgroundColor: "#79b821"
-		}
-
-		// standard flat tile with only a label
-		standardTile("flatLabel", "device.switch", width: 2, height: 2, decoration: "flat") {
-			state "label", label: 'On Action', action: "switch.on", backgroundColor: "#ffffff", defaultState: true
-		}
-
-		// standard flat tile with icon and label
-		standardTile("flatIconLabel", "device.switch", width: 2, height: 2, decoration: "flat") {
-			state "iconLabel", label: 'Off Action', action: "switch.off", icon:"st.switches.switch.off", backgroundColor: "#ffffff", defaultState: true
-		}
-
-		// standard flat tile with only icon (Refreh text is IN the icon file)
-		standardTile("flatIcon", "device.switch", width: 2, height: 2, decoration: "flat") {
-			state "icon", action:"refresh.refresh", icon:"st.secondary.refresh", defaultState: true
-		}
-
-		// standard with defaultState = true
-		standardTile("flatDefaultState", "null", width: 2, height: 2, decoration: "flat") {
-			state "off", label: 'Fail!', icon: "st.switches.switch.off"
-			state "on", label: 'Pass!', icon: "st.switches.switch.on", defaultState: true
-		}
-
-		// standard with implicit defaultState based on order (0 index is selected)
-		standardTile("flatImplicitDefaultState1", "null", width: 2, height: 2, decoration: "flat") {
-			state "on", label: 'Pass!', icon: "st.switches.switch.on"
-			state "off", label: 'Fail!', icon: "st.switches.switch.off"
-		}
-
-		// standard with implicit defaultState based on state.name == default
-		standardTile("flatImplicitDefaultState2", "null", width: 2, height: 2, decoration: "flat") {
-			state "off", label: 'Fail!', icon: "st.switches.switch.off"
-			state "default", label: 'Pass!', icon: "st.switches.switch.on"
-		}
-
-		// utility tiles to fill the spaces
-		standardTile("empty2x2", "null", width: 2, height: 2, decoration: "flat") {
-			state "emptySmall", label:'', defaultState: true
-		}
-		standardTile("empty4x2", "null", width: 4, height: 2, decoration: "flat") {
-			state "emptyBigger", label:'', defaultState: true
-		}
-
-		// multi-line text (explicit newlines)
-		standardTile("multiLine", "device.multiLine", width: 2, height: 2) {
-			state "multiLine", label: '${currentValue}', defaultState: true
-		}
-
-		standardTile("multiLineWithIcon", "device.multiLine", width: 2, height: 2) {
-			state "multiLineIcon", label: '${currentValue}', icon: "st.switches.switch.off", defaultState: true
-		}
-
-		main("actionRings")
-		details([
-			"actionRings", "actionFlat", "noActionFlat",
-
-			"flatLabel", "flatIconLabel", "flatIcon",
-
-			"flatDefaultState", "flatImplicitDefaultState1", "flatImplicitDefaultState2",
-
-			"multiLine", "multiLineWithIcon"
-		])
-	}
-}
-
-def installed() {
-	sendEvent(name: "switch", value: "off")
-	sendEvent(name: "multiLine", value: "Line 1\nLine 2\nLine 3")
-}
-
-def parse(String description) {
-}
-
-def on() {
-	log.debug "on()"
-	sendEvent(name: "switch", value: "on")
-}
-
-def off() {
-	log.debug "off()"
-	sendEvent(name: "switch", value: "off")
-}

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

@@ -1,106 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (
-		name: "valueDeviceTile",
-		namespace: "smartthings/tile-ux",
-		author: "SmartThings") {
-
-		capability "Sensor"
-	}
-
-	tiles(scale: 2) {
-		valueTile("text", "device.text", width: 2, height: 2) {
-			state "val", label:'${currentValue}', defaultState: true
-		}
-
-		valueTile("longText", "device.longText", width: 2, height: 2) {
-			state "val", label:'${currentValue}', defaultState: true
-		}
-
-		valueTile("integer", "device.integer", width: 2, height: 2) {
-			state "val", label:'${currentValue}', defaultState: true
-		}
-
-		valueTile("integerFloat", "device.integerFloat", width: 2, height: 2) {
-			state "val", label:'${currentValue}', defaultState: true
-		}
-
-		valueTile("pi", "device.pi", width: 2, height: 2) {
-			state "val", label:'${currentValue}', defaultState: true
-		}
-
-		valueTile("floatAsText", "device.floatAsText", width: 2, height: 2) {
-			state "val", label:'${currentValue}', defaultState: true
-		}
-
-		valueTile("bgColor", "device.integer", width: 2, height: 2) {
-			state "val", label:'${currentValue}', backgroundColor: "#e86d13", defaultState: true
-		}
-
-		valueTile("bgColorRange", "device.integer", width: 2, height: 2) {
-			state "val", label:'${currentValue}', defaultState: true, backgroundColors: [
-				[value: 10, color: "#ff0000"],
-				[value: 90, color: "#0000ff"]
-			]
-		}
-
-		valueTile("bgColorRangeSingleItem", "device.integer", width: 2, height: 2) {
-			state "val", label:'${currentValue}', defaultState: true, backgroundColors: [
-				[value: 10, color: "#333333"]
-			]
-		}
-
-		valueTile("bgColorRangeConflict", "device.integer", width: 2, height: 2) {
-			state "valWithConflict", label:'${currentValue}', defaultState: true, backgroundColors: [
-				[value: 10, color: "#990000"],
-				[value: 10, color: "#000099"]
-			]
-		}
-
-		valueTile("noValue", "device.nada", width: 4, height: 2) {
-			state "noval", label:'${currentValue}', defaultState: true
-		}
-
-		valueTile("multiLine", "device.multiLine", width: 3, height: 2) {
-			state "val", label: '${currentValue}', defaultState: true
-		}
-
-		valueTile("multiLineWithIcon", "device.multiLine", width: 3, height: 2) {
-			state "val", label: '${currentValue}', icon: "st.switches.switch.off", defaultState: true
-		}
-
-		main("text")
-		details([
-			"text", "longText", "integer",
-            "integerFloat", "pi", "floatAsText",
-            "bgColor", "bgColorRange", "bgColorRangeSingleItem",
-            "bgColorRangeConflict", "noValue",
-            "multiLine", "multiLineWithIcon"
-		])
-	}
-}
-
-def installed() {
-	sendEvent(name: "text", value: "Test")
-	sendEvent(name: "longText", value: "The Longer The Text, The Better The Test")
-	sendEvent(name: "integer", value: 47)
-	sendEvent(name: "integerFloat", value: 47.0)
-	sendEvent(name: "pi", value: 3.14159)
-	sendEvent(name: "floatAsText", value: "3.14159")
-	sendEvent(name: "multiLine", value: "Line 1\nLine 2\nLine 3")
-}
-
-def parse(String description) {
-}

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

@@ -1,151 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (name: "genericDeviceTile", namespace: "smartthings/tile-ux", author: "SmartThings") {
-		capability "Actuator"
-		capability "Switch"
-		capability "Switch Level"
-
-		command "levelUp"
-		command "levelDown"
-		command "randomizeLevel"
-	}
-
-	tiles(scale: 2) {
-		multiAttributeTile(name:"basicTile", type:"generic", width:6, height:4) {
-			tileAttribute("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			}
-		}
-		multiAttributeTile(name:"sliderTile", type:"generic", width:6, height:4) {
-			tileAttribute("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "off", label:'${name}', backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "turningOff", label:'${name}', backgroundColor:"#ffffff", nextState:"turningOn"
-			}
-			tileAttribute("device.level", key: "SECONDARY_CONTROL") {
-				attributeState "level", icon: 'st.Weather.weather1', action:"randomizeLevel", defaultState: true
-			}
-			tileAttribute("device.level", key: "SLIDER_CONTROL") {
-				attributeState "level", action:"switch level.setLevel", defaultState: true
-			}
-		}
-		multiAttributeTile(name:"valueTile", type:"generic", width:6, height:4) {
-			tileAttribute("device.level", key: "PRIMARY_CONTROL") {
-				attributeState "level", label:'${currentValue}', defaultState: true, backgroundColors:[
-					[value: 0, color: "#ff0000"],
-					[value: 20, color: "#ffff00"],
-					[value: 40, color: "#00ff00"],
-					[value: 60, color: "#00ffff"],
-					[value: 80, color: "#0000ff"],
-					[value: 100, color: "#ff00ff"]
-				]
-			}
-			tileAttribute("device.switch", key: "SECONDARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "off", label:'${name}', action:"switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'…', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "turningOff", label:'…', action:"switch.on", backgroundColor:"#ffffff", nextState:"turningOn"
-			}
-			tileAttribute("device.level", key: "VALUE_CONTROL") {
-				attributeState "VALUE_UP", action: "levelUp"
-				attributeState "VALUE_DOWN", action: "levelDown"
-			}
-		}
-		multiAttributeTile(name:"lengthyTile", type:"generic", width:6, height:4) {
-			tileAttribute("device.lengthyText", key: "PRIMARY_CONTROL") {
-				attributeState "lengthyText", label:'The value of this tile is long and should wrap to two lines', backgroundColor:"#79b821", defaultState: true
-			}
-			tileAttribute("device.lengthyText", key: "SECONDARY_CONTROL") {
-				attributeState "lengthyText", label:'The value of this tile is long and should wrap to two lines', backgroundColor:"#79b821", defaultState: true
-			}
-		}
-		multiAttributeTile(name:"multilineTile", type:"generic", width:6, height:4) {
-			tileAttribute("device.multilineText", key: "PRIMARY_CONTROL") {
-				attributeState "multiLineText", label:'Line 1 YES\nLine 2 YES\nLine 3 NO', backgroundColor:"#79b821", defaultState: true
-			}
-			tileAttribute("device.multilineText", key: "SECONDARY_CONTROL") {
-				attributeState "multiLineText", label:'Line 1 YES\nLine 2 YES\nLine 3 NO', backgroundColor:"#79b821", defaultState: true
-			}
-		}
-		multiAttributeTile(name:"lengthyTileWithIcon", type:"generic", width:6, height:4) {
-			tileAttribute("device.lengthyText", key: "PRIMARY_CONTROL") {
-				attributeState "lengthyText", label:'The value of this tile is long and should wrap to two lines', backgroundColor:"#79b821", icon: "st.switches.switch.on", defaultState: true
-			}
-			tileAttribute("device.lengthyText", key: "SECONDARY_CONTROL") {
-				attributeState "lengthyText", label:'The value of this tile is long and should wrap to two lines', backgroundColor:"#79b821", icon: "st.switches.switch.on", defaultState: true
-			}
-		}
-		multiAttributeTile(name:"multilineTileWithIcon", type:"generic", width:6, height:4) {
-			tileAttribute("device.multilineText", key: "PRIMARY_CONTROL") {
-				attributeState "multilineText", label:'Line 1 YES\nLine 2 YES\nLine 3 NO', backgroundColor:"#79b821", icon: "st.switches.switch.on", defaultState: true
-			}
-			tileAttribute("device.multilineText", key: "SECONDARY_CONTROL") {
-				attributeState "multilineText", label:'Line 1 YES\nLine 2 YES\nLine 3 NO', backgroundColor:"#79b821", icon: "st.switches.switch.on", defaultState: true
-			}
-		}
-
-		main(["basicTile"])
-		details(["basicTile", "sliderTile", "valueTile", "lengthyTile", "multilineTile", "lengthyTileWithIcon", "multilineTileWithIcon"])
-	}
-}
-
-def installed() {
-	sendEvent(name: "lengthyText", value: "The value of this tile is long and should wrap to two lines")
-	sendEvent(name: "multilineText", value: "Line 1 YES\nLine 2 YES\nLine 3 NO")
-}
-
-def parse(String description) {
-	// This is a simulated device. No incoming data to parse.
-}
-
-def on() {
-	log.debug "turningOn"
-	sendEvent(name: "switch", value: "on")
-}
-
-def off() {
-	log.debug "turningOff"
-	sendEvent(name: "switch", value: "off")
-}
-
-def setLevel(percent) {
-	log.debug "setLevel: ${percent}, this"
-	sendEvent(name: "level", value: percent)
-}
-
-def randomizeLevel() {
-	def level = Math.round(Math.random() * 100)
-	setLevel(level)
-}
-
-def levelUp() {
-	def level = device.latestValue("level") as Integer ?: 0
-	if (level < 100) {
-		level = level + 1
-	}
-	setLevel(level)
-}
-
-def levelDown() {
-	def level = device.latestValue("level") as Integer ?: 0
-	if (level > 0) {
-		level = level - 1
-	}
-	setLevel(level)
-}

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

@@ -1,208 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (
-		name: "lightingDeviceTile",
-		namespace: "smartthings/tile-ux",
-		author: "SmartThings") {
-
-		capability "Switch Level"
-		capability "Actuator"
-		capability "Color Control"
-		capability "Power Meter"
-		capability "Switch"
-		capability "Refresh"
-		capability "Sensor"
-
-		command "setAdjustedColor"
-		command "reset"
-		command "refresh"
-	}
-
-	tiles(scale: 2) {
-		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true) {
-			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-			}
-			tileAttribute ("device.power", key: "SECONDARY_CONTROL") {
-				attributeState "power", label:'Power level: ${currentValue}W', icon: "st.Appliances.appliances17"
-			}
-			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-				attributeState "level", action:"switch level.setLevel"
-			}
-			tileAttribute ("device.color", key: "COLOR_CONTROL") {
-				attributeState "color", action:"setAdjustedColor"
-			}
-		}
-
-		multiAttributeTile(name:"switchNoPower", type: "lighting", width: 6, height: 4, canChangeIcon: true) {
-			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-			}
-			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-				attributeState "level", action:"switch level.setLevel"
-			}
-			tileAttribute ("device.color", key: "COLOR_CONTROL") {
-				attributeState "color", action:"setAdjustedColor"
-			}
-		}
-
-		multiAttributeTile(name:"switchNoSlider", type: "lighting", width: 6, height: 4, canChangeIcon: true) {
-			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-			}
-			tileAttribute ("device.power", key: "SECONDARY_CONTROL") {
-				attributeState "power", label:'The power level is currently: ${currentValue}W', icon: "st.Appliances.appliances17"
-			}
-			tileAttribute ("device.color", key: "COLOR_CONTROL") {
-				attributeState "color", action:"setAdjustedColor"
-			}
-		}
-
-		multiAttributeTile(name:"switchNoSliderOrColor", type: "lighting", width: 6, height: 4, canChangeIcon: true) {
-			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-			}
-			tileAttribute ("device.power", key: "SECONDARY_CONTROL") {
-				attributeState "power", label:'The light is currently consuming this amount of power: ${currentValue}W', icon: "st.Appliances.appliances17"
-			}
-		}
-
-		valueTile("color", "device.color", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "color", label: '${currentValue}'
-		}
-
-		standardTile("reset", "device.reset", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "reset", label:"Reset Color", action:"reset", icon:"st.lights.philips.hue-single", defaultState: true
-		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "refresh", label:"", action:"refresh.refresh", icon:"st.secondary.refresh", defaultState: true
-		}
-
-		main(["switch"])
-		details(["switch", "switchNoPower", "switchNoSlider", "switchNoSliderOrColor", "color", "refresh", "reset"])
-	}
-}
-
-// parse events into attributes
-def parse(description) {
-	log.debug "parse() - $description"
-	def results = []
-	def map = description
-	if (description instanceof String)  {
-		log.debug "Hue Bulb stringToMap - ${map}"
-		map = stringToMap(description)
-	}
-	if (map?.name && map?.value) {
-		results << createEvent(name: "${map?.name}", value: "${map?.value}")
-	}
-	results
-}
-
-// handle commands
-def on() {
-	//log.trace parent.on(this)
-	sendEvent(name: "switch", value: "on")
-}
-
-def off() {
-	//log.trace parent.off(this)
-	sendEvent(name: "switch", value: "off")
-}
-
-def nextLevel() {
-	def level = device.latestValue("level") as Integer ?: 0
-	if (level <= 100) {
-		level = Math.min(25 * (Math.round(level / 25) + 1), 100) as Integer
-	}
-	else {
-		level = 25
-	}
-	setLevel(level)
-}
-
-def setLevel(percent) {
-	log.debug "setLevel: ${percent}, this"
-	sendEvent(name: "level", value: percent)
-	def power = Math.round(percent / 1.175) * 0.1
-	sendEvent(name: "power", value: power)
-}
-
-def setSaturation(percent) {
-	log.debug "setSaturation: ${percent}, $this"
-	sendEvent(name: "saturation", value: percent)
-}
-
-def setHue(percent) {
-	log.debug "setHue: ${percent}, $this"
-	sendEvent(name: "hue", value: percent)
-}
-
-def setColor(value) {
-	log.debug "setColor: ${value}, $this"
-	if (value.hue) { sendEvent(name: "hue", value: value.hue)}
-	if (value.saturation) { sendEvent(name: "saturation", value: value.saturation)}
-	if (value.hex) { sendEvent(name: "color", value: value.hex)}
-	if (value.level) { sendEvent(name: "level", value: value.level)}
-	if (value.switch) { sendEvent(name: "switch", value: value.switch)}
-}
-
-def reset() {
-	log.debug "Executing 'reset'"
-	setAdjustedColor([level:100, hex:"#90C638", saturation:56, hue:23])
-}
-
-def setAdjustedColor(value) {
-	if (value) {
-		log.trace "setAdjustedColor: ${value}"
-		def adjusted = value + [:]
-		adjusted.hue = adjustOutgoingHue(value.hue)
-		// Needed because color picker always sends 100
-		adjusted.level = null
-		setColor(adjusted)
-	}
-}
-
-def refresh() {
-	log.debug "Executing 'refresh'"
-}
-
-def adjustOutgoingHue(percent) {
-	def adjusted = percent
-	if (percent > 31) {
-		if (percent < 63.0) {
-			adjusted = percent + (7 * (percent -30 ) / 32)
-		}
-		else if (percent < 73.0) {
-			adjusted = 69 + (5 * (percent - 62) / 10)
-		}
-		else {
-			adjusted = percent + (2 * (100 - percent) / 28)
-		}
-	}
-	log.info "percent: $percent, adjusted: $adjusted"
-	adjusted
-}

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

@@ -1,122 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (
-		name: "mediaPlayerDeviceTile",
-		namespace: "smartthings/tile-ux",
-		author: "SmartThings") {
-
-		capability "Actuator"
-		capability "Switch"
-		capability "Refresh"
-		capability "Sensor"
-		capability "Music Player"
-	}
-
-	tiles(scale: 2) {
-		multiAttributeTile(name: "mediaMulti", type:"mediaPlayer", width:6, height:4) {
-			tileAttribute("device.status", key: "PRIMARY_CONTROL") {
-				attributeState("paused", label:"Paused",)
-				attributeState("playing", label:"Playing")
-				attributeState("stopped", label:"Stopped")
-			}
-			tileAttribute("device.status", key: "MEDIA_STATUS") {
-				attributeState("paused", label:"Paused", action:"music Player.play", nextState: "playing")
-				attributeState("playing", label:"Playing", action:"music Player.pause", nextState: "paused")
-				attributeState("stopped", label:"Stopped", action:"music Player.play", nextState: "playing")
-			}
-			tileAttribute("device.status", key: "PREVIOUS_TRACK") {
-				attributeState("status", action:"music Player.previousTrack", defaultState: true)
-			}
-			tileAttribute("device.status", key: "NEXT_TRACK") {
-				attributeState("status", action:"music Player.nextTrack", defaultState: true)
-			}
-			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-				attributeState("level", action:"music Player.setLevel")
-			}
-			tileAttribute ("device.mute", key: "MEDIA_MUTED") {
-				attributeState("unmuted", action:"music Player.mute", nextState: "muted")
-				attributeState("muted", action:"music Player.unmute", nextState: "unmuted")
-			}
-			tileAttribute("device.trackDescription", key: "MARQUEE") {
-				attributeState("trackDescription", label:"${currentValue}", defaultState: true)
-			}
-		}
-
-		main "mediaMulti"
-		details(["mediaMulti"])
-	}
-}
-
-def installed() {
-	state.tracks = [
-		"Gangnam Style (강남스타일)\nPSY\nPsy 6 (Six Rules), Part 1",
-		"Careless Whisper\nWham!\nMake It Big",
-		"Never Gonna Give You Up\nRick Astley\nWhenever You Need Somebody",
-		"Shake It Off\nTaylor Swift\n1989",
-		"Ironic\nAlanis Morissette\nJagged Little Pill",
-		"Hotline Bling\nDrake\nHotline Bling - Single"
-	]
-	state.currentTrack = 0
-
-	sendEvent(name: "level", value: 72)
-	sendEvent(name: "mute", value: "unmuted")
-	sendEvent(name: "status", value: "stopped")
-}
-
-def parse(description) {
-	// No parsing will happen with this simulated device.
-}
-
-def play() {
-	sendEvent(name: "status", value: "playing")
-	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
-}
-
-def pause() {
-	sendEvent(name: "status", value: "paused")
-	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
-}
-
-def stop() {
-	sendEvent(name: "status", value: "stopped")
-}
-
-def previousTrack() {
-	state.currentTrack = state.currentTrack - 1
-	if (state.currentTrack < 0)
-		state.currentTrack = state.tracks.size()-1
-
-	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
-}
-
-def nextTrack() {
-	state.currentTrack = state.currentTrack + 1
-	if (state.currentTrack == state.tracks.size())
-		state.currentTrack = 0
-
-	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
-}
-
-def mute() {
-	sendEvent(name: "mute", value: "muted")
-}
-
-def unmute() {
-	sendEvent(name: "mute", value: "unmuted")
-}
-
-def setLevel(level) {
-	sendEvent(name: "level", value: level)
-}

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

@@ -1,343 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (
-		name: "thermostatDeviceTile",
-		namespace: "smartthings/tile-ux",
-		author: "SmartThings") {
-
-		capability "Thermostat"
-		capability "Relative Humidity Measurement"
-
-		command "tempUp"
-		command "tempDown"
-		command "heatUp"
-		command "heatDown"
-		command "coolUp"
-		command "coolDown"
-		command "setTemperature", ["number"]
-	}
-
-	tiles(scale: 2) {
-		multiAttributeTile(name:"thermostatFull", type:"thermostat", width:6, height:4) {
-			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
-				attributeState("temp", label:'${currentValue}', unit:"dF", defaultState: true)
-			}
-			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
-				attributeState("VALUE_UP", action: "tempUp")
-				attributeState("VALUE_DOWN", action: "tempDown")
-			}
-			tileAttribute("device.humidity", key: "SECONDARY_CONTROL") {
-				attributeState("humidity", label:'${currentValue}%', unit:"%", defaultState: true)
-			}
-			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
-				attributeState("idle", backgroundColor:"#44b621")
-				attributeState("heating", backgroundColor:"#ffa81e")
-				attributeState("cooling", backgroundColor:"#269bd2")
-			}
-			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {
-				attributeState("off", label:'${name}')
-				attributeState("heat", label:'${name}')
-				attributeState("cool", label:'${name}')
-				attributeState("auto", label:'${name}')
-			}
-			tileAttribute("device.heatingSetpoint", key: "HEATING_SETPOINT") {
-				attributeState("heatingSetpoint", label:'${currentValue}', unit:"dF", defaultState: true)
-			}
-			tileAttribute("device.coolingSetpoint", key: "COOLING_SETPOINT") {
-				attributeState("coolingSetpoint", label:'${currentValue}', unit:"dF", defaultState: true)
-			}
-		}
-		multiAttributeTile(name:"thermostatNoHumidity", type:"thermostat", width:6, height:4) {
-			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
-                attributeState("coolingSetpoint", label:'${currentValue}', unit:"dF", defaultState: true)
-				attributeState("temp", label:'${currentValue}', unit:"dF")
-			}
-			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
-				attributeState("VALUE_UP", action: "tempUp")
-				attributeState("VALUE_DOWN", action: "tempDown")
-			}
-			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
-				attributeState("idle", backgroundColor:"#44b621")
-				attributeState("heating", backgroundColor:"#ffa81e")
-				attributeState("cooling", backgroundColor:"#269bd2")
-			}
-			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {
-				attributeState("off", label:'${name}')
-				attributeState("heat", label:'${name}')
-				attributeState("cool", label:'${name}')
-				attributeState("auto", label:'${name}')
-			}
-			tileAttribute("device.heatingSetpoint", key: "HEATING_SETPOINT") {
-                attributeState("coolingSetpoint", label:'${currentValue}', unit:"dF", defaultState: true)
-				attributeState("heatingSetpoint", label:'${currentValue}', unit:"dF")
-			}
-			tileAttribute("device.coolingSetpoint", key: "COOLING_SETPOINT") {
-				attributeState("coolingSetpoint", label:'${currentValue}', unit:"dF", defaultState: true)
-			}
-		}
-		multiAttributeTile(name:"thermostatBasic", type:"thermostat", width:6, height:4) {
-			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
-				attributeState("temp", label:'${currentValue}', unit:"dF", defaultState: true,
-				backgroundColors:[
-					[value: 31, color: "#153591"],
-					[value: 44, color: "#1e9cbb"],
-					[value: 59, color: "#90d2a7"],
-					[value: 74, color: "#44b621"],
-					[value: 84, color: "#f1d801"],
-					[value: 95, color: "#d04e00"],
-					[value: 96, color: "#bc2323"]
-				])
-			}
-			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
-				attributeState("VALUE_UP", action: "tempUp")
-				attributeState("VALUE_DOWN", action: "tempDown")
-			}
-		}
-
-		valueTile("temperature", "device.temperature", width: 2, height: 2) {
-			state("temperature", label:'${currentValue}', unit:"dF",
-				backgroundColors:[
-					[value: 31, color: "#153591"],
-					[value: 44, color: "#1e9cbb"],
-					[value: 59, color: "#90d2a7"],
-					[value: 74, color: "#44b621"],
-					[value: 84, color: "#f1d801"],
-					[value: 95, color: "#d04e00"],
-					[value: 96, color: "#bc2323"]
-				]
-			)
-		}
-		standardTile("tempDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "tempDown", label:'down', action:"tempDown", defaultState: true
-		}
-		standardTile("tempUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "tempUp", label:'up', action:"tempUp", defaultState: true
-		}
-
-		valueTile("heatingSetpoint", "device.heatingSetpoint", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "heat", label:'${currentValue} heat', unit: "F", backgroundColor:"#ffffff"
-		}
-		standardTile("heatDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "heatDown", label:'down', action:"heatDown", defaultState: true
-		}
-		standardTile("heatUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "heatUp", label:'up', action:"heatUp", defaultState: true
-		}
-
-		valueTile("coolingSetpoint", "device.coolingSetpoint", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "cool", label:'${currentValue} cool', unit:"F", backgroundColor:"#ffffff"
-		}
-		standardTile("coolDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "coolDown", label:'down', action:"coolDown", defaultState: true
-		}
-		standardTile("coolUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "coolUp", label:'up', action:"coolUp", defaultState: true
-		}
-
-		standardTile("mode", "device.thermostatMode", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "off", label:'${name}', action:"thermostat.heat", backgroundColor:"#ffffff"
-			state "heat", label:'${name}', action:"thermostat.cool", backgroundColor:"#ffa81e"
-			state "cool", label:'${name}', action:"thermostat.auto", backgroundColor:"#269bd2"
-			state "auto", label:'${name}', action:"thermostat.off", backgroundColor:"#79b821"
-		}
-		standardTile("fanMode", "device.thermostatFanMode", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "fanAuto", label:'${name}', action:"thermostat.fanOn", backgroundColor:"#ffffff"
-			state "fanOn", label:'${name}', action:"thermostat.fanCirculate", backgroundColor:"#ffffff"
-			state "fanCirculate", label:'${name}', action:"thermostat.fanAuto", backgroundColor:"#ffffff"
-		}
-		standardTile("operatingState", "device.thermostatOperatingState", width: 2, height: 2) {
-			state "idle", label:'${name}', backgroundColor:"#ffffff"
-			state "heating", label:'${name}', backgroundColor:"#ffa81e"
-			state "cooling", label:'${name}', backgroundColor:"#269bd2"
-		}
-
-
-		main("thermostatFull")
-		details([
-			"thermostatFull", "thermostatNoHumidity", "thermostatBasic",
-			"temperature","tempDown","tempUp",
-			"mode", "fanMode", "operatingState",
-			"heatingSetpoint", "heatDown", "heatUp",
-			"coolingSetpoint", "coolDown", "coolUp"
-		])
-	}
-}
-
-def installed() {
-	sendEvent(name: "temperature", value: 72, unit: "F")
-	sendEvent(name: "heatingSetpoint", value: 70, unit: "F")
-	sendEvent(name: "thermostatSetpoint", value: 70, unit: "F")
-	sendEvent(name: "coolingSetpoint", value: 76, unit: "F")
-	sendEvent(name: "thermostatMode", value: "off")
-	sendEvent(name: "thermostatFanMode", value: "fanAuto")
-	sendEvent(name: "thermostatOperatingState", value: "idle")
-	sendEvent(name: "humidity", value: 53, unit: "%")
-}
-
-def parse(String description) {
-}
-
-def evaluate(temp, heatingSetpoint, coolingSetpoint) {
-	log.debug "evaluate($temp, $heatingSetpoint, $coolingSetpoint"
-	def threshold = 1.0
-	def current = device.currentValue("thermostatOperatingState")
-	def mode = device.currentValue("thermostatMode")
-
-	def heating = false
-	def cooling = false
-	def idle = false
-	if (mode in ["heat","emergency heat","auto"]) {
-		if (heatingSetpoint - temp >= threshold) {
-			heating = true
-			sendEvent(name: "thermostatOperatingState", value: "heating")
-		}
-		else if (temp - heatingSetpoint >= threshold) {
-			idle = true
-		}
-		sendEvent(name: "thermostatSetpoint", value: heatingSetpoint)
-	}
-	if (mode in ["cool","auto"]) {
-		if (temp - coolingSetpoint >= threshold) {
-			cooling = true
-			sendEvent(name: "thermostatOperatingState", value: "cooling")
-		}
-		else if (coolingSetpoint - temp >= threshold && !heating) {
-			idle = true
-		}
-		sendEvent(name: "thermostatSetpoint", value: coolingSetpoint)
-	}
-	else {
-		sendEvent(name: "thermostatSetpoint", value: heatingSetpoint)
-	}
-
-	if (mode == "off") {
-		idle = true
-	}
-
-	if (idle && !heating && !cooling) {
-		sendEvent(name: "thermostatOperatingState", value: "idle")
-	}
-}
-
-def setHeatingSetpoint(Double degreesF) {
-	log.debug "setHeatingSetpoint($degreesF)"
-	sendEvent(name: "heatingSetpoint", value: degreesF)
-	evaluate(device.currentValue("temperature"), degreesF, device.currentValue("coolingSetpoint"))
-}
-
-def setCoolingSetpoint(Double degreesF) {
-	log.debug "setCoolingSetpoint($degreesF)"
-	sendEvent(name: "coolingSetpoint", value: degreesF)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), degreesF)
-}
-
-def setThermostatMode(String value) {
-	sendEvent(name: "thermostatMode", value: value)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def setThermostatFanMode(String value) {
-	sendEvent(name: "thermostatFanMode", value: value)
-}
-
-def off() {
-	sendEvent(name: "thermostatMode", value: "off")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def heat() {
-	sendEvent(name: "thermostatMode", value: "heat")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def auto() {
-	sendEvent(name: "thermostatMode", value: "auto")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def emergencyHeat() {
-	sendEvent(name: "thermostatMode", value: "emergency heat")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def cool() {
-	sendEvent(name: "thermostatMode", value: "cool")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def fanOn() {
-	sendEvent(name: "thermostatFanMode", value: "fanOn")
-}
-
-def fanAuto() {
-	sendEvent(name: "thermostatFanMode", value: "fanAuto")
-}
-
-def fanCirculate() {
-	sendEvent(name: "thermostatFanMode", value: "fanCirculate")
-}
-
-def poll() {
-	null
-}
-
-def tempUp() {
-	def ts = device.currentState("temperature")
-	def value = ts ? ts.integerValue + 1 : 72
-	sendEvent(name:"temperature", value: value)
-	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def tempDown() {
-	def ts = device.currentState("temperature")
-	def value = ts ? ts.integerValue - 1 : 72
-	sendEvent(name:"temperature", value: value)
-	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def setTemperature(value) {
-	def ts = device.currentState("temperature")
-	sendEvent(name:"temperature", value: value)
-	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def heatUp() {
-	def ts = device.currentState("heatingSetpoint")
-	def value = ts ? ts.integerValue + 1 : 68
-	sendEvent(name:"heatingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), value, device.currentValue("coolingSetpoint"))
-}
-
-def heatDown() {
-	def ts = device.currentState("heatingSetpoint")
-	def value = ts ? ts.integerValue - 1 : 68
-	sendEvent(name:"heatingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), value, device.currentValue("coolingSetpoint"))
-}
-
-
-def coolUp() {
-	def ts = device.currentState("coolingSetpoint")
-	def value = ts ? ts.integerValue + 1 : 76
-	sendEvent(name:"coolingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), value)
-}
-
-def coolDown() {
-	def ts = device.currentState("coolingSetpoint")
-	def value = ts ? ts.integerValue - 1 : 76
-	sendEvent(name:"coolingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), value)
-}

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

@@ -1,169 +0,0 @@
-/**
- *  Copyright 2016 SmartThings, Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *	  http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (
-		name: "videoPlayerDeviceTile",
-		namespace: "smartthings/tile-ux",
-		author: "SmartThings") {
-
-		capability "Configuration"
-		capability "Video Camera"
-		capability "Video Capture"
-		capability "Refresh"
-		capability "Switch"
-
-		// custom commands
-		command "start"
-		command "stop"
-		command "setProfileHD"
-		command "setProfileSDH"
-		command "setProfileSDL"
-	}
-
-	tiles(scale: 2) {
-		multiAttributeTile(name: "videoPlayer", type: "videoPlayer", width: 6, height: 4) {
-			tileAttribute("device.switch", key: "CAMERA_STATUS") {
-				attributeState("on", label: "Active", icon: "st.camera.dlink-indoor", action: "switch.off", backgroundColor: "#79b821", defaultState: true)
-				attributeState("off", label: "Inactive", icon: "st.camera.dlink-indoor", action: "switch.on", backgroundColor: "#ffffff")
-				attributeState("restarting", label: "Connecting", icon: "st.camera.dlink-indoor", backgroundColor: "#53a7c0")
-				attributeState("unavailable", label: "Unavailable", icon: "st.camera.dlink-indoor", action: "refresh.refresh", backgroundColor: "#F22000")
-			}
-
-			tileAttribute("device.errorMessage", key: "CAMERA_ERROR_MESSAGE") {
-				attributeState("errorMessage", label: "", value: "", defaultState: true)
-			}
-
-			tileAttribute("device.camera", key: "PRIMARY_CONTROL") {
-				attributeState("on", label: "Active", icon: "st.camera.dlink-indoor", backgroundColor: "#79b821", defaultState: true)
-				attributeState("off", label: "Inactive", icon: "st.camera.dlink-indoor", backgroundColor: "#ffffff")
-				attributeState("restarting", label: "Connecting", icon: "st.camera.dlink-indoor", backgroundColor: "#53a7c0")
-				attributeState("unavailable", label: "Unavailable", icon: "st.camera.dlink-indoor", backgroundColor: "#F22000")
-			}
-
-			tileAttribute("device.startLive", key: "START_LIVE") {
-				attributeState("live", action: "start", defaultState: true)
-			}
-
-			tileAttribute("device.stream", key: "STREAM_URL") {
-				attributeState("activeURL", defaultState: true)
-			}
-
-			tileAttribute("device.profile", key: "STREAM_QUALITY") {
-				attributeState("1", label: "720p", action: "setProfileHD", defaultState: true)
-				attributeState("2", label: "h360p", action: "setProfileSDH", defaultState: true)
-				attributeState("3", label: "l360p", action: "setProfileSDL", defaultState: true)
-			}
-
-			tileAttribute("device.betaLogo", key: "BETA_LOGO") {
-				attributeState("betaLogo", label: "", value: "", defaultState: true)
-			}
-		}
-		
-		multiAttributeTile(name: "videoPlayerMin", type: "videoPlayer", width: 6, height: 4) {
-			tileAttribute("device.switch", key: "CAMERA_STATUS") {
-				attributeState("on", label: "Active", icon: "st.camera.dlink-indoor", action: "switch.off", backgroundColor: "#79b821", defaultState: true)
-				attributeState("off", label: "Inactive", icon: "st.camera.dlink-indoor", action: "switch.on", backgroundColor: "#ffffff")
-				attributeState("restarting", label: "Connecting", icon: "st.camera.dlink-indoor", backgroundColor: "#53a7c0")
-				attributeState("unavailable", label: "Unavailable", icon: "st.camera.dlink-indoor", action: "refresh.refresh", backgroundColor: "#F22000")
-			}
-
-			tileAttribute("device.errorMessage", key: "CAMERA_ERROR_MESSAGE") {
-				attributeState("errorMessage", label: "", value: "", defaultState: true)
-			}
-
-			tileAttribute("device.camera", key: "PRIMARY_CONTROL") {
-				attributeState("on", label: "Active", icon: "st.camera.dlink-indoor", backgroundColor: "#79b821", defaultState: true)
-				attributeState("off", label: "Inactive", icon: "st.camera.dlink-indoor", backgroundColor: "#ffffff")
-				attributeState("restarting", label: "Connecting", icon: "st.camera.dlink-indoor", backgroundColor: "#53a7c0")
-				attributeState("unavailable", label: "Unavailable", icon: "st.camera.dlink-indoor", backgroundColor: "#F22000")
-			}
-
-			tileAttribute("device.startLive", key: "START_LIVE") {
-				attributeState("live", action: "start", defaultState: true)
-			}
-
-			tileAttribute("device.stream", key: "STREAM_URL") {
-				attributeState("activeURL", defaultState: true)
-			}
-		}
-
-		main("videoPlayer")
-		details([
-			"videoPlayer", "videoPlayerMin"
-		])
-	}
-}
-
-def installed() {
-}
-
-def parse(String description) {
-}
-
-def refresh() {
-	log.trace "refresh()"
-	// no-op
-}
-
-def on() {
-	log.trace "on()"
-	// no-op
-}
-
-def off() {
-	log.trace "off()"
-	// no-op
-}
-
-def setProfile(profile) {
-	log.trace "setProfile(): ${profile}"
-	sendEvent(name: "profile", value: profile, displayed: false)
-}
-
-def setProfileHD() {
-	setProfile(1)
-}
-
-def setProfileSDH() {
-	setProfile(2)
-}
-
-def setProfileSDL() {
-	setProfile(3)
-}
-
-def start() {
-	log.trace "start()"
-	def dataLiveVideo = [
-		OutHomeURL  : "https://devimages.apple.com.edgekey.net/streaming/examples/bipbop_4x3/bipbop_4x3_variant.m3u8",
-		InHomeURL   : "https://devimages.apple.com.edgekey.net/streaming/examples/bipbop_4x3/bipbop_4x3_variant.m3u8",
-		ThumbnailURL: "http://cdn.device-icons.smartthings.com/camera/dlink-indoor@2x.png",
-		cookie      : [key: "key", value: "value"]
-	]
-
-	def event = [
-		name           : "stream",
-		value          : groovy.json.JsonOutput.toJson(dataLiveVideo).toString(),
-		data		   : groovy.json.JsonOutput.toJson(dataLiveVideo),
-		descriptionText: "Starting the livestream",
-		eventType      : "VIDEO",
-		displayed      : false,
-		isStateChange  : true
-	]
-	sendEvent(event)
-}
-
-def stop() {
-	log.trace "stop()"
-}

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

@@ -13,7 +13,7 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-
+ 
 metadata {
 	definition (name: "Tyco Door/Window Sensor", namespace: "smartthings", author: "SmartThings") {
 		capability "Battery"
@@ -21,28 +21,28 @@ metadata {
 		capability "Contact Sensor"
 		capability "Refresh"
 		capability "Temperature Measurement"
-
+        
 		command "enrollResponse"
-
-
+ 
+ 
 		fingerprint inClusters: "0000,0001,0003,0402,0500,0020,0B05", outClusters: "0019", manufacturer: "Visonic", model: "MCT-340 SMA"
 	}
-
+ 
 	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
 	}
-
+ 
 	tiles {
     	standardTile("contact", "device.contact", width: 2, height: 2) {
 			state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
 			state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
 		}
-
+    	
 		valueTile("temperature", "device.temperature", inactiveLabel: false) {
 			state "temperature", label:'${currentValue}°',
 				backgroundColors:[
@@ -58,23 +58,23 @@ metadata {
 		valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false) {
 			state "battery", label:'${currentValue}% battery', unit:""
 		}
-
+        
         standardTile("refresh", "device.refresh", 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"
 		}
-
+ 
 		main (["contact", "temperature"])
 		details(["contact","temperature","battery","refresh","configure"])
 	}
 }
-
+ 
 def parse(String description) {
 	log.debug "description: $description"
-
+    
 	Map map = [:]
 	if (description?.startsWith('catchall:')) {
 		map = parseCatchAllMessage(description)
@@ -88,10 +88,10 @@ def parse(String 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}"
@@ -99,7 +99,7 @@ def parse(String description) {
     }
     return result
 }
-
+ 
 private Map parseCatchAllMessage(String description) {
     Map resultMap = [:]
     def cluster = zigbee.parse(description)
@@ -125,20 +125,20 @@ private Map parseCatchAllMessage(String description) {
 private boolean shouldProcessMessage(cluster) {
     // 0x0B is default response indicating message got through
     // 0x07 is bind message
-    boolean ignoredMessage = cluster.profileId != 0x0104 ||
+    boolean ignoredMessage = cluster.profileId != 0x0104 || 
         cluster.command == 0x0B ||
         cluster.command == 0x07 ||
         (cluster.data.size() > 0 && cluster.data.first() == 0x3e)
     return !ignoredMessage
 }
-
+ 
 private Map parseReportAttributeMessage(String description) {
 	Map descMap = (description - "read attr - ").split(",").inject([:]) { map, param ->
 		def nameAndValue = param.split(":")
 		map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
 	}
 	log.debug "Desc Map: $descMap"
-
+ 
 	Map resultMap = [:]
 	if (descMap.cluster == "0402" && descMap.attrId == "0000") {
 		def value = getTemperature(descMap.value)
@@ -147,10 +147,10 @@ private Map parseReportAttributeMessage(String description) {
 	else if (descMap.cluster == "0001" && descMap.attrId == "0020") {
 		resultMap = getBatteryResult(Integer.parseInt(descMap.value, 16))
 	}
-
+ 
 	return resultMap
 }
-
+ 
 private Map parseCustomMessage(String description) {
 	Map resultMap = [:]
 	if (description?.startsWith('temperature: ')) {
@@ -163,7 +163,7 @@ private Map parseCustomMessage(String description) {
 private Map parseIasMessage(String description) {
     List parsedMsg = description.split(' ')
     String msgCode = parsedMsg[2]
-
+    
     Map resultMap = [:]
     switch(msgCode) {
         case '0x0020': // Closed/No Motion/Dry
@@ -196,7 +196,7 @@ private Map parseIasMessage(String description) {
     }
     return resultMap
 }
-
+ 
 def getTemperature(value) {
 	def celsius = Integer.parseInt(value, 16).shortValue() / 100
 	if(getTemperatureScale() == "C"){
@@ -209,11 +209,11 @@ def getTemperature(value) {
 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) {
@@ -223,8 +223,7 @@ private Map getBatteryResult(rawValue) {
 		def minVolts = 2.1
     	def maxVolts = 3.0
 		def pct = (volts - minVolts) / (maxVolts - minVolts)
-		def roundedPct = Math.round(pct * 100)
-		result.value = Math.min(100, roundedPct)
+		result.value = Math.min(100, (int) pct * 100)
 		result.descriptionText = "${linkText} battery was ${result.value}%"
 	}
 
@@ -262,7 +261,7 @@ def refresh()
 {
 	log.debug "Refreshing Temperature and Battery"
 	[
-
+    
         "st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
 		"st rattr 0x${device.deviceNetworkId} 1 1 0x20"
 
@@ -275,24 +274,24 @@ def configure() {
 		log.debug "Configuring Reporting, IAS CIE, and Bindings."
 	def configCmds = [
     	"delay 1000",
-
+        
 		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-
+        
         "zcl global send-me-a-report 1 0x20 0x20 600 3600 {01}", "delay 200",
         "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-
+        
         "zcl global send-me-a-report 0x402 0 0x29 300 3600 {6400}", "delay 200",
         "send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-
-
+        
+        
         //"raw 0x500 {01 23 00 00 00}", "delay 200",
         //"send 0x${device.deviceNetworkId} 1 1", "delay 1500",
-
-
+        
+        
 		"zdo bind 0x${device.deviceNetworkId} 1 1 0x402 {${device.zigbeeId}} {}", "delay 500",
 		"zdo bind 0x${device.deviceNetworkId} 1 1 1 {${device.zigbeeId}} {}",
-
+        
         "delay 500"
 	]
     return configCmds + enrollResponse() + refresh() // send refresh cmds as part of config
@@ -300,11 +299,11 @@ def configure() {
 
 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) {

devicetypes/smartthings/wattvision.src/wattvision.groovy

@@ -33,7 +33,7 @@ metadata {
 			state "power", label: '${currentValue} W'
 		}
 
-		htmlTile(name: "powerContent", attribute: "powerContent", type: "HTML", whitelist: ["www.wattvision.com"] , url: '${currentValue}', width: 3, height: 2)
+		htmlTile(name: "powerContent", attribute: "powerContent", type: "HTML", whitelist: "www.wattvision.com" , url: '${currentValue}', width: 3, height: 2)
 
 		standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat") {
 			state "default", label: '', action: "refresh.refresh", icon: "st.secondary.refresh"

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

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

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

@@ -56,17 +56,21 @@ metadata {
 def parse(String description) {
     log.debug "description is $description"
 
-    def event = zigbee.getEvent(description)
-    if (event) {
-        log.info event
-        if (event.name == "power") {
+    def resultMap = zigbee.getKnownDescription(description)
+    if (resultMap) {
+        log.info resultMap
+        if (resultMap.type == "update") {
+            log.info "$device updates: ${resultMap.value}"
+        }
+        else if (resultMap.type == "power") {
+            def powerValue
             if (device.getDataValue("manufacturer") != "OSRAM") {       //OSRAM devices do not reliably update power
-                event.value = (event.value as Integer) / 10             //TODO: The divisor value needs to be set as part of configuration
-                sendEvent(event)
+                powerValue = (resultMap.value as Integer)/10            //TODO: The divisor value needs to be set as part of configuration
+                sendEvent(name: "power", value: powerValue)
             }
         }
         else {
-            sendEvent(event)
+            sendEvent(name: resultMap.type, value: resultMap.value)
         }
     }
     else {

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

@@ -51,9 +51,15 @@ metadata {
 def parse(String description) {
     log.debug "description is $description"
 
-    def event = zigbee.getEvent(description)
-    if (event) {
-        sendEvent(event)
+    def resultMap = zigbee.getKnownDescription(description)
+    if (resultMap) {
+        log.info resultMap
+        if (resultMap.type == "update") {
+            log.info "$device updates: ${resultMap.value}"
+        }
+        else {
+            sendEvent(name: resultMap.type, value: resultMap.value)
+        }
     }
     else {
         log.warn "DID NOT PARSE MESSAGE for description : $description"

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

@@ -11,9 +11,6 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-
-//@Deprecated - Moved to zll-rgbw-bulb
-
 /* Philips Hue (via Zigbee)
 
 Capabilities:
@@ -25,10 +22,10 @@ Capabilities:
   Sensor
   Switch
   Switch Level
-
+  
 Custom Commands:
   setAdjustedColor
-
+    
 */
 
 metadata {
@@ -44,7 +41,7 @@ metadata {
 
 		command "setAdjustedColor"
 
-		//fingerprint profileId: "C05E", inClusters: "0000,0003,0004,0005,0006,0008,0300,1000", outClusters: "0019"
+		fingerprint profileId: "C05E", inClusters: "0000,0003,0004,0005,0006,0008,0300,1000", outClusters: "0019"
 	}
 
 	// simulator metadata

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

@@ -83,19 +83,32 @@ def uninstalled() {
 }
 
 def configure() {
+    /*
     def cmds =
-        zigbee.configureReporting(CLUSTER_DOORLOCK, DOORLOCK_ATTR_LOCKSTATE,
-                                  TYPE_ENUM8, 0, 3600, null) +
-        zigbee.configureReporting(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING,
-                                  TYPE_U8, 600, 21600, 0x01)
+        zigbee.configSetup("${CLUSTER_DOORLOCK}", "${DOORLOCK_ATTR_LOCKSTATE}",
+                           "${TYPE_ENUM8}", 0, 3600, "{01}") +
+        zigbee.configSetup("${CLUSTER_POWER}", "${POWER_ATTR_BATTERY_PERCENTAGE_REMAINING}",
+                           "${TYPE_U8}", 600, 21600, "{01}")
+    */
+    def zigbeeId = device.zigbeeId
+    def cmds =
+        [
+            "zdo bind 0x${device.deviceNetworkId} 0x${device.endpointId} 1 ${CLUSTER_DOORLOCK} {$zigbeeId} {}", "delay 200",
+            "zcl global send-me-a-report ${CLUSTER_DOORLOCK} ${DOORLOCK_ATTR_LOCKSTATE} ${TYPE_ENUM8} 0 3600 {01}", "delay 200",
+            "send 0x${device.deviceNetworkId} 1 0x${device.endpointId}", "delay 200",
+
+            "zdo bind 0x${device.deviceNetworkId} 0x${device.endpointId} 1 ${CLUSTER_POWER} {$zigbeeId} {}", "delay 200",
+            "zcl global send-me-a-report ${CLUSTER_POWER} ${POWER_ATTR_BATTERY_PERCENTAGE_REMAINING} ${TYPE_U8} 600 21600 {01}", "delay 200",
+            "send 0x${device.deviceNetworkId} 1 0x${device.endpointId}", "delay 200",
+        ]
     log.info "configure() --- cmds: $cmds"
     return cmds + refresh() // send refresh cmds as part of config
 }
 
 def refresh() {
     def cmds =
-        zigbee.readAttribute(CLUSTER_DOORLOCK, DOORLOCK_ATTR_LOCKSTATE) +
-        zigbee.readAttribute(CLUSTER_POWER, POWER_ATTR_BATTERY_PERCENTAGE_REMAINING)
+        zigbee.refreshData("${CLUSTER_DOORLOCK}", "${DOORLOCK_ATTR_LOCKSTATE}") +
+        zigbee.refreshData("${CLUSTER_POWER}", "${POWER_ATTR_BATTERY_PERCENTAGE_REMAINING}")
     log.info "refresh() --- cmds: $cmds"
     return cmds
 }
@@ -108,27 +121,34 @@ def parse(String description) {
         map = parseReportAttributeMessage(description)
     }
 
+    log.debug "parse() --- Parse returned $map"
     def result = map ? createEvent(map) : null
-    log.debug "parse() --- returned: $result"
     return result
 }
 
 // Lock capability commands
 def lock() {
-    def cmds = zigbee.command(CLUSTER_DOORLOCK, DOORLOCK_CMD_LOCK_DOOR)
-    log.info "lock() -- cmds: $cmds"
-    return cmds
+    //def cmds = zigbee.zigbeeCommand("${CLUSTER_DOORLOCK}", "${DOORLOCK_CMD_LOCK_DOOR}", "{}")
+    //log.info "lock() -- cmds: $cmds"
+    //return cmds
+    "st cmd 0x${device.deviceNetworkId} 0x${device.endpointId} ${CLUSTER_DOORLOCK} ${DOORLOCK_CMD_LOCK_DOOR} {}"
 }
 
 def unlock() {
-    def cmds = zigbee.command(CLUSTER_DOORLOCK, DOORLOCK_CMD_UNLOCK_DOOR)
-    log.info "unlock() -- cmds: $cmds"
-    return cmds
+    //def cmds = zigbee.zigbeeCommand("${CLUSTER_DOORLOCK}", "${DOORLOCK_CMD_UNLOCK_DOOR}", "{}")
+    //log.info "unlock() -- cmds: $cmds"
+    //return cmds
+    "st cmd 0x${device.deviceNetworkId} 0x${device.endpointId} ${CLUSTER_DOORLOCK} ${DOORLOCK_CMD_UNLOCK_DOOR} {}"
 }
 
 // Private methods
 private Map parseReportAttributeMessage(String description) {
+    log.trace "parseReportAttributeMessage() --- description: $description"
+
     Map descMap = zigbee.parseDescriptionAsMap(description)
+
+    log.debug "parseReportAttributeMessage() --- descMap: $descMap"
+
     Map resultMap = [:]
     if (descMap.clusterInt == CLUSTER_POWER && descMap.attrInt == POWER_ATTR_BATTERY_PERCENTAGE_REMAINING) {
         resultMap.name = "battery"
@@ -136,24 +156,18 @@ private Map parseReportAttributeMessage(String description) {
         if (device.getDataValue("manufacturer") == "Yale") {            //Handling issue with Yale locks incorrect battery reporting
             resultMap.value = Integer.parseInt(descMap.value, 16)
         }
+        log.info "parseReportAttributeMessage() --- battery: ${resultMap.value}"
     }
     else if (descMap.clusterInt == CLUSTER_DOORLOCK && descMap.attrInt == DOORLOCK_ATTR_LOCKSTATE) {
         def value = Integer.parseInt(descMap.value, 16)
-        def linkText = getLinkText(device)
         resultMap.name = "lock"
-        if (value == 0) {
-            resultMap.value = "unknown"
-            resultMap.descriptionText = "${linkText} is not fully locked"
-        } else if (value == 1) {
-            resultMap.value = "locked"
-            resultMap.descriptionText = "${linkText} is locked"
-        } else if (value == 2) {
-            resultMap.value = "unlocked"
-            resultMap.descriptionText = "${linkText} is unlocked"
-        } else {
-            resultMap.value = "unknown"
-            resultMap.descriptionText = "${linkText} is in unknown lock state"
-        }
+        resultMap.putAll([0:["value":"unknown",
+                             "descriptionText":"Not fully locked"],
+                          1:["value":"locked"],
+                          2:["value":"unlocked"]].get(value,
+                                                      ["value":"unknown",
+                                                       "descriptionText":"Unknown lock state"]))
+        log.info "parseReportAttributeMessage() --- lock: ${resultMap.value}"
     }
     else {
         log.debug "parseReportAttributeMessage() --- ignoring attribute"

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

@@ -51,15 +51,22 @@ metadata {
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
-    def event = zigbee.getEvent(description)
-    if (event) {
-        if (event.name == "power") {
+
+    def resultMap = zigbee.getKnownDescription(description)
+    if (resultMap) {
+        log.info resultMap
+        if (resultMap.type == "update") {
+            log.info "$device updates: ${resultMap.value}"
+        }
+        else if (resultMap.type == "power") {
             def powerValue
-            powerValue = (event.value as Integer)/10            //TODO: The divisor value needs to be set as part of configuration
-            sendEvent(name: "power", value: powerValue)
+            if (device.getDataValue("manufacturer") != "OSRAM") {       //OSRAM devices do not reliably update power
+                powerValue = (resultMap.value as Integer)/10            //TODO: The divisor value needs to be set as part of configuration
+                sendEvent(name: "power", value: powerValue)
+            }
         }
         else {
-            sendEvent(event)
+            sendEvent(name: resultMap.type, value: resultMap.value)
         }
     }
     else {

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

@@ -20,7 +20,6 @@ metadata {
         capability "Switch"
 
         fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006"
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0006", outClusters: "0003, 0006, 0019, 0406", manufacturer: "Leviton", model: "ZSS-10", deviceJoinName: "Leviton Switch"
     }
 
     // simulator metadata
@@ -54,9 +53,16 @@ metadata {
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
-    def event = zigbee.getEvent(description)
-    if (event) {
-        sendEvent(event)
+
+    def resultMap = zigbee.getKnownDescription(description)
+    if (resultMap) {
+        log.info resultMap
+        if (resultMap.type == "update") {
+            log.info "$device updates: ${resultMap.value}"
+        }
+        else {
+            sendEvent(name: resultMap.type, value: resultMap.value)
+        }
     }
     else {
         log.warn "DID NOT PARSE MESSAGE for description : $description"

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

@@ -73,9 +73,16 @@ metadata {
 // Parse incoming device messages to generate events
 def parse(String description) {
     log.debug "description is $description"
-    def event = zigbee.getEvent(description)
-    if (event) {
-        sendEvent(event)
+
+    def finalResult = zigbee.getKnownDescription(description)
+    if (finalResult) {
+        log.info finalResult
+        if (finalResult.type == "update") {
+            log.info "$device updates: ${finalResult.value}"
+        }
+        else {
+            sendEvent(name: finalResult.type, value: finalResult.value)
+        }
     }
     else {
         log.warn "DID NOT PARSE MESSAGE for description : $description"

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

@@ -1,102 +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: "ZLL Dimmer Bulb", namespace: "smartthings", author: "SmartThings") {
-
-        capability "Actuator"
-        capability "Configuration"
-        capability "Polling"
-        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: "0019"
-        //fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 1000", outClusters: "0000,0019", manufacturer: "CREE", model: "Connected A-19 60W Equivalent", deviceJoinName: "Cree Connected Bulb"
-        fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 1000, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Classic A60 W clear", deviceJoinName: "OSRAM LIGHTIFY LED Smart Connected Light"
-        fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 1000, 0B04, FC0F", outClusters: "0019", manufacturer: "OSRAM", model: "Classic A60 W clear - LIGHTIFY", deviceJoinName: "OSRAM LIGHTIFY LED Smart Connected Light"
-        fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 1000", outClusters: "0019", manufacturer: "Philips", model: "LWB006", deviceJoinName: "Philips Hue 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(scale: 2) {
-        multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
-            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
-                attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
-                attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-            }
-            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-                attributeState "level", action:"switch level.setLevel"
-            }
-        }
-        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-        main "switch"
-        details(["switch", "refresh"])
-    }
-}
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-    log.debug "description is $description"
-
-    def resultMap = zigbee.getEvent(description)
-    if (resultMap) {
-        sendEvent(resultMap)
-    }
-    else {
-        log.debug "DID NOT PARSE MESSAGE for description : $description"
-        log.debug zigbee.parseDescriptionAsMap(description)
-    }
-}
-
-def off() {
-    zigbee.off() + ["delay 1500"] + zigbee.onOffRefresh()
-}
-
-def on() {
-    zigbee.on() + ["delay 1500"] + zigbee.onOffRefresh()
-}
-
-def setLevel(value) {
-    zigbee.setLevel(value) + ["delay 1500"] + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
-}
-
-def refresh() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh()
-}
-
-def poll() {
-    refresh()
-}
-
-def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
-}

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

@@ -1,150 +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: "ZLL RGBW Bulb", namespace: "smartthings", author: "SmartThings") {
-
-        capability "Actuator"
-        capability "Color Control"
-        capability "Color Temperature"
-        capability "Configuration"
-        capability "Polling"
-        capability "Refresh"
-        capability "Switch"
-        capability "Switch Level"
-
-        fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300", outClusters: "0019"
-        fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 1000", outClusters: "0019"
-        fingerprint profileId: "C05E", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0300, 1000", outClusters: "0019", "manufacturer":"OSRAM", "model":"Classic A60 RGBW", deviceJoinName: "OSRAM LIGHTIFY LED Classic A60 RGBW"
-    }
-
-    // UI tile definitions
-    tiles(scale: 2) {
-        multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
-            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
-                attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
-                attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
-            }
-            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-                attributeState "level", action:"switch level.setLevel"
-            }
-            tileAttribute ("device.color", key: "COLOR_CONTROL") {
-                attributeState "color", action:"color control.setColor"
-            }
-        }
-        controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2700..6500)") {
-            state "colorTemperature", action:"color temperature.setColorTemperature"
-        }
-        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "colorTemperature", label: '${currentValue} K'
-        }
-        standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-
-        main(["switch"])
-        details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
-    }
-}
-
-//Globals
-private getATTRIBUTE_HUE() { 0x0000 }
-private getATTRIBUTE_SATURATION() { 0x0001 }
-private getHUE_COMMAND() { 0x00 }
-private getSATURATION_COMMAND() { 0x03 }
-private getCOLOR_CONTROL_CLUSTER() { 0x0300 }
-private getATTRIBUTE_COLOR_TEMPERATURE() { 0x0007 }
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-    log.debug "description is $description"
-
-    def finalResult = zigbee.getEvent(description)
-    if (finalResult) {
-        log.debug finalResult
-        sendEvent(finalResult)
-    }
-    else {
-        def zigbeeMap = zigbee.parseDescriptionAsMap(description)
-        log.trace "zigbeeMap : $zigbeeMap"
-
-        if (zigbeeMap?.clusterInt == COLOR_CONTROL_CLUSTER) {
-            if(zigbeeMap.attrInt == ATTRIBUTE_HUE){  //Hue Attribute
-                def hueValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 360)
-                sendEvent(name: "hue", value: hueValue, displayed:false)
-            }
-            else if(zigbeeMap.attrInt == ATTRIBUTE_SATURATION){ //Saturation Attribute
-                def saturationValue = Math.round(zigbee.convertHexToInt(zigbeeMap.value) / 255 * 100)
-                sendEvent(name: "saturation", value: saturationValue, displayed:false)
-            }
-        }
-        else {
-            log.info "DID NOT PARSE MESSAGE for description : $description"
-        }
-    }
-}
-
-def on() {
-    zigbee.on() + ["delay 1500"] + zigbee.onOffRefresh()
-}
-
-def off() {
-    zigbee.off() + ["delay 1500"] + zigbee.onOffRefresh()
-}
-
-def refresh() {
-    refreshAttributes() + configureAttributes()
-}
-
-def poll() {
-    refreshAttributes()
-}
-
-def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    configureAttributes() + refreshAttributes()
-}
-
-def configureAttributes() {
-    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_HUE, 0x20, 1, 3600, 0x01) + zigbee.configureReporting(COLOR_CONTROL_CLUSTER, ATTRIBUTE_SATURATION, 0x20, 1, 3600, 0x01)
-}
-
-def refreshAttributes() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh() + zigbee.readAttribute(0x0300, 0x00) + zigbee.readAttribute(0x0300, ATTRIBUTE_HUE) + zigbee.readAttribute(0x0300, ATTRIBUTE_SATURATION)
-}
-
-def setColorTemperature(value) {
-    zigbee.setColorTemperature(value) + ["delay 1500"] + zigbee.colorTemperatureRefresh()
-}
-
-def setLevel(value) {
-    zigbee.setLevel(value) + ["delay 1500"] + zigbee.levelRefresh()         //adding refresh because of ZLL bulb not conforming to send-me-a-report
-}
-
-def setColor(value){
-    log.trace "setColor($value)"
-    zigbee.on() + setHue(value.hue) + ["delay 300"] + setSaturation(value.saturation) + ["delay 2000"] + refreshAttributes()
-}
-
-def setHue(value) {
-    def scaledHueValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-    zigbee.command(COLOR_CONTROL_CLUSTER, HUE_COMMAND, scaledHueValue, "00", "0500")       //payload-> hue value, direction (00-> shortest distance), transition time (1/10th second) (0500 in U16 reads 5)
-}
-
-def setSaturation(value) {
-    def scaledSatValue = zigbee.convertToHexString(Math.round(value * 0xfe / 100.0), 2)
-    zigbee.command(COLOR_CONTROL_CLUSTER, SATURATION_COMMAND, scaledSatValue, "0500")      //payload-> sat value, transition time
-}

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

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

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

@@ -1,205 +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: "Z-Wave Dimmer Switch Generic", namespace: "smartthings", author: "SmartThings") {
-		capability "Switch Level"
-		capability "Actuator"
-		capability "Switch"
-		capability "Polling"
-		capability "Refresh"
-		capability "Sensor"
-
-		fingerprint inClusters: "0x26", deviceJoinName: "Z-Wave Dimmer"
-	}
-
-	simulator {
-		status "on":  "command: 2003, payload: FF"
-		status "off": "command: 2003, payload: 00"
-		status "09%": "command: 2003, payload: 09"
-		status "10%": "command: 2003, payload: 0A"
-		status "33%": "command: 2003, payload: 21"
-		status "66%": "command: 2003, payload: 42"
-		status "99%": "command: 2003, payload: 63"
-
-		// reply messages
-		reply "2001FF,delay 5000,2602": "command: 2603, payload: FF"
-		reply "200100,delay 5000,2602": "command: 2603, payload: 00"
-		reply "200119,delay 5000,2602": "command: 2603, payload: 19"
-		reply "200132,delay 5000,2602": "command: 2603, payload: 32"
-		reply "20014B,delay 5000,2602": "command: 2603, payload: 4B"
-		reply "200163,delay 5000,2602": "command: 2603, payload: 63"
-	}
-
-	tiles(scale: 2) {
-		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
-			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			}
-			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-				attributeState "level", action:"switch level.setLevel"
-			}
-		}
-
-		standardTile("refresh", "device.switch", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-
-		valueTile("level", "device.level", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "level", label:'${currentValue} %', unit:"%", backgroundColor:"#ffffff"
-		}
-
-		main(["switch"])
-		details(["switch", "level", "refresh"])
-
-	}
-}
-
-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)
-		}
-	}
-	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}"
-	}
-	return 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: "%")
-	}
-	return 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])
-}
-
-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 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)
-}
-
-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: "%")
-	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 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)
-}
-
-def poll() {
-	zwave.switchMultilevelV1.switchMultilevelGet().format()
-}
-
-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)
-}
-
-def invertSwitch(invert=true) {
-	if (invert) {
-		zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 4, size: 1).format()
-	}
-	else {
-		zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 4, size: 1).format()
-	}
-}

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

@@ -25,9 +25,7 @@ metadata {
 
 		fingerprint deviceId: "0x2001", inClusters: "0x30,0x80,0x84,0x85,0x86,0x72"
 		fingerprint deviceId: "0x07", inClusters: "0x30"
-		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x98"
 		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x86,0x72,0x98", outClusters: "0x5A,0x82"
-		fingerprint deviceId: "0x0701", inClusters: "0x5E,0x80,0x71,0x85,0x70,0x72,0x86,0x30,0x31,0x84,0x59,0x73,0x5A,0x8F,0x98,0x7A", outClusters:"0x20" // Philio multi+
 	}
 
 	// simulator metadata
@@ -35,7 +33,6 @@ metadata {
 		// status messages
 		status "open":  "command: 2001, payload: FF"
 		status "closed": "command: 2001, payload: 00"
-		status "wake up": "command: 8407, payload: "
 	}
 
 	// UI tile definitions
@@ -81,7 +78,7 @@ def updated() {
 	def cmds = []
 	if (!state.MSR) {
 		cmds = [
-			command(zwave.manufacturerSpecificV2.manufacturerSpecificGet()),
+			zwave.manufacturerSpecificV2.manufacturerSpecificGet().format(),
 			"delay 1200",
 			zwave.wakeUpV1.wakeUpNoMoreInformation().format()
 		]
@@ -94,9 +91,9 @@ def updated() {
 }
 
 def configure() {
-	commands([
-		zwave.manufacturerSpecificV2.manufacturerSpecificGet(),
-		zwave.batteryV1.batteryGet()
+	delayBetween([
+		zwave.manufacturerSpecificV2.manufacturerSpecificGet().format(),
+		batteryGetCommand()
 	], 6000)
 }
 
@@ -147,11 +144,12 @@ def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cm
 			result << sensorValueEvent(1)
 		} else if (cmd.event == 0x03) {
 			result << createEvent(descriptionText: "$device.displayName covering was removed", isStateChange: true)
-			if(!state.MSR) result << response(command(zwave.manufacturerSpecificV2.manufacturerSpecificGet()))
+			result << response(zwave.wakeUpV1.wakeUpIntervalSet(seconds:4*3600, nodeid:zwaveHubNodeId))
+			if(!state.MSR) result << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
 		} else if (cmd.event == 0x05 || cmd.event == 0x06) {
 			result << createEvent(descriptionText: "$device.displayName detected glass breakage", isStateChange: true)
 		} else if (cmd.event == 0x07) {
-			if(!state.MSR) result << response(command(zwave.manufacturerSpecificV2.manufacturerSpecificGet()))
+			if(!state.MSR) result << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
 			result << createEvent(name: "motion", value: "active", descriptionText:"$device.displayName detected motion")
 		}
 	} else if (cmd.notificationType) {
@@ -169,11 +167,12 @@ def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd)
 	def event = createEvent(descriptionText: "${device.displayName} woke up", isStateChange: false)
 	def cmds = []
 	if (!state.MSR) {
-		cmds << command(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
+		cmds << zwave.wakeUpV1.wakeUpIntervalSet(seconds:4*3600, nodeid:zwaveHubNodeId).format()
+		cmds << zwave.manufacturerSpecificV2.manufacturerSpecificGet().format()
 		cmds << "delay 1200"
 	}
 	if (!state.lastbat || now() - state.lastbat > 53*60*60*1000) {
-		cmds << command(zwave.batteryV1.batteryGet())
+		cmds << batteryGetCommand()
 	} else {
 		cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
 	}
@@ -210,7 +209,7 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
 		if (msr == "0086-0102-0059") {
 			result << response(zwave.securityV1.securityMessageEncapsulation().encapsulate(zwave.batteryV1.batteryGet()).format())
 		} else {
-			result << response(command(zwave.batteryV1.batteryGet()))
+			result << response(batteryGetCommand())
 		}
 	}
 
@@ -218,7 +217,7 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
-	def encapsulatedCommand = cmd.encapsulatedCommand([0x20: 1, 0x25: 1, 0x30: 1, 0x31: 5, 0x80: 1, 0x84: 1, 0x71: 3, 0x9C: 1])
+	def encapsulatedCommand = cmd.encapsulatedCommand([0x20: 1, 0x85: 2, 0x70: 1])
 	// log.debug "encapsulated: $encapsulatedCommand"
 	if (encapsulatedCommand) {
 		state.sec = 1
@@ -230,44 +229,28 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	createEvent(descriptionText: "$device.displayName: $cmd", displayed: false)
 }
 
-private command(physicalgraph.zwave.Command cmd) {
-	if (state.sec == 1) {
-		zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
-	} else {
-		cmd.format()
+def batteryGetCommand() {
+	def cmd = zwave.batteryV1.batteryGet()
+	if (state.sec) {
+		cmd = zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd)
 	}
-}
-
-private commands(commands, delay=200) {
-	delayBetween(commands.collect{ command(it) }, delay)
+	cmd.format()
 }
 
 def retypeBasedOnMSR() {
 	switch (state.MSR) {
 		case "0086-0002-002D":
-			log.debug "Changing device type to Z-Wave Water Sensor"
+			log.debug("Changing device type to Z-Wave Water Sensor")
 			setDeviceType("Z-Wave Water Sensor")
 			break
 		case "011F-0001-0001":  // Schlage motion
 		case "014A-0001-0001":  // Ecolink motion
-		case "014A-0004-0001":  // Ecolink motion +
 		case "0060-0001-0002":  // Everspring SP814
 		case "0060-0001-0003":  // Everspring HSP02
 		case "011A-0601-0901":  // Enerwave ZWN-BPC
-			log.debug "Changing device type to Z-Wave Motion Sensor"
+			log.debug("Changing device type to Z-Wave Motion Sensor")
 			setDeviceType("Z-Wave Motion Sensor")
 			break
-		case "013C-0002-000D":  // Philio multi +
-			log.debug "Changing device type to 3-in-1 Multisensor Plus (SG)"
-			setDeviceType("3-in-1 Multisensor Plus (SG)")
-			break
-		case "0109-2001-0106":  // Vision door/window
-			log.debug "Changing device type to Z-Wave Plus Door/Window Sensor"
-			setDeviceType("Z-Wave Plus Door/Window Sensor")
-			break
-		case "0109-2002-0205": // Vision Motion
-			log.debug "Changing device type to Z-Wave Plus Motion/Temp Sensor"
-			setDeviceType("Z-Wave Plus Motion/Temp Sensor")
-			break
+		
 	}
 }

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

@@ -21,13 +21,6 @@ metadata {
 		capability "Motion Sensor"
 		capability "Sensor"
 		capability "Battery"
-
-		fingerprint mfr: "011F", prod: "0001", model: "0001", deviceJoinName: "Schlage Motion Sensor"  // Schlage motion
-		fingerprint mfr: "014A", prod: "0001", model: "0001", deviceJoinName: "Ecolink Motion Sensor"  // Ecolink motion
-		fingerprint mfr: "014A", prod: "0004", model: "0001", deviceJoinName: "Ecolink Motion Sensor"  // Ecolink motion +
-		fingerprint mfr: "0060", prod: "0001", model: "0002", deviceJoinName: "Everspring Motion Sensor"  // Everspring SP814
-		fingerprint mfr: "0060", prod: "0001", model: "0003", deviceJoinName: "Everspring Motion Sensor"  // Everspring HSP02
-		fingerprint mfr: "011A", prod: "0601", model: "0901", deviceJoinName: "Enerwave Motion Sensor"  // Enerwave ZWN-BPC
 	}
 
 	simulator {
@@ -64,7 +57,7 @@ def parse(String description) {
 	return result
 }
 
-def sensorValueEvent(value) {
+def sensorValueEvent(Short value) {
 	if (value) {
 		createEvent(name: "motion", value: "active", descriptionText: "$device.displayName detected motion")
 	} else {
@@ -101,24 +94,24 @@ def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cm
 {
 	def result = []
 	if (cmd.notificationType == 0x07) {
-		if (cmd.v1AlarmType == 0x07) {  // special case for nonstandard messages from Monoprice ensors
-			result << sensorValueEvent(cmd.v1AlarmLevel)
-		} else if (cmd.event == 0x01 || cmd.event == 0x02 || cmd.event == 0x07 || cmd.event == 0x08) {
+		if (cmd.event == 0x01 || cmd.event == 0x02) {
 			result << sensorValueEvent(1)
-		} else if (cmd.event == 0x00) {
-			result << sensorValueEvent(0)
 		} else if (cmd.event == 0x03) {
-			result << createEvent(name: "tamper", value: "detected", descriptionText: "$device.displayName covering was removed", isStateChange: true)
-			result << response(zwave.batteryV1.batteryGet())
+			result << createEvent(descriptionText: "$device.displayName covering was removed", isStateChange: true)
+			result << response(zwave.wakeUpV1.wakeUpIntervalSet(seconds:4*3600, nodeid:zwaveHubNodeId))
+			if(!state.MSR) result << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
 		} else if (cmd.event == 0x05 || cmd.event == 0x06) {
 			result << createEvent(descriptionText: "$device.displayName detected glass breakage", isStateChange: true)
+		} else if (cmd.event == 0x07) {
+			if(!state.MSR) result << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
+			result << sensorValueEvent(1)
 		}
 	} else if (cmd.notificationType) {
 		def text = "Notification $cmd.notificationType: event ${([cmd.event] + cmd.eventParameter).join(", ")}"
-		result << createEvent(name: "notification$cmd.notificationType", value: "$cmd.event", descriptionText: text, isStateChange: true, displayed: false)
+		result << createEvent(name: "notification$cmd.notificationType", value: "$cmd.event", descriptionText: text, displayed: false)
 	} else {
 		def value = cmd.v1AlarmLevel == 255 ? "active" : cmd.v1AlarmLevel ?: "inactive"
-		result << createEvent(name: "alarm $cmd.v1AlarmType", value: value, isStateChange: true, displayed: false)
+		result << createEvent(name: "alarm $cmd.v1AlarmType", value: value, displayed: false)
 	}
 	result
 }
@@ -132,9 +125,9 @@ def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd)
 	}
 	if (!state.lastbat || (new Date().time) - state.lastbat > 53*60*60*1000) {
 		result << response(zwave.batteryV1.batteryGet())
-	} else {
-		result << response(zwave.wakeUpV1.wakeUpNoMoreInformation())
+		result << response("delay 1200")
 	}
+	result << response(zwave.wakeUpV1.wakeUpNoMoreInformation())
 	result
 }
 

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

@@ -1,270 +0,0 @@
-/**
-*	Copyright 2016 SmartThings
-*	Copyright 2015 AstraLink
-*
-*	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.
-*
-*	Z-Wave Plus Door/Window Sensor, ZD2102*-5
-*
-*/
-
-metadata {
-	definition (name: "Z-Wave Plus Door/Window Sensor", namespace: "smartthings", author: "SmartThings") {
-		capability "Contact Sensor"
-		capability "Configuration"
-		capability "Battery"
-		capability "Sensor"
-
-		// for Astralink
-		attribute "ManufacturerCode", "string"
-		attribute "ProduceTypeCode", "string"
-		attribute "ProductCode", "string"
-		attribute "WakeUp", "string"
-		attribute "WirelessConfig", "string"
-
-		fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x98, 0x86, 0x72, 0x5A, 0x85, 0x59, 0x73, 0x80, 0x71, 0x70, 0x84, 0x7A"
-		fingerprint type:"8C07", inClusters: "5E,98,86,72,5A,71"
-		fingerprint mfr:"0109", prod:"2001", model:"0106"  // not using deviceJoinName because it's sold under different brand names
-	}
-
-	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"
-			}
-		}
-		valueTile("battery", "device.battery", decoration: "flat", inactiveLabel: false, width: 2, height: 2) {
-			state "battery", label:'${currentValue}% battery', unit:""
-		}
-
-		main (["contact"])
-		details(["contact","battery"])
-	}
-
-	simulator {
-		// messages the device returns in response to commands it receives
-		status "open (basic)" : "command: 9881, payload: 00 20 01 FF"
-		status "closed (basic)" : "command: 9881 payload: 00 20 01 00"
-		status "open (notification)" : "command: 9881, payload: 00 71 05 06 FF 00 FF 06 16 00 00"
-		status "closed (notification)" : "command: 9881, payload: 00 71 05 06 00 00 FF 06 17 00 00"
-		status "tamper: enclosure opened" : "command: 9881, payload: 00 71 05 07 FF 00 FF 07 03 00 00"
-		status "tamper: enclosure replaced" : "command: 9881, payload: 00 71 05 07 00 00 FF 07 00 00 00"
-		status "wake up" : "command: 9881, payload: 00 84 07"
-		status "battery (100%)" : "command: 9881, payload: 00 80 03 64"
-		status "battery low" : "command: 9881, payload: 00 80 03 FF"
-	}
-}
-
-def configure() {
-	log.debug "configure()"
-	def cmds = []
-
-	if (state.sec != 1) {
-		// secure inclusion may not be complete yet
-		cmds << "delay 1000"
-	}
-
-	cmds += secureSequence([
-		zwave.manufacturerSpecificV2.manufacturerSpecificGet(),
-		zwave.batteryV1.batteryGet(),
-	], 500)
-
-	cmds << "delay 8000"
-	cmds << secure(zwave.wakeUpV1.wakeUpNoMoreInformation())
-	return cmds
-}
-
-private getCommandClassVersions() {
-	[
-		0x71: 3,  // Notification
-		0x5E: 2,  // ZwaveplusInfo
-		0x59: 1,  // AssociationGrpInfo
-		0x85: 2,  // Association
-		0x20: 1,  // Basic
-		0x80: 1,  // Battery
-		0x70: 1,  // Configuration
-		0x5A: 1,  // DeviceResetLocally
-		0x7A: 2,  // FirmwareUpdateMd
-		0x72: 2,  // ManufacturerSpecific
-		0x73: 1,  // Powerlevel
-		0x98: 1,  // Security
-		0x84: 2,  // WakeUp
-		0x86: 1,  // Version
-	]
-}
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-	def result = []
-	def cmd
-	if (description.startsWith("Err 106")) {
-		state.sec = 0
-		result = createEvent( name: "secureInclusion", value: "failed", eventType: "ALERT",
-				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.startsWith("Err")) {
-		result = createEvent(descriptionText: "$device.displayName $description", isStateChange: true)
-	} else {
-		cmd = zwave.parse(description, commandClassVersions)
-		if (cmd) {
-			result = zwaveEvent(cmd)
-		}
-	}
-
-	if (result instanceof List) {
-		result = result.flatten()
-	}
-
-	log.debug "Parsed '$description' to $result"
-	return result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
-	def encapsulatedCommand = cmd.encapsulatedCommand(commandClassVersions)
-	log.debug "encapsulated: $encapsulatedCommand"
-	if (encapsulatedCommand) {
-		state.sec = 1
-		return zwaveEvent(encapsulatedCommand)
-	} else {
-		log.warn "Unable to extract encapsulated cmd from $cmd"
-		return [createEvent(descriptionText: cmd.toString())]
-	}
-}
-
-def sensorValueEvent(value) {
-	if (value) {
-		createEvent(name: "contact", value: "open", descriptionText: "$device.displayName is open")
-	} else {
-		createEvent(name: "contact", value: "closed", descriptionText: "$device.displayName is closed")
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
-	return sensorValueEvent(cmd.value)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
-	return sensorValueEvent(cmd.value)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.sensorbinaryv2.SensorBinaryReport cmd) {
-	return sensorValueEvent(cmd.sensorValue)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.sensoralarmv1.SensorAlarmReport cmd) {
-	return sensorValueEvent(cmd.sensorState)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
-	def result = []
-	if (cmd.notificationType == 0x06 && cmd.event == 0x16) {
-		result << sensorValueEvent(1)
-	} else if (cmd.notificationType == 0x06 && cmd.event == 0x17) {
-		result << sensorValueEvent(0)
-	} else if (cmd.notificationType == 0x07) {
-		if (cmd.event == 0x00) {
-			if (cmd.eventParametersLength == 0 || cmd.eventParameter[0] != 3) {
-				result << createEvent(descriptionText: "$device.displayName covering replaced", isStateChange: true, displayed: false)
-			} else {
-				result << sensorValueEvent(0)
-			}
-		} else if (cmd.event == 0x01 || cmd.event == 0x02) {
-			result << sensorValueEvent(1)
-		} else if (cmd.event == 0x03) {
-			result << createEvent(descriptionText: "$device.displayName covering was removed", isStateChange: true)
-			if (!device.currentState("ManufacturerCode")) {
-				result << response(secure(zwave.manufacturerSpecificV2.manufacturerSpecificGet()))
-			}
-		} else if (cmd.event == 0x05 || cmd.event == 0x06) {
-			result << createEvent(descriptionText: "$device.displayName detected glass breakage", isStateChange: true)
-		} else {
-			result << createEvent(descriptionText: "$device.displayName event $cmd.event ${cmd.eventParameter.inspect()}", isStateChange: true, displayed: false)
-		}
-	} else if (cmd.notificationType) {
-		result << createEvent(descriptionText: "$device.displayName notification $cmd.notificationType event $cmd.event ${cmd.eventParameter.inspect()}", isStateChange: true, displayed: false)
-	} else {
-		def value = cmd.v1AlarmLevel == 255 ? "active" : cmd.v1AlarmLevel ?: "inactive"
-		result << createEvent(name: "alarm $cmd.v1AlarmType", value: value, isStateChange: true, displayed: false)
-	}
-	return result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd) {
-	def event = createEvent(name: "WakeUp", value: "wakeup", descriptionText: "${device.displayName} woke up", isStateChange: true, displayed: false)  // for Astralink
-	def cmds = []
-
-	if (!device.currentState("ManufacturerCode")) {
-		cmds << secure(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
-		cmds << "delay 2000"
-	}
-	if (!state.lastbat || now() - state.lastbat > 10*60*60*1000) {
-		event.descriptionText += ", requesting battery"
-		cmds << secure(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType:1, scale:1))
-		cmds << "delay 800"
-		cmds << secure(zwave.batteryV1.batteryGet())
-		cmds << "delay 2000"
-	} else {
-		log.debug "not checking battery, was updated ${(now() - state.lastbat)/60000 as int} min ago"
-	}
-	cmds << secure(zwave.wakeUpV1.wakeUpNoMoreInformation())
-
-	return [event, response(cmds)]
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
-	def map = [ name: "battery", unit: "%" ]
-	if (cmd.batteryLevel == 0xFF) {
-		map.value = 1
-		map.descriptionText = "${device.displayName} has a low battery"
-		map.isStateChange = true
-	} else {
-		map.value = cmd.batteryLevel
-	}
-	def event = createEvent(map)
-
-	// Save at least one battery report in events list every few days
-	if (!event.isStateChange && (now() - 3*24*60*60*1000) > device.latestState("battery")?.date?.time) {
-		map.isStateChange = true
-	}
-	state.lastbat = now()
-	return [event]
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
-	def result = []
-	def manufacturerCode = String.format("%04X", cmd.manufacturerId)
-	def productTypeCode = String.format("%04X", cmd.productTypeId)
-	def productCode = String.format("%04X", cmd.productId)
-	def wirelessConfig = "ZWP"
-	log.debug "MSR ${manufacturerCode} ${productTypeCode} ${productCode}"
-
-	result << createEvent(name: "ManufacturerCode", value: manufacturerCode)
-	result << createEvent(name: "ProduceTypeCode", value: productTypeCode)
-	result << createEvent(name: "ProductCode", value: productCode)
-	result << createEvent(name: "WirelessConfig", value: wirelessConfig)
-
-	return result
-}
-
-def zwaveEvent(physicalgraph.zwave.Command cmd) {
-	return [createEvent(descriptionText: "$device.displayName: $cmd", displayed: false)]
-}
-
-private secure(physicalgraph.zwave.Command cmd) {
-	if (state.sec == 0) {  // default to secure
-		cmd.format()
-	} else {
-		zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
-	}
-}
-
-private secureSequence(commands, delay=200) {
-	delayBetween(commands.collect{ secure(it) }, delay)
-}

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

@@ -1,327 +0,0 @@
-/**
-*	Copyright 2016 SmartThings
-*	Copyright 2015 AstraLink
-*
-*	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.
-*
-*	Z-Wave Plus Motion Sensor with Temperature Measurement, ZP3102*-5
-*
-*/
-
-metadata {
-	definition (name: "Z-Wave Plus Motion/Temp Sensor", namespace: "smartthings", author: "SmartThings") {
-		capability "Motion Sensor"
-		capability "Temperature Measurement"
-		capability "Configuration"
-		capability "Battery"
-		capability "Sensor"
-
-		// for Astralink
-		attribute "ManufacturerCode", "string"
-		attribute "ProduceTypeCode", "string"
-		attribute "ProductCode", "string"
-		attribute "WakeUp", "string"
-		attribute "WirelessConfig", "string"
-				
-		fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x98, 0x86, 0x72, 0x5A, 0x85, 0x59, 0x73, 0x80, 0x71, 0x31, 0x70, 0x84, 0x7A"
-		fingerprint type:"8C07", inClusters: "5E,98,86,72,5A,31,71"
-		fingerprint mfr:"0109", prod:"2002", model:"0205"  // not using deviceJoinName because it's sold under different brand names
-	}
-
-	tiles {
-		standardTile("motion", "device.motion", width: 3, height: 2) {
-			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
-			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
-		}
-
-		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:'${currentValue}% battery', unit:"%"
-		}
-
-		main(["motion", "temperature"])
-		details(["motion", "temperature", "battery"])
-	}
-}
-
-def updated() {
-	if (!device.currentState("ManufacturerCode")) {
-		response(secure(zwave.manufacturerSpecificV2.manufacturerSpecificGet()))
-	}
-}
-
-def configure() {
-	log.debug "configure()"
-	def cmds = []
-
-	if (state.sec != 1) {
-		// secure inclusion may not be complete yet
-		cmds << "delay 1000"
-	}
-
-	cmds += secureSequence([
-		zwave.manufacturerSpecificV2.manufacturerSpecificGet(),
-		zwave.batteryV1.batteryGet(),
-		zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType:1, scale:1)
-	], 500)
-
-	cmds << "delay 8000"
-	cmds << secure(zwave.wakeUpV1.wakeUpNoMoreInformation())
-	return cmds
-}
-
-private getCommandClassVersions() {
-	[
-		0x71: 3,  // Notification
-		0x5E: 2,  // ZwaveplusInfo
-		0x59: 1,  // AssociationGrpInfo
-		0x85: 2,  // Association
-		0x20: 1,  // Basic
-		0x80: 1,  // Battery
-		0x70: 1,  // Configuration
-		0x5A: 1,  // DeviceResetLocally
-		0x7A: 2,  // FirmwareUpdateMd
-		0x72: 2,  // ManufacturerSpecific
-		0x73: 1,  // Powerlevel
-		0x98: 1,  // Security
-		0x31: 5,  // SensorMultilevel
-		0x84: 2	  // WakeUp
-	]
-}
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-	def result = []
-	def cmd
-	if (description.startsWith("Err 106")) {
-		state.sec = 0
-		result = createEvent( name: "secureInclusion", value: "failed", eventType: "ALERT",
-				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.startsWith("Err")) {
-		result = createEvent(descriptionText: "$device.displayName $description", isStateChange: true)
-	} else {
-		cmd = zwave.parse(description, commandClassVersions)
-		if (cmd) {
-			result = zwaveEvent(cmd)
-		}
-	}
-
-	if (result instanceof List) {
-		result = result.flatten()
-	}
-
-	log.debug "Parsed '$description' to $result"
-	return result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
-	def encapsulatedCommand = cmd.encapsulatedCommand(commandClassVersions)
-	log.debug "encapsulated: $encapsulatedCommand"
-	if (encapsulatedCommand) {
-		state.sec = 1
-		return zwaveEvent(encapsulatedCommand)
-	} else {
-		log.warn "Unable to extract encapsulated cmd from $cmd"
-		return [createEvent(descriptionText: cmd.toString())]
-	}
-}
-
-def sensorValueEvent(value) {
-	def result = []
-	if (value) {
-		log.debug "sensorValueEvent($value) : active"
-		result << createEvent(name: "motion", value: "active", descriptionText: "$device.displayName detected motion")
-	} else {
-		log.debug "sensorValueEvent($value) : inactive"
-		result << createEvent(name: "motion", value: "inactive", descriptionText: "$device.displayName motion has stopped")
-	}
-	return result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
-	return sensorValueEvent(cmd.value)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
-	return sensorValueEvent(cmd.value)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd) {
-	return sensorValueEvent(cmd.value)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.sensorbinaryv2.SensorBinaryReport cmd) {
-	return sensorValueEvent(cmd.sensorValue)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.sensoralarmv1.SensorAlarmReport cmd) {
-	return sensorValueEvent(cmd.sensorState)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
-	def result = []
-	if (cmd.notificationType == 0x07) {
-		if (cmd.event == 0x01 || cmd.event == 0x02) {
-			result << sensorValueEvent(1)
-		} else if (cmd.event == 0x03) {
-			result << createEvent(descriptionText: "$device.displayName covering was removed", isStateChange: true)
-			result << response(secure(zwave.manufacturerSpecificV2.manufacturerSpecificGet()))
-		} else if (cmd.event == 0x05 || cmd.event == 0x06) {
-			result << createEvent(descriptionText: "$device.displayName detected glass breakage", isStateChange: true)
-		} else if (cmd.event == 0x07) {
-			result << sensorValueEvent(1)
-		} else if (cmd.event == 0x08) {
-			result << sensorValueEvent(1)
-		} else if (cmd.event == 0x00) {
-			if (cmd.eventParametersLength && cmd.eventParameter[0] == 3) {
-				result << createEvent(descriptionText: "$device.displayName covering replaced", isStateChange: true, displayed: false)
-			} else {
-				result << sensorValueEvent(0)
-			}
-		} else if (cmd.event == 0xFF) {
-			result << sensorValueEvent(1)
-		} else {
-			result << createEvent(descriptionText: "$device.displayName sent event $cmd.event")
-		}
-	} else if (cmd.notificationType) {
-		def text = "Notification $cmd.notificationType: event ${([cmd.event] + cmd.eventParameter).join(", ")}"
-		result << createEvent(name: "notification$cmd.notificationType", value: "$cmd.event", descriptionText: text, displayed: false)
-	} else {
-		def value = cmd.v1AlarmLevel == 255 ? "active" : cmd.v1AlarmLevel ?: "inactive"
-		result << createEvent(name: "alarm $cmd.v1AlarmType", value: value, displayed: false)
-	}
-	return result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd) {
-	def event = createEvent(name: "WakeUp", value: "wakeup", descriptionText: "${device.displayName} woke up", isStateChange: true, displayed: false)  // for Astralink
-	def cmds = []
-
-	if (!device.currentState("ManufacturerCode")) {
-		cmds << secure(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
-		cmds << "delay 2000"
-	}
-	if (!state.lastbat || now() - state.lastbat > 10*60*60*1000) {
-		event.descriptionText += ", requesting battery"
-		cmds << secure(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType:1, scale:1))
-		cmds << "delay 800"
-		cmds << secure(zwave.batteryV1.batteryGet())
-		cmds << "delay 2000"
-	} else {
-		log.debug "not checking battery, was updated ${(now() - state.lastbat)/60000 as int} min ago"
-	}
-	cmds << secure(zwave.wakeUpV1.wakeUpNoMoreInformation())
-
-	return [event, response(cmds)]
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
-	def result = []
-	def map = [ name: "battery", unit: "%" ]
-	if (cmd.batteryLevel == 0xFF) {
-		map.value = 1
-		map.descriptionText = "${device.displayName} has a low battery"
-		map.isStateChange = true
-	} else {
-		map.value = cmd.batteryLevel
-	}
-	def event = createEvent(map)
-
-	// Save at least one battery report in events list every few days
-	if (!event.isStateChange && (now() - 3*24*60*60*1000) > device.latestState("battery")?.date?.time) {
-		map.isStateChange = true
-	}
-	state.lastbat = now()
-	return [event]
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd) {
-	def result = []
-	def map = [:]
-	switch (cmd.sensorType) {
-		case 1:
-			def cmdScale = cmd.scale == 1 ? "F" : "C"
-			map.name = "temperature"
-			map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmdScale, cmd.precision)
-			map.unit = getTemperatureScale()
-			break;
-		case 3:
-			map.name = "illuminance"
-			map.value = cmd.scaledSensorValue.toInteger().toString()
-			map.unit = "lux"
-			break;
-		case 5:
-			map.name = "humidity"
-			map.value = cmd.scaledSensorValue.toInteger().toString()
-			map.unit = cmd.scale == 0 ? "%" : ""
-			break;
-		case 0x1E:
-			map.name = "loudness"
-			map.unit = cmd.scale == 1 ? "dBA" : "dB"
-			map.value = cmd.scaledSensorValue.toString()
-			break;
-		default:
-			map.descriptionText = cmd.toString()
-	}
-	result << createEvent(map)
-	return result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
-	def result = []
-	def manufacturerCode = String.format("%04X", cmd.manufacturerId)
-	def productTypeCode = String.format("%04X", cmd.productTypeId)
-	def productCode = String.format("%04X", cmd.productId)
-	def wirelessConfig = "ZWP"
-	log.debug "MSR ${manufacturerCode} ${productTypeCode} ${productCode}"
-	
-	result << createEvent(name: "ManufacturerCode", value: manufacturerCode)
-	result << createEvent(name: "ProduceTypeCode", value: productTypeCode)
-	result << createEvent(name: "ProductCode", value: productCode)
-	result << createEvent(name: "WirelessConfig", value: wirelessConfig)
-
-	if (manufacturerCode == "0109" && productTypeCode == "2002") {
-		result << response(secureSequence([
-			// Change re-trigger duration to 1 minute
-			zwave.configurationV1.configurationSet(parameterNumber: 1, configurationValue: [1], size: 1),
-			zwave.batteryV1.batteryGet(),
-			zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType:1, scale:1)
-		], 400))
-	}
-
-	return result
-}
-
-def zwaveEvent(physicalgraph.zwave.Command cmd) {
-	return [createEvent(descriptionText: "$device.displayName: $cmd", displayed: false)]
-}
-
-private secure(physicalgraph.zwave.Command cmd) {
-	if (state.sec == 0) {  // default to secure
-		cmd.format()
-	} else {
-		zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
-	}
-}
-
-private secureSequence(commands, delay=200) {
-	delayBetween(commands.collect{ secure(it) }, delay)
-}

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

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

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

@@ -1,143 +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: "Z-Wave Switch Generic", namespace: "smartthings", author: "SmartThings") {
-		capability "Actuator"
- 		capability "Switch"
-		capability "Polling"
-		capability "Refresh"
-		capability "Sensor"
-
-		fingerprint inClusters: "0x25", deviceJoinName: "Z-Wave Switch"
-	}
-
-	// simulator metadata
-	simulator {
-		status "on":  "command: 2003, payload: FF"
-		status "off": "command: 2003, payload: 00"
-
-		// reply messages
-		reply "2001FF,delay 100,2502": "command: 2503, payload: FF"
-		reply "200100,delay 100,2502": "command: 2503, payload: 00"
-	}
-
-	// 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.switch.on", backgroundColor: "#79b821"
-				attributeState "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
-			}
-		}
-
-		standardTile("refresh", "device.switch", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-
-		main "switch"
-		details(["switch","refresh"])
-	}
-}
-
-def parse(String description) {
-	def result = null
-	def cmd = zwave.parse(description, [0x20: 1, 0x70: 1])
-	if (cmd) {
-		result = createEvent(zwaveEvent(cmd))
-	}
-	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}"
-	}
-	return result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
-	[name: "switch", value: cmd.value ? "on" : "off", type: "physical"]
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
-	[name: "switch", value: cmd.value ? "on" : "off", type: "physical"]
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd) {
-	[name: "switch", value: cmd.value ? "on" : "off", type: "digital"]
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.configurationv1.ConfigurationReport cmd) {
-	def value = "when off"
-	if (cmd.configurationValue[0] == 1) {value = "when on"}
-	if (cmd.configurationValue[0] == 2) {value = "never"}
-	[name: "indicatorStatus", value: value, display: false]
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.hailv1.Hail cmd) {
-	[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.Command cmd) {
-	// Handles all Z-Wave commands we aren't interested in
-	[:]
-}
-
-def on() {
-	delayBetween([
-		zwave.basicV1.basicSet(value: 0xFF).format(),
-		zwave.switchBinaryV1.switchBinaryGet().format()
-	])
-}
-
-def off() {
-	delayBetween([
-		zwave.basicV1.basicSet(value: 0x00).format(),
-		zwave.switchBinaryV1.switchBinaryGet().format()
-	])
-}
-
-def poll() {
-	delayBetween([
-		zwave.switchBinaryV1.switchBinaryGet().format(),
-		zwave.manufacturerSpecificV1.manufacturerSpecificGet().format()
-	])
-}
-
-def refresh() {
-	delayBetween([
-		zwave.switchBinaryV1.switchBinaryGet().format(),
-		zwave.manufacturerSpecificV1.manufacturerSpecificGet().format()
-	])
-}
-
-def invertSwitch(invert=true) {
-	if (invert) {
-		zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 4, size: 1).format()
-	}
-	else {
-		zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 4, size: 1).format()
-	}
-}

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

@@ -15,15 +15,12 @@ metadata {
 	definition (name: "Z-Wave Switch", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
 		capability "Indicator"
- 		capability "Switch"
+		capability "Switch"
 		capability "Polling"
 		capability "Refresh"
 		capability "Sensor"
 
-		fingerprint mfr:"0063", prod:"4952", deviceJoinName: "Z-Wave Wall Switch"
-		fingerprint mfr:"0063", prod:"5257", deviceJoinName: "Z-Wave Wall Switch"
-		fingerprint mfr:"0063", prod:"5052", deviceJoinName: "Z-Wave Plug-In Switch"
-		fingerprint mfr:"0113", prod:"5257", deviceJoinName: "Z-Wave Wall Switch"
+		fingerprint inClusters: "0x25"
 	}
 
 	// simulator metadata
@@ -36,10 +33,6 @@ metadata {
 		reply "200100,delay 100,2502": "command: 2503, payload: 00"
 	}
 
-	preferences {
-		input "ledIndicator", "enum", title: "LED Indicator", description: "Turn LED indicator... ", required: false, options:["on": "When On", "off": "When Off", "never": "Never"], defaultValue: "off"
-	}
-
 	// tile definitions
 	tiles(scale: 2) {
 		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
@@ -59,27 +52,10 @@ metadata {
 		}
 
 		main "switch"
-		details(["switch","refresh"])
+		details(["switch","refresh","indicator"])
 	}
 }
 
-def updated(){
-  switch (ledIndicator) {
-        case "on":
-            indicatorWhenOn()
-            break
-        case "off":
-            indicatorWhenOff()
-            break
-        case "never":
-            indicatorNever()
-            break
-        default:
-            indicatorWhenOn()
-            break
-    }
-}
-
 def parse(String description) {
 	def result = null
 	def cmd = zwave.parse(description, [0x20: 1, 0x70: 1])
@@ -119,17 +95,11 @@ def zwaveEvent(physicalgraph.zwave.commands.hailv1.Hail cmd) {
 }
 
 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])
+	if (state.manufacturer != cmd.manufacturerName) {
+		updateDataValue("manufacturer", cmd.manufacturerName)
+	}
 }
 
-
 def zwaveEvent(physicalgraph.zwave.Command cmd) {
 	// Handles all Z-Wave commands we aren't interested in
 	[:]
@@ -163,19 +133,19 @@ def refresh() {
 	])
 }
 
-void indicatorWhenOn() {
+def indicatorWhenOn() {
 	sendEvent(name: "indicatorStatus", value: "when on", display: false)
-	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()))
+	zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()
 }
 
-void indicatorWhenOff() {
+def indicatorWhenOff() {
 	sendEvent(name: "indicatorStatus", value: "when off", display: false)
-	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 3, size: 1).format()))
+	zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 3, size: 1).format()
 }
 
-void indicatorNever() {
+def indicatorNever() {
 	sendEvent(name: "indicatorStatus", value: "never", display: false)
-	sendHubCommand(new physicalgraph.device.HubAction(zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 3, size: 1).format()))
+	zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 3, size: 1).format()
 }
 
 def invertSwitch(invert=true) {

smartapps/com-gidjit-smartthings-hub/gidjit-hub.src/gidjit-hub.groovy

@@ -1,252 +0,0 @@
-/**
- *  Gidjit Hub
- *
- *  Copyright 2016 Matthew Page
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-definition(
-    name: "Gidjit Hub",
-    namespace: "com.gidjit.smartthings.hub",
-    author: "Matthew Page",
-    description: "Act as an endpoint so user's of Gidjit can quickly access and control their devices and execute routines. Users can do this quickly as Gidjit filters these actions  based on their environment",
-    category: "Convenience",
-    iconUrl: "http://www.gidjit.com/appicon.png",
-    iconX2Url: "http://www.gidjit.com/appicon@2x.png",
-    iconX3Url: "http://www.gidjit.com/appicon@3x.png",
-    oauth: [displayName: "Gidjit", displayLink: "www.gidjit.com"])
-
-
-
-preferences {
-  section ("Allow Gidjit to have access, there by allowing you to quickly control and monitor the following devices") {
-    input "switches", "capability.switch", title: "Control/Monitor your switches", multiple: true, required: false
-    input "thermostats", "capability.thermostat", title: "Control/Monitor your thermostats", multiple: true, required: false
-    input "windowShades", "capability.windowShade", title: "Control/Monitor your window shades", multiple: true, required: false //windowShade
-    //input "bulbs", "capability.colorControl", title: "Control your lights", multiple: true, required: false //windowShade
-
-  }
-}
-mappings {
-  path("/structureinfo") {
-    action: [
-      GET: "structureInfo"
-    ]
-  }
-  path("/helloactions") {
-    action: [
-      GET: "helloActions"
-    ]
-  }
-  path("/helloactions/:label") {
-    action: [
-      PUT: "executeAction"
-    ]
-  }
-
-  path("/switch/:id/:command") {
-    action: [
-      PUT: "updateSwitch"
-    ]
-  }
-
-  path("/thermostat/:id/:command") {
-    action: [
-      PUT: "updateThermostat"
-    ]
-  }
-
-  path("/windowshade/:id/:command") {
-    action: [
-      PUT: "updateWindowShade"
-    ]
-  }
-  path("/acquiredata/:id") {
-    action: [
-      GET: "acquiredata"
-    ]
-  }
-}
-
-
-def installed() {
-	log.debug "Installed with settings: ${settings}"
-
-	initialize()
-}
-
-def updated() {
-	log.debug "Updated with settings: ${settings}"
-
-	unsubscribe()
-	initialize()
-}
-
-def initialize() {
-	// subscribe to attributes, devices, locations, etc.
-}
-def helloActions() {
-	def actions = location.helloHome?.getPhrases()*.label
-    if(!actions) {
-    	return []
-    }
-	return actions
-}
-def executeAction() {
-    def actions = location.helloHome?.getPhrases()*.label
-    def a = actions?.find() { it == params.label }
-    if (!a) {
-        httpError(400, "invalid label $params.label")
-        return
-    }
-    location.helloHome?.execute(params.label)
-}
-/*  this is the primary function called to query at the structure and its devices */
-def structureInfo() { //list all devices
-	def list = [:]
-    def currId = location.id
-    list[currId] = [:]
-    list[currId].name = location.name
-    list[currId].id = location.id
-    list[currId].temperatureScale = location.temperatureScale
-    list[currId].devices = [:]
-  
-    def setValues = {
-   		if (params.brief) {
-            return [id: it.id, name: it.displayName]
-        }
-        def newList = [id: it.id, name: it.displayName, suppCapab: it.capabilities.collect {
-            "$it.name"
-        }, suppAttributes: it.supportedAttributes.collect {
-            "$it.name"      
-        }, suppCommands: it.supportedCommands.collect {
-            "$it.name"      
-        }]
-
-        return newList
-    }
-    switches?.each {
-      list[currId].devices[it.id] = setValues(it)
-    }
-    thermostats?.each {
-      list[currId].devices[it.id] = setValues(it)
-    }
-    windowShades?.each {
-      list[currId].devices[it.id] = setValues(it)
-    }
-
-    return list
-
-}
-/*  This function returns all of the current values of the specified Devices attributes */
-def acquiredata() {
-	def resp = [:]
-    if (!params.id) {
-    	httpError(400, "invalid id $params.id")
-        return
-    }
-    def dev = switches.find() { it.id == params.id } ?: windowShades.find() { it.id == params.id } ?:
-    	thermostats.find() { it.id == params.id }    
-   
-    if (!dev) {
-    	httpError(400, "invalid id $params.id")
-        return    
-    }
-    def att = dev.supportedAttributes
-    att.each {
-    	resp[it.name] = dev.currentValue("$it.name")
-    }
-    return resp
-}
-
-void updateSwitch() {
-    // use the built-in request object to get the command parameter
-    def command = params.command
-	def sw = switches.find() { it.id == params.id }
-    if (!sw) {
-    	httpError(400, "invalid id $params.id")
-        return
-    }
-    switch(command) {
-        case "on":
-        	if ( sw.currentSwitch != "on" ) {
-            	sw.on()
-            }
-            break
-        case "off":
-        	if ( sw.currentSwitch != "off" ) {
-            	sw.off()
-            }
-            break
-        default:
-            httpError(400, "$command is not a valid")
-    }
-}
-
-
-void updateThermostat() {
-    // use the built-in request object to get the command parameter
-    def command = params.command
-	def therm = thermostats.find() { it.id == params.id }
-    if (!therm || !command) {
-    	httpError(400, "invalid id $params.id")
-        return
-    }
-    def passComm = [
-        "off",
-        "heat",
-        "emergencyHeat",
-        "cool",
-        "fanOn",
-        "fanAuto",
-        "fanCirculate",
-        "auto"
-
-	]
-    def passNumParamComm = [
-    	"setHeatingSetpoint",
-    	"setCoolingSetpoint",   
-    ]
-    def passStringParamComm = [
-        "setThermostatMode",
-        "setThermostatFanMode",
-	]
-    if (command in passComm) {
-    	therm."$command"()	
-    } else if (command in passNumParamComm && params.p1 && params.p1.isFloat()) {
-    	therm."$command"(Float.parseFloat(params.p1))	
-    } else if (command in passStringParamComm && params.p1) {
-    	therm."$command"(params.p1)	
-    } else {
-    	httpError(400, "$command is not a valid command")
-    }
-}
-
-void updateWindowShade() {
-    // use the built-in request object to get the command parameter
-    def command = params.command
-	def ws = windowShades.find() { it.id == params.id }
-    if (!ws || !command) {
-    	httpError(400, "invalid id $params.id")
-        return
-    }
-    def passComm = [
-		"open",
-        "close",
-        "presetPosition",
-	]
-    if (command in passComm) {
-    	ws."$command"()		
-    } else {
-    	httpError(400, "$command is not a valid command")
-    }
-}
-// TODO: implement event handlers

smartapps/com-obycode/beaconthings-manager.src/beaconthings-manager.groovy

@@ -1,147 +0,0 @@
-/**
- *  BeaconThing Manager
- *
- *  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.
- *
- */
-definition(
-    name: "BeaconThings Manager",
-    namespace: "com.obycode",
-    author: "obycode",
-    description: "SmartApp to interact with the BeaconThings iOS app. Use this app to integrate iBeacons into your smart home.",
-    category: "Convenience",
-    iconUrl: "http://beaconthingsapp.com/images/Icon-60.png",
-    iconX2Url: "http://beaconthingsapp.com/images/Icon-60@2x.png",
-    iconX3Url: "http://beaconthingsapp.com/images/Icon-60@3x.png",
-    oauth: true)
-
-
-preferences {
-	section("Allow BeaconThings to talk to your home") {
-
-	}
-}
-
-def installed() {
-  log.debug "Installed with settings: ${settings}"
-
-  initialize()
-}
-
-def initialize() {
-}
-
-def uninstalled() {
-  removeChildDevices(getChildDevices())
-}
-
-mappings {
-  path("/beacons") {
-    action: [
-    DELETE: "clearBeacons",
-    POST:   "addBeacon"
-    ]
-  }
-
-  path("/beacons/:id") {
-    action: [
-    PUT: "updateBeacon",
-    DELETE: "deleteBeacon"
-    ]
-  }
-}
-
-void clearBeacons() {
-  removeChildDevices(getChildDevices())
-}
-
-void addBeacon() {
-  def beacon = request.JSON?.beacon
-  if (beacon) {
-    def beaconId = "BeaconThings"
-    if (beacon.major) {
-      beaconId = "$beaconId-${beacon.major}"
-      if (beacon.minor) {
-        beaconId = "$beaconId-${beacon.minor}"
-      }
-    }
-    log.debug "adding beacon $beaconId"
-    def d = addChildDevice("com.obycode", "BeaconThing", beaconId,  null, [label:beacon.name, name:"BeaconThing", completedSetup: true])
-    log.debug "addChildDevice returned $d"
-
-    if (beacon.present) {
-      d.arrive(beacon.present)
-    }
-    else if (beacon.presence) {
-      d.setPresence(beacon.presence)
-    }
-  }
-}
-
-void updateBeacon() {
-  log.debug "updating beacon ${params.id}"
-  def beaconDevice = getChildDevice(params.id)
-  // def children = getChildDevices()
-  // def beaconDevice = children.find{ d -> d.deviceNetworkId == "${params.id}" }
-  if (!beaconDevice) {
-    log.debug "Beacon not found directly"
-    def children = getChildDevices()
-    beaconDevice = children.find{ d -> d.deviceNetworkId == "${params.id}" }
-    if (!beaconDevice) {
-      log.debug "Beacon not found in list either"
-      return
-    }
-  }
-
-  // This could be just updating the presence
-  def presence = request.JSON?.presence
-  if (presence) {
-    log.debug "Setting ${beaconDevice.label} to $presence"
-    beaconDevice.setPresence(presence)
-  }
-
-  // It could be someone arriving
-  def arrived = request.JSON?.arrived
-  if (arrived) {
-    log.debug "$arrived arrived at ${beaconDevice.label}"
-    beaconDevice.arrived(arrived)
-  }
-
-  // It could be someone left
-  def left = request.JSON?.left
-  if (left) {
-    log.debug "$left left ${beaconDevice.label}"
-    beaconDevice.left(left)
-  }
-
-  // or it could be updating the name
-  def beacon = request.JSON?.beacon
-  if (beacon) {
-    beaconDevice.label = beacon.name
-  }
-}
-
-void deleteBeacon() {
-  log.debug "deleting beacon ${params.id}"
-  deleteChildDevice(params.id)
-  // def children = getChildDevices()
-  // def beaconDevice = children.find{ d -> d.deviceNetworkId == "${params.id}" }
-  // if (beaconDevice) {
-  //   deleteChildDevice(beaconDevice.deviceNetworkId)
-  // }
-}
-
-private removeChildDevices(delete) {
-  delete.each {
-    deleteChildDevice(it.deviceNetworkId)
-  }
-}

smartapps/com-vinli-smartthings/vinli-home-connect.src/vinli-home-connect.groovy

@@ -67,11 +67,11 @@ mappings {
 def listAllDevices() {
    	def resp = []
    	switches.each {
-      resp << [name: it.name, label: it.label, value: it.currentValue("switch"), type: "switch", id: it.id, hub: it.hub?.name]
+      resp << [name: it.name, label: it.label, value: it.currentValue("switch"), type: "switch", id: it.id, hub: it.hub.name]
     }
     
     locks.each {
-      resp << [name: it.name, label: it.label, value: it.currentValue("lock"), type: "lock", id: it.id, hub: it.hub?.name]
+      resp << [name: it.name, label: it.label, value: it.currentValue("lock"), type: "lock", id: it.id, hub: it.hub.name]
     }
     return resp
 }

smartapps/dianoga/netatmo-connect.src/netatmo-connect.groovy

@@ -4,33 +4,29 @@
 import java.text.DecimalFormat
 import groovy.json.JsonSlurper
 
-private getApiUrl()			{ "https://api.netatmo.com" }
-private getVendorName()		{ "netatmo" }
-private getVendorAuthPath()	{ "${apiUrl}/oauth2/authorize?" }
-private getVendorTokenPath(){ "${apiUrl}/oauth2/token" }
+private apiUrl() 			{ "https://api.netatmo.com" }
+private getVendorName() 	{ "netatmo" }
+private getVendorAuthPath()	{ "https://api.netatmo.com/oauth2/authorize?" }
+private getVendorTokenPath(){ "https://api.netatmo.com/oauth2/token" }
 private getVendorIcon()		{ "https://s3.amazonaws.com/smartapp-icons/Partner/netamo-icon-1%402x.png" }
-private getClientId()		{ appSettings.clientId }
-private getClientSecret()	{ appSettings.clientSecret }
-private getServerUrl() 		{ appSettings.serverUrl }
-private getShardUrl()		{ return getApiServerUrl() }
-private getCallbackUrl()	{ "${serverUrl}/oauth/callback" }
-private getBuildRedirectUrl() { "${serverUrl}/oauth/initialize?appId=${app.id}&access_token=${state.accessToken}&apiServerUrl=${shardUrl}" }
+private getClientId() 		{ appSettings.clientId }
+private getClientSecret() 	{ appSettings.clientSecret }
+private getServerUrl() 		{ "https://graph.api.smartthings.com" }
 
 // Automatically generated. Make future change here.
 definition(
-	name: "Netatmo (Connect)",
-	namespace: "dianoga",
-	author: "Brian Steere",
-	description: "Netatmo Integration",
-	category: "SmartThings Labs",
-	iconUrl: "https://s3.amazonaws.com/smartapp-icons/Partner/netamo-icon-1.png",
-	iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Partner/netamo-icon-1%402x.png",
-	oauth: true,
-	singleInstance: true
+    name: "Netatmo (Connect)",
+    namespace: "dianoga",
+    author: "Brian Steere",
+    description: "Netatmo Integration",
+    category: "SmartThings Labs",
+    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Partner/netamo-icon-1.png",
+    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Partner/netamo-icon-1%402x.png",
+    oauth: true,
+    singleInstance: true
 ){
 	appSetting "clientId"
 	appSetting "clientSecret"
-	appSetting "serverUrl"
 }
 
 preferences {
@@ -39,52 +35,35 @@ preferences {
 }
 
 mappings {
-	path("/oauth/initialize") {action: [GET: "oauthInitUrl"]}
-	path("/oauth/callback") {action: [GET: "callback"]}
+	path("/receivedToken"){action: [POST: "receivedToken", GET: "receivedToken"]}
+	path("/receiveToken"){action: [POST: "receiveToken", GET: "receiveToken"]}
+    path("/auth"){action: [GET: "auth"]}
 }
 
 def authPage() {
 	log.debug "In authPage"
+	if(canInstallLabs()) {
+		def description = null
 
-	def description
-	def uninstallAllowed = false
-	def oauthTokenProvided = false
+		if (state.vendorAccessToken == null) {
+			log.debug "About to create access token."
 
-	if (!state.accessToken) {
-		log.debug "About to create access token."
-		state.accessToken = createAccessToken()
-	}
+			createAccessToken()
+			description = "Tap to enter Credentials."
 
-	if (canInstallLabs()) {
-
-		def redirectUrl = getBuildRedirectUrl()
-		log.debug "Redirect url = ${redirectUrl}"
-
-		if (state.authToken) {
+			return dynamicPage(name: "Credentials", title: "Authorize Connection", nextPage:"listDevices", uninstall: true, install:false) {
+				section { href url:buildRedirectUrl("auth"), style:"embedded", required:false, title:"Connect to ${getVendorName()}:", description:description }
+			}
+		} else {
 			description = "Tap 'Next' to proceed"
-			uninstallAllowed = true
-			oauthTokenProvided = true
-		} else {
-			description = "Click to enter Credentials."
-		}
 
-		if (!oauthTokenProvided) {
-			log.debug "Show the login page"
-			return dynamicPage(name: "Credentials", title: "Authorize Connection", nextPage:"listDevices", uninstall: uninstallAllowed, install:false) {
-				section() {
-					paragraph "Tap below to log in to the netatmo and authorize SmartThings access."
-					href url:redirectUrl, style:"embedded", required:false, title:"Connect to ${getVendorName()}:", description:description
-				}
-			}
-		} else {
-			log.debug "Show the devices page"
-			return dynamicPage(name: "Credentials", title: "Credentials Accepted!", nextPage:"listDevices", uninstall: uninstallAllowed, install:false) {
-				section() {
-					input(name:"Devices", style:"embedded", required:false, title:"${getVendorName()} is now connected to SmartThings!", description:description) 
-				}
+			return dynamicPage(name: "Credentials", title: "Credentials Accepted!", nextPage:"listDevices", uninstall: true, install:false) {
+				section { href url: buildRedirectUrl("receivedToken"), style:"embedded", required:false, title:"${getVendorName()} is now connected to SmartThings!", description:description }
 			}
 		}
-	} else {
+	}
+	else
+	{
 		def upgradeNeeded = """To use SmartThings Labs, your Hub should be completely up to date.
 
 To update your Hub, access Location Settings in the Main Menu (tap the gear next to your location name), select your Hub, and choose "Update Hub"."""
@@ -99,184 +78,44 @@ To update your Hub, access Location Settings in the Main Menu (tap the gear next
 	}
 }
 
+def auth() {
+	redirect location: oauthInitUrl()
+}
+
 def oauthInitUrl() {
 	log.debug "In oauthInitUrl"
 
+	/* OAuth Step 1: Request access code with our client ID */
+
 	state.oauthInitState = UUID.randomUUID().toString()
 
-	def oauthParams = [
-		response_type: "code",
+	def oauthParams = [ response_type: "code",
 		client_id: getClientId(),
-		client_secret: getClientSecret(),
 		state: state.oauthInitState,
-		redirect_uri: getCallbackUrl(),
+		redirect_uri: buildRedirectUrl("receiveToken") ,
 		scope: "read_station"
-	]
-
-	log.debug "REDIRECT URL: ${getVendorAuthPath() + toQueryString(oauthParams)}"
-
-	redirect (location: getVendorAuthPath() + toQueryString(oauthParams))
-}
-
-def callback() {
-	log.debug "callback()>> params: $params, params.code ${params.code}"
-
-	def code = params.code
-	def oauthState = params.state
-
-	if (oauthState == state.oauthInitState) {
-
-		def tokenParams = [
-			client_secret: getClientSecret(),
-			client_id : getClientId(),
-			grant_type: "authorization_code",
-			redirect_uri: getCallbackUrl(),
-			code: code,
-			scope: "read_station"
 		]
 
-		log.debug "TOKEN URL: ${getVendorTokenPath() + toQueryString(tokenParams)}"
-
-		def tokenUrl = getVendorTokenPath()
-		def params = [
-			uri: tokenUrl,
-			contentType: 'application/x-www-form-urlencoded',
-			body: tokenParams
-		]
-
-		log.debug "PARAMS: ${params}"
-
-		httpPost(params) { resp ->
-
-			def slurper = new JsonSlurper()
-
-			resp.data.each { key, value ->
-				def data = slurper.parseText(key)
-
-				state.refreshToken = data.refresh_token
-				state.authToken = data.access_token
-				state.tokenExpires = now() + (data.expires_in * 1000)
-				log.debug "swapped token: $resp.data"
-			}
-		}
-
-		// Handle success and failure here, and render stuff accordingly
-		if (state.authToken) {
-			success()
-		} else {
-			fail()
-		}
-
-	} else {
-		log.error "callback() failed oauthState != state.oauthInitState"
-	}
+	return getVendorAuthPath() + toQueryString(oauthParams)
 }
 
-def success() {
-	log.debug "in success"
-	def message = """
-	<p>We have located your """ + getVendorName() + """ account.</p>
-	<p>Tap 'Done' to continue to Devices.</p>
-	"""
-	connectionStatus(message)
+def buildRedirectUrl(endPoint) {
+	log.debug "In buildRedirectUrl"
+
+	return getServerUrl() + "/api/token/${state.accessToken}/smartapps/installations/${app.id}/${endPoint}"
 }
 
-def fail() {
-	log.debug "in fail"
-	def message = """
-	<p>The connection could not be established!</p>
-	<p>Click 'Done' to return to the menu.</p>
-	"""
-	connectionStatus(message)
-}
-
-def connectionStatus(message, redirectUrl = null) {
-	def redirectHtml = ""
-	if (redirectUrl) {
-		redirectHtml = """
-			<meta http-equiv="refresh" content="3; url=${redirectUrl}" />
-		"""
-	}
-
-	def html = """
-		<!DOCTYPE html>
-		<html>
-		<head>
-		<meta name="viewport" content="width=device-width, initial-scale=1">
-		<title>${getVendorName()} Connection</title>
-		<style type="text/css">
-			* { box-sizing: border-box; }
-			@font-face {
-				font-family: 'Swiss 721 W01 Thin';
-				src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.eot');
-				src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.eot?#iefix') format('embedded-opentype'),
-				url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.woff') format('woff'),
-				url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.ttf') format('truetype'),
-				url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.svg#swis721_th_btthin') format('svg');
-				font-weight: normal;
-				font-style: normal;
-			}
-			@font-face {
-				font-family: 'Swiss 721 W01 Light';
-				src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.eot');
-				src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.eot?#iefix') format('embedded-opentype'),
-				url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.woff') format('woff'),
-				url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.ttf') format('truetype'),
-				url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.svg#swis721_lt_btlight') format('svg');
-				font-weight: normal;
-				font-style: normal;
-			}
-			.container {
-				width: 100%;
-				padding: 40px;
-				/*background: #eee;*/
-				text-align: center;
-			}
-			img {
-				vertical-align: middle;
-			}
-			img:nth-child(2) {
-				margin: 0 30px;
-			}
-			p {
-				font-size: 2.2em;
-				font-family: 'Swiss 721 W01 Thin';
-				text-align: center;
-				color: #666666;
-				margin-bottom: 0;
-			}
-			/*
-			p:last-child {
-				margin-top: 0px;
-			}
-			*/
-			span {
-				font-family: 'Swiss 721 W01 Light';
-				}
-		</style>
-		</head>
-		<body>
-			<div class="container">
-				<img src=""" + getVendorIcon() + """ alt="Vendor icon" />
-				<img src="https://s3.amazonaws.com/smartapp-icons/Partner/support/connected-device-icn%402x.png" alt="connected device icon" />
-				<img src="https://s3.amazonaws.com/smartapp-icons/Partner/support/st-logo%402x.png" alt="SmartThings logo" />
-				${message}
-			</div>
-        </body>
-        </html>
-	"""
-	render contentType: 'text/html', data: html
-}
-
-def refreshToken() {
-	log.debug "In refreshToken"
+def receiveToken() {
+	log.debug "In receiveToken"
 
 	def oauthParams = [
 		client_secret: getClientSecret(),
 		client_id: getClientId(),
-		grant_type: "refresh_token",
-		refresh_token: state.refreshToken
-	]
+		grant_type: "authorization_code",
+		redirect_uri: buildRedirectUrl('receiveToken'),
+		code: params.code,
+		scope: "read_station"
+		]
 
 	def tokenUrl = getVendorTokenPath()
 	def params = [
@@ -285,7 +124,201 @@ def refreshToken() {
 		body: oauthParams,
 	]
 
-	// OAuth Step 2: Request access token with our client Secret and OAuth "Code"
+    log.debug params
+
+	/* OAuth Step 2: Request access token with our client Secret and OAuth "Code" */
+	try {
+		httpPost(params) { response ->
+        	log.debug response.data
+			def slurper = new JsonSlurper();
+
+			response.data.each {key, value ->
+				def data = slurper.parseText(key);
+				log.debug "Data: $data"
+
+				state.vendorRefreshToken = data.refresh_token
+				state.vendorAccessToken = data.access_token
+				state.vendorTokenExpires = now() + (data.expires_in * 1000)
+				return
+			}
+
+		}
+	} catch (Exception e) {
+		log.debug "Error: $e"
+	}
+
+	log.debug "State: $state"
+
+	if ( !state.vendorAccessToken ) {  //We didn't get an access token, bail on install
+		return
+	}
+
+	/* OAuth Step 3: Use the access token to call into the vendor API throughout your code using state.vendorAccessToken. */
+
+	def html = """
+        <!DOCTYPE html>
+        <html>
+        <head>
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title>${getVendorName()} Connection</title>
+        <style type="text/css">
+            * { box-sizing: border-box; }
+            @font-face {
+                font-family: 'Swiss 721 W01 Thin';
+                src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.eot');
+                src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.eot?#iefix') format('embedded-opentype'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.woff') format('woff'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.ttf') format('truetype'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.svg#swis721_th_btthin') format('svg');
+                font-weight: normal;
+                font-style: normal;
+            }
+            @font-face {
+                font-family: 'Swiss 721 W01 Light';
+                src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.eot');
+                src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.eot?#iefix') format('embedded-opentype'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.woff') format('woff'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.ttf') format('truetype'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.svg#swis721_lt_btlight') format('svg');
+                font-weight: normal;
+                font-style: normal;
+            }
+            .container {
+                width: 100%;
+                padding: 40px;
+                /*background: #eee;*/
+                text-align: center;
+            }
+            img {
+                vertical-align: middle;
+            }
+            img:nth-child(2) {
+                margin: 0 30px;
+            }
+            p {
+                font-size: 2.2em;
+                font-family: 'Swiss 721 W01 Thin';
+                text-align: center;
+                color: #666666;
+                margin-bottom: 0;
+            }
+        /*
+            p:last-child {
+                margin-top: 0px;
+            }
+        */
+            span {
+                font-family: 'Swiss 721 W01 Light';
+            }
+        </style>
+        </head>
+        <body>
+            <div class="container">
+                <img src=""" + getVendorIcon() + """ alt="Vendor icon" />
+                <img src="https://s3.amazonaws.com/smartapp-icons/Partner/support/connected-device-icn%402x.png" alt="connected device icon" />
+                <img src="https://s3.amazonaws.com/smartapp-icons/Partner/support/st-logo%402x.png" alt="SmartThings logo" />
+                <p>We have located your """ + getVendorName() + """ account.</p>
+                <p>Tap 'Done' to process your credentials.</p>
+			</div>
+        </body>
+        </html>
+        """
+	render contentType: 'text/html', data: html
+}
+
+def receivedToken() {
+	log.debug "In receivedToken"
+
+	def html = """
+        <!DOCTYPE html>
+        <html>
+        <head>
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title>Withings Connection</title>
+        <style type="text/css">
+            * { box-sizing: border-box; }
+            @font-face {
+                font-family: 'Swiss 721 W01 Thin';
+                src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.eot');
+                src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.eot?#iefix') format('embedded-opentype'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.woff') format('woff'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.ttf') format('truetype'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-thin-webfont.svg#swis721_th_btthin') format('svg');
+                font-weight: normal;
+                font-style: normal;
+            }
+            @font-face {
+                font-family: 'Swiss 721 W01 Light';
+                src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.eot');
+                src: url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.eot?#iefix') format('embedded-opentype'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.woff') format('woff'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.ttf') format('truetype'),
+                     url('https://s3.amazonaws.com/smartapp-icons/Partner/fonts/swiss-721-light-webfont.svg#swis721_lt_btlight') format('svg');
+                font-weight: normal;
+                font-style: normal;
+            }
+            .container {
+                width: 560px;
+                padding: 40px;
+                /*background: #eee;*/
+                text-align: center;
+            }
+            img {
+                vertical-align: middle;
+            }
+            img:nth-child(2) {
+                margin: 0 30px;
+            }
+            p {
+                font-size: 2.2em;
+                font-family: 'Swiss 721 W01 Thin';
+                text-align: center;
+                color: #666666;
+                margin-bottom: 0;
+            }
+        /*
+            p:last-child {
+                margin-top: 0px;
+            }
+        */
+            span {
+                font-family: 'Swiss 721 W01 Light';
+            }
+        </style>
+        </head>
+        <body>
+            <div class="container">
+                <img src=""" + getVendorIcon() + """ alt="Vendor icon" />
+                <img src="https://s3.amazonaws.com/smartapp-icons/Partner/support/connected-device-icn%402x.png" alt="connected device icon" />
+                <img src="https://s3.amazonaws.com/smartapp-icons/Partner/support/st-logo%402x.png" alt="SmartThings logo" />
+                <p>Tap 'Done' to continue to Devices.</p>
+			</div>
+        </body>
+        </html>
+        """
+	render contentType: 'text/html', data: html
+}
+
+// "
+
+def refreshToken() {
+	log.debug "In refreshToken"
+
+	def oauthParams = [
+		client_secret: getClientSecret(),
+		client_id: getClientId(),
+		grant_type: "refresh_token",
+		refresh_token: state.vendorRefreshToken
+		]
+
+	def tokenUrl = getVendorTokenPath()
+	def params = [
+		uri: tokenUrl,
+		contentType: 'application/x-www-form-urlencoded',
+		body: oauthParams,
+	]
+
+	/* OAuth Step 2: Request access token with our client Secret and OAuth "Code" */
 	try {
 		httpPost(params) { response ->
 			def slurper = new JsonSlurper();
@@ -294,9 +327,9 @@ def refreshToken() {
 				def data = slurper.parseText(key);
 				log.debug "Data: $data"
 
-				state.refreshToken = data.refresh_token
-				state.accessToken = data.access_token
-				state.tokenExpires = now() + (data.expires_in * 1000)
+				state.vendorRefreshToken = data.refresh_token
+				state.vendorAccessToken = data.access_token
+				state.vendorTokenExpires = now() + (data.expires_in * 1000)
 				return true
 			}
 
@@ -305,8 +338,9 @@ def refreshToken() {
 		log.debug "Error: $e"
 	}
 
-	// We didn't get an access token
-	if ( !state.accessToken ) {
+	log.debug "State: $state"
+
+	if ( !state.vendorAccessToken ) {  //We didn't get an access token
 		return false
 	}
 }
@@ -337,10 +371,10 @@ def initialize() {
 
 	settings.devices.each {
 		def deviceId = it
-		def detail = state?.deviceDetail[deviceId]
+		def detail = state.deviceDetail[deviceId]
 
 		try {
-			switch(detail?.type) {
+			switch(detail.type) {
 				case 'NAMain':
 					log.debug "Base station"
 					createChildDevice("Netatmo Basestation", deviceId, "${detail.type}.${deviceId}", detail.module_name)
@@ -448,13 +482,13 @@ def listDevices() {
 }
 
 def apiGet(String path, Map query, Closure callback) {
-	if(now() >= state.tokenExpires) {
+	if(now() >= state.vendorTokenExpires) {
 		refreshToken();
 	}
 
-	query['access_token'] = state.accessToken
+	query['access_token'] = state.vendorAccessToken
 	def params = [
-		uri: getApiUrl(),
+		uri: apiUrl(),
 		path: path,
 		'query': query
 	]
@@ -487,12 +521,12 @@ def poll() {
     log.debug "State: ${state.deviceState}"
 
 	settings.devices.each { deviceId ->
-		def detail = state?.deviceDetail[deviceId]
-		def data = state?.deviceState[deviceId]
-		def child = children?.find { it.deviceNetworkId == deviceId }
+		def detail = state.deviceDetail[deviceId]
+		def data = state.deviceState[deviceId]
+		def child = children.find { it.deviceNetworkId == deviceId }
 
 		log.debug "Update: $child";
-		switch(detail?.type) {
+		switch(detail.type) {
 			case 'NAMain':
 				log.debug "Updating NAMain $data"
 				child?.sendEvent(name: 'temperature', value: cToPref(data['Temperature']) as float, unit: getTemperatureScale())

smartapps/johnrucker/door-jammed-notification.src/door-jammed-notification.groovy

@@ -1,66 +0,0 @@
-/**
- *  Door Jammed Notification
- *
- *  Copyright 2015 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.
- *
- */
- 
-definition(
-    name: "Door Jammed Notification",
-    namespace: "JohnRucker",
-    author: "John.Rucker@Solar-current.com",
-    description: "Sends a SmartThings notification and text messages when your CoopBoss detects a door jam.",
-    category: "My Apps",
-    iconUrl: "http://coopboss.com/images/SmartThingsIcons/coopbossLogo.png",
-    iconX2Url: "http://coopboss.com/images/SmartThingsIcons/coopbossLogo2x.png",
-    iconX3Url: "http://coopboss.com/images/SmartThingsIcons/coopbossLogo3x.png")
-
-preferences {
-    section("When the door state changes") {
-        paragraph "Send a SmartThings notification when the coop's door jammed and did not close."
-		input "doorSensor", "capability.doorControl", title: "Select CoopBoss", required: true, multiple: false            
-        input("recipients", "contact", title: "Recipients", description: "Send notifications to") {
-        	input "phone", "phone", title: "Phone number?", required: true}
-	}
-}
-
-def installed() {
-	log.debug "Installed with settings: ${settings}"
-	initialize()
-}
-
-def updated() {
-	log.debug "Updated with settings: ${settings}"
-	unsubscribe()
-	initialize()
-}
-
-def initialize() {
-	subscribe(doorSensor, "doorState", coopDoorStateHandler)
-}
-
-def coopDoorStateHandler(evt) {
-	if (evt.value == "jammed"){
-        def msg = "WARNING ${doorSensor.displayName} door is jammed and did not close!"
-        log.debug "WARNING ${doorSensor.displayName} door is jammed and did not close, texting $phone"
-
-        if (location.contactBookEnabled) {
-            sendNotificationToContacts(msg, recipients)
-        }
-        else {
-            sendPush(msg)
-            if (phone) {
-                sendSms(phone, msg)
-            }
-        }
-	}        
-}

smartapps/johnrucker/door-state-to-color-light-hue-bulb.src/door-state-to-color-light-hue-bulb.groovy

@@ -1,141 +0,0 @@
-/**
- *  CoopBoss Door Status to color
- *
- *  Copyright 2015 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.
- *
- */
- 
-definition(
-    name: "Door State to Color Light (Hue Bulb)",
-    namespace: "JohnRucker",
-    author: "John Rucker",
-    description: "Change the color of your Hue bulbs based on your coop's door status.",
-    category: "My Apps",
-    iconUrl: "http://coopboss.com/images/SmartThingsIcons/coopbossLogo.png",
-    iconX2Url: "http://coopboss.com/images/SmartThingsIcons/coopbossLogo2x.png",
-    iconX3Url: "http://coopboss.com/images/SmartThingsIcons/coopbossLogo3x.png")
-
-
-preferences {
-	section("When the door opens/closese...") {
-    	paragraph "Sets a Hue bulb or bulbs to a color based on your coop's door status:\r  unknown = white\r  open = blue\r  opening = purple\r  closed = green\r  closing = pink\r  jammed = red\r  forced close = orange."
-		input "doorSensor", "capability.doorControl", title: "Select CoopBoss", required: true, multiple: false
-		input "bulbs", "capability.colorControl", title: "pick a bulb", required: true, multiple: true
-	}
-}
-
-def installed() {
-	log.debug "Installed with settings: ${settings}"
-	initialize()
-}
-
-def updated() {
-	log.debug "Updated with settings: ${settings}"
-	unsubscribe()
-	initialize()
-}
-
-def initialize() {
-	subscribe(doorSensor, "doorState", coopDoorStateHandler)
-}
-
-def coopDoorStateHandler(evt) {
-    log.debug "${evt.descriptionText}, $evt.value"
-	def color = "White"
-    def hueColor = 100
-    def saturation = 100
-    Map hClr = [:]
-    hClr.hex = "#FFFFFF"
-
-	switch(evt.value) {
-    	case "open":
-        	color = "Blue"
-            break;
-        case "opening":
-        	color = "Purple"
-            break;
-        case "closed":
-        	color = "Green"
-            break;
-    	case "closing":
-        	color = "Pink"
-            break;
-        case "jammed":
-        	color = "Red"
-            break;
-        case "forced close":
-        	color = "Orange"
-            break;
-        case "unknown":
-        	color = "White"
-            break;        
-    }   
-       
-	switch(color) {
-		case "White":
-			hueColor = 52
-			saturation = 19
-			break;
-		case "Daylight":
-			hueColor = 53
-			saturation = 91
-			break;
-		case "Soft White":
-			hueColor = 23
-			saturation = 56
-			break;
-		case "Warm White":
-			hueColor = 20
-			saturation = 80 //83
-			break;
-		case "Blue":
-			hueColor = 70
-            hClr.hex = "#0000FF"
-			break;
-		case "Green":
-			hueColor = 39
-            hClr.hex = "#00FF00"
-			break;
-		case "Yellow":
-			hueColor = 25
-            hClr.hex = "#FFFF00"            
-			break;
-		case "Orange":
-			hueColor = 10
-            hClr.hex = "#FF6000"
-			break;
-		case "Purple":
-			hueColor = 75
-            hClr.hex = "#BF7FBF"
-			break;
-		case "Pink":
-			hueColor = 83
-            hClr.hex = "#FF5F5F"
-			break;
-		case "Red":
-			hueColor = 100
-            hClr.hex = "#FF0000"
-			break;
-	}    
-    
-    //bulbs*.on()
-    bulbs*.setHue(hueColor)
-	bulbs*.setSaturation(saturation)   
-    bulbs*.setColor(hClr)
-    
-    //bulbs.each{
-    	//it.on()  // Turn the bulb on when open (this method does not come directly from the colorControl capability)
-    	//it.setLevel(100)  // Make sure the light brightness is 100%       
-    	//it.setHue(hueColor)
-		//it.setSaturation(saturation) 
-        //}        
-}

smartapps/osotech/plantlink-connector.src/plantlink-connector.groovy

@@ -370,7 +370,9 @@ def parse_api_response(resp, message) {
     }
 }
 
-def getServerUrl() { return getApiServerUrl() }
+def getServerUrl() { 
+	return "https://graph.api.smartthings.com" 
+}
 
 def debugEvent(message, displayEvent) {
     def results = [

smartapps/roomieremote-raconnect/simple-sync-connect.src/simple-sync-connect.groovy

@@ -1,383 +0,0 @@
-/**
- *  Simple Sync Connect
- *
- *  Copyright 2015 Roomie Remote, Inc.
- *
- *	Date: 2015-09-22
- */
-
-definition(
-    name: "Simple Sync Connect",
-    namespace: "roomieremote-raconnect",
-    author: "Roomie Remote, Inc.",
-    description: "Integrate SmartThings with your Simple Control activities via Simple Sync.",
-    category: "My Apps",
-    iconUrl: "https://s3.amazonaws.com/roomieuser/remotes/simplesync-60.png",
-    iconX2Url: "https://s3.amazonaws.com/roomieuser/remotes/simplesync-120.png",
-    iconX3Url: "https://s3.amazonaws.com/roomieuser/remotes/simplesync-120.png")
-
-preferences()
-{
-	page(name: "mainPage", title: "Simple Sync Setup", content: "mainPage", refreshTimeout: 5)
-    page(name:"agentDiscovery", title:"Simple Sync Discovery", content:"agentDiscovery", refreshTimeout:5)
-    page(name:"manualAgentEntry")
-    page(name:"verifyManualEntry")
-}
-
-def mainPage()
-{
-	if (canInstallLabs())
-    {
-       	return agentDiscovery()
-    }
-    else
-    {
-        def upgradeNeeded = """To use SmartThings Labs, your Hub should be completely up to date.
-
-To update your Hub, access Location Settings in the Main Menu (tap the gear next to your location name), select your Hub, and choose "Update Hub"."""
-
-        return dynamicPage(name:"mainPage", title:"Upgrade needed!", nextPage:"", install:false, uninstall: true) {
-            section("Upgrade")
-            {
-                paragraph "$upgradeNeeded"
-            }
-        }
-    }
-}
-
-def agentDiscovery(params=[:])
-{
-	int refreshCount = !state.refreshCount ? 0 : state.refreshCount as int
-    state.refreshCount = refreshCount + 1
-    def refreshInterval = refreshCount == 0 ? 2 : 5
-	
-    if (!state.subscribe)
-    {
-        subscribe(location, null, locationHandler, [filterEvents:false])
-        state.subscribe = true
-    }
-	
-    //ssdp request every fifth refresh
-    if ((refreshCount % 5) == 0)
-    {
-        discoverAgents()
-    }
-	
-    def agentsDiscovered = agentsDiscovered()
-    
-    return dynamicPage(name:"agentDiscovery", title:"Pair with Simple Sync", nextPage:"", refreshInterval: refreshInterval, install:true, uninstall: true) {
-        section("Pair with Simple Sync")
-        {
-            input "selectedAgent", "enum", required:true, title:"Select Simple Sync\n(${agentsDiscovered.size() ?: 0} found)", multiple:false, options:agentsDiscovered
-        	href(name:"manualAgentEntry",
-            	 title:"Manually Configure Simple Sync",
-                 required:false,
-                 page:"manualAgentEntry")
-        }
-    }
-}
-
-def manualAgentEntry()
-{
-	dynamicPage(name:"manualAgentEntry", title:"Manually Configure Simple Sync", nextPage:"verifyManualEntry", install:false, uninstall:true) {
-    	section("Manually Configure Simple Sync")
-        {
-        	paragraph "In the event that Simple Sync cannot be automatically discovered by your SmartThings hub, you may enter Simple Sync's IP address here."
-            input(name: "manualIPAddress", type: "text", title: "IP Address", required: true)
-        }
-    }
-}
-
-def verifyManualEntry()
-{
-    def hexIP = convertIPToHexString(manualIPAddress)
-    def hexPort = convertToHexString(47147)
-    def uuid = "593C03D2-1DA9-4CDB-A335-6C6DC98E56C3"
-    def hubId = ""
-    
-    for (hub in location.hubs)
-    {
-    	if (hub.localIP != null)
-        {
-        	hubId = hub.id
-            break
-        }
-    }
-    
-    def manualAgent = [deviceType: "04",
-    					mac: "unknown",
-    					ip: hexIP,
-                        port: hexPort,
-                        ssdpPath: "/upnp/Roomie.xml",
-                        ssdpUSN: "uuid:$uuid::urn:roomieremote-com:device:roomie:1",
-                        hub: hubId,
-                        verified: true,
-                        name: "Simple Sync $manualIPAddress"]
-	
-    state.agents[uuid] = manualAgent
-    
-    addOrUpdateAgent(state.agents[uuid])
-    
-    dynamicPage(name: "verifyManualEntry", title: "Manual Configuration Complete", nextPage: "", install:true, uninstall:true) {
-    	section("")
-        {
-        	paragraph("Tap Done to complete the installation process.")
-        }
-    }
-}
-
-def discoverAgents()
-{
-    def urn = getURN()
-    
-    sendHubCommand(new physicalgraph.device.HubAction("lan discovery $urn", physicalgraph.device.Protocol.LAN))
-}
-
-def agentsDiscovered()
-{
-    def gAgents = getAgents()
-    def agents = gAgents.findAll { it?.value?.verified == true }
-    def map = [:]
-    agents.each
-    {
-        map["${it.value.uuid}"] = it.value.name
-    }
-    map
-}
-
-def getAgents()
-{
-    if (!state.agents)
-    {
-    	state.agents = [:]
-    }
-    
-    state.agents
-}
-
-def installed()
-{
-	initialize()
-}
-
-def updated()
-{
-	initialize()
-}
-
-def initialize()
-{
-	if (state.subscribe)
-	{
-    	unsubscribe()
-		state.subscribe = false
-	}
-    
-    if (selectedAgent)
-    {
-    	addOrUpdateAgent(state.agents[selectedAgent])
-    }
-}
-
-def addOrUpdateAgent(agent)
-{
-	def children = getChildDevices()
-	def dni = agent.ip + ":" + agent.port
-    def found = false
-	
-	children.each
-	{
-		if ((it.getDeviceDataByName("mac") == agent.mac))
-		{
-        	found = true
-            
-            if (it.getDeviceNetworkId() != dni)
-            {
-				it.setDeviceNetworkId(dni)
-			}
-		}
-        else if (it.getDeviceNetworkId() == dni)
-        {
-        	found = true
-        }
-	}
-    
-	if (!found)
-	{
-        addChildDevice("roomieremote-agent", "Simple Sync", dni, agent.hub, [label: "Simple Sync"])
-	}
-}
-
-def locationHandler(evt)
-{
-    def description = evt?.description
-    def urn = getURN()
-    def hub = evt?.hubId
-    def parsedEvent = parseEventMessage(description)
-    
-    parsedEvent?.putAt("hub", hub)
-    
-    //SSDP DISCOVERY EVENTS
-	if (parsedEvent?.ssdpTerm?.contains(urn))
-	{
-        def agent = parsedEvent
-        def ip = convertHexToIP(agent.ip)
-        def agents = getAgents()
-        
-        agent.verified = true
-        agent.name = "Simple Sync $ip"
-        
-        if (!agents[agent.uuid])
-        {
-        	state.agents[agent.uuid] = agent
-        }
-    }
-}
-
-private def parseEventMessage(String description)
-{
-	def event = [:]
-	def parts = description.split(',')
-    
-	parts.each
-    { part ->
-		part = part.trim()
-		if (part.startsWith('devicetype:'))
-        {
-			def valueString = part.split(":")[1].trim()
-			event.devicetype = valueString
-		}
-		else if (part.startsWith('mac:'))
-        {
-			def valueString = part.split(":")[1].trim()
-			if (valueString)
-            {
-				event.mac = valueString
-			}
-		}
-		else if (part.startsWith('networkAddress:'))
-        {
-			def valueString = part.split(":")[1].trim()
-			if (valueString)
-            {
-				event.ip = valueString
-			}
-		}
-		else if (part.startsWith('deviceAddress:'))
-        {
-			def valueString = part.split(":")[1].trim()
-			if (valueString)
-            {
-				event.port = valueString
-			}
-		}
-		else if (part.startsWith('ssdpPath:'))
-        {
-			def valueString = part.split(":")[1].trim()
-			if (valueString)
-            {
-				event.ssdpPath = valueString
-			}
-		}
-		else if (part.startsWith('ssdpUSN:'))
-        {
-			part -= "ssdpUSN:"
-			def valueString = part.trim()
-			if (valueString)
-            {
-				event.ssdpUSN = valueString
-                
-                def uuid = getUUIDFromUSN(valueString)
-                
-                if (uuid)
-                {
-                	event.uuid = uuid
-                }
-			}
-		}
-		else if (part.startsWith('ssdpTerm:'))
-        {
-			part -= "ssdpTerm:"
-			def valueString = part.trim()
-			if (valueString)
-            {
-				event.ssdpTerm = valueString
-			}
-		}
-		else if (part.startsWith('headers'))
-        {
-			part -= "headers:"
-			def valueString = part.trim()
-			if (valueString)
-            {
-				event.headers = valueString
-			}
-		}
-		else if (part.startsWith('body'))
-        {
-			part -= "body:"
-			def valueString = part.trim()
-			if (valueString)
-            {
-				event.body = valueString
-			}
-		}
-	}
-
-	event
-}
-
-def getURN()
-{
-    return "urn:roomieremote-com:device:roomie:1"
-}
-
-def getUUIDFromUSN(usn)
-{
-	def parts = usn.split(":")
-	
-	for (int i = 0; i < parts.size(); ++i)
-	{
-		if (parts[i] == "uuid")
-		{
-			return parts[i + 1]
-		}
-	}
-}
-
-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)
-}
-
-def String convertToHexString(n)
-{
-	String hex = String.format("%X", n.toInteger())
-}
-
-def String convertIPToHexString(ipString)
-{
-	String hex = ipString.tokenize(".").collect {
-    	String.format("%02X", it.toInteger())
-    }.join()
-}
-
-def Boolean canInstallLabs()
-{
-    return hasAllHubsOver("000.011.00603")
-}
-
-def Boolean hasAllHubsOver(String desiredFirmware)
-{
-    return realHubFirmwareVersions.every { fw -> fw >= desiredFirmware }
-}
-
-def List getRealHubFirmwareVersions()
-{
-    return location.hubs*.firmwareVersionString.findAll { it }
-}

smartapps/roomieremote-ratrigger/simple-sync-trigger.src/simple-sync-trigger.groovy

@@ -1,296 +0,0 @@
-/**
- *  Simple Sync Trigger
- *
- *  Copyright 2015 Roomie Remote, Inc.
- *
- *	Date: 2015-09-22
- */
-definition(
-    name: "Simple Sync Trigger",
-    namespace: "roomieremote-ratrigger",
-    author: "Roomie Remote, Inc.",
-    description: "Trigger Simple Control activities when certain actions take place in your home.",
-    category: "My Apps",
-    iconUrl: "https://s3.amazonaws.com/roomieuser/remotes/simplesync-60.png",
-    iconX2Url: "https://s3.amazonaws.com/roomieuser/remotes/simplesync-120.png",
-    iconX3Url: "https://s3.amazonaws.com/roomieuser/remotes/simplesync-120.png")
-
-
-preferences {
-	page(name: "agentSelection", title: "Select your Simple Sync")
-	page(name: "refreshActivities", title: "Updating list of Simple Sync activities")
-    page(name: "control", title: "Run a Simple Control activity when something happens")
-	page(name: "timeIntervalInput", title: "Only during a certain time", install: true, uninstall: true) {
-		section {
-			input "starting", "time", title: "Starting", required: false
-			input "ending", "time", title: "Ending", required: false
-		}
-	}
-}
-
-def agentSelection()
-{
-	if (agent)
-    {
-		state.refreshCount = 0
-    }
-    
-	dynamicPage(name: "agentSelection", title: "Select your Simple Sync", nextPage: "control", install: false, uninstall: true) {
-		section {
-			input "agent", "capability.mediaController", title: "Simple Sync", required: true, multiple: false
-		}
-	}
-}
-
-def control()
-{
-	def activities = agent.latestValue('activities')
-    
-    if (!activities || !state.refreshCount)
-    {
-	    int refreshCount = !state.refreshCount ? 0 : state.refreshCount as int
-	    state.refreshCount = refreshCount + 1
-	    def refreshInterval = refreshCount == 0 ? 2 : 4
-		
-	    // Request activities every 5th attempt
-    	if((refreshCount % 5) == 0)
-        {
-    	    agent.getAllActivities()
-		}
-        
-        dynamicPage(name: "control", title: "Updating list of Simple Control activities", nextPage: "", refreshInterval: refreshInterval, install: false, uninstall: true) {
-        	section("") {
-            	paragraph "Retrieving activities from Simple Sync"
-            }
-        }
-	}
-	else
-    {
-	dynamicPage(name: "control", title: "Run a Simple Control activity when something happens", nextPage: "timeIntervalInput", install: false, uninstall: true) {
-		def anythingSet = anythingSet()
-		if (anythingSet) {
-			section("When..."){
-				ifSet "motion", "capability.motionSensor", title: "Motion Detected", required: false, multiple: true
-				ifSet "motionInactive", "capability.motionSensor", title: "Motion Stops", required: false, multiple: true
-				ifSet "contact", "capability.contactSensor", title: "Contact Opens", required: false, multiple: true
-				ifSet "contactClosed", "capability.contactSensor", title: "Contact Closes", required: false, multiple: true
-				ifSet "acceleration", "capability.accelerationSensor", title: "Acceleration Detected", required: false, multiple: true
-				ifSet "mySwitch", "capability.switch", title: "Switch Turned On", required: false, multiple: true
-				ifSet "mySwitchOff", "capability.switch", title: "Switch Turned Off", required: false, multiple: true
-				ifSet "arrivalPresence", "capability.presenceSensor", title: "Arrival Of", required: false, multiple: true
-				ifSet "departurePresence", "capability.presenceSensor", title: "Departure Of", required: false, multiple: true
-				ifSet "button1", "capability.button", title: "Button Press", required:false, multiple:true //remove from production
-				ifSet "triggerModes", "mode", title: "System Changes Mode", required: false, multiple: true
-				ifSet "timeOfDay", "time", title: "At a Scheduled Time", required: false
-			}
-		}
-		section(anythingSet ? "Select additional triggers" : "When...", hideable: anythingSet, hidden: true){
-			ifUnset "motion", "capability.motionSensor", title: "Motion Here", required: false, multiple: true
-			ifUnset "motionInactive", "capability.motionSensor", title: "Motion Stops", required: false, multiple: true
-			ifUnset "contact", "capability.contactSensor", title: "Contact Opens", required: false, multiple: true
-			ifUnset "contactClosed", "capability.contactSensor", title: "Contact Closes", required: false, multiple: true
-			ifUnset "acceleration", "capability.accelerationSensor", title: "Acceleration Detected", required: false, multiple: true
-			ifUnset "mySwitch", "capability.switch", title: "Switch Turned On", required: false, multiple: true
-			ifUnset "mySwitchOff", "capability.switch", title: "Switch Turned Off", required: false, multiple: true
-			ifUnset "arrivalPresence", "capability.presenceSensor", title: "Arrival Of", required: false, multiple: true
-			ifUnset "departurePresence", "capability.presenceSensor", title: "Departure Of", required: false, multiple: true
-			ifUnset "button1", "capability.button", title: "Button Press", required:false, multiple:true //remove from production
-			ifUnset "triggerModes", "mode", title: "System Changes Mode", required: false, multiple: true
-			ifUnset "timeOfDay", "time", title: "At a Scheduled Time", required: false
-		}
-		section("Run this activity"){
-	        input "activity", "enum", title: "Activity?", required: true, options: new groovy.json.JsonSlurper().parseText(activities ?: "[]").activities?.collect { ["${it.uuid}": it.name] }
-		}
-        
-		section("More options", hideable: true, hidden: true) {
-			input "frequency", "decimal", title: "Minimum time between actions (defaults to every event)", description: "Minutes", required: false
-			href "timeIntervalInput", title: "Only during a certain time", description: timeLabel ?: "Tap to set", state: timeLabel ? "complete" : "incomplete"
-			input "days", "enum", title: "Only on certain days of the week", multiple: true, required: false,
-				options: ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
-			input "modes", "mode", title: "Only when mode is", multiple: true, required: false
-			input "oncePerDay", "bool", title: "Only once per day", required: false, defaultValue: false
-		}
-		section([mobileOnly:true]) {
-			label title: "Assign a name", required: false
-			mode title: "Set for specific mode(s)"
-		}
-	}
-    }
-}
-
-private anythingSet() {
-	for (name in ["motion","motionInactive","contact","contactClosed","acceleration","mySwitch","mySwitchOff","arrivalPresence","departurePresence","button1","triggerModes","timeOfDay"]) {
-		if (settings[name]) {
-			return true
-		}
-	}
-	return false
-}
-
-private ifUnset(Map options, String name, String capability) {
-	if (!settings[name]) {
-		input(options, name, capability)
-	}
-}
-
-private ifSet(Map options, String name, String capability) {
-	if (settings[name]) {
-		input(options, name, capability)
-	}
-}
-
-def installed() {
-	subscribeToEvents()
-}
-
-def updated() {
-	unsubscribe()
-	unschedule()
-	subscribeToEvents()
-}
-
-def subscribeToEvents() {
-	log.trace "subscribeToEvents()"
-	subscribe(app, appTouchHandler)
-	subscribe(contact, "contact.open", eventHandler)
-	subscribe(contactClosed, "contact.closed", eventHandler)
-	subscribe(acceleration, "acceleration.active", eventHandler)
-	subscribe(motion, "motion.active", eventHandler)
-	subscribe(motionInactive, "motion.inactive", eventHandler)
-	subscribe(mySwitch, "switch.on", eventHandler)
-	subscribe(mySwitchOff, "switch.off", eventHandler)
-	subscribe(arrivalPresence, "presence.present", eventHandler)
-	subscribe(departurePresence, "presence.not present", eventHandler)
-	subscribe(button1, "button.pushed", eventHandler)
-
-	if (triggerModes) {
-		subscribe(location, modeChangeHandler)
-	}
-
-	if (timeOfDay) {
-		schedule(timeOfDay, scheduledTimeHandler)
-	}
-}
-
-def eventHandler(evt) {
-	if (allOk) {
-		def lastTime = state[frequencyKey(evt)]
-		if (oncePerDayOk(lastTime)) {
-			if (frequency) {
-				if (lastTime == null || now() - lastTime >= frequency * 60000) {
-					startActivity(evt)
-				}
-				else {
-					log.debug "Not taking action because $frequency minutes have not elapsed since last action"
-				}
-			}
-			else {
-				startActivity(evt)
-			}
-		}
-		else {
-			log.debug "Not taking action because it was already taken today"
-		}
-	}
-}
-
-def modeChangeHandler(evt) {
-	log.trace "modeChangeHandler $evt.name: $evt.value ($triggerModes)"
-	if (evt.value in triggerModes) {
-		eventHandler(evt)
-	}
-}
-
-def scheduledTimeHandler() {
-	eventHandler(null)
-}
-
-def appTouchHandler(evt) {
-	startActivity(evt)
-}
-
-private startActivity(evt) {
-	agent.startActivity(activity)
-
-	if (frequency) {
-		state.lastActionTimeStamp = now()
-	}
-}
-
-private frequencyKey(evt) {
-	//evt.deviceId ?: evt.value
-	"lastActionTimeStamp"
-}
-
-private dayString(Date date) {
-	def df = new java.text.SimpleDateFormat("yyyy-MM-dd")
-	if (location.timeZone) {
-		df.setTimeZone(location.timeZone)
-	}
-	else {
-		df.setTimeZone(TimeZone.getTimeZone("America/New_York"))
-	}
-	df.format(date)
-}
-
-private oncePerDayOk(Long lastTime) {
-	def result = true
-	if (oncePerDay) {
-		result = lastTime ? dayString(new Date()) != dayString(new Date(lastTime)) : true
-		log.trace "oncePerDayOk = $result"
-	}
-	result
-}
-
-// TODO - centralize somehow
-private getAllOk() {
-	modeOk && daysOk && timeOk
-}
-
-private getModeOk() {
-	def result = !modes || modes.contains(location.mode)
-	log.trace "modeOk = $result"
-	result
-}
-
-private getDaysOk() {
-	def result = true
-	if (days) {
-		def df = new java.text.SimpleDateFormat("EEEE")
-		if (location.timeZone) {
-			df.setTimeZone(location.timeZone)
-		}
-		else {
-			df.setTimeZone(TimeZone.getTimeZone("America/New_York"))
-		}
-		def day = df.format(new Date())
-		result = days.contains(day)
-	}
-	log.trace "daysOk = $result"
-	result
-}
-
-private getTimeOk() {
-	def result = true
-	if (starting && ending) {
-		def currTime = now()
-		def start = timeToday(starting).time
-		def stop = timeToday(ending).time
-		result = start < stop ? currTime >= start && currTime <= stop : currTime <= stop || currTime >= start
-	}
-	log.trace "timeOk = $result"
-	result
-}
-
-private hhmm(time, fmt = "h:mm a")
-{
-	def t = timeToday(time, location.timeZone)
-	def f = new java.text.SimpleDateFormat(fmt)
-	f.setTimeZone(location.timeZone ?: timeZone(time))
-	f.format(t)
-}
-
-private timeIntervalLabel()
-{
-	(starting && ending) ? hhmm(starting) + "-" + hhmm(ending, "h:mm a z") : ""
-}

smartapps/roomieremote-roomieconnect/simple-control.src/simple-control.groovy

@@ -1,774 +0,0 @@
-/**
- *  Simple Control
- *
- *  Copyright 2015 Roomie Remote, Inc.
- *
- *	Date: 2015-09-22
- */
-
-definition(
-    name: "Simple Control",
-    namespace: "roomieremote-roomieconnect",
-    author: "Roomie Remote, Inc.",
-    description: "Integrate SmartThings with your Simple Control activities.",
-    category: "My Apps",
-    iconUrl: "https://s3.amazonaws.com/roomieuser/remotes/simplesync-60.png",
-    iconX2Url: "https://s3.amazonaws.com/roomieuser/remotes/simplesync-120.png",
-    iconX3Url: "https://s3.amazonaws.com/roomieuser/remotes/simplesync-120.png")
-
-preferences()
-{
-	section("Allow Simple Control to Monitor and Control These Things...")
-    {
-    	input "switches", "capability.switch", title: "Which Switches?", multiple: true, required: false
-    	input "locks", "capability.lock", title: "Which Locks?", multiple: true, required: false
-        input "thermostats", "capability.thermostat", title: "Which Thermostats?", multiple: true, required: false
-        input "doorControls", "capability.doorControl", title: "Which Door Controls?", multiple: true, required: false
-        input "colorControls", "capability.colorControl", title: "Which Color Controllers?", multiple: true, required: false
-        input "musicPlayers", "capability.musicPlayer", title: "Which Music Players?", multiple: true, required: false
-        input "switchLevels", "capability.switchLevel", title: "Which Adjustable Switches?", multiple: true, required: false
-  	}
-	
-	page(name: "mainPage", title: "Simple Control Setup", content: "mainPage", refreshTimeout: 5)
-	page(name:"agentDiscovery", title:"Simple Sync Discovery", content:"agentDiscovery", refreshTimeout:5)
-	page(name:"manualAgentEntry")
-	page(name:"verifyManualEntry")
-}
-
-mappings {
-	path("/devices") {
-    	action: [
-        	GET: "getDevices"
-        ]
-	}
-    path("/:deviceType/devices") {
-    	action: [
-        	GET: "getDevices",
-            POST: "handleDevicesWithIDs"
-        ]
-    }
-    path("/device/:deviceType/:id") {
-    	action: [
-        	GET: "getDevice",
-            POST: "updateDevice"
-        ]
-    }
-	path("/subscriptions") {
-		action: [
-			GET: "listSubscriptions",
-			POST: "addSubscription", // {"deviceId":"xxx", "attributeName":"xxx","callbackUrl":"http://..."}
-            DELETE: "removeAllSubscriptions"
-		]
-	}
-	path("/subscriptions/:id") {
-		action: [
-			DELETE: "removeSubscription"
-		]
-	}
-}
-
-private getAllDevices()
-{
-	//log.debug("getAllDevices()")
-	([] + switches + locks + thermostats + imageCaptures + relaySwitches + doorControls + colorControls + musicPlayers + speechSynthesizers + switchLevels + indicators + mediaControllers + tones + tvs + alarms + valves + motionSensors + presenceSensors + beacons + pushButtons + smokeDetectors + coDetectors + contactSensors + accelerationSensors + energyMeters + powerMeters + lightSensors + humiditySensors + temperatureSensors + speechRecognizers + stepSensors + touchSensors)?.findAll()?.unique { it.id }
-}
-
-def getDevices()
-{
-	//log.debug("getDevices, params: ${params}")
-    allDevices.collect {
-    	//log.debug("device: ${it}")
-		deviceItem(it)
-	}
-}
-
-def getDevice()
-{
-	//log.debug("getDevice, params: ${params}")
-    def device = allDevices.find { it.id == params.id }
-    if (!device)
-    {
-    	render status: 404, data: '{"msg": "Device not found"}'
-    }
-    else
-    {
-    	deviceItem(device)
-    }
-}
-
-def handleDevicesWithIDs()
-{
-	//log.debug("handleDevicesWithIDs, params: ${params}")
-	def data = request.JSON
-	def ids = data?.ids?.findAll()?.unique()
-    //log.debug("ids: ${ids}")
-    def command = data?.command
-	def arguments = data?.arguments
-	def type = params?.deviceType
-    //log.debug("device type: ${type}")
-    if (command)
-    {
-    	def statusCode = 404
-	    //log.debug("command ${command}, arguments ${arguments}")
-    	for (devId in ids)
-        {
-			def device = allDevices.find { it.id == devId }
-            //log.debug("device: ${device}")
-			// Check if we have a device that responds to the specified command
-			if (validateCommand(device, type, command)) {
-            	if (arguments) {
-					device."$command"(*arguments)
-                }
-                else {
-                	device."$command"()
-                }
-				statusCode = 200
-			} else {
-            	statusCode = 403
-			}
-		}
-        def responseData = "{}"
-        switch (statusCode)
-        {
-        	case 403:
-            	responseData = '{"msg": "Access denied. This command is not supported by current capability."}'
-                break
-			case 404:
-            	responseData = '{"msg": "Device not found"}'
-                break
-        }
-        render status: statusCode, data: responseData
-    }
-    else
-    {
-		ids.collect {
-    		def currentId = it
-    		def device = allDevices.find { it.id == currentId }
-        	if (device)
-        	{
-        		deviceItem(device)
-    	    }
-   		}
-	}
-}
-
-private deviceItem(device) {
-	[
-		id: device.id,
-		label: device.displayName,
-		currentState: device.currentStates,
-		capabilities: device.capabilities?.collect {[
-			name: it.name
-		]},
-		attributes: device.supportedAttributes?.collect {[
-			name: it.name,
-			dataType: it.dataType,
-			values: it.values
-		]},
-		commands: device.supportedCommands?.collect {[
-			name: it.name,
-			arguments: it.arguments
-		]},
-		type: [
-			name: device.typeName,
-			author: device.typeAuthor
-		]
-	]
-}
-
-def updateDevice()
-{
-	//log.debug("updateDevice, params: ${params}")
-	def data = request.JSON
-	def command = data?.command
-	def arguments = data?.arguments
-	def type = params?.deviceType
-    //log.debug("device type: ${type}")
-
-	//log.debug("updateDevice, params: ${params}, request: ${data}")
-	if (!command) {
-		render status: 400, data: '{"msg": "command is required"}'
-	} else {
-		def statusCode = 404
-		def device = allDevices.find { it.id == params.id }
-		if (device) {
-			// Check if we have a device that responds to the specified command
-			if (validateCommand(device, type, command)) {
-	        	if (arguments) {
-					device."$command"(*arguments)
-	            }
-	            else {
-	            	device."$command"()
-	            }
-				statusCode = 200
-			} else {
-	        	statusCode = 403
-			}
-		}
-		
-	    def responseData = "{}"
-	    switch (statusCode)
-	    {
-	    	case 403:
-	        	responseData = '{"msg": "Access denied. This command is not supported by current capability."}'
-	            break
-			case 404:
-	        	responseData = '{"msg": "Device not found"}'
-	            break
-	    }
-	    render status: statusCode, data: responseData
-	}
-}
-
-/**
- * Validating the command passed by the user based on capability.
- * @return boolean
- */
-def validateCommand(device, deviceType, command) {
-	//log.debug("validateCommand ${command}")
-    def capabilityCommands = getDeviceCapabilityCommands(device.capabilities)
-    //log.debug("capabilityCommands: ${capabilityCommands}")
-	def currentDeviceCapability = getCapabilityName(deviceType)
-    //log.debug("currentDeviceCapability: ${currentDeviceCapability}")
-	if (capabilityCommands[currentDeviceCapability]) {
-		return command in capabilityCommands[currentDeviceCapability] ? true : false
-	} else {
-		// Handling other device types here, which don't accept commands
-		httpError(400, "Bad request.")
-	}
-}
-
-/**
- * Need to get the attribute name to do the lookup. Only
- * doing it for the device types which accept commands
- * @return attribute name of the device type
- */
-def getCapabilityName(type) {
-    switch(type) {
-		case "switches":
-			return "Switch"
-		case "locks":
-			return "Lock"
-        case "thermostats":
-        	return "Thermostat"
-        case "doorControls":
-        	return "Door Control"
-        case "colorControls":
-        	return "Color Control"
-        case "musicPlayers":
-        	return "Music Player"
-        case "switchLevels":
-        	return "Switch Level"
-		default:
-			return type
-	}
-}
-
-/**
- * Constructing the map over here of
- * supported commands by device capability
- * @return a map of device capability -> supported commands
- */
-def getDeviceCapabilityCommands(deviceCapabilities) {
-	def map = [:]
-	deviceCapabilities.collect {
-		map[it.name] = it.commands.collect{ it.name.toString() }
-	}
-	return map
-}
-
-def listSubscriptions()
-{
-	//log.debug "listSubscriptions()"
-	app.subscriptions?.findAll { it.deviceId }?.collect {
-		def deviceInfo = state[it.deviceId]
-		def response = [
-			id: it.id,
-			deviceId: it.deviceId,
-			attributeName: it.data,
-			handler: it.handler
-		]
-		//if (!selectedAgent) {
-			response.callbackUrl = deviceInfo?.callbackUrl
-		//}
-		response
-	} ?: []
-}
-
-def addSubscription() {
-	def data = request.JSON
-	def attribute = data.attributeName
-	def callbackUrl = data.callbackUrl
-
-	//log.debug "addSubscription, params: ${params}, request: ${data}"
-	if (!attribute) {
-		render status: 400, data: '{"msg": "attributeName is required"}'
-	} else {
-		def device = allDevices.find { it.id == data.deviceId }
-		if (device) {
-			//if (!selectedAgent) {
-				//log.debug "Adding callbackUrl: $callbackUrl"
-				state[device.id] = [callbackUrl: callbackUrl]
-			//}
-			//log.debug "Adding subscription"
-			def subscription = subscribe(device, attribute, deviceHandler)
-			if (!subscription || !subscription.eventSubscription) {
-            	//log.debug("subscriptions: ${app.subscriptions}")
-                //for (sub in app.subscriptions)
-                //{
-                	//log.debug("subscription.id ${sub.id} subscription.handler ${sub.handler} subscription.deviceId ${sub.deviceId}")
-                    //log.debug(sub.properties.collect{it}.join('\n'))
-				//}
-				subscription = app.subscriptions?.find { it.device.id == data.deviceId && it.data == attribute && it.handler == 'deviceHandler' }
-			}
-
-			def response = [
-				id: subscription.id,
-				deviceId: subscription.device?.id,
-				attributeName: subscription.data,
-				handler: subscription.handler
-			]
-			//if (!selectedAgent) {
-				response.callbackUrl = callbackUrl
-			//}
-			response
-		} else {
-			render status: 400, data: '{"msg": "Device not found"}'
-		}
-	}
-}
-
-def removeSubscription()
-{
-	def subscription = app.subscriptions?.find { it.id == params.id }
-	def device = subscription?.device
-
-	//log.debug "removeSubscription, params: ${params}, subscription: ${subscription}, device: ${device}"
-	if (device) {
-		//log.debug "Removing subscription for device: ${device.id}"
-		state.remove(device.id)
-		unsubscribe(device)
-	}
-	render status: 204, data: "{}"
-}
-
-def removeAllSubscriptions()
-{
-	for (sub in app.subscriptions)
-    {
-    	//log.debug("Subscription: ${sub}")
-        //log.debug(sub.properties.collect{it}.join('\n'))
-        def handler = sub.handler
-        def device = sub.device
-        
-    	if (device && handler == 'deviceHandler')
-        {
-	        //log.debug(device.properties.collect{it}.join('\n'))
-        	//log.debug("Removing subscription for device: ${device}")
-            state.remove(device.id)
-            unsubscribe(device)
-        }
-    }
-}
-
-def deviceHandler(evt) {
-	def deviceInfo = state[evt.deviceId]
-	//if (selectedAgent) {
-    //	sendToRoomie(evt, agentCallbackUrl)
-	//} else if (deviceInfo) {
-    if (deviceInfo)
-    {
-		if (deviceInfo.callbackUrl) {
-			sendToRoomie(evt, deviceInfo.callbackUrl)
-		} else {
-			log.warn "No callbackUrl set for device: ${evt.deviceId}"
-		}
-	} else {
-		log.warn "No subscribed device found for device: ${evt.deviceId}"
-	}
-}
-
-def sendToRoomie(evt, String callbackUrl) {
-	def callback = new URI(callbackUrl)
-	def host = callback.port != -1 ? "${callback.host}:${callback.port}" : callback.host
-	def path = callback.query ? "${callback.path}?${callback.query}".toString() : callback.path
-	sendHubCommand(new physicalgraph.device.HubAction(
-		method: "POST",
-		path: path,
-		headers: [
-			"Host": host,
-			"Content-Type": "application/json"
-		],
-		body: [evt: [deviceId: evt.deviceId, name: evt.name, value: evt.value]]
-	))
-}
-
-def mainPage()
-{
-	if (canInstallLabs())
-    {
-       	return agentDiscovery()
-    }
-    else
-    {
-        def upgradeNeeded = """To use SmartThings Labs, your Hub should be completely up to date.
-
-To update your Hub, access Location Settings in the Main Menu (tap the gear next to your location name), select your Hub, and choose "Update Hub"."""
-
-        return dynamicPage(name:"mainPage", title:"Upgrade needed!", nextPage:"", install:false, uninstall: true) {
-            section("Upgrade")
-            {
-                paragraph "$upgradeNeeded"
-            }
-        }
-    }
-}
-
-def agentDiscovery(params=[:])
-{
-	int refreshCount = !state.refreshCount ? 0 : state.refreshCount as int
-    state.refreshCount = refreshCount + 1
-    def refreshInterval = refreshCount == 0 ? 2 : 5
-	
-    if (!state.subscribe)
-    {
-        subscribe(location, null, locationHandler, [filterEvents:false])
-        state.subscribe = true
-    }
-	
-    //ssdp request every fifth refresh
-    if ((refreshCount % 5) == 0)
-    {
-        discoverAgents()
-    }
-	
-    def agentsDiscovered = agentsDiscovered()
-    
-    return dynamicPage(name:"agentDiscovery", title:"Pair with Simple Sync", nextPage:"", refreshInterval: refreshInterval, install:true, uninstall: true) {
-        section("Pair with Simple Sync")
-        {
-            input "selectedAgent", "enum", required:false, title:"Select Simple Sync\n(${agentsDiscovered.size() ?: 0} found)", multiple:false, options:agentsDiscovered
-        	href(name:"manualAgentEntry",
-            	 title:"Manually Configure Simple Sync",
-                 required:false,
-                 page:"manualAgentEntry")
-        }
-        section("Allow Simple Control to Monitor and Control These Things...")
-        {
-			input "switches", "capability.switch", title: "Which Switches?", multiple: true, required: false
-			input "locks", "capability.lock", title: "Which Locks?", multiple: true, required: false
-			input "thermostats", "capability.thermostat", title: "Which Thermostats?", multiple: true, required: false
-			input "doorControls", "capability.doorControl", title: "Which Door Controls?", multiple: true, required: false
-			input "colorControls", "capability.colorControl", title: "Which Color Controllers?", multiple: true, required: false
-			input "musicPlayers", "capability.musicPlayer", title: "Which Music Players?", multiple: true, required: false
-			input "switchLevels", "capability.switchLevel", title: "Which Adjustable Switches?", multiple: true, required: false
-	  	}
-    }
-}
-
-def manualAgentEntry()
-{
-	dynamicPage(name:"manualAgentEntry", title:"Manually Configure Simple Sync", nextPage:"verifyManualEntry", install:false, uninstall:true) {
-    	section("Manually Configure Simple Sync")
-        {
-        	paragraph "In the event that Simple Sync cannot be automatically discovered by your SmartThings hub, you may enter Simple Sync's IP address here."
-            input(name: "manualIPAddress", type: "text", title: "IP Address", required: true)
-        }
-    }
-}
-
-def verifyManualEntry()
-{
-    def hexIP = convertIPToHexString(manualIPAddress)
-    def hexPort = convertToHexString(47147)
-    def uuid = "593C03D2-1DA9-4CDB-A335-6C6DC98E56C3"
-    def hubId = ""
-    
-    for (hub in location.hubs)
-    {
-    	if (hub.localIP != null)
-        {
-        	hubId = hub.id
-            break
-        }
-    }
-    
-    def manualAgent = [deviceType: "04",
-    					mac: "unknown",
-    					ip: hexIP,
-                        port: hexPort,
-                        ssdpPath: "/upnp/Roomie.xml",
-                        ssdpUSN: "uuid:$uuid::urn:roomieremote-com:device:roomie:1",
-                        hub: hubId,
-                        verified: true,
-                        name: "Simple Sync $manualIPAddress"]
-	
-    state.agents[uuid] = manualAgent
-    
-    addOrUpdateAgent(state.agents[uuid])
-    
-    dynamicPage(name: "verifyManualEntry", title: "Manual Configuration Complete", nextPage: "", install:true, uninstall:true) {
-    	section("")
-        {
-        	paragraph("Tap Done to complete the installation process.")
-        }
-    }
-}
-
-def discoverAgents()
-{
-    def urn = getURN()
-    
-    sendHubCommand(new physicalgraph.device.HubAction("lan discovery $urn", physicalgraph.device.Protocol.LAN))
-}
-
-def agentsDiscovered()
-{
-    def gAgents = getAgents()
-    def agents = gAgents.findAll { it?.value?.verified == true }
-    def map = [:]
-    agents.each
-    {
-        map["${it.value.uuid}"] = it.value.name
-    }
-    map
-}
-
-def getAgents()
-{
-    if (!state.agents)
-    {
-    	state.agents = [:]
-    }
-    
-    state.agents
-}
-
-def installed()
-{
-	initialize()
-}
-
-def updated()
-{
-	initialize()
-}
-
-def initialize()
-{
-	if (state.subscribe)
-	{
-    	unsubscribe()
-		state.subscribe = false
-	}
-    
-    if (selectedAgent)
-    {
-    	addOrUpdateAgent(state.agents[selectedAgent])
-    }
-}
-
-def addOrUpdateAgent(agent)
-{
-	def children = getChildDevices()
-	def dni = agent.ip + ":" + agent.port
-    def found = false
-	
-	children.each
-	{
-		if ((it.getDeviceDataByName("mac") == agent.mac))
-		{
-        	found = true
-            
-            if (it.getDeviceNetworkId() != dni)
-            {
-				it.setDeviceNetworkId(dni)
-			}
-		}
-        else if (it.getDeviceNetworkId() == dni)
-        {
-        	found = true
-        }
-	}
-    
-	if (!found)
-	{
-        addChildDevice("roomieremote-agent", "Simple Sync", dni, agent.hub, [label: "Simple Sync"])
-	}
-}
-
-def locationHandler(evt)
-{
-    def description = evt?.description
-    def urn = getURN()
-    def hub = evt?.hubId
-    def parsedEvent = parseEventMessage(description)
-    
-    parsedEvent?.putAt("hub", hub)
-    
-    //SSDP DISCOVERY EVENTS
-	if (parsedEvent?.ssdpTerm?.contains(urn))
-	{
-        def agent = parsedEvent
-        def ip = convertHexToIP(agent.ip)
-        def agents = getAgents()
-        
-        agent.verified = true
-        agent.name = "Simple Sync $ip"
-        
-        if (!agents[agent.uuid])
-        {
-        	state.agents[agent.uuid] = agent
-        }
-    }
-}
-
-private def parseEventMessage(String description)
-{
-	def event = [:]
-	def parts = description.split(',')
-    
-	parts.each
-    { part ->
-		part = part.trim()
-		if (part.startsWith('devicetype:'))
-        {
-			def valueString = part.split(":")[1].trim()
-			event.devicetype = valueString
-		}
-		else if (part.startsWith('mac:'))
-        {
-			def valueString = part.split(":")[1].trim()
-			if (valueString)
-            {
-				event.mac = valueString
-			}
-		}
-		else if (part.startsWith('networkAddress:'))
-        {
-			def valueString = part.split(":")[1].trim()
-			if (valueString)
-            {
-				event.ip = valueString
-			}
-		}
-		else if (part.startsWith('deviceAddress:'))
-        {
-			def valueString = part.split(":")[1].trim()
-			if (valueString)
-            {
-				event.port = valueString
-			}
-		}
-		else if (part.startsWith('ssdpPath:'))
-        {
-			def valueString = part.split(":")[1].trim()
-			if (valueString)
-            {
-				event.ssdpPath = valueString
-			}
-		}
-		else if (part.startsWith('ssdpUSN:'))
-        {
-			part -= "ssdpUSN:"
-			def valueString = part.trim()
-			if (valueString)
-            {
-				event.ssdpUSN = valueString
-                
-                def uuid = getUUIDFromUSN(valueString)
-                
-                if (uuid)
-                {
-                	event.uuid = uuid
-                }
-			}
-		}
-		else if (part.startsWith('ssdpTerm:'))
-        {
-			part -= "ssdpTerm:"
-			def valueString = part.trim()
-			if (valueString)
-            {
-				event.ssdpTerm = valueString
-			}
-		}
-		else if (part.startsWith('headers'))
-        {
-			part -= "headers:"
-			def valueString = part.trim()
-			if (valueString)
-            {
-				event.headers = valueString
-			}
-		}
-		else if (part.startsWith('body'))
-        {
-			part -= "body:"
-			def valueString = part.trim()
-			if (valueString)
-            {
-				event.body = valueString
-			}
-		}
-	}
-
-	event
-}
-
-def getURN()
-{
-    return "urn:roomieremote-com:device:roomie:1"
-}
-
-def getUUIDFromUSN(usn)
-{
-	def parts = usn.split(":")
-	
-	for (int i = 0; i < parts.size(); ++i)
-	{
-		if (parts[i] == "uuid")
-		{
-			return parts[i + 1]
-		}
-	}
-}
-
-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)
-}
-
-def String convertToHexString(n)
-{
-	String hex = String.format("%X", n.toInteger())
-}
-
-def String convertIPToHexString(ipString)
-{
-	String hex = ipString.tokenize(".").collect {
-    	String.format("%02X", it.toInteger())
-    }.join()
-}
-
-def Boolean canInstallLabs()
-{
-    return hasAllHubsOver("000.011.00603")
-}
-
-def Boolean hasAllHubsOver(String desiredFirmware)
-{
-    return realHubFirmwareVersions.every { fw -> fw >= desiredFirmware }
-}
-
-def List getRealHubFirmwareVersions()
-{
-    return location.hubs*.firmwareVersionString.findAll { it }
-}
-
-

smartapps/smartthings/button-controller.src/button-controller.groovy

@@ -297,8 +297,8 @@ private getTimeOk() {
 	def result = true
 	if (starting && ending) {
 		def currTime = now()
-		def start = timeToday(starting, location.timeZone).time
-		def stop = timeToday(ending, location.timeZone).time
+		def start = timeToday(starting).time
+		def stop = timeToday(ending).time
 		result = start < stop ? currTime >= start && currTime <= stop : currTime <= stop || currTime >= start
 	}
 	log.trace "timeOk = $result"

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

@@ -463,32 +463,29 @@ def pollChildren(child = null) {
 }
 
 // Poll Child is invoked from the Child Device itself as part of the Poll Capability
-def pollChild(){
+def pollChild(child){
 
-	def devices = getChildDevices()
-
-	if (pollChildren()){
-		devices.each { child ->
-			if (!child.device.deviceNetworkId.startsWith("ecobee_sensor")){
-				if(atomicState.thermostats[child.device.deviceNetworkId] != null) {
-					def tData = atomicState.thermostats[child.device.deviceNetworkId]
-					log.info "pollChild(child)>> data for ${child.device.deviceNetworkId} : ${tData.data}"
-					child.generateEvent(tData.data) //parse received message from parent
-				} else if(atomicState.thermostats[child.device.deviceNetworkId] == null) {
-					log.error "ERROR: Device connection removed? no data for ${child.device.deviceNetworkId}"
-					return null
-				}
+	if (pollChildren(child)){
+		if (!child.device.deviceNetworkId.startsWith("ecobee_sensor")){
+			if(atomicState.thermostats[child.device.deviceNetworkId] != null) {
+				def tData = atomicState.thermostats[child.device.deviceNetworkId]
+				log.info "pollChild(child)>> data for ${child.device.deviceNetworkId} : ${tData.data}"
+				child.generateEvent(tData.data) //parse received message from parent
+			} else if(atomicState.thermostats[child.device.deviceNetworkId] == null) {
+				log.error "ERROR: Device connection removed? no data for ${child.device.deviceNetworkId}"
+				return null
 			}
 		}
 	} else {
-		log.info "ERROR: pollChildren()"
+		log.info "ERROR: pollChildren(child) for ${child.device.deviceNetworkId} after polling"
 		return null
 	}
 
 }
 
 void poll() {
-	pollChild()
+	def devices = getChildDevices()
+	devices.each {pollChild(it)}
 }
 
 def availableModes(child) {

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

@@ -39,7 +39,6 @@ preferences {
 	page(name: "completionPage")
 	page(name: "numbersPage")
 	page(name: "controllerExplanationPage")
-	page(name: "unsupportedDevicesPage")
 }
 
 def rootPage() {
@@ -48,9 +47,6 @@ def rootPage() {
 		section("What to dim") {
 			input(name: "dimmers", type: "capability.switchLevel", title: "Dimmers", description: null, multiple: true, required: true, submitOnChange: true)
 			if (dimmers) {
-				if (dimmersContainUnsupportedDevices()) {
-					href(name: "toUnsupportedDevicesPage", page: "unsupportedDevicesPage", title: "Some of your selected dimmers don't seem to be supported", description: "Tap here to fix it", required: true)
-				}
 				href(name: "toNumbersPage", page: "numbersPage", title: "Duration & Direction", description: numbersPageHrefDescription(), state: "complete")
 			}
 		}
@@ -75,31 +71,6 @@ def rootPage() {
 	}
 }
 
-def unsupportedDevicesPage() {
-
-	def unsupportedDimmers = dimmers.findAll { !hasSetLevelCommand(it) }
-
-	dynamicPage(name: "unsupportedDevicesPage") {
-		if (unsupportedDimmers) {
-			section("These devices do not support the setLevel command") {
-				unsupportedDimmers.each {
-					paragraph deviceLabel(it)
-				}
-			}
-			section {
-				input(name: "dimmers", type: "capability.sensor", title: "Please remove the above devices from this list.", submitOnChange: true, multiple: true)
-			}
-			section {
-				paragraph "If you think there is a mistake here, please contact support."
-			}
-		} else {
-			section {
-				paragraph "You're all set. You can hit the back button, now. Thanks for cleaning up your settings :)"
-			}
-		}
-	}
-}
-
 def controllerExplanationPage() {
 	dynamicPage(name: "controllerExplanationPage", title: "How To Control Gentle Wake Up") {
 
@@ -237,7 +208,7 @@ def completionPage() {
 		}
 
 		section("Notifications") {
-			input("recipients", "contact", title: "Send notifications to", required: false) {
+			input("recipients", "contact", title: "Send notifications to") {
 				input(name: "completionPhoneNumber", type: "phone", title: "Text This Number", description: "Phone number", required: false)
 				input(name: "completionPush", type: "bool", title: "Send A Push Notification", description: "Phone number", required: false)
 			}
@@ -557,16 +528,14 @@ def updateDimmers(percentComplete) {
 		} else {
 
 			def shouldChangeColors = (colorize && colorize != "false")
+			def canChangeColors = hasSetColorCommand(dimmer)
 
-			if (shouldChangeColors && hasSetColorCommand(dimmer)) {
-				def hue = getHue(dimmer, nextLevel)
-				log.debug "Setting ${deviceLabel(dimmer)} level to ${nextLevel} and hue to ${hue}"
-				dimmer.setColor([hue: hue, saturation: 100, level: nextLevel])
-			} else if (hasSetLevelCommand(dimmer)) {
-				log.debug "Setting ${deviceLabel(dimmer)} level to ${nextLevel}"
-				dimmer.setLevel(nextLevel)
+			log.debug "Setting ${deviceLabel(dimmer)} to ${nextLevel}"
+
+			if (shouldChangeColors && canChangeColors) {
+				dimmer.setColor([hue: getHue(dimmer, nextLevel), saturation: 100, level: nextLevel])
 			} else {
-				log.warn "${deviceLabel(dimmer)} does not have setColor or setLevel commands."
+				dimmer.setLevel(nextLevel)
 			}
 
 		}
@@ -720,7 +689,7 @@ def completionPercentage() {
 
 	def now = new Date().getTime()
 	def timeElapsed = now - atomicState.start
-	def totalRunTime = totalRunTimeMillis() ?: 1
+	def totalRunTime = totalRunTimeMillis()
 	def percentComplete = timeElapsed / totalRunTime * 100
 	log.debug "percentComplete: ${percentComplete}"
 
@@ -848,21 +817,24 @@ private getRedHue(level) {
 	if (level >= 96) return 17
 }
 
-private dimmersContainUnsupportedDevices() {
-	def found = dimmers.find { hasSetLevelCommand(it) == false }
-	return found != null
-}
-
 private hasSetLevelCommand(device) {
-	return hasCommand(device, "setLevel")
+	def isDimmer = false
+	device.supportedCommands.each {
+		if (it.name.contains("setLevel")) {
+			isDimmer = true
+		}
+	}
+	return isDimmer
 }
 
 private hasSetColorCommand(device) {
-	return hasCommand(device, "setColor")
-}
-
-private hasCommand(device, String command) {
-	return (device.supportedCommands.find { it.name == command } != null)
+	def hasColor = false
+	device.supportedCommands.each {
+		if (it.name.contains("setColor")) {
+			hasColor = true
+		}
+	}
+	return hasColor
 }
 
 private dimmersWithSetColorCommand() {
@@ -1101,4 +1073,4 @@ def hasStartLevel() {
 
 def hasEndLevel() {
 	return (endLevel != null && endLevel != "")
-}
+}

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

@@ -24,13 +24,12 @@ definition(
 	category: "SmartThings Labs",
 	iconUrl: "https://s3.amazonaws.com/smartapp-icons/Partner/hue.png",
 	iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Partner/hue@2x.png",
-    singleInstance: true
+        //singleInstance: true
 )
 
 preferences {
 	page(name:"mainPage", title:"Hue Device Setup", content:"mainPage", refreshTimeout:5)
 	page(name:"bridgeDiscovery", title:"Hue Bridge Discovery", content:"bridgeDiscovery", refreshTimeout:5)
-	page(name:"bridgeDiscoveryFailed", title:"Bridge Discovery Failed", content:"bridgeDiscoveryFailed", refreshTimeout:0)
 	page(name:"bridgeBtnPush", title:"Linking with your Hue", content:"bridgeLinking", refreshTimeout:5)
 	page(name:"bulbDiscovery", title:"Hue Device Setup", content:"bulbDiscovery", refreshTimeout:5)
 }
@@ -54,23 +53,14 @@ def bridgeDiscovery(params=[:])
 	def options = bridges ?: []
 	def numFound = options.size() ?: 0
 
-	if (numFound == 0) {
-		if (state.bridgeRefreshCount == 25) {
-			log.trace "Cleaning old bridges memory"
-			state.bridges = [:]
-			app.updateSetting("selectedHue", "")
-		} else if (state.bridgeRefreshCount > 100) {
-			// five minutes have passed, give up
-			// there seems to be a problem going back from discovey failed page in some instances (compared to pressing next)
-			// however it is probably a SmartThings settings issue
-			state.bridges = [:]
-			app.updateSetting("selectedHue", "")
-			state.bridgeRefreshCount = 0
-			return bridgeDiscoveryFailed()
-		}
-	}
+	if (numFound == 0 && state.bridgeRefreshCount > 25) {
+    	log.trace "Cleaning old bridges memory"
+    	state.bridges = [:]
+        state.bridgeRefreshCount = 0
+        app.updateSetting("selectedHue", "")
+    }
 
-	ssdpSubscribe()
+	subscribe(location, null, locationHandler, [filterEvents:false])
 
 	//bridge discovery request every 15 //25 seconds
 	if((bridgeRefreshCount % 5) == 0) {
@@ -78,7 +68,7 @@ def bridgeDiscovery(params=[:])
 	}
 
 	//setup.xml request every 3 seconds except on discoveries
-	if(((bridgeRefreshCount % 3) == 0) && ((bridgeRefreshCount % 5) != 0)) {
+	if(((bridgeRefreshCount % 1) == 0) && ((bridgeRefreshCount % 5) != 0)) {
 		verifyHueBridges()
 	}
 
@@ -89,13 +79,6 @@ def bridgeDiscovery(params=[:])
 	}
 }
 
-def bridgeDiscoveryFailed() {
-	return dynamicPage(name:"bridgeDiscoveryFailed", title: "Bridge Discovery Failed", nextPage: "bridgeDiscovery") {
-		section("Failed to discover any Hue Bridges. Please confirm that the Hue Bridge is connected to the same network as your SmartThings Hub, and that it has power.") {
-		}
-	}
-}
-
 def bridgeLinking()
 {
 	int linkRefreshcount = !state.linkRefreshcount ? 0 : state.linkRefreshcount as int
@@ -105,15 +88,19 @@ def bridgeLinking()
 	def nextPage = ""
 	def title = "Linking with your Hue"
     def paragraphText
+    def hueimage = null
 	if (selectedHue) {
 		paragraphText = "Press the button on your Hue Bridge to setup a link. "
+        hueimage = "http://huedisco.mediavibe.nl/wp-content/uploads/2013/09/pair-bridge.png"
     } else {
     	paragraphText = "You haven't selected a Hue Bridge, please Press \"Done\" and select one before clicking next."
+        hueimage = null
     }
 	if (state.username) { //if discovery worked
 		nextPage = "bulbDiscovery"
 		title = "Success!"
 		paragraphText = "Linking to your hub was a success! Please click 'Next'!"
+        hueimage = null
 	}
 
 	if((linkRefreshcount % 2) == 0 && !state.username) {
@@ -123,6 +110,8 @@ def bridgeLinking()
 	return dynamicPage(name:"bridgeBtnPush", title:title, nextPage:nextPage, refreshInterval:refreshInterval) {
 		section("") {
 			paragraph """${paragraphText}"""
+            if (hueimage != null)
+            	image "${hueimage}"
 		}
 	}
 }
@@ -146,14 +135,13 @@ def bulbDiscovery() {
 	if((bulbRefreshCount % 5) == 0) {
 		discoverHueBulbs()
 	}
-	def selectedBridge = state.bridges.find { key, value -> value?.serialNumber?.equalsIgnoreCase(selectedHue) }
-	def title = selectedBridge?.value?.name ?: "Find bridges"
 
 	return dynamicPage(name:"bulbDiscovery", title:"Bulb Discovery Started!", nextPage:"", refreshInterval:refreshInterval, install:true, uninstall: true) {
 		section("Please wait while we discover your Hue Bulbs. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
 			input "selectedBulbs", "enum", required:false, title:"Select Hue Bulbs (${numFound} found)", multiple:true, options:bulboptions
 		}
 		section {
+			def title = getBridgeIP() ? "Hue bridge (${getBridgeIP()})" : "Find bridges"
 			href "bridgeDiscovery", title: title, description: "", state: selectedHue ? "complete" : "incomplete", params: [override: true]
 
 		}
@@ -164,10 +152,6 @@ private discoverBridges() {
 	sendHubCommand(new physicalgraph.device.HubAction("lan discovery urn:schemas-upnp-org:device:basic:1", physicalgraph.device.Protocol.LAN))
 }
 
-void ssdpSubscribe() {
-	subscribe(location, "ssdpTerm.urn:schemas-upnp-org:device:basic:1", ssdpBridgeHandler)
-}
-
 private sendDeveloperReq() {
 	def token = app.id
     def host = getBridgeIP()
@@ -177,7 +161,7 @@ private sendDeveloperReq() {
 		headers: [
 			HOST: host
 		],
-		body: [devicetype: "$token-0"]], "${selectedHue}", [callback: "usernameHandler"]))
+		body: [devicetype: "$token-0", username: "$token-0"]], "${selectedHue}"))
 }
 
 private discoverHueBulbs() {
@@ -187,17 +171,16 @@ private discoverHueBulbs() {
 		path: "/api/${state.username}/lights",
 		headers: [
 			HOST: host
-		]], "${selectedHue}", [callback: "lightsHandler"]))
+		]], "${selectedHue}"))
 }
 
 private verifyHueBridge(String deviceNetworkId, String host) {
-	log.trace "Verify Hue Bridge $deviceNetworkId"
 	sendHubCommand(new physicalgraph.device.HubAction([
 		method: "GET",
 		path: "/description.xml",
 		headers: [
 			HOST: host
-		]], deviceNetworkId, [callback: "bridgeDescriptionHandler"]))
+		]], deviceNetworkId))
 }
 
 private verifyHueBridges() {
@@ -305,53 +288,17 @@ def bulbListHandler(hub, data = "") {
         def object = new groovy.json.JsonSlurper().parseText(data)
         object.each { k,v ->
             if (v instanceof Map)
-                bulbs[k] = [id: k, name: v.name, type: v.type, modelid: v.modelid, hub:hub]
+                bulbs[k] = [id: k, name: v.name, type: v.type, hub:hub]
         }
     }
     def bridge = null
-	if (selectedHue) {
-		bridge = getChildDevice(selectedHue)
-	}
+	if (selectedHue)
+        bridge = getChildDevice(selectedHue)
     bridge.sendEvent(name: "bulbList", value: hub, data: bulbs, isStateChange: true, displayed: false)
     msg = "${bulbs.size()} bulbs found. ${bulbs}"
 	return msg
 }
 
-private upgradeDeviceType(device, newHueType) {
-	def deviceType = getDeviceType(newHueType)
-
-	// Automatically change users Hue bulbs to correct device types
-	if (deviceType && !(device?.typeName?.equalsIgnoreCase(deviceType))) {
-		log.debug "Update device type: \"$device.label\" ${device?.typeName}->$deviceType"
-		device.setDeviceType(deviceType)
-	}
-}
-
-private getDeviceType(hueType) {
-	// Determine ST device type based on Hue classification of light
-	if (hueType?.equalsIgnoreCase("Dimmable light"))
-		return "Hue Lux Bulb"
-	else if (hueType?.equalsIgnoreCase("Extended Color Light"))
-		return "Hue Bulb"
-	else if (hueType?.equalsIgnoreCase("Color Light"))
-		return "Hue Bloom"
-	else if (hueType?.equalsIgnoreCase("Color Temperature Light"))
-		return "Hue White Ambiance Bulb"
-	else
-		return null
-}
-
-private addChildBulb(dni, hueType, name, hub, update=false, device = null) {
-	def deviceType = getDeviceType(hueType)
-
-	if (deviceType) {
-		return addChildDevice("smartthings", deviceType, dni, hub, ["label": name])
-	} else {
-		log.warn "Device type $hueType not supported"
-		return null
-	}
-}
-
 def addBulbs() {
 	def bulbs = getHueBulbs()
 	selectedBulbs?.each { dni ->
@@ -360,30 +307,30 @@ def addBulbs() {
 			def newHueBulb
 			if (bulbs instanceof java.util.Map) {
 				newHueBulb = bulbs.find { (app.id + "/" + it.value.id) == dni }
-
-				if (newHueBulb != null) {
-					d = addChildBulb(dni, newHueBulb?.value?.type, newHueBulb?.value?.name, newHueBulb?.value?.hub)
-					if (d) {
-						log.debug "created ${d.displayName} with id $dni"
-						d.completedSetup = true
-						d.refresh()
-					}
-				} else {
-					log.debug "$dni in not longer paired to the Hue Bridge or ID changed"
-				}
+                if (newHueBulb != null) {
+                    if (newHueBulb?.value?.type?.equalsIgnoreCase("Dimmable light") ) {
+                        d = addChildDevice("smartthings", "Hue Lux Bulb", dni, newHueBulb?.value.hub, ["label":newHueBulb?.value.name])
+                    } else {
+                        d = addChildDevice("smartthings", "Hue Bulb", dni, newHueBulb?.value.hub, ["label":newHueBulb?.value.name])
+                    }
+                    log.debug "created ${d.displayName} with id $dni"
+                    d.refresh()
+                } else {
+                	log.debug "$dni in not longer paired to the Hue Bridge or ID changed"
+                }
 			} else {
-			 	//backwards compatable
+            	//backwards compatable
 				newHueBulb = bulbs.find { (app.id + "/" + it.id) == dni }
-				d = addChildBulb(dni, "Extended Color Light", newHueBulb?.value?.name, newHueBulb?.value?.hub)
-				d?.completedSetup = true
-				d?.refresh()
+				d = addChildDevice("smartthings", "Hue Bulb", dni, newHueBulb?.hub, ["label":newHueBulb?.name])
+                d.refresh()
 			}
 		} else {
 			log.debug "found ${d.displayName} with id $dni already exists, type: '$d.typeName'"
 			if (bulbs instanceof java.util.Map) {
-				// Update device type if incorrect
-				def newHueBulb = bulbs.find { (app.id + "/" + it.value.id) == dni }
-				upgradeDeviceType(d, newHueBulb?.value?.type)
+            	def newHueBulb = bulbs.find { (app.id + "/" + it.value.id) == dni }
+				if (newHueBulb?.value?.type?.equalsIgnoreCase("Dimmable light") && d.typeName == "Hue Bulb") {
+					d.setDeviceType("Hue Lux Bulb")
+				}
 			}
 		}
 	}
@@ -405,16 +352,14 @@ def addBridge() {
                     	def oldDNI = it.deviceNetworkId
                         log.debug "updating dni for device ${it} with $newDNI - previous DNI = ${it.deviceNetworkId}"
                         it.setDeviceNetworkId("${newDNI}")
-						if (oldDNI == selectedHue) {
-							app.updateSetting("selectedHue", newDNI)
-						}
+                        if (oldDNI == selectedHue)
+                        	app.updateSetting("selectedHue", newDNI)
                         newbridge = false
                     }
                 }
             }
         	if (newbridge) {
 				d = addChildDevice("smartthings", "Hue Bridge", selectedHue, vbridge.value.hub)
-				d?.completedSetup = true
  				log.debug "created ${d.displayName} with id ${d.deviceNetworkId}"
                 def childDevice = getChildDevice(d.deviceNetworkId)
                 childDevice.sendEvent(name: "serialNumber", value: vbridge.value.serialNumber)
@@ -437,125 +382,6 @@ def addBridge() {
 	}
 }
 
-def ssdpBridgeHandler(evt) {
-	def description = evt.description
-	log.trace "Location: $description"
-
-	def hub = evt?.hubId
-	def parsedEvent = parseLanMessage(description)
-	parsedEvent << ["hub":hub]
-
-	def bridges = getHueBridges()
-	log.trace bridges.toString()
-	if (!(bridges."${parsedEvent.ssdpUSN.toString()}")) {
-		//bridge does not exist
-		log.trace "Adding bridge ${parsedEvent.ssdpUSN}"
-		bridges << ["${parsedEvent.ssdpUSN.toString()}":parsedEvent]
-	} else {
-		// update the values
-		def ip = convertHexToIP(parsedEvent.networkAddress)
-		def port = convertHexToInt(parsedEvent.deviceAddress)
-		def host = ip + ":" + port
-		log.debug "Device ($parsedEvent.mac) was already found in state with ip = $host."
-		def dstate = bridges."${parsedEvent.ssdpUSN.toString()}"
-		def dni = "${parsedEvent.mac}"
-		def d = getChildDevice(dni)
-		def networkAddress = null
-		if (!d) {
-			childDevices.each {
-				if (it.getDeviceDataByName("mac")) {
-					def newDNI = "${it.getDeviceDataByName("mac")}"
-					if (newDNI != it.deviceNetworkId) {
-						def oldDNI = it.deviceNetworkId
-						log.debug "updating dni for device ${it} with $newDNI - previous DNI = ${it.deviceNetworkId}"
-						it.setDeviceNetworkId("${newDNI}")
-						if (oldDNI == selectedHue) {
-							app.updateSetting("selectedHue", newDNI)
-						}
-						doDeviceSync()
-					}
-				}
-			}
-		} else {
-			if (d.getDeviceDataByName("networkAddress")) {
-				networkAddress = d.getDeviceDataByName("networkAddress")
-			} else {
-				networkAddress = d.latestState('networkAddress').stringValue
-			}
-			log.trace "Host: $host - $networkAddress"
-			if (host != networkAddress) {
-				log.debug "Device's port or ip changed for device $d..."
-				dstate.ip = ip
-				dstate.port = port
-				dstate.name = "Philips hue ($ip)"
-				d.sendEvent(name:"networkAddress", value: host)
-				d.updateDataValue("networkAddress", host)
-			}
-		}
-	}
-}
-
-void bridgeDescriptionHandler(physicalgraph.device.HubResponse hubResponse) {
-	log.trace "description.xml response (application/xml)"
-	def body = hubResponse.xml
-	if (body?.device?.modelName?.text().startsWith("Philips hue bridge")) {
-		def bridges = getHueBridges()
-		def bridge = bridges.find {it?.key?.contains(body?.device?.UDN?.text())}
-		if (bridge) {
-			// serialNumber from API is in format of 0017882413ad (mac address), however on the actual bridge only last six
-			// characters are printed on the back so using that to identify bridge
-			def idNumber = body?.device?.serialNumber?.text()
-			if (idNumber?.size() >= 6)
-				idNumber = idNumber[-6..-1].toUpperCase()
-
-			// usually in form of bridge name followed by (ip), i.e. defaults to Philips Hue (192.168.1.2)
-			// replace IP with serial number to make it easier for user to identify
-			def name = body?.device?.friendlyName?.text()
-			def index = name?.indexOf('(')
-			if (index != -1) {
-				name = name.substring(0,index)
-				name += " ($idNumber)"
-			}
-			bridge.value << [name:name, serialNumber:body?.device?.serialNumber?.text(), verified: true]
-		} else {
-			log.error "/description.xml returned a bridge that didn't exist"
-		}
-	}
-}
-
-void lightsHandler(physicalgraph.device.HubResponse hubResponse) {
-	if (isValidSource(hubResponse.mac)) {
-		def body = hubResponse.json
-		if (!body?.state?.on) { //check if first time poll made it here by mistake
-			def bulbs = getHueBulbs()
-			log.debug "Adding bulbs to state!"
-			body.each { k, v ->
-				bulbs[k] = [id: k, name: v.name, type: v.type, modelid: v.modelid, hub: hubResponse.hubId]
-			}
-		}
-	}
-}
-
-void usernameHandler(physicalgraph.device.HubResponse hubResponse) {
-	if (isValidSource(hubResponse.mac)) {
-		def body = hubResponse.json
-		if (body.success != null) {
-			if (body.success[0] != null) {
-				if (body.success[0].username)
-					state.username = body.success[0].username
-			}
-		} else if (body.error != null) {
-			//TODO: handle retries...
-			log.error "ERROR: application/json ${body.error}"
-		}
-	}
-}
-
-/**
- * @deprecated This has been replaced by the combination of {@link #ssdpBridgeHandler()}, {@link #bridgeDescriptionHandler()},
- * {@link #lightsHandler()}, and {@link #usernameHandler()}. After a pending event subscription migration, it can be removed.
- */
-@Deprecated
 def locationHandler(evt) {
 	def description = evt.description
     log.trace "Location: $description"
@@ -591,19 +417,17 @@ def locationHandler(evt) {
                             def oldDNI = it.deviceNetworkId
                             log.debug "updating dni for device ${it} with $newDNI - previous DNI = ${it.deviceNetworkId}"
                             it.setDeviceNetworkId("${newDNI}")
-							if (oldDNI == selectedHue) {
-								app.updateSetting("selectedHue", newDNI)
-							}
+                            if (oldDNI == selectedHue)
+                                app.updateSetting("selectedHue", newDNI)
                             doDeviceSync()
                         }
                     }
                 }
 			} else {
-				if (d.getDeviceDataByName("networkAddress")) {
-					networkAddress = d.getDeviceDataByName("networkAddress")
-				} else {
-					networkAddress = d.latestState('networkAddress').stringValue
-				}
+            	if (d.getDeviceDataByName("networkAddress"))
+                	networkAddress = d.getDeviceDataByName("networkAddress")
+            	else
+                	networkAddress = d.latestState('networkAddress').stringValue
                 log.trace "Host: $host - $networkAddress"
                 if(host != networkAddress) {
                     log.debug "Device's port or ip changed for device $d..."
@@ -636,9 +460,8 @@ def locationHandler(evt) {
 			def body = new groovy.json.JsonSlurper().parseText(parsedEvent.body)
 			if (body.success != null) {
 				if (body.success[0] != null) {
-					if (body.success[0].username) {
+					if (body.success[0].username)
 						state.username = body.success[0].username
-					}
 				}
 			} else if (body.error != null) {
 				//TODO: handle retries...
@@ -649,7 +472,7 @@ def locationHandler(evt) {
 					def bulbs = getHueBulbs()
 					log.debug "Adding bulbs to state!"
 					body.each { k,v ->
-						bulbs[k] = [id: k, name: v.name, type: v.type, modelid: v.modelid, hub:parsedEvent.hub]
+						bulbs[k] = [id: k, name: v.name, type: v.type, hub:parsedEvent.hub]
 					}
 				}
 			}
@@ -663,7 +486,11 @@ def doDeviceSync(){
 	log.trace "Doing Hue Device Sync!"
 	convertBulbListToMap()
 	poll()
-	ssdpSubscribe()
+    try {
+		subscribe(location, null, locationHandler, [filterEvents:false])
+    } catch (all) {
+    	log.trace "Subscription already exist"
+ 	}
 	discoverBridges()
 }
 
@@ -689,7 +516,7 @@ def parse(childDevice, description) {
             	log.warn "Parsing Body failed - trying again..."
                 poll()
             }
-            if (body instanceof java.util.Map) {
+            if (body instanceof java.util.HashMap) {
             	//poll response
                 def bulbs = getChildDevices()
                 for (bulb in body) {
@@ -775,20 +602,6 @@ def parse(childDevice, description) {
 	}
 }
 
-def hubVerification(bodytext) {
-	log.trace "Bridge sent back description.xml for verification"
-    def body = new XmlSlurper().parseText(bodytext)
-    if (body?.device?.modelName?.text().startsWith("Philips hue bridge")) {
-        def bridges = getHueBridges()
-        def bridge = bridges.find {it?.key?.contains(body?.device?.UDN?.text())}
-        if (bridge) {
-            bridge.value << [name:body?.device?.friendlyName?.text(), serialNumber:body?.device?.serialNumber?.text(), verified: true]
-        } else {
-            log.error "/description.xml returned a bridge that didn't exist"
-        }
-    }
-}
-
 def on(childDevice) {
 	log.debug "Executing 'on'"
 	put("lights/${getId(childDevice)}/state", [on: true])
@@ -829,53 +642,35 @@ def setColorTemperature(childDevice, huesettings) {
 }
 
 def setColor(childDevice, huesettings) {
-    log.debug "Executing 'setColor($huesettings)'"
+	log.debug "Executing 'setColor($huesettings)'"
+	def hue = Math.min(Math.round(huesettings.hue * 65535 / 100), 65535)
+	def sat = Math.min(Math.round(huesettings.saturation * 255 / 100), 255)
+    def alert = huesettings.alert ? huesettings.alert : "none"
+    def transition = huesettings.transition ? huesettings.transition : 4
 
-    def value = [:]
-    def hue = null
-    def sat = null
-    def xy = null
+	def value = [sat: sat, hue: hue, alert: alert, transitiontime: transition]
+	if (huesettings.level != null) {
+        if (huesettings.level == 1) value.bri = 1 else value.bri = Math.min(Math.round(huesettings.level * 255 / 100), 255)
+		value.on = value.bri > 0
+	}
 
-    if (huesettings.hex != null) {
-        value.xy = getHextoXY(huesettings.hex)
-    } else {
-        if (huesettings.hue != null)
-            value.hue = Math.min(Math.round(huesettings.hue * 65535 / 100), 65535)
-        if (huesettings.saturation != null)
-            value.sat = Math.min(Math.round(huesettings.saturation * 255 / 100), 255)
-    }
+	if (huesettings.switch) {
+		value.on = huesettings.switch == "on"
+	}
 
-    // Default behavior is to turn light on
-    value.on = true
-
-    if (huesettings.level != null) {
-        if (huesettings.level <= 0)
-            value.on = false
-        else if (huesettings.level == 1)
-            value.bri = 1
-        else
-            value.bri = Math.min(Math.round(huesettings.level * 255 / 100), 255)
-    }
-    value.alert = huesettings.alert ? huesettings.alert : "none"
-    value.transitiontime = huesettings.transitiontime ? huesettings.transitiontime : 4
-
-    // Make sure to turn off light if requested
-    if (huesettings.switch == "off")
-        value.on = false
-
-    log.debug "sending command $value"
-    put("lights/${getId(childDevice)}/state", value)
-    return "Color set to $value"
+	log.debug "sending command $value"
+	put("lights/${getId(childDevice)}/state", value)
 }
 
 def nextLevel(childDevice) {
-    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(childDevice,level)
+	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(childDevice,level)
 }
 
 private getId(childDevice) {
@@ -890,11 +685,15 @@ private getId(childDevice) {
 private poll() {
 	def host = getBridgeIP()
 	def uri = "/api/${state.username}/lights/"
-	log.debug "GET: $host$uri"
-	sendHubCommand(new physicalgraph.device.HubAction("""GET ${uri} HTTP/1.1
+    try {
+		sendHubCommand(new physicalgraph.device.HubAction("""GET ${uri} HTTP/1.1
 HOST: ${host}
 
 """, physicalgraph.device.Protocol.LAN, selectedHue))
+	} catch (all) {
+        log.warn "Parsing Body failed - trying again..."
+        doDeviceSync()
+    }
 }
 
 private put(path, body) {
@@ -944,57 +743,6 @@ private getBridgeIP() {
     return host
 }
 
-private getHextoXY(String colorStr) {
-    // For the hue bulb the corners of the triangle are:
-    // -Red: 0.675, 0.322
-    // -Green: 0.4091, 0.518
-    // -Blue: 0.167, 0.04
-
-    def cred = Integer.valueOf( colorStr.substring( 1, 3 ), 16 )
-    def cgreen = Integer.valueOf( colorStr.substring( 3, 5 ), 16 )
-    def cblue = Integer.valueOf( colorStr.substring( 5, 7 ), 16 )
-
-    double[] normalizedToOne = new double[3];
-    normalizedToOne[0] = (cred / 255);
-    normalizedToOne[1] = (cgreen / 255);
-    normalizedToOne[2] = (cblue / 255);
-    float red, green, blue;
-
-    // Make red more vivid
-    if (normalizedToOne[0] > 0.04045) {
-        red = (float) Math.pow(
-                (normalizedToOne[0] + 0.055) / (1.0 + 0.055), 2.4);
-    } else {
-        red = (float) (normalizedToOne[0] / 12.92);
-    }
-
-    // Make green more vivid
-    if (normalizedToOne[1] > 0.04045) {
-        green = (float) Math.pow((normalizedToOne[1] + 0.055) / (1.0 + 0.055), 2.4);
-    } else {
-        green = (float) (normalizedToOne[1] / 12.92);
-    }
-
-    // Make blue more vivid
-    if (normalizedToOne[2] > 0.04045) {
-        blue = (float) Math.pow((normalizedToOne[2] + 0.055) / (1.0 + 0.055), 2.4);
-    } else {
-        blue = (float) (normalizedToOne[2] / 12.92);
-    }
-
-    float X = (float) (red * 0.649926 + green * 0.103455 + blue * 0.197109);
-    float Y = (float) (red * 0.234327 + green * 0.743075 + blue * 0.022598);
-    float Z = (float) (red * 0.0000000 + green * 0.053077 + blue * 1.035763);
-
-    float x = (X != 0 ? X / (X + Y + Z) : 0);
-    float y = (Y != 0 ? Y / (X + Y + Z) : 0);
-
-    double[] xy = new double[2];
-    xy[0] = x;
-    xy[1] = y;
-    return xy;
-}
-
 private Integer convertHexToInt(hex) {
 	Integer.parseInt(hex,16)
 }
@@ -1004,7 +752,7 @@ def convertBulbListToMap() {
 		if (state.bulbs instanceof java.util.List) {
 			def map = [:]
 			state.bulbs.unique {it.id}.each { bulb ->
-				map << ["${bulb.id}":["id":bulb.id, "name":bulb.name, "type": bulb.type, "modelid": bulb.modelid, "hub":bulb.hub]]
+				map << ["${bulb.id}":["id":bulb.id, "name":bulb.name, "hub":bulb.hub]]
 			}
 			state.bulbs = map
 		}

smartapps/smartthings/ifttt.src/ifttt.groovy

@@ -131,69 +131,19 @@ def update() {
 	def type = params.deviceType
 	def data = request.JSON
 	def devices = settings[type]
-	def device = settings[type]?.find { it.id == params.id }
 	def command = data.command
 
 	log.debug "[PROD] update, params: ${params}, request: ${data}, devices: ${devices*.id}"
-	
-	if (!device) {
-		httpError(404, "Device not found")
-	} 
-	
-	if (validateCommand(device, type, command)) {
-		device."$command"()
-	} else {
-		httpError(403, "Access denied. This command is not supported by current capability.")
+	if (command) {
+		def device = devices?.find { it.id == params.id }
+		if (!device) {
+			httpError(404, "Device not found")
+		} else {
+			device."$command"()
+		}
 	}
 }
 
-/**
- * Validating the command passed by the user based on capability.
- * @return boolean
- */
-def validateCommand(device, deviceType, command) {
-	def capabilityCommands = getDeviceCapabilityCommands(device.capabilities)
-	def currentDeviceCapability = getCapabilityName(deviceType)
-	if (capabilityCommands[currentDeviceCapability]) {
-		return command in capabilityCommands[currentDeviceCapability] ? true : false
-	} else {
-		// Handling other device types here, which don't accept commands
-		httpError(400, "Bad request.")
-	}
-}
-
-/**
- * Need to get the attribute name to do the lookup. Only
- * doing it for the device types which accept commands
- * @return attribute name of the device type
- */
-def getCapabilityName(type) {
-    switch(type) {
-		case "switches":
-			return "Switch"
-		case "alarms":
-			return "Alarm"
-		case "locks":
-			return "Lock"
-		default:
-			return type
-	}
-}
-
-/**
- * Constructing the map over here of
- * supported commands by device capability
- * @return a map of device capability -> supported commands
- */
-def getDeviceCapabilityCommands(deviceCapabilities) {
-	def map = [:]
-	deviceCapabilities.collect {
-		map[it.name] = it.commands.collect{ it.name.toString() }
-	}
-	return map
-}
-
-
 def show() {
 	def type = params.deviceType
 	def devices = settings[type]

smartapps/smartthings/its-too-cold.src/its-too-cold.groovy

@@ -73,8 +73,7 @@ def temperatureHandler(evt) {
 			// TODO: Send "Temperature back to normal" SMS, turn switch off
 		} else {
 			log.debug "Temperature dropped below $tooCold:  sending SMS to $phone1 and activating $mySwitch"
-			def tempScale = location.temperatureScale ?: "F"
-			send("${temperatureSensor1.displayName} is too cold, reporting a temperature of ${evt.value}${evt.unit?:tempScale}")
+			send("${temperatureSensor1.displayName} is too cold, reporting a temperature of ${evt.value}${evt.unit?:"F"}")
 			switch1?.on()
 		}
 	}

smartapps/smartthings/its-too-hot.src/its-too-hot.groovy

@@ -73,8 +73,7 @@ def temperatureHandler(evt) {
 			// TODO: Send "Temperature back to normal" SMS, turn switch off
 		} else {
 			log.debug "Temperature rose above $tooHot:  sending SMS to $phone1 and activating $mySwitch"
-			def tempScale = location.temperatureScale ?: "F"
-			send("${temperatureSensor1.displayName} is too hot, reporting a temperature of ${evt.value}${evt.unit?:tempScale}")
+			send("${temperatureSensor1.displayName} is too hot, reporting a temperature of ${evt.value}${evt.unit?:"F"}")
 			switch1?.on()
 		}
 	}

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

@@ -27,6 +27,7 @@ definition(
 ) {
 	appSetting "clientId"
 	appSetting "clientSecret"
+    appSetting "serverUrl"
 }
 
 preferences {
@@ -191,7 +192,7 @@ def getSmartThingsClientId() {
    return "pREqugabRetre4EstetherufrePumamExucrEHuc"
 }
 
-def getServerUrl() { getApiServerUrl() }
+def getServerUrl() { appSettings.serverUrl }
 
 def buildRedirectUrl()
 {

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

@@ -339,7 +339,7 @@ def initialize() {
 	state.aux = 0
 	if (selectedhubs || selectedactivities) {
 		addDevice()
-        runEvery5Minutes("poll")
+        runEvery5Minutes("discovery")
 	}
 }
 
@@ -394,9 +394,9 @@ def discovery() {
         }
 	} catch (java.net.SocketTimeoutException e) {
 		log.warn "Connection to the hub timed out. Please restart the hub and try again."
-    state.resethub = true
+        state.resethub = true
  	} catch (e) {
-    log.info "Logitech Harmony - Error: $e"
+		log.warn "Hostname in certificate didn't match. Please try again later."
 	}
     return null
 }
@@ -474,7 +474,7 @@ def activity(dni,mode) {
 def poll() {
 	// GET THE LIST OF ACTIVITIES
     if (state.HarmonyAccessToken) {
-    	  getActivityList()
+    	getActivityList()
         def Params = [auth: state.HarmonyAccessToken]
         def url = "https://home.myharmony.com/cloudapi/state?${toQueryString(Params)}"
         try {
@@ -520,17 +520,14 @@ def poll() {
                 return "Poll completed $map - $state.hubs"
             }
         } catch (groovyx.net.http.HttpResponseException e) {
-              if (e.statusCode == 401) { // token is expired
-                  state.remove("HarmonyAccessToken")
-                  log.warn "Harmony Access token has expired"
-              }
-        } catch (java.net.SocketTimeoutException e) {
-        	log.warn "Connection to the hub timed out. Please restart the hub and try again."
-              state.resethub = true
-        } catch (e) {
-        	log.info "Logitech Harmony - Error: $e"
-        }
-    }
+            if (e.statusCode == 401) { // token is expired
+                state.remove("HarmonyAccessToken")
+                return "Harmony Access token has expired"
+            }
+		} catch(Exception e) {
+        	log.trace e
+		}
+	}
 }
 
 
@@ -658,73 +655,29 @@ def updateDevice() {
 	def data = request.JSON
 	def command = data.command
 	def arguments = data.arguments
+
 	log.debug "updateDevice, params: ${params}, request: ${data}"
 	if (!command) {
 		render status: 400, data: '{"msg": "command is required"}'
 	} else {
 		def device = allDevices.find { it.id == params.id }
-    if (device) {
-        if (validateCommand(device, command)) {
-            if (arguments) {
-                device."$command"(*arguments)
-            } else {
-                device."$command"()
-            }
-            render status: 204, data: "{}"
-        } else {
-          render status: 403, data: '{"msg": "Access denied. This command is not supported by current capability."}'
-        }
-    } else {
-      render status: 404, data: '{"msg": "Device not found"}'
-    }
-  }
-}
-
-/**
- * Validating the command passed by the user based on capability.
- * @return boolean
- */
-def validateCommand(device, command) {
-	def capabilityCommands = getDeviceCapabilityCommands(device.capabilities)
-	def currentDeviceCapability = getCapabilityName(device)
-	if (currentDeviceCapability != "" && capabilityCommands[currentDeviceCapability]) {
-    return (command in capabilityCommands[currentDeviceCapability] || (currentDeviceCapability == "Switch" && command == "setLevel" && device.hasCommand("setLevel"))) ? true : false
-	} else {
-		// Handling other device types here, which don't accept commands
-		httpError(400, "Bad request.")
+		if (device) {
+        	if (device.hasCommand("$command")) {
+                if (arguments) {
+                    device."$command"(*arguments)
+                } else {
+                    device."$command"()
+                }
+                render status: 204, data: "{}"
+           	} else {
+				render status: 404, data: '{"msg": "Command not supported by this Device"}'
+			}
+		} else {
+			render status: 404, data: '{"msg": "Device not found"}'
+		}
 	}
 }
 
-/**
- * Need to get the attribute name to do the lookup. Only
- * doing it for the device types which accept commands
- * @return attribute name of the device type
- */
-def getCapabilityName(device) {
-    def capName = ""
-    if (switches.find{it.id == device.id})
-			capName = "Switch"
-		else if (alarms.find{it.id == device.id})
-			capName = "Alarm"
-		else if (locks.find{it.id == device.id})
-			capName = "Lock"
-    log.trace "Device: $device - Capability Name: $capName"
-		return capName
-}
-
-/**
- * Constructing the map over here of
- * supported commands by device capability
- * @return a map of device capability -> supported commands
- */
-def getDeviceCapabilityCommands(deviceCapabilities) {
-	def map = [:]
-	deviceCapabilities.collect {
-		map[it.name] = it.commands.collect{ it.name.toString() }
-	}
-	return map
-}
-
 def listSubscriptions() {
 	log.debug "listSubscriptions()"
 	app.subscriptions?.findAll { it.device?.device && it.device.id }?.collect {
@@ -823,33 +776,18 @@ def deviceHandler(evt) {
 }
 
 def sendToHarmony(evt, String callbackUrl) {
-  def callback = new URI(callbackUrl)
-  if (callback.port != -1) {
-  	def host = callback.port != -1 ? "${callback.host}:${callback.port}" : callback.host
-  	def path = callback.query ? "${callback.path}?${callback.query}".toString() : callback.path
-  	sendHubCommand(new physicalgraph.device.HubAction(
-  		method: "POST",
-  		path: path,
-  		headers: [
-  			"Host": host,
-  			"Content-Type": "application/json"
-  		],
-  		body: [evt: [deviceId: evt.deviceId, name: evt.name, value: evt.value]]
-  	))
-  } else {
-    def params = [
-      uri: callbackUrl,
-      body: [evt: [deviceId: evt.deviceId, name: evt.name, value: evt.value]]
-    ]
-    try {
-        log.debug "Sending data to Harmony Cloud: $params"
-        httpPostJson(params) { resp ->
-            log.debug "Harmony Cloud - Response: ${resp.status}"
-        }
-    } catch (e) {
-        log.error "Harmony Cloud - Something went wrong: $e"
-    }
-  }
+	def callback = new URI(callbackUrl)
+	def host = callback.port != -1 ? "${callback.host}:${callback.port}" : callback.host
+	def path = callback.query ? "${callback.path}?${callback.query}".toString() : callback.path
+	sendHubCommand(new physicalgraph.device.HubAction(
+		method: "POST",
+		path: path,
+		headers: [
+			"Host": host,
+			"Content-Type": "application/json"
+		],
+		body: [evt: [deviceId: evt.deviceId, name: evt.name, value: evt.value]]
+	))
 }
 
 def listHubs() {

smartapps/smartthings/notify-me-when.src/i18n/messages.properties

@@ -1,31 +1,31 @@
-'''Acceleration Detected'''.ko=가속이 감지되었을 때
-'''Arrival Of'''.ko=도착했을 때
-'''Both Push and SMS?'''.ko=푸시 알람과 SMS 모두 사용
-'''Button Pushed'''.ko=버튼이 눌렸을 때
-'''Contact Closes'''.ko=닫힘이 감지되었을 때
-'''Contact Opens'''.ko=열림이 감지되었을 때
-'''Departure Of'''.ko=출발할 때
+'''Acceleration Detected'''.ko=가속화 감지됨
+'''Arrival Of'''.ko=도착
+'''Both Push and SMS?'''.ko=푸시 메시지와 SMS를 모두 사용하시겠습니까?
+'''Button Pushed'''.ko=버튼이 눌렸습니다
+'''Contact Closes'''.ko=접점 닫힘
+'''Contact Opens'''.ko=접점 열림
+'''Departure Of'''.ko=출발
 '''Message Text'''.ko=문자 메시지
-'''Minutes'''.ko=메시지 전송 간격(분)
-'''Motion Here'''.ko=움직임이 감지되었을 때
-'''Phone Number (for SMS, optional)'''.ko=전화번호 (옵션)
+'''Minutes'''.ko=분
+'''Motion Here'''.ko=동작
+'''Phone Number (for SMS, optional)'''.ko=휴대전화 번호(문자 메시지 - 옵션)
 '''Receive notifications when anything happens in your home.'''.ko=집 안에 무슨 일이 일어나면 알림이 전송됩니다.
-'''Smoke Detected'''.ko=연기가 감지되었을 때
-'''Switch Turned Off'''.ko=스위치가 꺼졌을 때
-'''Switch Turned On'''.ko=스위치가 켜졌을 때
-'''Choose one or more, when...'''.ko=다음 상황 중 하나 이상 선택
+'''Smoke Detected'''.ko=연기가 감지되었습니다
+'''Switch Turned Off'''.ko=스위치 꺼짐
+'''Switch Turned On'''.ko=스위치 꺼짐
+'''Choose one or more, when...'''.ko=다음의 경우 하나 이상 선택
 '''Yes'''.ko=예
 '''No'''.ko=아니요
-'''Send this message (optional, sends standard status message if not specified)'''.ko=메시지 작성 (작성하지 않을 경우 디폴트 메시지 전송)
-'''Via a push notification and/or an SMS message'''.ko=푸시 알람 및 SMS 설정
-'''Set for specific mode(s)'''.ko=특정 상태 설정
+'''Send this message (optional, sends standard status message if not specified)'''.ko=이 메시지 전송(선택적, 지정되지 않은 경우 표준 상태 메시지를 보냅니다)
+'''Via a push notification and/or an SMS message'''.ko=푸시 알림 및/또는 문자 메시지를 통해
+'''Set for specific mode(s)'''.ko=특정 모드 설정
 '''Tap to set'''.ko=눌러서 설정
-'''Minimum time between messages (optional, defaults to every message)'''.ko=메시지 전송 간격 설정
-'''If outside the US please make sure to enter the proper country code'''.ko=미국 이외 국가에 거주한다면 국가 코드와 함께 입력하여 주세요.
-'''Water Sensor Wet'''.ko=누수가 감지되었을 때
-'''{{ triggerEvent.linkText }} has arrived at the {{ location.name }}'''.ko={{ location.name }}에 {{ triggerEvent.linkText }} 귀가
-'''{{ triggerEvent.linkText }} has arrived at {{ location.name }}'''.ko={{ location.name }}에 {{ triggerEvent.linkText }} 귀가
-'''{{ triggerEvent.linkText }} has left the {{ location.name }}'''.ko={{ location.name }}에서 {{ triggerEvent.linkText }} 외출
-'''{{ triggerEvent.linkText }} has left {{ location.name }}'''.ko={{ location.name }}에서 {{ triggerEvent.linkText }} 외출
-'''Assign a name'''.ko=이름 설정
-'''Choose Modes'''.ko=상태 선택
+'''Minimum time between messages (optional, defaults to every message)'''.ko=메시지작 간 최소 시간(선택 사항, 모든 메시지의 기본 설정)
+'''If outside the US please make sure to enter the proper country code'''.ko=미국 이외 거주자는 적절한 국가 코드를 입력했는지 확인하십시오
+'''Water Sensor Wet'''.ko=Water Sensor에서 물이 감지되었습니다
+'''{{ triggerEvent.linkText }} has arrived at the {{ location.name }}'''.ko={{ triggerEvent.linkText }}님이 {{ location.name }}에 도착했습니다
+'''{{ triggerEvent.linkText }} has arrived at {{ location.name }}'''.ko={{ triggerEvent.linkText }}님이 {{ location.name }}에 도착했습니다
+'''{{ triggerEvent.linkText }} has left the {{ location.name }}'''.ko={{ triggerEvent.linkText }}님이 {{ location.name }}을(를) 떠났습니다
+'''{{ triggerEvent.linkText }} has left {{ location.name }}'''.ko={{ triggerEvent.linkText }}님이 {{ location.name }}을(를) 떠났습니다
+'''Assign a name'''.ko=이름 배정
+'''Choose Modes'''.ko=모드 선택