MSA-950: 임희진

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.7"
+        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/duncanidahoct/aeon-hem-gen5-zwave-plus.src/aeon-hem-gen5-zwave-plus.groovy

@@ -1,442 +0,0 @@
-/*
- *  Aeon HEM Gen5(zwave plus)
- *
- *  Copyright 2016 Dillon A. Miller
- *
- *  v0.8 of Aeon HEM Gen5(zwave plus) code, released 04/15/2016 for Aeotec Model zw095-a
- *  This Gen5 device handler is not backward compatible with the Aeon V1 or V2 device. If your model number is not zw095-a, don't use it.
- *
- *  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.
- *
- *  Some code used from various SmartThings device handlers created by:
- *		Brock Haymond, Barry A. Burke, and Robert Vandervoort. Portions of the metering code came from ElasticDev.
- *
- *  Link to find the latest version of the Device Handler code:
- *		https://gist.github.com/DuncanIdahoCT/deb2bafdd28af4fce3073b9d9f4ecafa
- *
- *  General notes:
- *		You may need to change the device type to this device handler after you pair it to your hub. I'm not sure why it doesn't always automatically pair using this handler even though the fingerprint matches...
- *		Also, you need to hit the button on the back of the HEM Gen5 a couple (two-three) times to get it to flash the red light on the front rapidly to ensure it's in inclusion mode. It isn't in the right mode if it's just flashing slow.
- *		Once the red light is solid, look in your things list and find it, could be just called z-wave, then change it's name and device type using the graph api to this custom handler to make it start working.
- *		The config with default intervals will send right away after you set the HEM Gen5 to this handler, please wait a few minutes before sending the config again or changing the intervals under preferences.
- *		The purpose of the config button is just really to resend the config with monitor interval prefs, as sometimes the config isn't fully applied, See the list of config items at the bottom of this code.
- *		You may need to send the config a few times, with about 2 minutes delay between to get all the properties to take. Not sure why-but if you look in the debug log in the graph api for this device you can see if they all applied.
- *		I had to unplug and replug my device after extensive testing and repeatedly setting the config over and over. Could be it works for you the first time, or you may need to pull power and re plug too in order to get all the Pole 1/2 data to show in the app.
- *
- *	Known Issues:
- *		Issue 1:
- *			Not sure if this is the device handler or just a general SmartThings IOS App issue but sometimes when you set the preferences, it just spins in the app.
- *			If you are watching the log you can see it did set the preferences. Not sure why the app gets stuck, but just reload the app and should be fine.
- *		Issue 2:
- *			Not really a problem, more like a limitation; the clamps 1/2 data packets are sent to the ST hub based on monitor intervals for reports groups 1-3 which you can set in the device preferences.
- *			What this means is that, if you are paying attention to the tile data, you'll notice the center Total values don't quite work out to be the sum of Pole 1/2 values.
- *			This is simply because the base HEM data can be "polled" whereas the clamp 1/2 data is sent. And only sent on a schedule.
- *
- *  Change log:
- *		v0.1 - released 04/04/16:
- *			Added support for secure inclusion and command encapsulation
- *		v0.2 - released 04/05/16:
- *			Added configuration settings using some preference variables that you can control from the app
- *		v0.3 - released 04/05/16:
- *			Added clamp1 and clamp2 data display, may have to hit configure a few times (wait at least 2 minute each time) to make the top left and right boxes show data from the clamps.
- *		v0.4 - released 04/06/16:
- *			Changed the "main" tile to display a clean total kWh, although the ST app seems to make everything on the main Things list all CAPS so it's actually displayed as KWH...
- *		v0.5 - released 04/07/16:
- *			Changed the main thing list device icon to st.Lighting.light14 cause it has a leaf!.
- *		v0.6 - released 04/07/16:
- *			Added a cost per kWh preference and a cost tile that is calculated on kWh.
- *			Also added a timestamp of last reset button tap to work with above cost feature.
- *		v0.7 - released 04/08/16:
- *			Removed individual value tile polling actions and polling function.
- *			Cleaned up and well-formed code
- *		v0.8 - released 04/15/16:
- *			Slightly adjusted the size of the tiles to fit all tiles into the App screen without scrolling.
- *			Further commented and cleaned up the code in preparation for submission to SmartThings as an official device handler.
- *			Submitted for consideration by SmartThings.
- *
- *	To do:
- *		Features:
- *			Color code tiles or tile values for hi/low usage conditions.
- *			Possibly integrate a second tile set page with peak/min usage of watts and/or amps values over time.
- *			Integrate PlotWatt or other online Energy tracking API based service.
- *		Fixes:
- *			Determine why app sometimes freezes when setting preferences, I have seen this with other devices, e.g. Arrival Sensor, Jasco Wall Switches, etc...
- *
- */
-
-// metadata
-metadata {
-	definition (name: "Aeon HEM Gen5(zwave plus)", namespace: "DuncanIdahoCT", author: "Dillon A. Miller") {
-		capability "Energy Meter"
-		capability "Power Meter"
-		capability "Configuration"
-		capability "Polling"
-		capability "Refresh"
-		capability "Sensor"
-		command "reset"
-		fingerprint deviceId: "0x3101", inClusters: "0x98"
-		fingerprint inClusters: "0x5E,0x86,0x72,0x32,0x56,0x60,0x70,0x59,0x85,0x7A,0x73,0xEF,0x5A", outClusters: "0x82"
-	}
-
-	// simulator
-	simulator {
-
-		for (int i = 0; i <= 10000; i += 1000) {
-	  	status "power  ${i} W": 
-			new physicalgraph.zwave.Zwave().meterV3.meterReport(scaledMeterValue: i, precision: 3, meterType: 1, scale: 2, size: 4).incomingMessage()
-		}
-		for (int i = 0; i <= 100; i += 10) {
-			status "energy  ${i} kWh":
-			new physicalgraph.zwave.Zwave().meterV3.meterReport(scaledMeterValue: i, precision: 3, meterType: 1, scale: 0, size: 4).incomingMessage()
-		}
-	}
-
-	// tile definitions
-	tiles (scale: 2) {
-		// This tile is not displayed on the tile screen for this device but rather in the Things list.
-		valueTile("list-energy", "device.energy") {
-			state "default", label:'${currentValue} kWh', icon: "st.Lighting.light14"
-		}
-		// Tiles with a digit below relate to Clamp 1 and Clamp 2. Tiles with no digit are totals for clamps or volts.
-		valueTile("current1", "device.current1", decoration: "flat", width: 2, height: 2) {
-			state "default", label:'Pole 1\n${currentValue}\nAmps'
-		}
-		valueTile("current", "device.current", decoration: "flat", width: 2, height: 2) {
-			state "default", label:'Total\n${currentValue}\nAmps'
-		}
-		valueTile("current2", "device.current2", decoration: "flat", width: 2, height: 2) {
-			state "default", label:'Pole 2\n${currentValue}\nAmps'
-		}
-		valueTile("power1", "device.power1", decoration: "flat", width: 2, height: 2) {
-			state "default", label:'Pole 1\n${currentValue}\nWatts'
-		}
-		valueTile("power", "device.power", decoration: "flat", width: 2, height: 2) {
-			state "default", label:'Total\n${currentValue}\nWatts'
-		}
-		valueTile("power2", "device.power2", decoration: "flat", width: 2, height: 2) {
-			state "default", label:'Pole 2\n${currentValue}\nWatts'
-		}
-		valueTile("voltage", "device.voltage", decoration: "flat", width: 2, height: 1) {
-			state "default", label:'${currentValue} V'
-		}
-		valueTile("energy", "device.energy", decoration: "flat", width: 2, height: 1) {
-			state "default", label:'${currentValue} kWh'
-		}
-		valueTile("cost", "device.cost", decoration: "flat", width: 2, height: 1) {
-			state "default", label:'\$${currentValue}'
-		}
-		valueTile("lastresetlabel", "device.lastresettime", decoration: "flat", width: 3, height: 1) {
-			state "default", label:'Last Reset Timestamp'
-		}
-		valueTile("lastresettime", "device.lastresettime", decoration: "flat", width: 3, height: 1) {
-			state "default", label:'${currentValue}'
-		}
-		standardTile("configure", "device.power", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "configure", label:'', action:"configuration.configure", icon:"st.secondary.configure"
-		}
-		standardTile("reset", "device.energy", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:'reset kWh', action:"reset"
-		}
-		standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-		main "list-energy"
-		details(["current1","current","current2","power1","power","power2","voltage","energy","cost","lastresetlabel","lastresettime","configure","reset","refresh"])
-	}
-
-	preferences {
-		
-		input "kWhCost", "string",
-			title: "Cost in \$/kWh",
-			description: "Your Electric Bill Cost Per kWh",
-			defaultValue: "0.19514" as String,
-			required: false,
-			displayDuringSetup: true
-		input "monitorInterval1", "integer",
-			title: "Volts & kWh Report",
-			description: "Interval (secs) for Volts & kWh Report",
-			defaultValue: 60,
-			range: "1..4294967295?",
-			required: false,
-			displayDuringSetup: true
-		input "monitorInterval2", "integer",
-			title: "Amps Report",
-			description: "Interval (secs) for Amps Report",
-			defaultValue: 30,
-			range: "1..4294967295?",
-			required: false,
-			displayDuringSetup: true
-		input "monitorInterval3", "integer",
-			title: "Watts Report",
-			description: "Interval (secs) for Watts Report",
-			defaultValue: 6,
-			range: "1..4294967295?",
-			required: false,
-			displayDuringSetup: true
-	}
-
-}
-
-def updated(){
-	if (state.sec && !isConfigured()) {
-		// in case we miss the SCSR
-		response(configure())
-	}
-}
-
-def parse(String description){
-	def result = null
-	if (description.startsWith("Err 106")) {
-		state.sec = 0
-		result = createEvent( name: "secureInclusion", value: "failed", isStateChange: true,
-			descriptionText: "This sensor failed to complete the network security key exchange. If you are unable to control it via SmartThings, you must remove it from your network and add it again.")
-	} else if (description != "updated") {
-		def cmd = zwave.parse(description, [0x32: 3, 0x56: 1, 0x59: 1, 0x5A: 1, 0x60: 3, 0x70: 1, 0x72: 2, 0x73: 1, 0x82: 1, 0x85: 2, 0x86: 2, 0x8E: 2, 0xEF: 1])
-		if (cmd) {
-			result = zwaveEvent(cmd)
-		}
-	}
-//log.debug "Parsed '${description}' to ${result.inspect()}"
-	return result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
-	def encapsulatedCommand = cmd.encapsulatedCommand([0x32: 3, 0x56: 1, 0x59: 1, 0x5A: 1, 0x60: 3, 0x70: 1, 0x72: 2, 0x73: 1, 0x82: 1, 0x85: 2, 0x86: 2, 0x8E: 2, 0xEF: 1])
-	state.sec = 1
-//log.debug "encapsulated: ${encapsulatedCommand}"
-	if (encapsulatedCommand) {
-		zwaveEvent(encapsulatedCommand)
-	} else {
-		log.warn "Unable to extract encapsulated cmd from $cmd"
-		createEvent(descriptionText: cmd.toString())
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityCommandsSupportedReport cmd) {
-	response(configure())
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.configurationv1.ConfigurationReport cmd) {
-    log.debug "---CONFIGURATION REPORT V1--- ${device.displayName} parameter ${cmd.parameterNumber} with a byte size of ${cmd.size} is set to ${cmd.configurationValue}"
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.associationv2.AssociationReport cmd) {
-    log.debug "---ASSOCIATION REPORT V2--- ${device.displayName} groupingIdentifier: ${cmd.groupingIdentifier}, maxNodesSupported: ${cmd.maxNodesSupported}, nodeId: ${cmd.nodeId}, reportsToFollow: ${cmd.reportsToFollow}"
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.meterv3.MeterReport cmd) {
-    def meterTypes = ["Unknown", "Electric", "Gas", "Water"]
-    def electricNames = ["energy", "energy", "power", "count",  "voltage", "current", "powerFactor",  "unknown"]
-    def electricUnits = ["kWh",    "kVAh",   "W",     "pulses", "V",       "A",       "Power Factor", ""]
-
-    //NOTE ScaledPreviousMeterValue does not always contain a value
-    def previousValue = cmd.scaledPreviousMeterValue ?: 0
-
-    //Here is where all HEM polled values are defined. Scale(0-7) is in reference to the Aeon Labs HEM Gen5 data for kWh, kVAh, W, V, A, and M.S.T. respectively.
-    //If scale 7 (M.S.T.) is polled, you would receive Scale2(0-1) which is kVar, and kVarh respectively. We are ignoring the Scale2 ranges in this device handler.
-    def map = [ name: electricNames[cmd.scale], unit: electricUnits[cmd.scale], displayed: state.display]
-    switch(cmd.scale) {
-        case 0: //kWh
-						previousValue = device.currentValue("energy") ?: cmd.scaledPreviousMeterValue ?: 0
-						BigDecimal costDecimal = cmd.scaledMeterValue * (kWhCost as BigDecimal)
-						def costDisplay = String.format("%5.2f",costDecimal)
-						sendEvent(name: "cost", value: costDisplay, unit: "", descriptionText: "Display Cost: \$${costDisp}")
-						map.value = cmd.scaledMeterValue
-            break;
-        case 1: //kVAh (not used in the U.S.)
-            map.value = cmd.scaledMeterValue
-            break;
-        case 2: //Watts
-            previousValue = device.currentValue("power") ?: cmd.scaledPreviousMeterValue ?: 0
-            map.value = Math.round(cmd.scaledMeterValue)
-            break;
-        case 3: //pulses
-						map.value = Math.round(cmd.scaledMeterValue)
-            break;
-        case 4: //Volts
-            previousValue = device.currentValue("voltage") ?: cmd.scaledPreviousMeterValue ?: 0
-            map.value = cmd.scaledMeterValue
-            break;
-        case 5: //Amps
-            previousValue = device.currentValue("current") ?: cmd.scaledPreviousMeterValue ?: 0
-            map.value = cmd.scaledMeterValue
-            break;
-        case 6: //Power Factor
-        case 7: //Scale2 values (not currently implimented or needed)
-            map.value = cmd.scaledMeterValue
-            break;
-        default:
-            break;
-    }
-createEvent(map)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.multichannelv3.MultiChannelCmdEncap cmd) {
-	//This is where the HEM clamp1 and clamp2 (subdevice) report values are defined. Scale(2,5) is in reference to the Aeon Labs HEM Gen5 (subdevice) data for W, and A respectively.
-	//Z-Wave Command Class 0x60 (multichannelv3) is necessary to interpret the subdevice data from the HEM clamps.
-	//In addition, "cmd.commandClass == 50" and "encapsulatedCommand([0x30: 1, 0x31: 1])" below is necessary to properly receive and inturpret the encasulated subdevice data sent to the SmartThings hub by the HEM.
-	//The numbered "command class" references: 50, 0x30v1, and 0x31v1 do not seem to be true Z-Wave Command Classes and any correlation is seemingly coincidental.
-	//It should also be noted that without the above, the data received will not be processed here under the 0x60 (multichannelv3) command class and you will see unhandled messages from the HEM along with references to command class 50 as well as Meter Types 33, and 161.
-	//sourceEndPoint 1, and 2 are the Clamps 1, and 2.
-	def dispValue
-	def newValue
-	def formattedValue
-	def MAX_AMPS = 220
-	def MAX_WATTS = 24000
-	if (cmd.commandClass == 50) { //50 is likely a manufacturer specific code, Z-Wave specifies this as a "Basic Window Covering" so it's not a true Z-Wave Command Class.   
-		def encapsulatedCommand = cmd.encapsulatedCommand([0x30: 1, 0x31: 1]) // The documentation on working with Z-Wave subdevices and the technical specs from Aeon Labs do not explain this adequately, but it's necessary.
-	//log.debug ("Command from endpoint ${cmd.sourceEndPoint}: ${encapsulatedCommand}")
-		if (encapsulatedCommand) {
-			if (cmd.sourceEndPoint == 1) {
-				if (encapsulatedCommand.scale == 2 ) {
-						newValue = Math.round(encapsulatedCommand.scaledMeterValue)
-	                    if (newValue > MAX_WATTS) { return }
-						formattedValue = newValue
-						dispValue = "${formattedValue}"
-						sendEvent(name: "power1", value: dispValue as String, unit: "", descriptionText: "L1 Power: ${formattedValue} Watts")
-				}
-				if (encapsulatedCommand.scale == 5 ) {
-						newValue = Math.round(encapsulatedCommand.scaledMeterValue * 100) / 100
-	                    if (newValue > MAX_AMPS) { return }
-						formattedValue = String.format("%5.2f", newValue)
-						dispValue = "${formattedValue}"
-						sendEvent(name: "current1", value: dispValue as String, unit: "", descriptionText: "L1 Current: ${formattedValue} Amps")
-				}
-			}
-			else if (cmd.sourceEndPoint == 2) {
-				if (encapsulatedCommand.scale == 2 ) {
-						newValue = Math.round(encapsulatedCommand.scaledMeterValue)
-	                    if (newValue > MAX_WATTS) { return }
-						formattedValue = newValue
-						dispValue = "${formattedValue}"
-						sendEvent(name: "power2", value: dispValue as String, unit: "", descriptionText: "L2 Power: ${formattedValue} Watts")
-				}
-				if (encapsulatedCommand.scale == 5 ) {
-						newValue = Math.round(encapsulatedCommand.scaledMeterValue * 100) / 100
-	                    if (newValue > MAX_AMPS) { return }
-						formattedValue = String.format("%5.2f", newValue)
-						dispValue = "${formattedValue}"
-						sendEvent(name: "current2", value: dispValue as String, unit: "", descriptionText: "L2 Current: ${formattedValue} Amps")
-				}
-			}
-		}
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.Command cmd) {
-	//This will log any unhandled command output to the debug window.
-	log.debug "Unhandled: $cmd"
-    createEvent(descriptionText: cmd.toString(), isStateChange: false)
-}
-
-def refresh() {
-	def request = [
-	//This is where the tile action "refresh" is defined. Refresh is very basic. It simply gets and displays the latest values from the HEM exclusive of the clamp subdevices.
-		zwave.meterV3.meterGet(scale: 0),	//kWh
-		zwave.meterV3.meterGet(scale: 2),	//Wattage
-		zwave.meterV3.meterGet(scale: 4),	//Volts
-		zwave.meterV3.meterGet(scale: 5),	//Amps
-	]
-	commands(request)
-}
-
-def reset() {
-	//This is where the tile action "reset" is defined. Reset is only meant to be used once a month on the end/beginning of your electric utility billing cycle.
-	//Tapping reset will send the meter reset command to HEM and zero out the kWh data so you can start fresh.
-	//This will also clear the cost data and reset the last reset timestamp. Finally it will poll for latest values from the HEM.
-	//This has no impact on Pole1 or Pole2 (clamp1 and clamp2 subdevice) tile data as that is sent via reports from the HEM.
-	def dateString = new Date().format("M/d/YY", location.timeZone)
-	def timeString = new Date().format("h:mm a", location.timeZone)    
-	state.lastresettime = dateString+" @ "+timeString
-	sendEvent(name: "lastresettime", value: state.lastresettime)	
-	def request = [
-		zwave.meterV3.meterReset(),
-		zwave.meterV3.meterGet(scale: 0),	//kWh
-		zwave.meterV3.meterGet(scale: 2),	//Wattage
-		zwave.meterV3.meterGet(scale: 4),	//Volts
-		zwave.meterV3.meterGet(scale: 5),	//Amps
-	]
-	commands(request)
-}
-
-def configure() {
-	//This is where the tile action "configure" is defined. Configure resends the configuration commands below (using the variables set by the preferences section above) to the HEM Gen5 device.
-	//If you're watching the debug log when you tap configure, you should see the full configuration report come back slowly over about a minute.
-	//If you don't see the full configuration report (seven messages) followed by the association report, tap configure again.
-	def monitorInt1 = 60
-		if (monitorInterval1) {
-			monitorInt1=monitorInterval1.toInteger()
-		}
-	def monitorInt2 = 30
-		if (monitorInterval2) {
-			monitorInt2=monitorInterval2.toInteger()
-		}
-	def monitorInt3 = 6
-		if (monitorInterval3) {
-			monitorInt3=monitorInterval3.toInteger()
-	}
-	log.debug "Sending configure commands - kWhCost '${kWhCost}', monitorInterval1 '${monitorInt1}', monitorInterval2 '${monitorInt2}', monitorInterval3 '${monitorInt3}'"
-	def request = [
-		// Reset switch configuration to defaults.
-	//zwave.configurationV1.configurationSet(parameterNumber: 255, size: 1, scaledConfigurationValue: 1),
-		// Disable selective reporting, so always update based on schedule below <set to 1 to reduce network traffic>.
-		zwave.configurationV1.configurationSet(parameterNumber: 3, size: 1, scaledConfigurationValue: 1),
-		// (DISABLED by first option) Don't send unless watts have changed by 50 <default>.
-		zwave.configurationV1.configurationSet(parameterNumber: 4, size: 2, scaledConfigurationValue: 10),
-		// (DISABLED by first option) Or by 10% <default>.
-		zwave.configurationV1.configurationSet(parameterNumber: 8, size: 1, scaledConfigurationValue: 5),
-
-		// Which reports need to send in Report group 1.
-		zwave.configurationV1.configurationSet(parameterNumber: 101, size: 4, scaledConfigurationValue: 6149),
-		// Which reports need to send in Report group 2.
-		zwave.configurationV1.configurationSet(parameterNumber: 102, size: 4, scaledConfigurationValue: 1572872),
-		// Which reports need to send in Report group 3.
-		zwave.configurationV1.configurationSet(parameterNumber: 103, size: 4, scaledConfigurationValue: 770),
-		// Interval to send Report group 1.
-		zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: monitorInt1),
-		// Interval to send Report group 2.
-		zwave.configurationV1.configurationSet(parameterNumber: 112, size: 4, scaledConfigurationValue: monitorInt2),
-		// Interval to send Report group 3.
-		zwave.configurationV1.configurationSet(parameterNumber: 113, size: 4, scaledConfigurationValue: monitorInt3),
-
-		// Report which configuration commands were sent to and received by the HEM Gen5 successfully.
-		zwave.configurationV1.configurationGet(parameterNumber: 3),
-		zwave.configurationV1.configurationGet(parameterNumber: 4),
-		zwave.configurationV1.configurationGet(parameterNumber: 8),
-		zwave.configurationV1.configurationGet(parameterNumber: 101),
-		zwave.configurationV1.configurationGet(parameterNumber: 102),
-		zwave.configurationV1.configurationGet(parameterNumber: 103),
-		zwave.configurationV1.configurationGet(parameterNumber: 111),
-		zwave.configurationV1.configurationGet(parameterNumber: 112),
-		zwave.configurationV1.configurationGet(parameterNumber: 113),
-		zwave.associationV2.associationGet(groupingIdentifier: 1)
-	]
-	commands(request)
-}
-
-private setConfigured() {
-	updateDataValue("configured", "true")
-}
-
-private isConfigured() {
-	getDataValue("configured") == "true"
-}
-
-private command(physicalgraph.zwave.Command cmd) {
-	if (state.sec) {
-		zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
-	} else {
-		cmd.format()
-	}
-}
-
-private commands(commands, delay=500) {
-	delayBetween(commands.collect{ command(it) }, delay)
-}

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/smartthings/arrival-sensor-ha.src/arrival-sensor-ha.groovy

@@ -11,17 +11,6 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
- 
- /*
- *  Purpose: Arrival Sensor HA DTH File
- *
- *  Filename: Arrival-Sensor-HA.src/Arrival-Sensor-HA.groovy
- *
- *  Change History:
- *  1. 20160115 TW - Update/Edit to support i18n translations
- *  2. 20160121 TW - Update to V4 battery calcs, added pref's page title translations
- */
- 
 metadata {
     definition (name: "Arrival Sensor HA", namespace: "smartthings", author: "SmartThings") {
         capability "Tone"
@@ -43,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
         }
     }
@@ -93,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))
     }
