MSA-615: Add control for the indicator light on the enerwave zw15sm switch. This is a modification to the stock metering switch device type.

devicetypes/osotech/plantlink.src/plantlink.groovy

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

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

@@ -43,7 +43,7 @@ metadata {
 	tiles {
 		standardTile("presence", "device.presence", width: 2, height: 2, canChangeBackground: true) {
 			state "present", labelIcon:"st.presence.tile.present", backgroundColor:"#53a7c0"
-			state "not present", labelIcon:"st.presence.tile.not-present", backgroundColor:"#ebeef2"
+			state "not present", labelIcon:"st.presence.tile.not-present", backgroundColor:"#ffffff"
 		}
 		standardTile("beep", "device.beep", decoration: "flat") {
 			state "beep", label:'', action:"tone.beep", icon:"st.secondary.beep", backgroundColor:"#ffffff"

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

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

devicetypes/smartthings/enerwave-zw15sm-metering-switch.src/enerwave-zw15sm-metering-switch.groovy

@@ -0,0 +1,249 @@
+/**
+ *  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.
+ * modified by lgkahn v1 for control of the on/off light
+ * the lite when on/off is not the normal parameter settings of the config class and there also
+ * is no never lite option.. So custom code for this device only.
+ *
+ */
+metadata {
+	definition (name: "Enerwave ZW15SM Metering Switch", namespace: "smartthings", author: "LGKahn") {
+		capability "Energy Meter"
+		capability "Actuator"
+		capability "Switch"
+		capability "Power Meter"
+		capability "Polling"
+		capability "Refresh"
+		capability "Configuration"
+		capability "Sensor"
+        capability "Indicator"
+        
+      
+        
+		fingerprint inClusters: "0x25,0x32"
+	}
+
+	// simulator metadata
+	simulator {
+		status "on":  "command: 2003, payload: FF"
+		status "off": "command: 2003, payload: 00"
+
+		for (int i = 0; i <= 10000; i += 1000) {
+			status "power  ${i} W": new physicalgraph.zwave.Zwave().meterV1.meterReport(
+				scaledMeterValue: i, precision: 3, meterType: 4, scale: 2, size: 4).incomingMessage()
+		}
+		for (int i = 0; i <= 100; i += 10) {
+			status "energy  ${i} kWh": new physicalgraph.zwave.Zwave().meterV1.meterReport(
+				scaledMeterValue: i, precision: 3, meterType: 0, scale: 0, size: 4).incomingMessage()
+		}
+
+		// reply messages
+		reply "2001FF,delay 100,2502": "command: 2503, payload: FF"
+		reply "200100,delay 100,2502": "command: 2503, payload: 00"
+
+	}
+
+	// tile definitions
+	tiles {
+		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
+			state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
+			state "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
+		}
+		valueTile("power", "device.power") {
+			state "default", label:'${currentValue} W'
+		}
+		valueTile("energy", "device.energy") {
+			state "default", label:'${currentValue} kWh'
+		}
+		standardTile("reset", "device.energy", inactiveLabel: false, decoration: "flat") {
+			state "default", label:'reset kWh', action:"reset"
+		}
+		standardTile("refresh", "device.power", inactiveLabel: false, decoration: "flat") {
+			state "default", label:'', action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+
+		standardTile("indicatorStatus", "device.indicatorStatus", width: 1, height: 1, inactiveLabel: false, decoration: "flat") {
+			state "when off", action:"indicator.indicatorWhenOn", icon:"st.indicators.lit-when-off"
+			state "when on", action:"indicator.indicatorWhenOff", icon:"st.indicators.lit-when-on"
+		
+		}
+		main(["switch","power","energy"])
+		details(["switch","power","energy","indicatorStatus","refresh","reset"])
+	}
+}
+
+def updated() {
+	try {
+		if (!state.MSR) {
+			response(zwave.manufacturerSpecificV2.manufacturerSpecificGet().format())
+		}
+	} catch (e) { log.debug e }
+}
+
+def parse(String description) {
+	def result = null
+    //log.debug "in parse desc = $description"
+    
+	if(description == "updated") return 
+	def cmd = zwave.parse(description, [0x20: 1, 0x32: 1, 0x72: 2])
+	if (cmd) {
+		result = zwaveEvent(cmd)
+	}
+	return result
+}
+
+
+
+def zwaveEvent(physicalgraph.zwave.commands.meterv1.MeterReport cmd) {
+	if (cmd.scale == 0) {
+		createEvent(name: "energy", value: cmd.scaledMeterValue, unit: "kWh")
+	} else if (cmd.scale == 1) {
+		createEvent(name: "energy", value: cmd.scaledMeterValue, unit: "kVAh")
+	} else if (cmd.scale == 2) {
+		createEvent(name: "power", value: Math.round(cmd.scaledMeterValue), unit: "W")
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd)
+{
+	def evt = createEvent(name: "switch", value: cmd.value ? "on" : "off", type: "physical")
+	if (evt.isStateChange) {
+		[evt, response(["delay 3000", zwave.meterV2.meterGet(scale: 2).format()])]
+	} else {
+		evt
+	}
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.switchbinaryv1.SwitchBinaryReport cmd)
+{
+	createEvent(name: "switch", value: cmd.value ? "on" : "off", type: "digital")
+}
+
+
+def zwaveEvent(physicalgraph.zwave.commands.configurationv1.ConfigurationReport cmd) {
+
+   // log.debug "in config report  got indicatorstatus = $state.currentIndicatorStatus"	
+	[name: "indicatorStatus", value: state.currentIndicatorStatus, display: true]
+}
+
+def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
+	def result = []
+
+	
+	def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
+	log.debug "msr: $msr"
+	updateDataValue("MSR", msr)
+
+	// retypeBasedOnMSR()
+
+	result << createEvent(descriptionText: "$device.displayName MSR: $msr", isStateChange: false)
+
+	if (msr.startsWith("0086") && !state.aeonconfig) {  // Aeon Labs meter
+		state.aeonconfig = 1
+		result << response(delayBetween([
+			zwave.configurationV1.configurationSet(parameterNumber: 101, size: 4, scaledConfigurationValue: 4).format(),   // report power in watts
+			zwave.configurationV1.configurationSet(parameterNumber: 111, size: 4, scaledConfigurationValue: 300).format(), // every 5 min
+			zwave.configurationV1.configurationSet(parameterNumber: 102, size: 4, scaledConfigurationValue: 8).format(),   // report energy in kWh
+			zwave.configurationV1.configurationSet(parameterNumber: 112, size: 4, scaledConfigurationValue: 300).format(), // every 5 min
+			zwave.configurationV1.configurationSet(parameterNumber: 103, size: 4, scaledConfigurationValue: 0).format(),    // no third report
+			//zwave.configurationV1.configurationSet(parameterNumber: 113, size: 4, scaledConfigurationValue: 300).format(), // every 5 min
+			zwave.meterV2.meterGet(scale: 0).format(),
+			zwave.meterV2.meterGet(scale: 2).format(),
+		]))
+	} else {
+		result << response(delayBetween([
+			zwave.meterV2.meterGet(scale: 0).format(),
+			zwave.meterV2.meterGet(scale: 2).format(),
+		]))
+	}
+
+	result
+}
+
+def zwaveEvent(physicalgraph.zwave.Command cmd) {
+	log.debug "$device.displayName: Unhandled: $cmd"
+	[:]
+}
+
+def on() {
+
+log.debug "in on"
+	[
+    
+		zwave.basicV1.basicSet(value: 0xFF).format(),
+		zwave.switchBinaryV1.switchBinaryGet().format(),
+		"delay 3000",
+		zwave.meterV2.meterGet(scale: 2).format()
+	]
+}
+
+def off() {
+log.debug "in off"
+	[
+    	zwave.basicV1.basicSet(value: 0x00).format(),
+		zwave.switchBinaryV1.switchBinaryGet().format(),
+		"delay 3000",
+		zwave.meterV2.meterGet(scale: 2).format()
+	]
+}
+
+def poll() {
+	delayBetween([
+		zwave.switchBinaryV1.switchBinaryGet().format(),
+		zwave.meterV2.meterGet(scale: 0).format(),
+		zwave.meterV2.meterGet(scale: 2).format()
+	])
+}
+
+def refresh() {
+	def value = "when off"
+   
+    log.debug "in refresh for whenon got indicatorstatus = $state.currentIndicatorStatus"
+    sendEvent(name: "indicatorStatus", value: state.currentIndicatorStatus, display: true)
+	
+	delayBetween([
+		zwave.switchBinaryV1.switchBinaryGet().format(),
+		zwave.meterV2.meterGet(scale: 0).format(),
+		zwave.meterV2.meterGet(scale: 2).format()
+	])
+}
+
+def configure() {
+	zwave.manufacturerSpecificV2.manufacturerSpecificGet().format()
+}
+
+def reset() {
+			 state.currentIndicatorStatus = "when on"
+	return [
+		zwave.meterV2.meterReset().format(),
+		zwave.meterV2.meterGet(scale: 0).format()
+	]
+}
+
+
+
+
+def indicatorWhenOn() {
+log.debug "in when on"
+ state.currentIndicatorStatus = "when on"
+	sendEvent(name: "indicatorStatus", value: "when on", display: true)
+zwave.configurationV1.configurationSet(parameterNumber: 0x01, size: 1, scaledConfigurationValue: 1).format()
+	}
+
+def indicatorWhenOff() {
+log.debug "in when off"
+ state.currentIndicatorStatus = "when off"
+	sendEvent(name: "indicatorStatus", value: "when off", display: true)	  
+zwave.configurationV1.configurationSet(parameterNumber: 0x01, size: 1, scaledConfigurationValue: 0).format()
+	}
+
+
+

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

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

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

@@ -25,7 +25,7 @@ metadata {
 	tiles {
 		standardTile("presence", "device.presence", width: 2, height: 2, canChangeBackground: true) {
 			state("present", labelIcon:"st.presence.tile.mobile-present", backgroundColor:"#53a7c0")
-			state("not present", labelIcon:"st.presence.tile.mobile-not-present", backgroundColor:"#ebeef2")
+			state("not present", labelIcon:"st.presence.tile.mobile-not-present", backgroundColor:"#ffffff")
 		}
 		main "presence"
 		details "presence"

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

@@ -346,8 +346,8 @@ def getTemperature(value) {
 		log.debug "Acceleration"
         def name = "acceleration"
 		def value = numValue.endsWith("1") ? "active" : "inactive"
-		def linkText = getLinkText(device)
-		def descriptionText = "$linkText was $value"
+		//def linkText = getLinkText(device)
+		def descriptionText = "was $value"
 		def isStateChange = isStateChange(device, name, value)
 		[
 			name: name,

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

@@ -1,98 +0,0 @@
-/**
- *  Copyright 2015 SmartThings
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-
-metadata {
-    definition (name: "ZigBee Dimmer Power", namespace: "smartthings", author: "SmartThings") {
-        capability "Actuator"
-        capability "Configuration"
-        capability "Refresh"
-        capability "Power Meter"
-        capability "Sensor"
-        capability "Switch"
-        capability "Switch Level"
-
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0B04"
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008, 0702"
-    }
-
-    tiles(scale: 2) {
-        multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
-            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-                attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-                attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-            }
-            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-                attributeState "level", action:"switch level.setLevel"
-            }
-            tileAttribute ("power", key: "SECONDARY_CONTROL") {
-                attributeState "power", label:'${currentValue} W'
-            }
-        }
-        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-        main "switch"
-        details(["switch", "refresh"])
-    }
-}
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-    log.debug "description is $description"
-
-    def resultMap = zigbee.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
-                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(name: resultMap.type, value: resultMap.value)
-        }
-    }
-    else {
-        log.warn "DID NOT PARSE MESSAGE for description : $description"
-        log.debug zigbee.parseDescriptionAsMap(description)
-    }
-}
-
-def off() {
-    zigbee.off()
-}
-
-def on() {
-    zigbee.on()
-}
-
-def setLevel(value) {
-    zigbee.setLevel(value)
-}
-
-def refresh() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.simpleMeteringPowerRefresh() + zigbee.electricMeasurementPowerRefresh() + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.simpleMeteringPowerConfig() + zigbee.electricMeasurementPowerConfig()
-}
-
-def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.simpleMeteringPowerConfig() + zigbee.electricMeasurementPowerConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.simpleMeteringPowerRefresh() + zigbee.electricMeasurementPowerRefresh()
-}

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

@@ -11,77 +11,133 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-
 metadata {
-    definition (name: "ZigBee Dimmer", namespace: "smartthings", author: "SmartThings") {
-        capability "Actuator"
-        capability "Configuration"
-        capability "Refresh"
-        capability "Sensor"
-        capability "Switch"
-        capability "Switch Level"
+	definition (name: "ZigBee Dimmer", namespace: "smartthings", author: "SmartThings") {
+		capability "Switch Level"
+		capability "Actuator"
+		capability "Switch"
+		capability "Configuration"
+		capability "Sensor"
+		capability "Refresh"
 
+		fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0B05", outClusters: "0019"
+	}
 
-        fingerprint profileId: "0104", inClusters: "0000, 0003, 0004, 0005, 0006, 0008"
-    }
+	// simulator metadata
+	simulator {
+		// status messages
+		status "on": "on/off: 1"
+		status "off": "on/off: 0"
 
-    tiles(scale: 2) {
-        multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
-            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
-                attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
-                attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-            }
-            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-                attributeState "level", action:"switch level.setLevel"
-            }
-        }
-        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-        main "switch"
-        details(["switch", "refresh"])
-    }
+		// reply messages
+		reply "zcl on-off on": "on/off: 1"
+		reply "zcl on-off off": "on/off: 0"
+	}
+
+	tiles(scale: 2) {
+		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
+				attributeState "level", action:"switch level.setLevel"
+			}
+		}
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+		valueTile("level", "device.level", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "level", label:'${currentValue} %', unit:"%", backgroundColor:"#ffffff"
+		}
+		main "switch"
+		details(["switch", "refresh", "level", "levelSliderControl"])
+	}
 }
 
 // Parse incoming device messages to generate events
 def parse(String description) {
-    log.debug "description is $description"
+	log.info description
+	if (description?.startsWith("catchall:")) {
+		def msg = zigbee.parse(description)
+		log.trace msg
+		log.trace "data: $msg.data"
+	}
+	else {
+		def name = description?.startsWith("on/off: ") ? "switch" : null
+		def value = name == "switch" ? (description?.endsWith(" 1") ? "on" : "off") : null
+		def result = createEvent(name: name, value: value)
+		log.debug "Parse returned ${result?.descriptionText}"
+		return result
+	}
+}
 
-    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"
-        log.debug zigbee.parseDescriptionAsMap(description)
-    }
+// Commands to device
+def on() {
+	log.debug "on()"
+	sendEvent(name: "switch", value: "on")
+	"st cmd 0x${device.deviceNetworkId} ${endpointId} 6 1 {}"
 }
 
 def off() {
-    zigbee.off()
+	log.debug "off()"
+	sendEvent(name: "switch", value: "off")
+	"st cmd 0x${device.deviceNetworkId} ${endpointId} 6 0 {}"
 }
-
-def on() {
-    zigbee.on()
-}
-
 def setLevel(value) {
-    zigbee.setLevel(value)
+	log.trace "setLevel($value)"
+	def cmds = []
+
+	if (value == 0) {
+		sendEvent(name: "switch", value: "off")
+		cmds << "st cmd 0x${device.deviceNetworkId} ${endpointId} 6 0 {}"
+	}
+	else if (device.latestValue("switch") == "off") {
+        sendEvent(name: "switch", value: "on")
+        cmds << "st cmd 0x${device.deviceNetworkId} ${endpointId} 6 1 {}"
+        
+	}
+
+	sendEvent(name: "level", value: value)
+    def level = hexString(Math.round(value * 255/100))
+	cmds << "st cmd 0x${device.deviceNetworkId} ${endpointId} 8 4 {${level} 0000}"
+
+	//log.debug cmds
+	cmds
 }
 
 def refresh() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.onOffConfig() + zigbee.levelConfig()
+	[
+		"st wattr 0x${device.deviceNetworkId} 1 6 0", "delay 200",
+		"st wattr 0x${device.deviceNetworkId} 1 8 0"
+	]
 }
 
 def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh()
+
+	/*log.debug "binding to switch and level control cluster"
+	[
+		"zdo bind 0x${device.deviceNetworkId} 1 1 6 {${device.zigbeeId}} {}", "delay 200",
+		"zdo bind 0x${device.deviceNetworkId} 1 1 8 {${device.zigbeeId}} {}"
+	]
+    */
+
+	//set transition time to 2 seconds. Not currently working.
+	"st wattr 0x${device.deviceNetworkId} 1 8 0x10 0x21 {1400}"
+}
+
+
+
+private hex(value, width=2) {
+	def s = new BigInteger(Math.round(value).toString()).toString(16)
+	while (s.size() < width) {
+		s = "0" + s
+	}
+	s
+}
+
+private getEndpointId() {
+	new BigInteger(device.endpointId, 16).toString()
 }

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

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

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

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

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

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

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

@@ -1,130 +0,0 @@
-/**
- *  Copyright 2015 SmartThings
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- *  ZigBee White Color Temperature Bulb
- *
- *  Author: SmartThings
- *  Date: 2015-09-22
- */
-
-metadata {
-    definition (name: "ZigBee White Color Temperature Bulb", namespace: "smartthings", author: "SmartThings") {
-
-        capability "Actuator"
-        capability "Color Temperature"
-        capability "Configuration"
-        capability "Refresh"
-        capability "Sensor"
-        capability "Switch"
-        capability "Switch Level"
-
-        attribute "colorName", "string"
-        command "setGenericName"
-
-        fingerprint profileId: "0104", inClusters: "0000,0003,0004,0005,0006,0008,0300,0B04", outClusters: "0019"
-    }
-
-    // UI tile definitions
-    tiles(scale: 2) {
-        multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
-            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
-                attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#79b821", nextState:"turningOff"
-                attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-            }
-            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-                attributeState "level", action:"switch level.setLevel"
-            }
-            tileAttribute ("colorName", key: "SECONDARY_CONTROL") {
-                attributeState "colorName", label:'${currentValue}'
-            }
-        }
-
-        standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-
-        controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2700..6500)") {
-            state "colorTemperature", action:"color temperature.setColorTemperature"
-        }
-        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "colorTemperature", label: '${currentValue} K'
-        }
-
-        main(["switch"])
-        details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
-    }
-}
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-    log.debug "description is $description"
-
-    def 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"
-        log.debug zigbee.parseDescriptionAsMap(description)
-    }
-}
-
-def off() {
-    zigbee.off()
-}
-
-def on() {
-    zigbee.on()
-}
-
-def setLevel(value) {
-    zigbee.setLevel(value)
-}
-
-def refresh() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh() + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig()
-}
-
-def configure() {
-    log.debug "Configuring Reporting and Bindings."
-    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
-}
-
-def setColorTemperature(value) {
-    setGenericName(value)
-    zigbee.setColorTemperature(value)
-}
-
-//Naming based on the wiki article here: http://en.wikipedia.org/wiki/Color_temperature
-def setGenericName(value){
-    if (value != null) {
-        def genericName = "White"
-        if (value < 3300) {
-            genericName = "Soft White"
-        } else if (value < 4150) {
-            genericName = "Moonlight"
-        } else if (value <= 5000) {
-            genericName = "Cool White"
-        } else if (value >= 5000) {
-            genericName = "Daylight"
-        }
-        sendEvent(name: "colorName", value: genericName)
-    }
-}

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

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

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

@@ -1,389 +0,0 @@
-/**
- *  Required PlantLink Connector
- *  This SmartApp forwards the raw data of the deviceType to myplantlink.com
- *  and returns it back to your device after calculating soil and plant type.
- *
- *  Copyright 2015 Oso Technologies
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-import groovy.json.JsonBuilder
-import java.util.regex.Matcher
-import java.util.regex.Pattern
- 
-definition(
-    name: "PlantLink Connector",
-    namespace: "Osotech",
-    author: "Oso Technologies",
-    description: "This SmartApp connects to myplantlink.com and forwards the device data to it so it can calculate easy to read plant status for your specific plant's needs.",
-    category:  "Convenience",
-    iconUrl:   "https://dashboard.myplantlink.com/images/apple-touch-icon-76x76-precomposed.png",
-    iconX2Url: "https://dashboard.myplantlink.com/images/apple-touch-icon-120x120-precomposed.png",
-    iconX3Url: "https://dashboard.myplantlink.com/images/apple-touch-icon-152x152-precomposed.png"
-) {
-    appSetting "client_id"
-    appSetting "client_secret"
-    appSetting "https_plantLinkServer"
-}
-
-preferences {
-    page(name: "auth", title: "Step 1 of 2", nextPage:"deviceList", content:"authPage")
-    page(name: "deviceList", title: "Step 2 of 2", install:true, uninstall:false){
-        section {
-            input "plantlinksensors", "capability.sensor", title: "Select PlantLink sensors", multiple: true
-        }
-    }
-}
-
-mappings {
-    path("/swapToken") {
-        action: [
-                GET: "swapToken"
-        ]
-    }
-}
-
-def authPage(){
-    if(!atomicState.accessToken){
-        createAccessToken()
-        atomicState.accessToken = state.accessToken
-    }
-
-	def redirectUrl = oauthInitUrl()
-    def uninstallAllowed = false
-    def oauthTokenProvided = false
-    if(atomicState.authToken){
-        uninstallAllowed = true
-        oauthTokenProvided = true
-    }
-
-    if (!oauthTokenProvided) {
-        return dynamicPage(name: "auth", title: "Step 1 of 2", nextPage:null, uninstall:uninstallAllowed) {
-            section(){
-                href(name:"login",
-                     url:redirectUrl, 
-                     style:"embedded",
-                     title:"PlantLink", 
-                     image:"https://dashboard.myplantlink.com/images/PLlogo.png", 
-                     description:"Tap to login to myplantlink.com")
-            }
-        }
-    }else{
-        return dynamicPage(name: "auth", title: "Step 1 of 2 - Completed", nextPage:"deviceList", uninstall:uninstallAllowed) {
-	        section(){
-               paragraph "You are logged in to myplantlink.com, tap next to continue", image: iconUrl
- 			   href(url:redirectUrl, title:"Or", description:"tap to switch accounts")
-            }
-        }
-    }
-}
-
-def installed() {
-    log.debug "Installed with settings: ${settings}"
-    initialize()
-}
-
-def updated() {
-    log.debug "Updated with settings: ${settings}"
-    unsubscribe()
-    initialize()
-}
-
-def uninstalled() {
-    if (plantlinksensors){
-        plantlinksensors.each{ sensor_device ->
-            sensor_device.setInstallSmartApp("needSmartApp")
-        }
-    }
-}
-
-def initialize() {
-    atomicState.attached_sensors = [:]
-    if (plantlinksensors){
-        subscribe(plantlinksensors, "moisture_status", moistureHandler)
-        subscribe(plantlinksensors, "battery_status", batteryHandler)
-        plantlinksensors.each{ sensor_device ->
-            sensor_device.setStatusIcon("Waiting on First Measurement")
-            sensor_device.setInstallSmartApp("connectedToSmartApp")
-        }
-    }
-}
-
-def dock_sensor(device_serial, expected_plant_name) {
-    def docking_body_json_builder = new JsonBuilder([version: '1c', smartthings_device_id: device_serial])
-    def docking_params = [
-            uri        : appSettings.https_plantLinkServer,
-            path       : "/api/v1/smartthings/links",
-            headers    : ["Content-Type": "application/json", "Authorization": "Bearer ${atomicState.authToken}"],
-            contentType: "application/json",
-            body: docking_body_json_builder.toString()
-    ]
-    def plant_post_body_map = [
-            plant_type_key: 999999,
-            soil_type_key : 1000004
-    ]
-    def plant_post_params = [
-            uri        : appSettings.https_plantLinkServer,
-            path       : "/api/v1/plants",
-            headers    : ["Content-Type": "application/json", "Authorization": "Bearer ${atomicState.authToken}"],
-            contentType: "application/json",
-    ]
-    log.debug "Creating new plant on myplantlink.com - ${expected_plant_name}"
-    httpPost(docking_params) { docking_response ->
-        if (parse_api_response(docking_response, "Docking a link")) {
-            if (docking_response.data.plants.size() == 0) {
-                log.debug "creating plant for - ${expected_plant_name}"
-                plant_post_body_map["name"] = expected_plant_name
-                plant_post_body_map['links_key'] = [docking_response.data.key]
-                def plant_post_body_json_builder = new JsonBuilder(plant_post_body_map)
-                plant_post_params["body"] = plant_post_body_json_builder.toString()
-                httpPost(plant_post_params) { plant_post_response ->
-                    if(parse_api_response(plant_post_response, 'creating plant')){
-                        def attached_map = atomicState.attached_sensors
-                        attached_map[device_serial] = plant_post_response.data
-                        atomicState.attached_sensors = attached_map
-                    }
-                }
-            } else {
-                def plant = docking_response.data.plants[0]
-                def attached_map = atomicState.attached_sensors
-                attached_map[device_serial] = plant
-                atomicState.attached_sensors = attached_map
-                checkAndUpdatePlantIfNeeded(plant, expected_plant_name)
-            }
-        }
-    }
-    return true
-}
-
-def checkAndUpdatePlantIfNeeded(plant, expected_plant_name){
-    def plant_put_params = [
-		uri : appSettings.https_plantLinkServer,
-        headers : ["Content-Type": "application/json", "Authorization": "Bearer ${atomicState.authToken}"],
-        contentType : "application/json"
-    ]
-    if (plant.name != expected_plant_name) {
-        log.debug "updating plant for - ${expected_plant_name}"
-        plant_put_params["path"] = "/api/v1/plants/${plant.key}"
-        def plant_put_body_map = [
-			name: expected_plant_name
-        ]
-        def plant_put_body_json_builder = new JsonBuilder(plant_put_body_map)
-        plant_put_params["body"] = plant_put_body_json_builder.toString()
-        httpPut(plant_put_params) { plant_put_response ->
-            parse_api_response(plant_put_response, 'updating plant name')
-        }
-    }
-}
-
-def moistureHandler(event){
-    def expected_plant_name = "SmartThings - ${event.displayName}"
-    def device_serial = getDeviceSerialFromEvent(event)
-    
-    if (!atomicState.attached_sensors.containsKey(device_serial)){
-        dock_sensor(device_serial, expected_plant_name)
-    }else{
-        def measurement_post_params = [
-                uri: appSettings.https_plantLinkServer,
-                path: "/api/v1/smartthings/links/${device_serial}/measurements",
-                headers: ["Content-Type": "application/json", "Authorization": "Bearer ${atomicState.authToken}"],
-                contentType: "application/json",
-                body: event.value
-        ]
-        httpPost(measurement_post_params) { measurement_post_response ->
-            if (parse_api_response(measurement_post_response, 'creating moisture measurement') &&
-                    measurement_post_response.data.size() >0){
-                def measurement = measurement_post_response.data[0]
-                def plant =  measurement.plant
-                log.debug plant
-                checkAndUpdatePlantIfNeeded(plant, expected_plant_name)
-                plantlinksensors.each{ sensor_device ->
-                    if (sensor_device.id == event.deviceId){
-                        sensor_device.setStatusIcon(plant.status)
-                        if (plant.last_measurements && plant.last_measurements[0].moisture){
-                            sensor_device.setPlantFuelLevel(plant.last_measurements[0].moisture * 100 as int)
-                        }
-                        if (plant.last_measurements && plant.last_measurements[0].battery){
-                            sensor_device.setBatteryLevel(plant.last_measurements[0].battery * 100 as int)
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-def batteryHandler(event){
-    def expected_plant_name = "SmartThings - ${event.displayName}"
-    def device_serial = getDeviceSerialFromEvent(event)
-    
-    if (!atomicState.attached_sensors.containsKey(device_serial)){
-        dock_sensor(device_serial, expected_plant_name)
-    }else{
-        def measurement_post_params = [
-                uri: appSettings.https_plantLinkServer,
-                path: "/api/v1/smartthings/links/${device_serial}/measurements",
-                headers: ["Content-Type": "application/json", "Authorization": "Bearer ${atomicState.authToken}"],
-                contentType: "application/json",
-                body: event.value
-        ]
-        httpPost(measurement_post_params) { measurement_post_response ->
-            parse_api_response(measurement_post_response, 'creating battery measurement')
-        }
-    }
-}
-
-def getDeviceSerialFromEvent(event){
-    def pattern = /.*"zigbeedeviceid"\s*:\s*"(\w+)".*/
-    def match_result = (event.value =~ pattern)
-    return match_result[0][1]
-}
-
-def oauthInitUrl(){
-	atomicState.oauthInitState = UUID.randomUUID().toString()
-    def oauthParams = [
-            response_type: "code",
-            client_id: appSettings.client_id,
-            state: atomicState.oauthInitState,
-            redirect_uri: buildRedirectUrl()
-    ]
-    return appSettings.https_plantLinkServer + "/oauth/oauth2/authorize?" + toQueryString(oauthParams)
-}
-
-def buildRedirectUrl(){
-    return getServerUrl() + "/api/token/${atomicState.accessToken}/smartapps/installations/${app.id}/swapToken"
-}
-
-def swapToken(){
-    def code = params.code
-    def oauthState = params.state
-    def stcid = appSettings.client_id
-    def postParams = [
-            method: 'POST',
-            uri: "https://oso-tech.appspot.com",
-            path: "/api/v1/oauth-token",
-            query: [grant_type:'authorization_code', code:params.code, client_id:stcid,
-                    client_secret:appSettings.client_secret, redirect_uri: buildRedirectUrl()],
-    ]
-
-    def jsonMap
-    httpPost(postParams) { resp ->
-        jsonMap = resp.data
-    }
-
-    atomicState.refreshToken = jsonMap.refresh_token
-    atomicState.authToken = jsonMap.access_token
-
-    def html = """
-<html>
-<head>
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<style>
-	.container {
-		padding:25px;
-	}
-	.flex1 {
-    	width:33%;
-		float:left;
-		text-align: center;
-	}
-	p {
-		font-size: 2em;
-		font-family: Verdana, Geneva, sans-serif;
-		text-align: center;
-		color: #777;
-	}
-</style>
-</head>
-<body>
-	<div class="container">
-		<div class="flex1"><img src="https://dashboard.myplantlink.com/images/PLlogo.png" alt="PlantLink" height="75"/></div>
-		<div class="flex1"><img src="https://s3.amazonaws.com/smartapp-icons/Partner/support/connected-device-icn%402x.png" alt="connected to"  height="25" style="padding-top:25px;" /></div>
-		<div class="flex1"><img src="https://s3.amazonaws.com/smartapp-icons/Partner/support/st-logo%402x.png" alt="SmartThings" height="75"/></div>
-		<br clear="all">
-  </div>
-  <div class="container">
-		<p>Your PlantLink Account is now connected to SmartThings!</p>
-		<p style="color:green;">Click <strong>Done</strong> at the top right to finish setup.</p>
-	</div>
-</body>
-</html>
-"""
-    render contentType: 'text/html', data: html
-}
-
-private refreshAuthToken() {
-    def stcid = appSettings.client_id
-    def refreshParams = [
-            method: 'POST',
-            uri: "https://hardware-dot-oso-tech.appspot.com",
-            path: "/api/v1/oauth-token",
-            query: [grant_type:'refresh_token', code:"${atomicState.refreshToken}", client_id:stcid,
-                    client_secret:appSettings.client_secret],
-    ]
-    try{
-        def jsonMap
-        httpPost(refreshParams) { resp ->
-            if(resp.status == 200){
-                log.debug "OAuth Token refreshed"
-                jsonMap = resp.data
-                if (resp.data) {
-                    atomicState.refreshToken = resp?.data?.refresh_token
-                    atomicState.authToken = resp?.data?.access_token
-                    if (data?.action && data?.action != "") {
-                        log.debug data.action
-                        "{data.action}"()
-                        data.action = ""
-                    }
-                }
-                data.action = ""
-            }else{
-                log.debug "refresh failed ${resp.status} : ${resp.status.code}"
-            }
-        }
-    }
-    catch(Exception e){
-        log.debug "caught exception refreshing auth token: " + e
-    }
-}
-
-def parse_api_response(resp, message) {
-    if (resp.status == 200) {
-        return true
-    } else {
-        log.error "sent ${message} Json & got http status ${resp.status} - ${resp.status.code}"
-        if (resp.status == 401) {
-            refreshAuthToken()
-            return false
-        } else {
-            debugEvent("Authentication error, invalid authentication method, lack of credentials, etc.", true)
-            return false
-        }
-    }
-}
-
-def getServerUrl() { 
-	return "https://graph.api.smartthings.com" 
-}
-
-def debugEvent(message, displayEvent) {
-    def results = [
-            name: "appdebug",
-            descriptionText: message,
-            displayed: displayEvent
-    ]
-    log.debug "Generating AppDebug Event: ${results}"
-    sendEvent (results)
-}
-
-def toQueryString(Map m){
-    return m.collect { k, v -> "${k}=${URLEncoder.encode(v.toString())}" }.sort().join("&")
-}