@@ -104,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)"
     }
@@ -118,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)
         }
     }
@@ -144,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)
 }
 
@@ -177,4 +158,4 @@ def checkPresenceCallback() {
     if (timeSinceLastCheckin >= theCheckInterval) {
         handlePresenceEvent(false)
     }
-}
+}

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

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

devicetypes/smartthings/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/hue-bloom.src/hue-bloom.groovy

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

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

@@ -17,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.
@@ -46,10 +43,16 @@ metadata {
 			}
 		}
 
+		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'
         }
@@ -57,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"])
 	}
 }
@@ -71,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}")
 	}
@@ -107,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) {
@@ -223,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,96 +1,97 @@
-/**
- *  Hue Lux Bulb
- *
- *  Philips Hue Type "Dimmable Light"
- *
- *  Author: SmartThings
- */
-// for the UI
-metadata {
-	// Automatically generated. Make future change here.
-	definition (name: "Hue Lux Bulb", namespace: "smartthings", author: "SmartThings") {
-		capability "Switch Level"
-		capability "Actuator"
-		capability "Switch"
-		capability "Refresh"
-		capability "Sensor"
-
-        command "refresh"
-	}
-
-	simulator {
-		// TODO: define status and reply messages here
-	}
-
-    tiles(scale: 2) {
-        multiAttributeTile(name:"rich-control", type: "lighting", canChangeIcon: true){
-            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-              attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#00A0DC", nextState:"turningOff"
-              attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#C6C7CC", nextState:"turningOn"
-              attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#00A0DC", nextState:"turningOff"
-              attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#C6C7CC", nextState:"turningOn"
-            }
-            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-              attributeState "level", action:"switch level.setLevel", range:"(0..100)"
-            }
-            tileAttribute ("device.level", key: "SECONDARY_CONTROL") {
-	            attributeState "level", label: 'Level ${currentValue}%'
-			}
-        }
-
-        controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false, range:"(0..100)") {
-            state "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(["rich-control"])
-        details(["rich-control", "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 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 refresh() {
-	log.debug "Executing 'refresh'"
-	parent.manualRefresh()
-}
+/**
+ *  Hue Lux Bulb
+ *
+ *  Author: SmartThings
+ */
+// for the UI
+metadata {
+	// Automatically generated. Make future change here.
+	definition (name: "Hue Lux Bulb", namespace: "smartthings", author: "SmartThings") {
+		capability "Switch Level"
+		capability "Actuator"
+		capability "Color Temperature"
+		capability "Switch"
+		capability "Refresh"
+		capability "Sensor"
+
+        command "refresh"
+	}
+
+	simulator {
+		// TODO: define status and reply messages here
+	}
+
+    tiles(scale: 2) {
+        multiAttributeTile(name:"rich-control", type: "lighting", canChangeIcon: true){
+            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+              attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+              attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+              attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+              attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+            }
+            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+              attributeState "level", action:"switch level.setLevel", range:"(0..100)"
+            }
+            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) {
+            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+        }
+
+        main(["switch"])
+        details(["rich-control", "colorTempSliderControl","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() {
+	parent.on(this)
+	sendEvent(name: "switch", value: "on")
+}
+
+void off() {
+	parent.off(this)
+	sendEvent(name: "switch", value: "off")
+}
+
+void setLevel(percent) {
+	log.debug "Executing 'setLevel'"
+	parent.setLevel(this, percent)
+	sendEvent(name: "level", value: percent)
+}
+
+void refresh() {
+	log.debug "Executing 'refresh'"
+	parent.manualRefresh()
+}

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

@@ -19,14 +19,13 @@
 #
 # Change History:
 #	1. 20160205 TW Initial release with informal Korean translation.
-#	2. 20160224 TW Updated with formal Korean translation.
 #==============================================================================
 # Korean (ko)
 # Device Preferences
-'''Give your device a name'''.ko=기기 이름 설정
-'''Set Device Image'''.ko=기기 이미지 설정
+'''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,28 +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.
-===============================================================================
- *  Purpose: Mobile Presence DTH File
+ *  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.
  *
- *  Filename: mobile-presence.src/mobile-presence.groovy
- *
- *  Change History:
- *  1. 20160205 TW - Update/Edit to support i18n translations
-===============================================================================
  */
- 
 metadata {
 	definition (name: "Mobile Presence", namespace: "smartthings", author: "SmartThings") {
 		capability "Presence Sensor"
@@ -53,7 +41,6 @@ def parse(String description) {
 	def isStateChange = isStateChange(device, name, value)
 
 	def results = [
-    	translatable: true,
 		name: name,
 		value: value,
 		unit: null,
@@ -85,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
 	}
 }
@@ -97,4 +84,4 @@ private getState(String value) {
 		case "not present": return "left"
 		default: return value
 	}
-}
+}

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

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

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

@@ -1,26 +1,19 @@
-/*
-===============================================================================
- *  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.
-===============================================================================
- *  Purpose: SmartPower Outlet DTH File
+ *  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.
  *
- *  Filename: SmartPower-Outlet.src/SmartPower-Outlet.groovy
+ *	SmartPower Outlet (CentraLite)
  *
- *  Change History:
- *  1. 20160117 TW - Update/Edit to support i18n translations
-===============================================================================
+ *	Author: SmartThings
+ *	Date: 2015-08-23
  */
 metadata {
 	// Automatically generated. Make future change here.
@@ -65,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'
@@ -98,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 {

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

@@ -1,44 +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.
-#==============================================================================
-# Purpose: SmartSense Moisture Sensor i18n Translation File
-#
-# Filename: SmartSense-Moisture-Sensor.src/i18n/messages.properties
-#
-# Change History:
-#	1. 20160116 TW Initial release with formal Korean translation.
-#==============================================================================
-# Korean (ko)
-# Device Preferences
-'''Dry'''.ko=건조
-'''Wet'''.ko=누수
+
+# 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,29 +1,18 @@
-/*
-===============================================================================
- *  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.
-===============================================================================
- *  Purpose: SmartSense Moisture Sensor DTH File
+ *  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.
  *
- *  Filename: SmartSense-Moisture-Sensor.src/SmartSense-Moisture-Sensor.groovy
- *
- *  Change History:
- *  1. 20160116 TW - Update/Edit to support i18n translations
- *  2. 20160125 TW = Incorporated new battery mapping from TM
-===============================================================================
  */
-
 metadata {
 	definition (name: "SmartSense Moisture Sensor",namespace: "smartthings", author: "SmartThings") {
 		capability "Configuration"
@@ -54,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
 		}
 	}
@@ -127,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) {
@@ -231,8 +220,7 @@ private Map getBatteryResult(rawValue) {
 
 	def result = [
 		name: 'battery',
-		value: '--',
-		translatable: true
+		value: '--'
 	]
 
 	def volts = rawValue / 10
@@ -240,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") {
@@ -257,7 +245,7 @@ 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 {
@@ -265,7 +253,7 @@ private Map getBatteryResult(rawValue) {
 				def maxVolts = 3.0
 				def pct = (volts - minVolts) / (maxVolts - minVolts)
 				result.value = Math.min(100, (int) pct * 100)
-				result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+				result.descriptionText = "${linkText} battery was ${result.value}%"
 			}
 		}
 	}
@@ -275,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
 	]
 }
 

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

@@ -1,43 +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.
-#==============================================================================
-# Purpose: SmartSense Motion Sensor i18n Translation File
-#
-# Filename: SmartSense-Motion-Sensor.src/i18n/messages.properties
-#
-# Change History:
-#	1. 20160116 TW Initial release with formal Korean translation.
-#	2. 20160224 TW Updated formal Korean translations from Mike Stoller.
-#==============================================================================
-# Korean (ko)
-# Device Preferences
-'''battery'''.ko=배터리
-'''Temperature Offset'''.ko=온도 직접 설정
-'''This feature allows you to correct any temperature variations by selecting an offset. Ex: If your sensor consistently reports a temp that's 5 degrees too warm, you'd enter '-5'. If 3 degrees too cold, enter '+3'.'''.ko=기준 온도를 원하는대로 몇 도 올리거나 내려서 설정할 수 있습니다.
-'''Degrees'''.ko=온도
+
+# 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,17 @@
-/*
-===============================================================================
- *  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.
-===============================================================================
- *  Purpose: SmartSense Motion Sensor DTH File
+ *  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.
  *
- *  Filename: SmartSense-Motion-Sensor.src/SmartSense-Motion-Sensor.groovy
- *
- *  Change History:
- *  1. 20160116 TW - Update/Edit to support i18n translations
- *  2. 20160125 TW = Incorporated new battery mapping from TM
-===============================================================================
  */
 
 metadata {
@@ -57,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
 		}
 	}
@@ -246,8 +236,7 @@ private Map getBatteryResult(rawValue) {
 
 	def result = [
 		name: 'battery',
-		value: '--',
-		translatable: true
+		value: '--'
 	]
 
 	def volts = rawValue / 10
@@ -255,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") {
@@ -272,8 +261,7 @@ 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 {
@@ -281,7 +269,7 @@ private Map getBatteryResult(rawValue) {
 				def maxVolts = 3.0
 				def pct = (volts - minVolts) / (maxVolts - minVolts)
 				result.value = Math.min(100, (int) pct * 100)
-				result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+				result.descriptionText = "${linkText} battery was ${result.value}%"
 			}
 		}
 	}
@@ -291,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
 	]
 }
 

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

@@ -1,50 +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.
-#==============================================================================
-# Purpose: SmartSense Multi Sensor i18n Translation File
-#
-# Filename: SmartSense-Multi-Sensor.src/i18n/messages.properties
-#
-# Change History:
-#	1. 20160117 TW Initial release with informal Korean translation.
-#==============================================================================
-# Korean (ko)
-# Device Preferences
-'''Yes'''.ko=예
+
+# 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,27 +1,17 @@
-/*
-===============================================================================
- *  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.
-===============================================================================
- *  Purpose: SmartSense Multi Sensor DTH File
+ *  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.
  *
- *  Filename: SmartSense-Multi-Sensor.src/SmartSense-Multi-Sensor.groovy
- *
- *  Change History:
- *  1. 20160117 TW - Update/Edit to support i18n translations
- *  2. 20160125 TW = Incorporated new battery mapping from TM
-===============================================================================
  */
 
 metadata {
@@ -72,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}°',
@@ -283,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)
 		}
 	}
 }
@@ -311,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
@@ -323,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") {
@@ -340,7 +330,7 @@ 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 {
@@ -348,7 +338,7 @@ private Map getBatteryResult(rawValue) {
 				def maxVolts = 3.0
 				def pct = (volts - minVolts) / (maxVolts - minVolts)
 				result.value = Math.min(100, (int) pct * 100)
-				result.descriptionText = "{{ device.displayName }} battery was {{ value }}%"
+				result.descriptionText = "${linkText} battery was ${result.value}%"
 			}
 		}
 	}
@@ -358,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
 	]
 }
 
@@ -471,15 +451,15 @@ def configure() {
 		"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 {0100}", "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 {0100}", "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 {0100}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0014 0x29 1 3600 {01}", "delay 200",
 		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
 		]
 
@@ -548,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/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,52 +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 "default", label: '${currentValue}'
-		}
-
-		controlTile("rgbSelector", "device.color", "color", height: 6, width: 6, inactiveLabel: false) {
-			state "color", action: "color control.setColor"
-		}
-
-		main("currentColor")
-		details([
-			"rgbSelector"
-		])
-	}
-}
-
-// parse events into attributes
-def parse(String description) {
-	log.debug "Parsing '${description}'"
-}
-
-def setSaturation(percent) {
-	log.debug "Executing 'setSaturation'"
-	sendEvent(name: "saturation", value: percent)
-}
-
-def setHue(percent) {
-	log.debug "Executing 'setHue'"
-	sendEvent(name: "hue", value: percent)
-}

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

@@ -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 "default", label:'${currentValue}'
-		}
-
-		controlTile("rangeSliderConstrained", "device.rangedLevel", "slider", height: 2, width: 4, range: "(40..60)") {
-			state "level", action:"setRangedLevel"
-		}
-
-		main("rangeValue")
-		details([
-			"tinySlider", "mediumSlider",
-			"largeSlider",
-			"rangeSlider", "rangeValue",
-			"rangeSliderConstrained"
-		])
-	}
-}
-
-def installed() {
-	sendEvent(name: "level", value: 63)
-	sendEvent(name: "rangedLevel", value: 47)
-}
-
-def parse(String description) {
-}
-
-def setLevel(value) {
-	log.debug "setting level to $value"
-	sendEvent(name:"level", value:value)
-}
-
-def setRangedLevel(value) {
-	log.debug "setting ranged level to $value"
-	sendEvent(name:"rangedLevel", value:value)
-}

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

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

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

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

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

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

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

@@ -1,211 +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 "default", label:"Reset Color", action:"reset", icon:"st.lights.philips.hue-single"
-		}
-		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-		}
-
-		main(["switch"])
-		details(["switch", "switchNoPower", "switchNoSlider", "switchNoSliderOrColor", "color", "refresh", "reset"])
-	}
-}
-
-// parse events into attributes
-def parse(description) {
-	log.debug "parse() - $description"
-	def results = []
-	def map = description
-	if (description instanceof String)  {
-		log.debug "Hue Bulb stringToMap - ${map}"
-		map = stringToMap(description)
-	}
-	if (map?.name && map?.value) {
-		results << createEvent(name: "${map?.name}", value: "${map?.value}")
-	}
-	results
-}
-
-// handle commands
-def on() {
-	//log.trace parent.on(this)
-	sendEvent(name: "switch", value: "on")
-}
-
-def off() {
-	//log.trace parent.off(this)
-	sendEvent(name: "switch", value: "off")
-}
-
-def nextLevel() {
-	def level = device.latestValue("level") as Integer ?: 0
-	if (level <= 100) {
-		level = Math.min(25 * (Math.round(level / 25) + 1), 100) as Integer
-	}
-	else {
-		level = 25
-	}
-	setLevel(level)
-}
-
-def setLevel(percent) {
-	log.debug "setLevel: ${percent}, this"
-	sendEvent(name: "level", value: percent)
-	def power = Math.round(percent / 1.175) * 0.1
-	sendEvent(name: "power", value: power)
-}
-
-def setSaturation(percent) {
-	log.debug "setSaturation: ${percent}, $this"
-	sendEvent(name: "saturation", value: percent)
-}
-
-def setHue(percent) {
-	log.debug "setHue: ${percent}, $this"
-	sendEvent(name: "hue", value: percent)
-}
-
-def setColor(value) {
-	log.debug "setColor: ${value}, $this"
-	if (value.hue) { sendEvent(name: "hue", value: value.hue)}
-	if (value.saturation) { sendEvent(name: "saturation", value: value.saturation)}
-	if (value.hex) { sendEvent(name: "color", value: value.hex)}
-	if (value.level) { sendEvent(name: "level", value: value.level)}
-	if (value.switch) { sendEvent(name: "switch", value: value.switch)}
-}
-
-def reset() {
-	log.debug "Executing 'reset'"
-	setAdjustedColor([level:100, hex:"#90C638", saturation:56, hue:23])
-	//parent.poll()
-}
-
-def setAdjustedColor(value) {
-	if (value) {
-		log.trace "setAdjustedColor: ${value}"
-		def adjusted = value + [:]
-		adjusted.hue = adjustOutgoingHue(value.hue)
-		// Needed because color picker always sends 100
-		adjusted.level = null
-		setColor(adjusted)
-	}
-}
-
-def refresh() {
-	log.debug "Executing 'refresh'"
-	//parent.manualRefresh()
-}
-
-def adjustOutgoingHue(percent) {
-	def adjusted = percent
-	if (percent > 31) {
-		if (percent < 63.0) {
-			adjusted = percent + (7 * (percent -30 ) / 32)
-		}
-		else if (percent < 73.0) {
-			adjusted = 69 + (5 * (percent - 62) / 10)
-		}
-		else {
-			adjusted = percent + (2 * (100 - percent) / 28)
-		}
-	}
-	log.info "percent: $percent, adjusted: $adjusted"
-	adjusted
-}
-

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

@@ -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("default", action:"music Player.previousTrack")
-			}
-			tileAttribute("device.status", key: "NEXT_TRACK") {
-				attributeState("default", action:"music Player.nextTrack")
-			}
-			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-				attributeState("level", action:"music Player.setLevel")
-			}
-			tileAttribute ("device.mute", key: "MEDIA_MUTED") {
-				attributeState("unmuted", action:"music Player.mute", nextState: "muted")
-				attributeState("muted", action:"music Player.unmute", nextState: "unmuted")
-			}
-			tileAttribute("device.trackDescription", key: "MARQUEE") {
-				attributeState("default", label:"${currentValue}")
-			}
-		}
-
-		main "mediaMulti"
-		details(["mediaMulti"])
-	}
-}
-
-def installed() {
-	state.tracks = [
-		"Gangnam Style (강남스타일)\nPSY\nPsy 6 (Six Rules), Part 1",
-		"Careless Whisper\nWham!\nMake It Big",
-		"Never Gonna Give You Up\nRick Astley\nWhenever You Need Somebody",
-		"Shake It Off\nTaylor Swift\n1989",
-		"Ironic\nAlanis Morissette\nJagged Little Pill",
-		"Hotline Bling\nDrake\nHotline Bling - Single"
-	]
-	state.currentTrack = 0
-
-	sendEvent(name: "level", value: 72)
-	sendEvent(name: "mute", value: "unmuted")
-	sendEvent(name: "status", value: "stopped")
-}
-
-def parse(description) {
-	// No parsing will happen with this simulated device.
-}
-
-def play() {
-	sendEvent(name: "status", value: "playing")
-	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
-}
-
-def pause() {
-	sendEvent(name: "status", value: "paused")
-	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
-}
-
-def stop() {
-	sendEvent(name: "status", value: "stopped")
-}
-
-def previousTrack() {
-	state.currentTrack = state.currentTrack - 1
-	if (state.currentTrack < 0)
-		state.currentTrack = state.tracks.size()-1
-
-	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
-}
-
-def nextTrack() {
-	state.currentTrack = state.currentTrack + 1
-	if (state.currentTrack == state.tracks.size())
-		state.currentTrack = 0
-
-	sendEvent(name: "trackDescription", value: state.tracks[state.currentTrack])
-}
-
-def mute() {
-	sendEvent(name: "mute", value: "muted")
-}
-
-def unmute() {
-	sendEvent(name: "mute", value: "unmuted")
-}
-
-def setLevel(level) {
-	sendEvent(name: "level", value: level)
-}

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

@@ -1,341 +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("default", label:'${currentValue}', unit:"dF")
-			}
-			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
-				attributeState("VALUE_UP", action: "tempUp")
-				attributeState("VALUE_DOWN", action: "tempDown")
-			}
-			tileAttribute("device.humidity", key: "SECONDARY_CONTROL") {
-				attributeState("default", label:'${currentValue}%', unit:"%")
-			}
-			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
-				attributeState("idle", backgroundColor:"#44b621")
-				attributeState("heating", backgroundColor:"#ffa81e")
-				attributeState("cooling", backgroundColor:"#269bd2")
-			}
-			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {
-				attributeState("off", label:'${name}')
-				attributeState("heat", label:'${name}')
-				attributeState("cool", label:'${name}')
-				attributeState("auto", label:'${name}')
-			}
-			tileAttribute("device.heatingSetpoint", key: "HEATING_SETPOINT") {
-				attributeState("default", label:'${currentValue}', unit:"dF")
-			}
-			tileAttribute("device.coolingSetpoint", key: "COOLING_SETPOINT") {
-				attributeState("default", label:'${currentValue}', unit:"dF")
-			}
-		}
-		multiAttributeTile(name:"thermostatNoHumidity", type:"thermostat", width:6, height:4) {
-			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
-				attributeState("default", label:'${currentValue}', unit:"dF")
-			}
-			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
-				attributeState("VALUE_UP", action: "tempUp")
-				attributeState("VALUE_DOWN", action: "tempDown")
-			}
-			tileAttribute("device.thermostatOperatingState", key: "OPERATING_STATE") {
-				attributeState("idle", backgroundColor:"#44b621")
-				attributeState("heating", backgroundColor:"#ffa81e")
-				attributeState("cooling", backgroundColor:"#269bd2")
-			}
-			tileAttribute("device.thermostatMode", key: "THERMOSTAT_MODE") {
-				attributeState("off", label:'${name}')
-				attributeState("heat", label:'${name}')
-				attributeState("cool", label:'${name}')
-				attributeState("auto", label:'${name}')
-			}
-			tileAttribute("device.heatingSetpoint", key: "HEATING_SETPOINT") {
-				attributeState("default", label:'${currentValue}', unit:"dF")
-			}
-			tileAttribute("device.coolingSetpoint", key: "COOLING_SETPOINT") {
-				attributeState("default", label:'${currentValue}', unit:"dF")
-			}
-		}
-		multiAttributeTile(name:"thermostatBasic", type:"thermostat", width:6, height:4) {
-			tileAttribute("device.temperature", key: "PRIMARY_CONTROL") {
-				attributeState("default", label:'${currentValue}', unit:"dF",
-				backgroundColors:[
-					[value: 31, color: "#153591"],
-					[value: 44, color: "#1e9cbb"],
-					[value: 59, color: "#90d2a7"],
-					[value: 74, color: "#44b621"],
-					[value: 84, color: "#f1d801"],
-					[value: 95, color: "#d04e00"],
-					[value: 96, color: "#bc2323"]
-				])
-			}
-			tileAttribute("device.temperature", key: "VALUE_CONTROL") {
-				attributeState("VALUE_UP", action: "tempUp")
-				attributeState("VALUE_DOWN", action: "tempDown")
-			}
-		}
-
-		valueTile("temperature", "device.temperature", width: 2, height: 2) {
-			state("temperature", label:'${currentValue}', unit:"dF",
-				backgroundColors:[
-					[value: 31, color: "#153591"],
-					[value: 44, color: "#1e9cbb"],
-					[value: 59, color: "#90d2a7"],
-					[value: 74, color: "#44b621"],
-					[value: 84, color: "#f1d801"],
-					[value: 95, color: "#d04e00"],
-					[value: 96, color: "#bc2323"]
-				]
-			)
-		}
-		standardTile("tempDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:'down', action:"tempDown"
-		}
-		standardTile("tempUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:'up', action:"tempUp"
-		}
-
-		valueTile("heatingSetpoint", "device.heatingSetpoint", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "heat", label:'${currentValue} heat', unit: "F", backgroundColor:"#ffffff"
-		}
-		standardTile("heatDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:'down', action:"heatDown"
-		}
-		standardTile("heatUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:'up', action:"heatUp"
-		}
-
-		valueTile("coolingSetpoint", "device.coolingSetpoint", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "cool", label:'${currentValue} cool', unit:"F", backgroundColor:"#ffffff"
-		}
-		standardTile("coolDown", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:'down', action:"coolDown"
-		}
-		standardTile("coolUp", "device.temperature", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "default", label:'up', action:"coolUp"
-		}
-
-		standardTile("mode", "device.thermostatMode", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "off", label:'${name}', action:"thermostat.heat", backgroundColor:"#ffffff"
-			state "heat", label:'${name}', action:"thermostat.cool", backgroundColor:"#ffa81e"
-			state "cool", label:'${name}', action:"thermostat.auto", backgroundColor:"#269bd2"
-			state "auto", label:'${name}', action:"thermostat.off", backgroundColor:"#79b821"
-		}
-		standardTile("fanMode", "device.thermostatFanMode", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
-			state "fanAuto", label:'${name}', action:"thermostat.fanOn", backgroundColor:"#ffffff"
-			state "fanOn", label:'${name}', action:"thermostat.fanCirculate", backgroundColor:"#ffffff"
-			state "fanCirculate", label:'${name}', action:"thermostat.fanAuto", backgroundColor:"#ffffff"
-		}
-		standardTile("operatingState", "device.thermostatOperatingState", width: 2, height: 2) {
-			state "idle", label:'${name}', backgroundColor:"#ffffff"
-			state "heating", label:'${name}', backgroundColor:"#ffa81e"
-			state "cooling", label:'${name}', backgroundColor:"#269bd2"
-		}
-
-
-		main("thermostatFull")
-		details([
-			"thermostatFull", "thermostatNoHumidity", "thermostatBasic",
-			"temperature","tempDown","tempUp",
-			"mode", "fanMode", "operatingState",
-			"heatingSetpoint", "heatDown", "heatUp",
-			"coolingSetpoint", "coolDown", "coolUp"
-		])
-	}
-}
-
-def installed() {
-	sendEvent(name: "temperature", value: 72, unit: "F")
-	sendEvent(name: "heatingSetpoint", value: 70, unit: "F")
-	sendEvent(name: "thermostatSetpoint", value: 70, unit: "F")
-	sendEvent(name: "coolingSetpoint", value: 76, unit: "F")
-	sendEvent(name: "thermostatMode", value: "off")
-	sendEvent(name: "thermostatFanMode", value: "fanAuto")
-	sendEvent(name: "thermostatOperatingState", value: "idle")
-	sendEvent(name: "humidity", value: 53, unit: "%")
-}
-
-def parse(String description) {
-}
-
-def evaluate(temp, heatingSetpoint, coolingSetpoint) {
-	log.debug "evaluate($temp, $heatingSetpoint, $coolingSetpoint"
-	def threshold = 1.0
-	def current = device.currentValue("thermostatOperatingState")
-	def mode = device.currentValue("thermostatMode")
-
-	def heating = false
-	def cooling = false
-	def idle = false
-	if (mode in ["heat","emergency heat","auto"]) {
-		if (heatingSetpoint - temp >= threshold) {
-			heating = true
-			sendEvent(name: "thermostatOperatingState", value: "heating")
-		}
-		else if (temp - heatingSetpoint >= threshold) {
-			idle = true
-		}
-		sendEvent(name: "thermostatSetpoint", value: heatingSetpoint)
-	}
-	if (mode in ["cool","auto"]) {
-		if (temp - coolingSetpoint >= threshold) {
-			cooling = true
-			sendEvent(name: "thermostatOperatingState", value: "cooling")
-		}
-		else if (coolingSetpoint - temp >= threshold && !heating) {
-			idle = true
-		}
-		sendEvent(name: "thermostatSetpoint", value: coolingSetpoint)
-	}
-	else {
-		sendEvent(name: "thermostatSetpoint", value: heatingSetpoint)
-	}
-
-	if (mode == "off") {
-		idle = true
-	}
-
-	if (idle && !heating && !cooling) {
-		sendEvent(name: "thermostatOperatingState", value: "idle")
-	}
-}
-
-def setHeatingSetpoint(Double degreesF) {
-	log.debug "setHeatingSetpoint($degreesF)"
-	sendEvent(name: "heatingSetpoint", value: degreesF)
-	evaluate(device.currentValue("temperature"), degreesF, device.currentValue("coolingSetpoint"))
-}
-
-def setCoolingSetpoint(Double degreesF) {
-	log.debug "setCoolingSetpoint($degreesF)"
-	sendEvent(name: "coolingSetpoint", value: degreesF)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), degreesF)
-}
-
-def setThermostatMode(String value) {
-	sendEvent(name: "thermostatMode", value: value)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def setThermostatFanMode(String value) {
-	sendEvent(name: "thermostatFanMode", value: value)
-}
-
-def off() {
-	sendEvent(name: "thermostatMode", value: "off")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def heat() {
-	sendEvent(name: "thermostatMode", value: "heat")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def auto() {
-	sendEvent(name: "thermostatMode", value: "auto")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def emergencyHeat() {
-	sendEvent(name: "thermostatMode", value: "emergency heat")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def cool() {
-	sendEvent(name: "thermostatMode", value: "cool")
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def fanOn() {
-	sendEvent(name: "thermostatFanMode", value: "fanOn")
-}
-
-def fanAuto() {
-	sendEvent(name: "thermostatFanMode", value: "fanAuto")
-}
-
-def fanCirculate() {
-	sendEvent(name: "thermostatFanMode", value: "fanCirculate")
-}
-
-def poll() {
-	null
-}
-
-def tempUp() {
-	def ts = device.currentState("temperature")
-	def value = ts ? ts.integerValue + 1 : 72
-	sendEvent(name:"temperature", value: value)
-	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def tempDown() {
-	def ts = device.currentState("temperature")
-	def value = ts ? ts.integerValue - 1 : 72
-	sendEvent(name:"temperature", value: value)
-	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def setTemperature(value) {
-	def ts = device.currentState("temperature")
-	sendEvent(name:"temperature", value: value)
-	evaluate(value, device.currentValue("heatingSetpoint"), device.currentValue("coolingSetpoint"))
-}
-
-def heatUp() {
-	def ts = device.currentState("heatingSetpoint")
-	def value = ts ? ts.integerValue + 1 : 68
-	sendEvent(name:"heatingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), value, device.currentValue("coolingSetpoint"))
-}
-
-def heatDown() {
-	def ts = device.currentState("heatingSetpoint")
-	def value = ts ? ts.integerValue - 1 : 68
-	sendEvent(name:"heatingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), value, device.currentValue("coolingSetpoint"))
-}
-
-
-def coolUp() {
-	def ts = device.currentState("coolingSetpoint")
-	def value = ts ? ts.integerValue + 1 : 76
-	sendEvent(name:"coolingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), value)
-}
-
-def coolDown() {
-	def ts = device.currentState("coolingSetpoint")
-	def value = ts ? ts.integerValue - 1 : 76
-	sendEvent(name:"coolingSetpoint", value: value)
-	evaluate(device.currentValue("temperature"), device.currentValue("heatingSetpoint"), value)
-}

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

@@ -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/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-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

@@ -53,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/zwave-door-window-sensor.src/zwave-door-window-sensor.groovy

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

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

@@ -57,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 {
@@ -94,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
 }

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!"

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/smartthings/-.src/-.groovy

@@ -0,0 +1,142 @@
+/**
+ *  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.
+ *
+ *  Virtual Thermostat
+ *
+ *  Author: SmartThings
+ */
+definition(
+    name: "임희진",
+    namespace: "smartthings",
+    author: "SmartThings",
+    description: "Control a space heater or window air conditioner in conjunction with any temperature sensor, like a SmartSense Multi.",
+    category: "Green Living",
+    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Meta/temp_thermo-switch.png",
+    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Meta/temp_thermo-switch@2x.png"
+)
+
+preferences {
+	section("Choose a temperature sensor... "){
+		input "sensor", "capability.temperatureMeasurement", title: "Sensor"
+	}
+	section("Select the heater or air conditioner outlet(s)... "){
+		input "outlets", "capability.switch", title: "Outlets", multiple: true
+	}
+	section("Set the desired temperature..."){
+		input "setpoint", "decimal", title: "Set Temp"
+	}
+	section("When there's been movement from (optional, leave blank to not require motion)..."){
+		input "motion", "capability.motionSensor", title: "Motion", required: false
+	}
+	section("Within this number of minutes..."){
+		input "minutes", "number", title: "Minutes", required: false
+	}
+	section("But never go below (or above if A/C) this value with or without motion..."){
+		input "emergencySetpoint", "decimal", title: "Emer Temp", required: false
+	}
+	section("Select 'heat' for a heater and 'cool' for an air conditioner..."){
+		input "mode", "enum", title: "Heating or cooling?", options: ["heat","cool"]
+	}
+}
+
+def installed()
+{
+	subscribe(sensor, "temperature", temperatureHandler)
+	if (motion) {
+		subscribe(motion, "motion", motionHandler)
+	}
+}
+
+def updated()
+{
+	unsubscribe()
+	subscribe(sensor, "temperature", temperatureHandler)
+	if (motion) {
+		subscribe(motion, "motion", motionHandler)
+	}
+}
+
+def temperatureHandler(evt)
+{
+	def isActive = hasBeenRecentMotion()
+	if (isActive || emergencySetpoint) {
+		evaluate(evt.doubleValue, isActive ? setpoint : emergencySetpoint)
+	}
+	else {
+		outlets.off()
+	}
+}
+
+def motionHandler(evt)
+{
+	if (evt.value == "active") {
+		def lastTemp = sensor.currentTemperature
+		if (lastTemp != null) {
+			evaluate(lastTemp, setpoint)
+		}
+	} else if (evt.value == "inactive") {
+		def isActive = hasBeenRecentMotion()
+		log.debug "INACTIVE($isActive)"
+		if (isActive || emergencySetpoint) {
+			def lastTemp = sensor.currentTemperature
+			if (lastTemp != null) {
+				evaluate(lastTemp, isActive ? setpoint : emergencySetpoint)
+			}
+		}
+		else {
+			outlets.off()
+		}
+	}
+}
+
+private evaluate(currentTemp, desiredTemp)
+{
+	log.debug "EVALUATE($currentTemp, $desiredTemp)"
+	def threshold = 1.0
+	if (mode == "cool") {
+		// air conditioner
+		if (currentTemp - desiredTemp >= threshold) {
+			outlets.on()
+		}
+		else if (desiredTemp - currentTemp >= threshold) {
+			outlets.off()
+		}
+	}
+	else {
+		// heater
+		if (desiredTemp - currentTemp >= threshold) {
+			outlets.on()
+		}
+		else if (currentTemp - desiredTemp >= threshold) {
+			outlets.off()
+		}
+	}
+}
+
+private hasBeenRecentMotion()
+{
+	def isActive = false
+	if (motion && minutes) {
+		def deltaMinutes = minutes as Long
+		if (deltaMinutes) {
+			def motionEvents = motion.eventsSince(new Date(now() - (60000 * deltaMinutes)))
+			log.trace "Found ${motionEvents?.size() ?: 0} events in the last $deltaMinutes minutes"
+			if (motionEvents.find { it.value == "active" }) {
+				isActive = true
+			}
+		}
+	}
+	else {
+		isActive = true
+	}
+	isActive
+}

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/hue-connect.src/hue-connect.groovy

@@ -24,7 +24,7 @@ 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 {
@@ -60,7 +60,7 @@ def bridgeDiscovery(params=[:])
         app.updateSetting("selectedHue", "")
     }
 
-	ssdpSubscribe()
+	subscribe(location, null, locationHandler, [filterEvents:false])
 
 	//bridge discovery request every 15 //25 seconds
 	if((bridgeRefreshCount % 5) == 0) {
@@ -68,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()
 	}
 
@@ -152,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()
@@ -165,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() {
@@ -175,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() {
@@ -293,52 +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
-		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 ->
@@ -348,7 +308,11 @@ def addBulbs() {
 			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 (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 {
@@ -357,15 +321,16 @@ def addBulbs() {
 			} else {
             	//backwards compatable
 				newHueBulb = bulbs.find { (app.id + "/" + it.id) == dni }
-				d = addChildBulb(dni, "Extended Color Light", newHueBulb?.value?.name, newHueBulb?.value?.hub)
+				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)
+				if (newHueBulb?.value?.type?.equalsIgnoreCase("Dimmable light") && d.typeName == "Hue Bulb") {
+					d.setDeviceType("Hue Lux Bulb")
+				}
 			}
 		}
 	}
@@ -387,9 +352,8 @@ 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
                     }
                 }
@@ -418,111 +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) {
-			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"
-		}
-	}
-}
-
-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"
@@ -558,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..."
@@ -603,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...
@@ -616,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]
 					}
 				}
 			}
@@ -630,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()
 }
 
@@ -742,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])
@@ -796,53 +642,35 @@ def setColorTemperature(childDevice, huesettings) {
 }
 
 def setColor(childDevice, huesettings) {
-    log.debug "Executing 'setColor($huesettings)'"
-    
-    def value = [:]
-    def hue = null
-    def sat = null
-    def xy = null
-    
-    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)
-    }
-    
-    // Default behavior is to turn light on 
-    value.on = true
+	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
 
-    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.transition = huesettings.transition ? huesettings.transition : 4
+	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
+	}
 
-    // Make sure to turn off light if requested
-    if (huesettings.switch == "off")
-        value.on = false
+	if (huesettings.switch) {
+		value.on = huesettings.switch == "on"
+	}
 
-    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) {
@@ -857,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) {
@@ -911,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)
 }
@@ -971,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/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=모드 선택

smartapps/smartthings/speaker-notify-with-sound.src/speaker-notify-with-sound.groovy

@@ -76,7 +76,7 @@ def mainPage() {
 		}
 		section{
 			input "actionType", "enum", title: "Action?", required: true, defaultValue: "Bell 1", options: [
-				"Custom Message",
+				//"Custom Message",
 				"Bell 1",
 				"Bell 2",
 				"Dogs Barking",
@@ -89,7 +89,7 @@ def mainPage() {
 				"Someone is arriving",
 				"Piano",
 				"Lightsaber"]
-			input "message","text",title:"Play this message", required:false, multiple: false
+			//input "message","text",title:"Play this message", required:false, multiple: false
 		}
 		section {
 			input "sonos", "capability.musicPlayer", title: "On this Speaker player", required: true
@@ -408,15 +408,13 @@ private loadText() {
 		case "Lightsaber":
 			state.sound = [uri: "http://s3.amazonaws.com/smartapp-media/sonos/lightsaber.mp3", duration: "10"]
 			break;
-		case "Custom Message":
-			if (message) {
+		default:
+			/*if (message) {
 				state.sound = textToSpeech(message instanceof List ? message[0] : message) // not sure why this is (sometimes) needed)
 			}
 			else {
 				state.sound = textToSpeech("You selected the custom message option but did not enter a message in the $app.label Smart App")
-			}
-			break;
-		default:
+			}*/
 			state.sound = [uri: "http://s3.amazonaws.com/smartapp-media/sonos/bell1.mp3", duration: "10"]
 			break;
 	}

smartapps/smartthings/tile-ux/device-tile-controller.src/device-tile-controller.groovy

@@ -1,107 +0,0 @@
-/**
- *  Device Tile Controller
- *
- *  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.
- *
- */
-definition(
-    name: "Device Tile Controller",
-    namespace: "smartthings/tile-ux",
-    author: "SmartThings",
-    description: "A controller SmartApp to install virtual devices into your location in order to simulate various native Device Tiles.",
-    category: "SmartThings Internal",
-    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience.png",
-    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png",
-    iconX3Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png",
-    singleInstance: true)
-
-
-preferences {
-    // landing page
-    page(name: "defaultPage")
-}
-
-def defaultPage() {
-    dynamicPage(name: "defaultPage", install: true, uninstall: true) {
-        section {
-            paragraph "Select on Unselect the devices that you want to install"
-        }
-        section(title: "Multi Attribute Tile Types") {
-            input(type: "bool", name: "genericDeviceTile", title: "generic", description: "A device that showcases the various use of generic multi-attribute-tiles.", defaultValue: "false")
-            input(type: "bool", name: "lightingDeviceTile", title: "lighting", description: "A device that showcases the various use of lighting multi-attribute-tiles.", defaultValue: "false")
-            input(type: "bool", name: "thermostatDeviceTile", title: "thermostat", description: "A device that showcases the various use of thermostat multi-attribute-tiles.", defaultValue: "true")
-            input(type: "bool", name: "mediaPlayerDeviceTile", title: "media player", description: "A device that showcases the various use of mediaPlayer multi-attribute-tiles.", defaultValue: "false")
-            input(type: "bool", name: "videoPlayerDeviceTile", title: "video player", description: "A device that showcases the various use of videoPlayer multi-attribute-tiles.", defaultValue: "false")
-        }
-        section(title: "Device Tile Types") {
-            input(type: "bool", name: "standardDeviceTile", title: "standard device tiles", description: "A device that showcases the various use of standard device tiles.", defaultValue: "false")
-            input(type: "bool", name: "valueDeviceTile", title: "value device tiles", description: "A device that showcases the various use of value device tiles.", defaultValue: "false")
-            input(type: "bool", name: "presenceDeviceTile", title: "presence device tiles", description: "A device that showcases the various use of color control device tile.", defaultValue: "false")
-        }
-        section(title: "Other Tile Types") {
-            input(type: "bool", name: "carouselDeviceTile", title: "image carousel", description: "A device that showcases the various use of carousel device tile.", defaultValue: "false")
-            input(type: "bool", name: "sliderDeviceTile", title: "slider", description: "A device that showcases the various use of slider device tile.", defaultValue: "false")
-            input(type: "bool", name: "colorWheelDeviceTile", title: "color wheel", description: "A device that showcases the various use of color wheel device tile.", defaultValue: "false")
-        }
-    }
-}
-
-def installed() {
-    log.debug "Installed with settings: ${settings}"
-}
-
-def uninstalled() {
-    getChildDevices().each {
-        deleteChildDevice(it.deviceNetworkId)
-    }
-}
-
-def updated() {
-    log.debug "Updated with settings: ${settings}"
-    unsubscribe()
-    initializeDevices()
-}
-
-def initializeDevices() {
-    settings.each { key, value ->
-        log.debug "$key : $value"
-        def existingDevice = getChildDevices().find { it.name == key }
-        log.debug "$existingDevice"
-        if (existingDevice && !value) {
-            deleteChildDevice(existingDevice.deviceNetworkId)
-        } else if (!existingDevice && value) {
-            String dni = UUID.randomUUID()
-            log.debug "$dni"
-            addChildDevice(app.namespace, key, dni, null, [
-                label: labelMap()[key] ?: key,
-                completedSetup: true
-            ])
-        }
-    }
-}
-
-// Map the name of the Device to a proper Label
-def labelMap() {
-    [
-        genericDeviceTile: "Tile Multiattribute Generic",
-        lightingDeviceTile: "Tile Multiattribute Lighting",
-        thermostatDeviceTile: "Tile Multiattribute Thermostat",
-        mediaPlayerDeviceTile: "Tile Multiattribute Media Player",
-        videoPlayerDeviceTile: "Tile Multiattribute Video Player",
-        standardDeviceTile: "Tile Device Standard",
-        valueDeviceTile: "Tile Device Value",
-        presenceDeviceTile: "Tile Device Presence",
-        carouselDeviceTile: "Tile Device Carousel",
-        sliderDeviceTile: "Tile Device Slider",
-        colorWheelDeviceTile: "Tile Device Color Wheel"
-    ]
-}

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

@@ -234,7 +234,7 @@ def addSwitches() {
 		def d
 		if (selectedSwitch) {
 			d = getChildDevices()?.find {
-				it.deviceNetworkId == selectedSwitch.value.mac || it.device.getDataValue("mac") == selectedSwitch.value.mac
+				it.dni == selectedSwitch.value.mac || it.device.getDataValue("mac") == selectedSwitch.value.mac
 			}
 		}
 
@@ -265,7 +265,7 @@ def addMotions() {
 		def d
 		if (selectedMotion) {
 			d = getChildDevices()?.find {
-				it.deviceNetworkId == selectedMotion.value.mac || it.device.getDataValue("mac") == selectedMotion.value.mac
+				it.dni == selectedMotion.value.mac || it.device.getDataValue("mac") == selectedMotion.value.mac
 			}
 		}
 
@@ -296,7 +296,7 @@ def addLightSwitches() {
 		def d
 		if (selectedLightSwitch) {
 			d = getChildDevices()?.find {
-				it.deviceNetworkId == selectedLightSwitch.value.mac || it.device.getDataValue("mac") == selectedLightSwitch.value.mac
+				it.dni == selectedLightSwitch.value.mac || it.device.getDataValue("mac") == selectedLightSwitch.value.mac
 			}
 		}
 

smartapps/tslagle13/vacation-lighting-director.src/vacation-lighting-director.groovy

@@ -1,17 +1,11 @@
 /**
  *  Vacation Lighting Director
  * 
- * Version  2.5 - Moved scheduling over to Cron and added time as a trigger. 
- *				  Cleaned up formatting and some typos.
- *                Updated license.
- *                Made people option optional
- * 				  Added sttement to unschedule on mode change if people option is not selected
- *
- * Version  2.4 - Added information paragraphs
+ *  Version  2.4 - Added information paragraphs
  * 
  *  Source code can be found here: https://github.com/tslagle13/SmartThings/blob/master/smartapps/tslagle13/vacation-lighting-director.groovy
  *
- *  Copyright 2016 Tim Slagle
+ *  Copyright 2015 Tim Slagle
  *
  *  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:
@@ -40,7 +34,6 @@ preferences {
     page name:"pageSetup"
     page name:"Setup"
     page name:"Settings"
-    page name: "timeIntervalInput"
 
 }
 
@@ -58,7 +51,8 @@ def pageSetup() {
 	return dynamicPage(pageProperties) {
     	section(""){
         	paragraph "This app can be used to make your home seem occupied anytime you are away from your home. " +
-			"Please use each of the the sections below to setup the different preferences to your liking. " 
+			"Please use each othe the sections below to setup the different preferences to your liking. " +
+			"I recommend this app be used with at least two away modes.  An example would be 'Away Day' 'and Away Night'. " 
         }
         section("Setup Menu") {
             href "Setup", title: "Setup", description: "", state:greyedOut()
@@ -76,7 +70,7 @@ def Setup() {
     def newMode = [
         name:       	"newMode",
         type:       	"mode",
-        title:      	"Modes",
+        title:      	"Which?",
         multiple:   	true,
         required:   	true
     ]
@@ -102,6 +96,14 @@ def Setup() {
         required:	true,
     ]
     
+    def people = [
+        name:       "people",
+        type:       "capability.presenceSensor",
+        title:      "If these people are home do not change light status",
+        required:	true,
+        multiple:	true
+    ]
+    
     def pageName = "Setup"
     
     def pageProperties = [
@@ -114,11 +116,10 @@ def Setup() {
 
 		section(""){            
                     paragraph "In this section you need to setup the deatils of how you want your lighting to be affected while " +
-                    "you are away.  All of these settings are required in order for the simulator to run correctly."
+                    paragraph "you are away.  All of these settings are required in order for the simulator to run correctly."
         }
-        section("Simulator Triggers") {
-                    input newMode  
-                    href "timeIntervalInput", title: "Times", description: timeIntervalLabel(), refreshAfterSelection:true
+        section("Which mode change triggers the simulator? (This app will only run in selected mode(s))") {
+                    input newMode           
         }
         section("Light switches to turn on/off") {
                     input switches           
@@ -129,6 +130,9 @@ def Setup() {
         section("Number of active lights at any given time") {
                     input number_of_active_lights           
         }    
+        section("People") {
+                    input people            
+        }
     }
     
 }
@@ -158,58 +162,30 @@ def Settings() {
         title:      "Settings",
         nextPage:   "pageSetup"
     ]
-    
-    def people = [
-        name:       "people",
-        type:       "capability.presenceSensor",
-        title:      "If these people are home do not change light status",
-        required:	false,
-        multiple:	true
-    ]
 
     return dynamicPage(pageProperties) {
 
 		section(""){              
                     paragraph "In this section you can restrict how your simulator runs.  For instance you can restrict on which days it will run " +
-                    "as well as a delay for the simulator to start after it is in the correct mode.  Delaying the simulator helps with false starts based on a incorrect mode change."
+                    paragraph "as well as a delay for the simulator to start after it is in the correct mode.  Delaying the simulator helps with false starts based on a incorrect mode change."
         }
         section("Delay to start simulator") {
                     input falseAlarmThreshold
         }
-        section("People") {
-        			paragraph "Not using this setting may cause some lights to remain on when you arrive home"
-                    input people            
-        }
         section("More options") {
+                    href "timeIntervalInput", title: "Only during a certain time", description: getTimeLabel(starting, ending), state: greyedOutTime(starting, ending), refreshAfterSelection:true
                     input days
         } 
     }   
 }
 
-def timeIntervalInput() {
-	dynamicPage(name: "timeIntervalInput") {
+page(name: "timeIntervalInput", title: "Only during a certain time", refreshAfterSelection:true) {
 		section {
-			input "startTimeType", "enum", title: "Starting at", options: [["time": "A specific time"], ["sunrise": "Sunrise"], ["sunset": "Sunset"]], defaultValue: "time", submitOnChange: true
-			if (startTimeType in ["sunrise","sunset"]) {
-				input "startTimeOffset", "number", title: "Offset in minutes (+/-)", range: "*..*", required: false
-			}
-			else {
-				input "starting", "time", title: "Start time", required: false
-			}
+			input "starting", "time", title: "Starting", required: false 
+			input "ending", "time", title: "Ending", required: false 
 		}
-		section {
-			input "endTimeType", "enum", title: "Ending at", options: [["time": "A specific time"], ["sunrise": "Sunrise"], ["sunset": "Sunset"]], defaultValue: "time", submitOnChange: true
-			if (endTimeType in ["sunrise","sunset"]) {
-				input "endTimeOffset", "number", title: "Offset in minutes (+/-)", range: "*..*", required: false
-			}
-			else {
-				input "ending", "time", title: "End time", required: false
-			}
-		}
-	}
 }
 
-
 def installed() {
 initialize()
 }
@@ -225,13 +201,10 @@ def initialize(){
 	if (newMode != null) {
 		subscribe(location, modeChangeHandler)
     }
-    if (starting != null) {
-    	schedule(starting, modeChangeHandler)
-    }
-    log.debug "Installed with settings: ${settings}"
 }
 
 def modeChangeHandler(evt) {
+	log.debug "Mode change to: ${evt.value}"
 		def delay = (falseAlarmThreshold != null && falseAlarmThreshold != "") ? falseAlarmThreshold * 60 : 2 * 60  
     	runIn(delay, scheduleCheck)
 }
@@ -239,54 +212,48 @@ def modeChangeHandler(evt) {
 
 //Main logic to pick a random set of lights from the large set of lights to turn on and then turn the rest off
 def scheduleCheck(evt) {
-    if(allOk){
-        log.debug("Running")
-        // turn off all the switches
-        switches.off()
-        
-        // grab a random switch
-        def random = new Random()
-        def inactive_switches = switches
-        for (int i = 0 ; i < number_of_active_lights ; i++) {
-            // if there are no inactive switches to turn on then let's break
-            if (inactive_switches.size() == 0){
-                break
-            }
-            
-            // grab a random switch and turn it on
-            def random_int = random.nextInt(inactive_switches.size())
-            inactive_switches[random_int].on()
-            
-            // then remove that switch from the pool off switches that can be turned on
-            inactive_switches.remove(random_int)
-        }
-        
-        // re-run again when the frequency demands it
-        schedule("0 0/${frequency_minutes} * 1/1 * ? *", scheduleCheck)
+if(allOk){
+log.debug("Running")
+  // turn off all the switches
+  switches.off()
+
+  // grab a random switch
+  def random = new Random()
+  def inactive_switches = switches
+  for (int i = 0 ; i < number_of_active_lights ; i++) {
+    // if there are no inactive switches to turn on then let's break
+    if (inactive_switches.size() == 0){
+      break
     }
-    //Check to see if mode is ok but not time/day.  If mode is still ok, check again after frequency period.
-    else if (modeOk) {
-        log.debug("mode OK.  Running again")
-        switches.off()
-    }
-    //if none is ok turn off frequency check and turn off lights.
-    else {
-    	if(people){
-        	//don't turn off lights if anyone is home
-        	if(someoneIsHome()){
-        	    log.debug("Stopping Check for Light")
-        	    unschedule()
-        	}
-        	else{
-        	    log.debug("Stopping Check for Light and turning off all lights")
-        	    switches.off()
-        	    unschedule()
-        	}
+
+    // grab a random switch and turn it on
+    def random_int = random.nextInt(inactive_switches.size())
+    inactive_switches[random_int].on()
+
+    // then remove that switch from the pool off switches that can be turned on
+    inactive_switches.remove(random_int)
+  }
+
+  // re-run again when the frequency demands it
+  runIn(frequency_minutes * 60, scheduleCheck)
+}
+//Check to see if mode is ok but not time/day.  If mode is still ok, check again after frequency period.
+else if (modeOk) {
+	log.debug("mode OK.  Running again")
+	runIn(frequency_minutes * 60, scheduleCheck)
+    switches.off()
+}
+//if none is ok turn off frequency check and turn off lights.
+else if(people){
+    //don't turn off lights if anyone is home
+		if(someoneIsHome()){
+		log.debug("Stopping Check for Light")
     	}
-        else if (!modeOk) {
-        	unschedule()
-        }
+        else{
+    log.debug("Stopping Check for Light and turning off all lights")
+	switches.off()
     }
+}
 }      
 
 
@@ -319,6 +286,26 @@ private getDaysOk() {
 	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
+	}
+    
+    else if (starting){
+    	result = currTime >= start
+    }
+    else if (ending){
+    	result = currTime <= stop
+    }
+    
+	log.trace "timeOk = $result"
+	result
+}
+
 private getHomeIsEmpty() {
   def result = true
 
@@ -343,59 +330,25 @@ private getSomeoneIsHome() {
   return result
 }
 
-private getTimeOk() {
-	def result = true
-	def start = timeWindowStart()
-	def stop = timeWindowStop()
-	if (start && stop && location.timeZone) {
-		result = timeOfDayIsBetween(start, stop, new Date(), location.timeZone)
-	}
-	log.trace "timeOk = $result"
-	result
-}
-
-private timeWindowStart() {
-	def result = null
-	if (startTimeType == "sunrise") {
-		result = location.currentState("sunriseTime")?.dateValue
-		if (result && startTimeOffset) {
-			result = new Date(result.time + Math.round(startTimeOffset * 60000))
-		}
-	}
-	else if (startTimeType == "sunset") {
-		result = location.currentState("sunsetTime")?.dateValue
-		if (result && startTimeOffset) {
-			result = new Date(result.time + Math.round(startTimeOffset * 60000))
-		}
-	}
-	else if (starting && location.timeZone) {
-		result = timeToday(starting, location.timeZone)
-	}
-	log.trace "timeWindowStart = ${result}"
-	result
-}
-
-private timeWindowStop() {
-	def result = null
-	if (endTimeType == "sunrise") {
-		result = location.currentState("sunriseTime")?.dateValue
-		if (result && endTimeOffset) {
-			result = new Date(result.time + Math.round(endTimeOffset * 60000))
-		}
-	}
-	else if (endTimeType == "sunset") {
-		result = location.currentState("sunsetTime")?.dateValue
-		if (result && endTimeOffset) {
-			result = new Date(result.time + Math.round(endTimeOffset * 60000))
-		}
-	}
-	else if (ending && location.timeZone) {
-		result = timeToday(ending, location.timeZone)
-	}
-	log.trace "timeWindowStop = ${result}"
-	result
+
+//gets the label for time restriction. Label phrasing changes depending on if there is both start and stop times or just one start/stop time.
+def getTimeLabel(starting, ending){
+
+	def timeLabel = "Tap to set"
+	
+    if(starting && ending){
+    	timeLabel = "Between" + " " + hhmm(starting) + " "  + "and" + " " +  hhmm(ending)
+    }
+    else if (starting) {
+		timeLabel = "Start at" + " " + hhmm(starting)
+    }
+    else if(ending){
+    timeLabel = "End at" + hhmm(ending)
+    }
+	timeLabel
 }
 
+//fomrats time to readable format for time label
 private hhmm(time, fmt = "h:mm a")
 {
 	def t = timeToday(time, location.timeZone)
@@ -404,41 +357,6 @@ private hhmm(time, fmt = "h:mm a")
 	f.format(t)
 }
 
-private timeIntervalLabel() {
-	def start = ""
-	switch (startTimeType) {
-		case "time":
-			if (ending) {
-            	start += hhmm(starting)
-            }
-			break
-		case "sunrise":
-		case "sunset":
-        	start += startTimeType[0].toUpperCase() + startTimeType[1..-1]
-			if (startTimeOffset) {
-				start += startTimeOffset > 0 ? "+${startTimeOffset} min" : "${startTimeOffset} min"
-			}
-			break
-	}
-
-    def finish = ""
-	switch (endTimeType) {
-		case "time":
-			if (ending) {
-            	finish += hhmm(ending)
-            }
-			break
-		case "sunrise":
-		case "sunset":
-        	finish += endTimeType[0].toUpperCase() + endTimeType[1..-1]
-			if (endTimeOffset) {
-				finish += endTimeOffset > 0 ? "+${endTimeOffset} min" : "${endTimeOffset} min"
-			}
-			break
-	}
-	start && finish ? "${start} to ${finish}" : ""
-}
-
 //sets complete/not complete for the setup section on the main dynamic page
 def greyedOut(){
 	def result = ""
@@ -451,7 +369,16 @@ def greyedOut(){
 //sets complete/not complete for the settings section on the main dynamic page
 def greyedOutSettings(){
 	def result = ""
-    if (people || days || falseAlarmThreshold ) {
+    if (starting || ending || days || falseAlarmThreshold) {
+    	result = "complete"	
+    }
+    result
+}
+
+//sets complete/not complete for time restriction section in settings
+def greyedOutTime(starting, ending){
+	def result = ""
+    if (starting || ending) {
     	result = "complete"	
     }
     result