smartapps/tslagle13/hello-home-phrase-director.src/hello-home-phrase-director.groovy

@@ -1,4 +1,4 @@
-/**
+    /**
      *  Magic Home
      *
      *  Copyright 2014 Tim Slagle
@@ -198,7 +198,7 @@
     
     //set home mode when house is occupied
     def setHome() {
-    sendOutOfDateNotification()
+    
     log.info("Setting Home Mode!!")
     if(anyoneIsHome()) {
           if(state.sunMode == "sunset"){
@@ -319,14 +319,3 @@
     private hideOptionsSection() {
     	(starting || ending || days || modes) ? false : true
     }
-    
-    def sendOutOfDateNotification(){
-    	if(!state.lastTime){
-    		state.lastTime = (new Date() + 31).getTime()
-            sendNotification("Your version of Hello, Home Phrase Director is currently out of date. Please look for the new version of Hello, Home Phrase Director now called 'Routine Director' in the marketplace.")
-        }
-        else if (((new Date()).getTime()) >= state.lastTime){
-        	sendNotification("Your version of Hello, Home Phrase Director is currently out of date. Please look for the new version of Hello, Home Phrase Director now called 'Routine Director' in the marketplace.")
-        	state.lastTime = (new Date() + 31).getTime()
-        }
-    }

smartapps/tslagle13/routine-director.src/routine-director.groovy

@@ -1,346 +0,0 @@
-/**
- *  Rotuine Director
- *
- *
- *  Changelog
- *
- *  2015-09-01
- *     --Added Contact Book
- *     --Removed references to phrases and replaced with routines
- *     --Added bool logic to inputs instead of enum for "yes" "no" options
- *     --Fixed halting error with code installation
- *
- *  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:
- *
- *      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: "Routine Director",
-    namespace: "tslagle13",
-    author: "Tim Slagle",
-    description: "Monitor a set of presence sensors and activate routines based on whether your home is empty or occupied.  Each presence status change will check against the current 'sun state' to run routines based on occupancy and whether the sun is up or down.",
-    category: "Convenience",
-    iconUrl: "http://icons.iconarchive.com/icons/icons8/ios7/512/Very-Basic-Home-Filled-icon.png",
-    iconX2Url: "http://icons.iconarchive.com/icons/icons8/ios7/512/Very-Basic-Home-Filled-icon.png"
-)
-
-preferences {
-    page(name: "selectRoutines")
-
-    page(name: "Settings", title: "Settings", uninstall: true, install: true) {
-        section("False alarm threshold (defaults to 10 min)") {
-            input "falseAlarmThreshold", "decimal", title: "Number of minutes", required: false
-        }
-
-        section("Zip code (for sunrise/sunset)") {
-            input "zip", "text", required: true
-        }
-
-        section("Notifications") {
-            input "sendPushMessage", "bool", title: "Send notifications when house is empty?"
-            input "sendPushMessageHome", "bool", title: "Send notifications when home is occupied?"
-        }
-        section("Send Notifications?") {
-            input("recipients", "contact", title: "Send notifications to") {
-                input "phone", "phone", title: "Send an SMS to this number?", required:false
-            }
-        }
-
-        section(title: "More options", hidden: hideOptionsSection(), hideable: true) {
-            label title: "Assign a name", required: false
-            input "days", "enum", title: "Only on certain days of the week", multiple: true, required: false,
-                options: ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
-            input "modes", "mode", title: "Only when mode is", multiple: true, required: false
-        }
-    }
-}
-
-def selectRoutines() {
-    def configured = (settings.awayDay && settings.awayNight && settings.homeDay && settings.homeNight)
-    dynamicPage(name: "selectRoutines", title: "Configure", nextPage: "Settings", uninstall: true) {
-        section("Who?") {
-            input "people", "capability.presenceSensor", title: "Monitor These Presences", required: true, multiple: true, submitOnChange: true
-        }
-
-        def routines = location.helloHome?.getPhrases()*.label
-        if (routines) {
-            routines.sort()
-            section("Run This Routine When...") {
-                    log.trace routines
-                    input "awayDay", "enum", title: "Everyone Is Away And It's Day", required: true, options: routines, submitOnChange: true
-                    input "awayNight", "enum", title: "Everyone Is Away And It's Night", required: true, options: routines, submitOnChange: true
-                    input "homeDay", "enum", title: "At Least One Person Is Home And It's Day", required: true, options: routines, submitOnChange: true
-                    input "homeNight", "enum", title: "At Least One Person Is Home And It's Night", required: true, options: routines, submitOnChange: true
-                }
-                /*    section("Select modes used for each condition.") { This allows the director to know which rotuine has already been ran so it does not run again if someone else comes home. 
-        input "homeModeDay", "mode", title: "Select Mode Used for 'Home Day'", required: true
-        input "homeModeNight", "mode", title: "Select Mode Used for 'Home Night'", required: true
-    }*/
-        }
-    }
-}
-
-def installed() {
-	log.debug "Updated with settings: ${settings}"
-    initialize()
-}
-
-def updated() {
-	log.debug "Updated with settings: ${settings}"
-    unsubscribe()
-    initialize()
-}
-
-def initialize() {
-    subscribe(people, "presence", presence)
-    checkSun()
-    subscribe(location, "sunrise", setSunrise)
-    subscribe(location, "sunset", setSunset)
-    state.homestate = null
-}
-
-//check current sun state when installed.
-def checkSun() {
-    def zip = settings.zip as String
-    def sunInfo = getSunriseAndSunset(zipCode: zip)
-    def current = now()
-
-    if (sunInfo.sunrise.time < current && sunInfo.sunset.time > current) {
-        state.sunMode = "sunrise"
-        runIn(60,"setSunrise")
-    }
-    else {
-        state.sunMode = "sunset"
-        runIn(60,"setSunset")
-    }
-}
-
-//change to sunrise mode on sunrise event
-def setSunrise(evt) {
-    state.sunMode = "sunrise";
-    changeSunMode(newMode);
-    log.debug "Current sun mode is ${state.sunMode}"
-}
-
-//change to sunset mode on sunset event
-def setSunset(evt) {
-    state.sunMode = "sunset";
-    changeSunMode(newMode)
-    log.debug "Current sun mode is ${state.sunMode}"
-}
-
-//change mode on sun event
-def changeSunMode(newMode) {
-    if (allOk) {
-
-        if (everyoneIsAway()) /*&& (state.sunMode == "sunrise")*/ {
-            log.info("Home is Empty  Setting New Away Mode")
-            def delay = (falseAlarmThreshold != null && falseAlarmThreshold != "") ? falseAlarmThreshold * 60 : 10 * 60
-            setAway()
-        }
-/*
-        else if (everyoneIsAway() && (state.sunMode == "sunset")) {
-            log.info("Home is Empty  Setting New Away Mode")
-            def delay = (falseAlarmThreshold != null && falseAlarmThreshold != "") ? falseAlarmThreshold * 60 : 10 * 60
-            setAway()
-        }*/
-        else if (anyoneIsHome()) {
-            log.info("Home is Occupied Setting New Home Mode")
-            setHome()
-
-
-        }
-    }
-}
-
-//presence change run logic based on presence state of home
-def presence(evt) {
-    if (allOk) {
-        if (evt.value == "not present") {
-            log.debug("Checking if everyone is away")
-
-            if (everyoneIsAway()) {
-                log.info("Nobody is home, running away sequence")
-                def delay = (falseAlarmThreshold != null && falseAlarmThreshold != "") ? falseAlarmThreshold * 60 : 10 * 60
-                runIn(delay, "setAway")
-            }
-        }
-        else {
-            def lastTime = state[evt.deviceId]
-            if (lastTime == null || now() - lastTime >= 1 * 60000) {
-                log.info("Someone is home, running home sequence")
-                setHome()
-            }
-            state[evt.deviceId] = now()
-
-        }
-    }
-}
-
-//if empty set home to one of the away modes
-def setAway() {
-    if (everyoneIsAway()) {
-        if (state.sunMode == "sunset") {
-            def message = "Performing \"${awayNight}\" for you as requested."
-            log.info(message)
-            sendAway(message)
-            location.helloHome.execute(settings.awayNight)
-            state.homestate = "away"
-
-        }
-        else if (state.sunMode == "sunrise") {
-            def message = "Performing \"${awayDay}\" for you as requested."
-            log.info(message)
-            sendAway(message)
-            location.helloHome.execute(settings.awayDay)
-            state.homestate = "away"
-        }
-        else {
-            log.debug("Mode is the same, not evaluating")
-        }
-    }
-}
-
-//set home mode when house is occupied
-def setHome() {
-    log.info("Setting Home Mode!!")
-    if (anyoneIsHome()) {
-        if (state.sunMode == "sunset") {
-            if (state.homestate != "homeNight") {
-                def message = "Performing \"${homeNight}\" for you as requested."
-                log.info(message)
-                sendHome(message)
-                location.helloHome.execute(settings.homeNight)
-                state.homestate = "homeNight"
-            }
-        }
-
-        if (state.sunMode == "sunrise") {
-            if (state.homestate != "homeDay") {
-                def message = "Performing \"${homeDay}\" for you as requested."
-                log.info(message)
-                sendHome(message)
-                location.helloHome.execute(settings.homeDay)
-                state.homestate = "homeDay"
-            }
-        }
-    }
-}
-
-private everyoneIsAway() {
-  def result = true
-
-  if(people.findAll { it?.currentPresence == "present" }) {
-    result = false
-  }
-
-  log.debug("everyoneIsAway: ${result}")
-
-  return result
-}
-
-private anyoneIsHome() {
-  def result = false
-
-  if(people.findAll { it?.currentPresence == "present" }) {
-    result = true
-  }
-
-  log.debug("anyoneIsHome: ${result}")
-
-  return result
-}
-
-def sendAway(msg) {
-    if (sendPushMessage) {
-    	if (recipients) {
-        	sendNotificationToContacts(msg, recipients)
-        }
-        else {
-        	sendPush(msg)
-        	if(phone){
-            		sendSms(phone, msg)
-        	}	
-        }    
-    }
-
-    log.debug(msg)
-}
-
-def sendHome(msg) {
-    if (sendPushMessageHome) {
-    	if (recipients) {
-        	sendNotificationToContacts(msg, recipients)
-        }
-        else {
-        	sendPush(msg)
-                if(phone){
-            		sendSms(phone, msg)
-        	}
-        }    
-    }
-
-    log.debug(msg)
-}
-
-private getAllOk() {
-    modeOk && daysOk && timeOk
-}
-
-private getModeOk() {
-    def result = !modes || modes.contains(location.mode)
-    log.trace "modeOk = $result"
-    result
-}
-
-private getDaysOk() {
-    def result = true
-    if (days) {
-        def df = new java.text.SimpleDateFormat("EEEE")
-        if (location.timeZone) {
-            df.setTimeZone(location.timeZone)
-        }
-        else {
-            df.setTimeZone(TimeZone.getTimeZone("America/New_York"))
-        }
-        def day = df.format(new Date())
-        result = days.contains(day)
-    }
-    log.trace "daysOk = $result"
-    result
-}
-
-private getTimeOk() {
-    def result = true
-    if (starting && ending) {
-        def currTime = now()
-        def start = timeToday(starting, location?.timeZone).time
-        def stop = timeToday(ending, location?.timeZone).time
-        result = start < stop ? currTime >= start && currTime <= stop : currTime <= stop || currTime >= start
-    }
-    log.trace "timeOk = $result"
-    result
-}
-
-private hhmm(time, fmt = "h:mm a") {
-    def t = timeToday(time, location.timeZone)
-    def f = new java.text.SimpleDateFormat(fmt)
-    f.setTimeZone(location.timeZone?:timeZone(time))
-    f.format(t)
-}
-
-private getTimeIntervalLabel() {
-    (starting && ending) ? hhmm(starting) + "-" + hhmm(ending, "h:mm a z"): ""
-}
-
-private hideOptionsSection() {
-    (starting || ending || days || modes) ? false: true
-}