MSA-2069: home auto

devicetypes/erocm123/sonoff-wifi-switch.src/sonoff-wifi-switch.groovy

@@ -0,0 +1,450 @@
+/**
+ *  Copyright 2016 Eric Maycock
+ *
+ *  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.
+ *
+ *  Sonoff Wifi Switch
+ *
+ *  Author: Eric Maycock (erocm123)
+ *  Date: 2016-06-02
+ */
+ 
+import groovy.json.JsonSlurper
+import groovy.util.XmlSlurper
+
+metadata {
+	definition (name: "Sonoff Wifi Switch", namespace: "erocm123", author: "Eric Maycock") {
+        capability "Actuator"
+		capability "Switch"
+		capability "Refresh"
+		capability "Sensor"
+        capability "Configuration"
+        capability "Health Check"
+        
+        command "reboot"
+        
+        attribute   "needUpdate", "string"
+	}
+
+	simulator {
+	}
+    
+    preferences {
+        input description: "Once you change values on this page, the corner of the \"configuration\" icon will change orange until all configuration parameters are updated.", title: "Settings", displayDuringSetup: false, type: "paragraph", element: "paragraph"
+		generate_preferences(configuration_model())
+	}
+
+	tiles (scale: 2){      
+		multiAttributeTile(name:"switch", type: "generic", width: 6, height: 4, canChangeIcon: true){
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "on", label:'${name}', action:"switch.off", backgroundColor:"#00a0dc", icon: "st.switches.switch.on", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", backgroundColor:"#ffffff", icon: "st.switches.switch.off", nextState:"turningOn"
+				attributeState "turningOn", label:'${name}', action:"switch.off", backgroundColor:"#00a0dc", icon: "st.switches.switch.off", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", backgroundColor:"#ffffff", icon: "st.switches.switch.on", nextState:"turningOn"
+			}
+        }
+
+		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
+		}
+        standardTile("configure", "device.needUpdate", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+            state "NO" , label:'', action:"configuration.configure", icon:"st.secondary.configure"
+            state "YES", label:'', action:"configuration.configure", icon:"https://github.com/erocm123/SmartThingsPublic/raw/master/devicetypes/erocm123/qubino-flush-1d-relay.src/configure@2x.png"
+        }
+        standardTile("reboot", "device.reboot", decoration: "flat", height: 2, width: 2, inactiveLabel: false) {
+            state "default", label:"Reboot", action:"reboot", icon:"", backgroundColor:"#ffffff"
+        }
+        valueTile("ip", "ip", width: 2, height: 1) {
+    		state "ip", label:'IP Address\r\n${currentValue}'
+		}
+        valueTile("uptime", "uptime", width: 2, height: 1) {
+    		state "uptime", label:'Uptime ${currentValue}'
+		}
+        
+    }
+
+	main(["switch"])
+	details(["switch",
+             "refresh","configure","reboot",
+             "ip", "uptime"])
+}
+
+def installed() {
+	log.debug "installed()"
+	configure()
+}
+
+def configure() {
+    logging("configure()", 1)
+    def cmds = []
+    cmds = update_needed_settings()
+    if (cmds != []) cmds
+}
+
+def updated()
+{
+    logging("updated()", 1)
+    def cmds = [] 
+    cmds = update_needed_settings()
+    sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "lan", hubHardwareId: device.hub.hardwareID])
+    sendEvent(name:"needUpdate", value: device.currentValue("needUpdate"), displayed:false, isStateChange: true)
+    if (cmds != []) response(cmds)
+}
+
+private def logging(message, level) {
+    if (logLevel != "0"){
+    switch (logLevel) {
+       case "1":
+          if (level > 1)
+             log.debug "$message"
+       break
+       case "99":
+          log.debug "$message"
+       break
+    }
+    }
+}
+
+def parse(description) {
+	//log.debug "Parsing: ${description}"
+    def events = []
+    def descMap = parseDescriptionAsMap(description)
+    def body
+    //log.debug "descMap: ${descMap}"
+
+    if (!state.mac || state.mac != descMap["mac"]) {
+		log.debug "Mac address of device found ${descMap["mac"]}"
+        updateDataValue("mac", descMap["mac"])
+	}
+    
+    if (state.mac != null && state.dni != state.mac) state.dni = setDeviceNetworkId(state.mac)
+    if (descMap["body"]) body = new String(descMap["body"].decodeBase64())
+
+    if (body && body != "") {
+    
+    if(body.startsWith("{") || body.startsWith("[")) {
+    def slurper = new JsonSlurper()
+    def result = slurper.parseText(body)
+    
+    log.debug "result: ${result}"
+    
+    if (result.containsKey("type")) {
+        if (result.type == "configuration")
+            events << update_current_properties(result)
+    }
+    if (result.containsKey("power")) {
+        events << createEvent(name: "switch", value: result.power)
+    }
+    if (result.containsKey("uptime")) {
+        events << createEvent(name: "uptime", value: result.uptime, displayed: false)
+    }
+    } else {
+        //log.debug "Response is not JSON: $body"
+    }
+    }
+
+    if (!device.currentValue("ip") || (device.currentValue("ip") != getDataValue("ip"))) events << createEvent(name: 'ip', value: getDataValue("ip"))
+
+    return events
+}
+
+def parseDescriptionAsMap(description) {
+	description.split(",").inject([:]) { map, param ->
+		def nameAndValue = param.split(":")
+        
+        if (nameAndValue.length == 2) map += [(nameAndValue[0].trim()):nameAndValue[1].trim()]
+        else map += [(nameAndValue[0].trim()):""]
+	}
+}
+
+def on() {
+	log.debug "on()"
+    def cmds = []
+    cmds << getAction("/on")
+    return cmds
+}
+
+def off() {
+    log.debug "off()"
+	def cmds = []
+    cmds << getAction("/off")
+    return cmds
+}
+
+def refresh() {
+	log.debug "refresh()"
+    def cmds = []
+    cmds << getAction("/status")
+    return cmds
+}
+
+def ping() {
+    log.debug "ping()"
+    refresh()
+}
+
+private getAction(uri){ 
+  updateDNI()
+  def userpass
+  //log.debug uri
+  if(password != null && password != "") 
+    userpass = encodeCredentials("admin", password)
+    
+  def headers = getHeader(userpass)
+
+  def hubAction = new physicalgraph.device.HubAction(
+    method: "GET",
+    path: uri,
+    headers: headers
+  )
+  return hubAction    
+}
+
+private postAction(uri, data){ 
+  updateDNI()
+  
+  def userpass
+  
+  if(password != null && password != "") 
+    userpass = encodeCredentials("admin", password)
+  
+  def headers = getHeader(userpass)
+  
+  def hubAction = new physicalgraph.device.HubAction(
+    method: "POST",
+    path: uri,
+    headers: headers,
+    body: data
+  )
+  return hubAction    
+}
+
+private setDeviceNetworkId(ip, port = null){
+    def myDNI
+    if (port == null) {
+        myDNI = ip
+    } else {
+  	    def iphex = convertIPtoHex(ip)
+  	    def porthex = convertPortToHex(port)
+        myDNI = "$iphex:$porthex"
+    }
+    log.debug "Device Network Id set to ${myDNI}"
+    return myDNI
+}
+
+private updateDNI() { 
+    if (state.dni != null && state.dni != "" && device.deviceNetworkId != state.dni) {
+       device.deviceNetworkId = state.dni
+    }
+}
+
+private getHostAddress() {
+    if (override == "true" && ip != null && ip != ""){
+        return "${ip}:80"
+    }
+    else if(getDeviceDataByName("ip") && getDeviceDataByName("port")){
+        return "${getDeviceDataByName("ip")}:${getDeviceDataByName("port")}"
+    }else{
+	    return "${ip}:80"
+    }
+}
+
+private String convertIPtoHex(ipAddress) { 
+    String hex = ipAddress.tokenize( '.' ).collect {  String.format( '%02x', it.toInteger() ) }.join()
+    return hex
+}
+
+private String convertPortToHex(port) {
+	String hexport = port.toString().format( '%04x', port.toInteger() )
+    return hexport
+}
+
+private encodeCredentials(username, password){
+	def userpassascii = "${username}:${password}"
+    def userpass = "Basic " + userpassascii.encodeAsBase64().toString()
+    return userpass
+}
+
+private getHeader(userpass = null){
+    def headers = [:]
+    headers.put("Host", getHostAddress())
+    headers.put("Content-Type", "application/x-www-form-urlencoded")
+    if (userpass != null)
+       headers.put("Authorization", userpass)
+    return headers
+}
+
+def reboot() {
+	log.debug "reboot()"
+    def uri = "/reboot"
+    getAction(uri)
+}
+
+def sync(ip, port) {
+    def existingIp = getDataValue("ip")
+    def existingPort = getDataValue("port")
+    if (ip && ip != existingIp) {
+        updateDataValue("ip", ip)
+        sendEvent(name: 'ip', value: ip)
+    }
+    if (port && port != existingPort) {
+        updateDataValue("port", port)
+    }
+}
+
+def generate_preferences(configuration_model)
+{
+    def configuration = parseXml(configuration_model)
+   
+    configuration.Value.each
+    {
+        if(it.@hidden != "true" && it.@disabled != "true"){
+        switch(it.@type)
+        {   
+            case ["number"]:
+                input "${it.@index}", "number",
+                    title:"${it.@label}\n" + "${it.Help}",
+                    range: "${it.@min}..${it.@max}",
+                    defaultValue: "${it.@value}",
+                    displayDuringSetup: "${it.@displayDuringSetup}"
+            break
+            case "list":
+                def items = []
+                it.Item.each { items << ["${it.@value}":"${it.@label}"] }
+                input "${it.@index}", "enum",
+                    title:"${it.@label}\n" + "${it.Help}",
+                    defaultValue: "${it.@value}",
+                    displayDuringSetup: "${it.@displayDuringSetup}",
+                    options: items
+            break
+            case ["password"]:
+                input "${it.@index}", "password",
+                    title:"${it.@label}\n" + "${it.Help}",
+                    displayDuringSetup: "${it.@displayDuringSetup}"
+            break
+            case "decimal":
+               input "${it.@index}", "decimal",
+                    title:"${it.@label}\n" + "${it.Help}",
+                    range: "${it.@min}..${it.@max}",
+                    defaultValue: "${it.@value}",
+                    displayDuringSetup: "${it.@displayDuringSetup}"
+            break
+            case "boolean":
+               input "${it.@index}", "boolean",
+                    title:"${it.@label}\n" + "${it.Help}",
+                    defaultValue: "${it.@value}",
+                    displayDuringSetup: "${it.@displayDuringSetup}"
+            break
+        }
+        }
+    }
+}
+
+ /*  Code has elements from other community source @CyrilPeponnet (Z-Wave Parameter Sync). */
+
+def update_current_properties(cmd)
+{
+    def currentProperties = state.currentProperties ?: [:]
+    currentProperties."${cmd.name}" = cmd.value
+
+    if (settings."${cmd.name}" != null)
+    {
+        if (settings."${cmd.name}".toString() == cmd.value)
+        {
+            sendEvent(name:"needUpdate", value:"NO", displayed:false, isStateChange: true)
+        }
+        else
+        {
+            sendEvent(name:"needUpdate", value:"YES", displayed:false, isStateChange: true)
+        }
+    }
+    state.currentProperties = currentProperties
+}
+
+
+def update_needed_settings()
+{
+    def cmds = []
+    def currentProperties = state.currentProperties ?: [:]
+     
+    def configuration = parseXml(configuration_model())
+    def isUpdateNeeded = "NO"
+    
+    cmds << getAction("/configSet?name=haip&value=${device.hub.getDataValue("localIP")}")
+    cmds << getAction("/configSet?name=haport&value=${device.hub.getDataValue("localSrvPortTCP")}")
+    
+    configuration.Value.each
+    {     
+        if ("${it.@setting_type}" == "lan" && it.@disabled != "true"){
+            if (currentProperties."${it.@index}" == null)
+            {
+               if (it.@setonly == "true"){
+                  logging("Setting ${it.@index} will be updated to ${it.@value}", 2)
+                  cmds << getAction("/configSet?name=${it.@index}&value=${it.@value}")
+               } else {
+                  isUpdateNeeded = "YES"
+                  logging("Current value of setting ${it.@index} is unknown", 2)
+                  cmds << getAction("/configGet?name=${it.@index}")
+               }
+            }
+            else if ((settings."${it.@index}" != null || it.@hidden == "true") && currentProperties."${it.@index}" != (settings."${it.@index}"? settings."${it.@index}".toString() : "${it.@value}"))
+            { 
+                isUpdateNeeded = "YES"
+                logging("Setting ${it.@index} will be updated to ${settings."${it.@index}"}", 2)
+                cmds << getAction("/configSet?name=${it.@index}&value=${settings."${it.@index}"}")
+            } 
+        }
+    }
+    
+    sendEvent(name:"needUpdate", value: isUpdateNeeded, displayed:false, isStateChange: true)
+    return cmds
+}
+
+def configuration_model()
+{
+'''
+<configuration>
+<Value type="password" byteSize="1" index="password" label="Password" min="" max="" value="" setting_type="preference" fw="">
+<Help>
+</Help>
+</Value>
+<Value type="list" byteSize="1" index="pos" label="Boot Up State" min="0" max="2" value="0" setting_type="lan" fw="">
+<Help>
+Default: Off
+</Help>
+    <Item label="Off" value="0" />
+    <Item label="On" value="1" />
+    <Item label="Previous" value="2" />
+</Value>
+<Value type="number" byteSize="1" index="autooff" label="Auto Off" min="0" max="65536" value="0" setting_type="lan" fw="">
+<Help>
+Automatically turn the switch off after this many seconds.
+Range: 0 to 65536
+Default: 0 (Disabled)
+</Help>
+</Value>
+<Value type="list" byteSize="1" index="switchtype" label="External Switch Type" min="0" max="1" value="0" setting_type="lan" fw="">
+<Help>
+If a switch is attached to GPIO 14.
+Default: Momentary
+</Help>
+    <Item label="Momentary" value="0" />
+    <Item label="Toggle" value="1" />
+</Value>
+<Value type="list" index="logLevel" label="Debug Logging Level?" value="0" setting_type="preference" fw="">
+<Help>
+</Help>
+    <Item label="None" value="0" />
+    <Item label="Reports" value="1" />
+    <Item label="All" value="99" />
+</Value>
+</configuration>
+'''
+}

devicetypes/plaidsystems/spruce-sensor.src/spruce-sensor.groovy

@@ -1,5 +1,5 @@
 /**
- *  Spruce Sensor -updated with SLP model number 5/2017
+ *  Spruce Sensor -Pre-release V2 10/8/2015
  *
  *  Copyright 2014 Plaid Systems
  *
@@ -14,33 +14,25 @@
  *
  -------10/20/2015 Updates--------
  -Fix/add battery reporting interval to update
- -remove polling and/or refresh
- 
- -------5/2017 Updates--------
- -Add fingerprints for SLP
- -add device health, check every 60mins + 2mins
+ -remove polling and/or refresh(?)
  */
- 
 metadata {
-	definition (name: "Spruce Sensor", namespace: "plaidsystems", author: "Plaid Systems") {
+	definition (name: "Spruce Sensor", namespace: "plaidsystems", author: "NCauffman") {
 		
 		capability "Configuration"
 		capability "Battery"
         capability "Relative Humidity Measurement"
         capability "Temperature Measurement"
         capability "Sensor"
-        capability "Health Check"
         //capability "Polling"
 		
         attribute "maxHum", "string"
         attribute "minHum", "string"        
         
-        
         command "resetHumidity"
         command "refresh"
         
-        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0402,0405", outClusters: "0003, 0019", manufacturer: "PLAID SYSTEMS", model: "PS-SPRZMS-01", deviceJoinName: "Spruce Sensor"
-        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0402,0405", outClusters: "0003, 0019", manufacturer: "PLAID SYSTEMS", model: "PS-SPRZMS-SLP1", deviceJoinName: "Spruce Sensor"
+        fingerprint profileId: "0104", inClusters: "0000,0001,0003,0402,0405", outClusters: "0003, 0019", manufacturer: "PLAID SYSTEMS", model: "PS-SPRZMS-01"
 	}
 
 	preferences {
@@ -301,11 +293,6 @@ def setConfig(){
     sendEvent(name: 'configuration',value: configInterval, descriptionText: "Configuration initialized")
 }
 
-def installed(){
-	//check every 1 hour + 2mins
-    sendEvent(name: "checkInterval", value: 1 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-}
-
 //when device preferences are changed
 def updated(){	
     log.debug "device updated"
@@ -316,8 +303,6 @@ def updated(){
             sendEvent(name: 'configuration',value: 0, descriptionText: "Settings changed and will update at next report. Measure interval set to ${interval} mins")
     	}
     }
-    //check every 1 hour + 2mins
-    sendEvent(name: "checkInterval", value: 1 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
 }
 
 //poll
@@ -410,4 +395,4 @@ private byte[] reverseArray(byte[] array) {
         i++;
     }
     return array
-}
+}

devicetypes/smartthings/aeon-multisensor-6.src/README.md

@@ -27,9 +27,13 @@ Works with:
 ## Device Health
 
 Aeon Labs MultiSensor 6 is polled by the hub.
-Aeon MultiSensor reports in once every hour.
+As of hubCore version 0.14.38 the hub sends up reports every 15 minutes regardless of whether the state changed.
+Device-Watch allows 2 check-in misses from device plus some lag time. So Check-in interval = (2*15 + 2)mins = 32 mins.
+Not to mention after going OFFLINE when the device is plugged back in, it might take a considerable amount of time for
+the device to appear as ONLINE again. This is because if this listening device does not respond to two poll requests in a row,
+it is not polled for 5 minutes by the hub. This can delay up the process of being marked ONLINE by quite some time.
 
-* __122min__ checkInterval
+* __32min__ checkInterval
 
 ## Troubleshooting
 

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

@@ -130,13 +130,13 @@ metadata {
 }
 
 def installed(){
-// Device-Watch simply pings if no device events received for 122min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+// Device-Watch simply pings if no device events received for 32min(checkInterval)
+	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 }
 
 def updated() {
-// Device-Watch simply pings if no device events received for 122min(checkInterval)
-	sendEvent(name: "checkInterval", value: 2 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+// Device-Watch simply pings if no device events received for 32min(checkInterval)
+	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 	log.debug "Updated with settings: ${settings}"
 	log.debug "${device.displayName} is now ${device.latestValue("powerSupply")}"
 

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

@@ -158,7 +158,7 @@ def generateEvent(Map results) {
 	if(results) {
 
 			def linkText = getLinkText(device)
-		def supportedThermostatModes = ["off"]
+		def supportedThermostatModes = []
 		def thermostatMode = null
 
 		results.each { name, value ->

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

@@ -105,8 +105,6 @@ def parse(String description) {
 				} else {
 					log.warn "TEMP REPORTING CONFIG FAILED- error code: ${descMap.data[0]}"
 				}
-			} else if (descMap?.clusterInt == zigbee.IAS_ZONE_CLUSTER && descMap.attrInt == zigbee.ATTRIBUTE_IAS_ZONE_STATUS && descMap?.value) {
-				map = translateZoneStatus(new ZoneStatus(zigbee.convertToInt(descMap?.value)))
 			}
 		}
 	} else if (map.name == "temperature") {
@@ -131,10 +129,6 @@ def parse(String description) {
 private Map parseIasMessage(String description) {
 	ZoneStatus zs = zigbee.parseZoneStatus(description)
 
-	translateZoneStatus(zs)
-}
-
-private Map translateZoneStatus(ZoneStatus zs) {
 	return zs.isAlarm1Set() ? getMoistureResult('wet') : getMoistureResult('dry')
 }
 
@@ -203,8 +197,7 @@ def ping() {
 def refresh() {
 	log.debug "Refreshing Temperature and Battery"
 	def refreshCmds = zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
-			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) +
-			zigbee.readAttribute(zigbee.IAS_ZONE_CLUSTER, zigbee.ATTRIBUTE_IAS_ZONE_STATUS)
+			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020)
 
 	return refreshCmds + zigbee.enrollResponse()
 }

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

@@ -111,8 +111,6 @@ def parse(String description) {
 				def value = descMap.value.endsWith("01") ? "active" : "inactive"
 				log.debug "Doing a read attr motion event"
 				map = getMotionResult(value)
-			} else if (descMap?.clusterInt == zigbee.IAS_ZONE_CLUSTER && descMap.attrInt == zigbee.ATTRIBUTE_IAS_ZONE_STATUS && descMap?.value) {
-				map = translateZoneStatus(new ZoneStatus(zigbee.convertToInt(descMap?.value)))
 			}
 		}
 	} else if (map.name == "temperature") {
@@ -137,10 +135,6 @@ def parse(String description) {
 private Map parseIasMessage(String description) {
 	ZoneStatus zs = zigbee.parseZoneStatus(description)
 
-	translateZoneStatus(zs)
-}
-
-private Map translateZoneStatus(ZoneStatus zs) {
 	// Some sensor models that use this DTH use alarm1 and some use alarm2 to signify motion
 	return (zs.isAlarm1Set() || zs.isAlarm2Set()) ? getMotionResult('active') : getMotionResult('inactive')
 }
@@ -171,8 +165,8 @@ private Map getBatteryResult(rawValue) {
 			def pct = batteryMap[volts]
 			result.value = pct
 		} else {
-			def minVolts = 2.4
-			def maxVolts = 2.7
+			def minVolts = 2.1
+			def maxVolts = 3.0
 			def pct = (volts - minVolts) / (maxVolts - minVolts)
 			def roundedPct = Math.round(pct * 100)
 			if (roundedPct <= 0)
@@ -206,8 +200,7 @@ def refresh() {
 	log.debug "refresh called"
 
 	def refreshCmds = zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) +
-			zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
-			zigbee.readAttribute(zigbee.IAS_ZONE_CLUSTER, zigbee.ATTRIBUTE_IAS_ZONE_STATUS)
+			zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000)
 
 	return refreshCmds + zigbee.enrollResponse()
 }

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

@@ -134,9 +134,8 @@ def parse(String description) {
 				} else {
 					log.warn "TEMP REPORTING CONFIG FAILED- error code: ${descMap.data[0]}"
 				}
-			} else if (descMap?.clusterInt == zigbee.IAS_ZONE_CLUSTER && descMap.attrInt == zigbee.ATTRIBUTE_IAS_ZONE_STATUS && descMap?.value) {
-				maps += translateZoneStatus(new ZoneStatus(zigbee.convertToInt(descMap?.value)))
 			} else {
+
 				maps += handleAcceleration(descMap)
 			}
 		}
@@ -230,11 +229,6 @@ private List<Map> parseAxis(List<Map> attrData) {
 
 private List<Map> parseIasMessage(String description) {
 	ZoneStatus zs = zigbee.parseZoneStatus(description)
-
-	translateZoneStatus(zs)
-}
-
-private List<Map> translateZoneStatus(ZoneStatus zs) {
 	List<Map> results = []
 
 	if (garageSensor != "Yes") {
@@ -274,7 +268,7 @@ private Map getBatteryResult(rawValue) {
 			result.value = pct
 		} else {
 			def minVolts = 2.1
-			def maxVolts = 2.7
+			def maxVolts = 3.0
 			def pct = (volts - minVolts) / (maxVolts - minVolts)
 			def roundedPct = Math.round(pct * 100)
 			if (roundedPct <= 0)
@@ -319,7 +313,7 @@ def refresh() {
 	def refreshCmds = zigbee.readAttribute(zigbee.TEMPERATURE_MEASUREMENT_CLUSTER, 0x0000) +
 			zigbee.readAttribute(zigbee.POWER_CONFIGURATION_CLUSTER, 0x0020) +
 			zigbee.readAttribute(0xFC02, 0x0010, [mfgCode: manufacturerCode]) +
-			zigbee.readAttribute(zigbee.IAS_ZONE_CLUSTER, zigbee.ATTRIBUTE_IAS_ZONE_STATUS) + zigbee.enrollResponse()
+			zigbee.enrollResponse()
 
 	return refreshCmds
 }

devicetypes/smartthings/zigbee-button.src/README.md

@@ -28,8 +28,9 @@ Works with:
 
 ## Device Health
 
-ZigBee Button is marked offline only in the case when Hub is offline.
+SmartThings platform will ping the device after `checkInterval` seconds of inactivity in last attempt to reach the device before marking it `OFFLINE` 
 
+* __722min__ checkInterval
 
 ## Troubleshooting
 

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

@@ -13,8 +13,6 @@
  *  for the specific language governing permissions and limitations under the License.
  *
  */
-
-import groovy.json.JsonOutput
 import physicalgraph.zigbee.zcl.DataType
 
 metadata {
@@ -185,6 +183,13 @@ private Map parseNonIasButtonMessage(Map descMap){
     }
 }
 
+/**
+ * PING is used by Device-Watch in attempt to reach the Device
+ * */
+def ping() {
+    refresh()
+}
+
 def refresh() {
     log.debug "Refreshing Battery"
 
@@ -193,6 +198,8 @@ def refresh() {
 }
 
 def configure() {
+    // Device-Watch allows 2 check-in misses from device (plus 2 mins lag time)
+    sendEvent(name: "checkInterval", value: 2 * 6 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
     log.debug "Configuring Reporting, IAS CIE, and Bindings."
     def cmds = []
     if (device.getDataValue("model") == "3450-L") {
@@ -252,8 +259,6 @@ def updated() {
 }
 
 def initialize() {
-    // Arrival sensors only goes OFFLINE when Hub is off
-    sendEvent(name: "DeviceWatch-Enroll", value: JsonOutput.toJson([protocol: "zigbee", scheme:"untracked"]), displayed: false)
     if ((device.getDataValue("manufacturer") == "OSRAM") && (device.getDataValue("model") == "LIGHTIFY Dimming Switch")) {
         sendEvent(name: "numberOfButtons", value: 2)
     }

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

@@ -15,9 +15,10 @@ metadata {
 	definition (name: "Z-Wave Thermostat", namespace: "smartthings", author: "SmartThings") {
 		capability "Actuator"
 		capability "Temperature Measurement"
+		capability "Relative Humidity Measurement"
 		capability "Thermostat"
 		capability "Configuration"
-		capability "Refresh"
+		capability "Polling"
 		capability "Sensor"
 		capability "Health Check"
 		
@@ -116,7 +117,7 @@ metadata {
 			state "cool", label:'${currentValue}° cool', backgroundColor:"#ffffff"
 		}
 		standardTile("refresh", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
-			state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
+			state "default", action:"polling.poll", icon:"st.secondary.refresh"
 		}
 		main "temperature"
 		details(["temperature", "mode", "fanMode", "heatSliderControl", "heatingSetpoint", "coolSliderControl", "coolingSetpoint", "refresh"])
@@ -124,20 +125,13 @@ metadata {
 }
 
 def installed(){
-	sendHubCommand(new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeSupportedGet().format()))
-	initialize()
+	// Device-Watch simply pings if no device events received for 32min(checkInterval)
+	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
 }
 
 def updated(){
-	initialize()
-}
-
-def initialize() {
 	// Device-Watch simply pings if no device events received for 32min(checkInterval)
 	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-	unschedule()
-	runEvery5Minutes("refresh")
-	refresh()
 }
 
 def parse(String description)
@@ -155,7 +149,6 @@ def parse(String description)
 		]
 		if (map.name == "thermostatMode") {
 			state.lastTriedMode = map.value
-			map.data = [supportedThermostatModes:state.supportedThermostatModes]
 			if (map.value == "cool") {
 				map2.value = device.latestValue("coolingSetpoint")
 				log.info "THERMOSTAT, latest cooling setpoint = ${map2.value}"
@@ -179,7 +172,6 @@ def parse(String description)
 		}
 	} else if (map.name == "thermostatFanMode" && map.isStateChange) {
 		state.lastTriedFanMode = map.value
-		map.data = [supportedThermostatFanModes: state.supportedThermostatFanModes]
 	}
 	log.debug "Parse returned $result"
 	result
@@ -313,26 +305,26 @@ def zwaveEvent(physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanMod
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeSupportedReport cmd) {
-	def supportedModes = []
-	if(cmd.off) { supportedModes << "off" }
-	if(cmd.heat) { supportedModes << "heat" }
-	if(cmd.cool) { supportedModes << "cool" }
-	if(cmd.auto) { supportedModes << "auto" }
-	if(cmd.auxiliaryemergencyHeat) { supportedModes << "emergency heat" }
+	def supportedModes = ""
+	if(cmd.off) { supportedModes += "off " }
+	if(cmd.heat) { supportedModes += "heat " }
+	if(cmd.auxiliaryemergencyHeat) { supportedModes += "emergency heat " }
+	if(cmd.cool) { supportedModes += "cool " }
+	if(cmd.auto) { supportedModes += "auto " }
 
-	state.supportedThermostatModes = supportedModes
-	sendEvent(name: "supportedThermostatModes", value: supportedModes, displayed: false)
+	state.supportedModes = supportedModes
+	// No events to be generated, return empty map
 	return [:]
 }
 
 def zwaveEvent(physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeSupportedReport cmd) {
-	def supportedFanModes = []
-	if(cmd.auto) { supportedFanModes << "auto" } // "fanAuto "
-	if(cmd.circulation) { supportedFanModes << "circulate" } // "fanCirculate"
-	if(cmd.low) { supportedFanModes << "on" } // "fanOn"
+	def supportedFanModes = ""
+	if(cmd.auto) { supportedFanModes += "auto " } // "fanAuto "
+	if(cmd.low) { supportedFanModes += "on " } // "fanOn"
+	if(cmd.circulation) { supportedFanModes += "circulate " } // "fanCirculate"
 
-	state.supportedThermostatFanModes = supportedFanModes
-	sendEvent(name: "supportedThermostatFanModes", value: supportedFanModes, displayed: false)
+	state.supportedFanModes = supportedFanModes
+	// No events to be generated, return empty map
 	return [:]
 }
 
@@ -345,17 +337,15 @@ def zwaveEvent(physicalgraph.zwave.Command cmd) {
 }
 
 // Command Implementations
-def refresh() {
-	def cmds = []
-	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeSupportedGet().format())
-	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeSupportedGet().format())
-	cmds << new physicalgraph.device.HubAction(zwave.thermostatModeV2.thermostatModeGet().format())
-	cmds << new physicalgraph.device.HubAction(zwave.thermostatFanModeV3.thermostatFanModeGet().format())
-	cmds << new physicalgraph.device.HubAction(zwave.sensorMultilevelV2.sensorMultilevelGet().format()) // current temperature
-	cmds << new physicalgraph.device.HubAction(zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format())
-	cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format())
-	cmds << new physicalgraph.device.HubAction(zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format())
-	sendHubCommand(cmds)
+def poll() {
+	delayBetween([
+		zwave.sensorMultilevelV3.sensorMultilevelGet().format(), // current temperature
+		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format(),
+		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format(),
+		zwave.thermostatModeV2.thermostatModeGet().format(),
+		zwave.thermostatFanModeV3.thermostatFanModeGet().format(),
+		zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format()
+	], 2300)
 }
 
 def quickSetHeat(degrees) {
@@ -426,14 +416,28 @@ def ping() {
 	poll()
 }
 
+def configure() {
+	delayBetween([
+		zwave.thermostatModeV2.thermostatModeSupportedGet().format(),
+		zwave.thermostatFanModeV3.thermostatFanModeSupportedGet().format(),
+		zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:[zwaveHubNodeId]).format(),
+		zwave.sensorMultilevelV3.sensorMultilevelGet().format(), // current temperature
+		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format(),
+		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format(),
+		zwave.thermostatModeV2.thermostatModeGet().format(),
+		zwave.thermostatFanModeV3.thermostatFanModeGet().format(),
+		zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format()
+	], 2300)
+}
+
 def modes() {
-	return state.supportedThermostatModes
+	["off", "heat", "cool", "auto", "emergency heat"]
 }
 
 def switchMode() {
 	def currentMode = device.currentState("thermostatMode")?.value
-	def lastTriedMode = state.lastTriedMode ?: currentMode ?: ["off"]
-	def supportedModes = getDataByName("supportedThermostatModes")
+	def lastTriedMode = state.lastTriedMode ?: currentMode ?: "off"
+	def supportedModes = getDataByName("supportedModes")
 	def modeOrder = modes()
 	def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
 	def nextMode = next(lastTriedMode)
@@ -450,7 +454,7 @@ def switchMode() {
 }
 
 def switchToMode(nextMode) {
-	def supportedModes = getDataByName("supportedThermostatModes")
+	def supportedModes = getDataByName("supportedModes")
 	if(supportedModes && !supportedModes.contains(nextMode)) log.warn "thermostat mode '$nextMode' is not supported"
 	if (nextMode in modes()) {
 		state.lastTriedMode = nextMode
@@ -462,9 +466,9 @@ def switchToMode(nextMode) {
 
 def switchFanMode() {
 	def currentMode = device.currentState("thermostatFanMode")?.value
-	def lastTriedMode = state.lastTriedFanMode ?: currentMode ?: ["off"]
-	def supportedModes = getDataByName("supportedThermostatFanModes") ?: ["auto", "on"]
-	def modeOrder = state.supportedThermostatFanModes
+	def lastTriedMode = state.lastTriedFanMode ?: currentMode ?: "off"
+	def supportedModes = getDataByName("supportedFanModes") ?: "auto on" // "fanAuto fanOn"
+	def modeOrder = ["auto", "circulate", "on"]                 // "fanAuto", "fanCirculate", "fanOn"
 	def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
 	def nextMode = next(lastTriedMode)
 	while (!supportedModes?.contains(nextMode) && nextMode != "auto") { // "fanAuto"
@@ -474,7 +478,7 @@ def switchFanMode() {
 }
 
 def switchToFanMode(nextMode) {
-	def supportedFanModes = getDataByName("supportedThermostatFanModes")
+	def supportedFanModes = getDataByName("supportedFanModes")
 	if(supportedFanModes && !supportedFanModes.contains(nextMode)) log.warn "thermostat mode '$nextMode' is not supported"
 
 	def returnCommand

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

@@ -58,7 +58,6 @@ metadata {
 def installed() {
 	// Device-Watch simply pings if no device events received for 32min(checkInterval)
 	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-	response(refresh())
 }
 
 def updated() {

smartapps/erocm123/sonoff-connect.src/sonoff-connect.groovy

@@ -0,0 +1,409 @@
+/**
+ *  Copyright 2016 Eric Maycock
+ *
+ *  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.
+ *
+ *  Sonoff (Connect)
+ *
+ *  Author: Eric Maycock (erocm123)
+ *  Date: 2016-06-02
+ */
+
+definition(
+    name: "Sonoff (Connect)",
+    namespace: "erocm123",
+    author: "Eric Maycock (erocm123)",
+    description: "Service Manager for Sonoff switches",
+    category: "Convenience",
+    iconUrl:   "https://raw.githubusercontent.com/erocm123/SmartThingsPublic/master/smartapps/erocm123/sonoff-connect.src/sonoff-connect-icon.png",
+    iconX2Url: "https://raw.githubusercontent.com/erocm123/SmartThingsPublic/master/smartapps/erocm123/sonoff-connect.src/sonoff-connect-icon-2x.png",
+    iconX3Url: "https://raw.githubusercontent.com/erocm123/SmartThingsPublic/master/smartapps/erocm123/sonoff-connect.src/sonoff-connect-icon-3x.png"
+)
+
+preferences {
+	page(name: "mainPage")
+    page(name: "configurePDevice")
+    page(name: "deletePDevice")
+    page(name: "changeName")
+    page(name: "discoveryPage", title: "Device Discovery", content: "discoveryPage", refreshTimeout:5)
+    page(name: "addDevices", title: "Add Sonoff Switches", content: "addDevices")
+    page(name: "manuallyAdd")
+    page(name: "manuallyAddConfirm")
+    page(name: "deviceDiscovery")
+}
+
+def mainPage() {
+	dynamicPage(name: "mainPage", title: "Manage your Sonoff switches", nextPage: null, uninstall: true, install: true) {
+        section("Configure"){
+           href "deviceDiscovery", title:"Discover Devices", description:""
+           href "manuallyAdd", title:"Manually Add Device", description:""
+        }
+        section("Installed Devices"){
+            getChildDevices().sort({ a, b -> a["deviceNetworkId"] <=> b["deviceNetworkId"] }).each {
+                href "configurePDevice", title:"$it.label", description:"", params: [did: it.deviceNetworkId]
+            }
+        }
+    }
+}
+
+def configurePDevice(params){
+   if (params?.did || params?.params?.did) {
+      if (params.did) {
+         state.currentDeviceId = params.did
+         state.currentDisplayName = getChildDevice(params.did)?.displayName
+      } else {
+         state.currentDeviceId = params.params.did
+         state.currentDisplayName = getChildDevice(params.params.did)?.displayName
+      }
+   }  
+   if (getChildDevice(state.currentDeviceId) != null) getChildDevice(state.currentDeviceId).configure()
+   dynamicPage(name: "configurePDevice", title: "Configure Sonoff Switches created with this app", nextPage: null) {
+		section {
+            app.updateSetting("${state.currentDeviceId}_label", getChildDevice(state.currentDeviceId).label)
+            input "${state.currentDeviceId}_label", "text", title:"Device Name", description: "", required: false
+            href "changeName", title:"Change Device Name", description: "Edit the name above and click here to change it"
+        }
+        section {
+              href "deletePDevice", title:"Delete $state.currentDisplayName", description: ""
+        }
+   }
+}
+
+def manuallyAdd(){
+   dynamicPage(name: "manuallyAdd", title: "Manually add a Sonoff device", nextPage: "manuallyAddConfirm") {
+		section {
+			paragraph "This process will manually create a Sonoff device based on the entered IP address. The SmartApp needs to then communicate with the device to obtain additional information from it. Make sure the device is on and connected to your wifi network."
+            input "deviceType", "enum", title:"Device Type", description: "", required: false, options: ["Sonoff Wifi Switch","Sonoff TH Wifi Switch","Sonoff POW Wifi Switch","Sonoff Dual Wifi Switch","Sonoff 4CH Wifi Switch"]
+            input "ipAddress", "text", title:"IP Address", description: "", required: false 
+		}
+    }
+}
+
+def manuallyAddConfirm(){
+   if ( ipAddress =~ /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/) {
+       log.debug "Creating Sonoff Wifi Switch with dni: ${convertIPtoHex(ipAddress)}:${convertPortToHex("80")}"
+       addChildDevice("erocm123", deviceType ? deviceType : "Sonoff Wifi Switch", "${convertIPtoHex(ipAddress)}:${convertPortToHex("80")}", location.hubs[0].id, [
+           "label": (deviceType ? deviceType : "Sonoff Wifi Switch") + " (${ipAddress})",
+           "data": [
+           "ip": ipAddress,
+           "port": "80" 
+           ]
+       ])
+   
+       app.updateSetting("ipAddress", "")
+            
+       dynamicPage(name: "manuallyAddConfirm", title: "Manually add a Sonoff device", nextPage: "mainPage") {
+		   section {
+			   paragraph "The device has been added. Press next to return to the main page."
+	    	}
+       }
+    } else {
+        dynamicPage(name: "manuallyAddConfirm", title: "Manually add a Sonoff device", nextPage: "mainPage") {
+		    section {
+			    paragraph "The entered ip address is not valid. Please try again."
+		    }
+        }
+    }
+}
+
+def deletePDevice(){
+    try {
+        unsubscribe()
+        deleteChildDevice(state.currentDeviceId)
+        dynamicPage(name: "deletePDevice", title: "Deletion Summary", nextPage: "mainPage") {
+            section {
+                paragraph "The device has been deleted. Press next to continue"
+            } 
+        }
+    
+	} catch (e) {
+        dynamicPage(name: "deletePDevice", title: "Deletion Summary", nextPage: "mainPage") {
+            section {
+                paragraph "Error: ${(e as String).split(":")[1]}."
+            } 
+        }
+    
+    }
+}
+
+def changeName(){
+    def thisDevice = getChildDevice(state.currentDeviceId)
+    thisDevice.label = settings["${state.currentDeviceId}_label"]
+
+    dynamicPage(name: "changeName", title: "Change Name Summary", nextPage: "mainPage") {
+	    section {
+            paragraph "The device has been renamed. Press \"Next\" to continue"
+        }
+    }
+}
+
+def discoveryPage(){
+   return deviceDiscovery()
+}
+
+def deviceDiscovery(params=[:])
+{
+	def devices = devicesDiscovered()
+    
+	int deviceRefreshCount = !state.deviceRefreshCount ? 0 : state.deviceRefreshCount as int
+	state.deviceRefreshCount = deviceRefreshCount + 1
+	def refreshInterval = 3
+    
+	def options = devices ?: []
+	def numFound = options.size() ?: 0
+
+	if ((numFound == 0 && state.deviceRefreshCount > 25) || params.reset == "true") {
+    	log.trace "Cleaning old device memory"
+    	state.devices = [:]
+        state.deviceRefreshCount = 0
+        app.updateSetting("selectedDevice", "")
+    }
+
+	ssdpSubscribe()
+
+	//sonoff discovery request every 15 //25 seconds
+	if((deviceRefreshCount % 5) == 0) {
+		discoverDevices()
+	}
+
+	//setup.xml request every 3 seconds except on discoveries
+	if(((deviceRefreshCount % 3) == 0) && ((deviceRefreshCount % 5) != 0)) {
+		verifyDevices()
+	}
+
+	return dynamicPage(name:"deviceDiscovery", title:"Discovery Started!", nextPage:"addDevices", refreshInterval:refreshInterval, uninstall: true) {
+		section("Please wait while we discover your Sonoff devices. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
+			input "selectedDevices", "enum", required:false, title:"Select Sonoff Switch (${numFound} found)", multiple:true, options:options
+		}
+        section("Options") {
+			href "deviceDiscovery", title:"Reset list of discovered devices", description:"", params: ["reset": "true"]
+		}
+	}
+}
+
+Map devicesDiscovered() {
+	def vdevices = getVerifiedDevices()
+	def map = [:]
+	vdevices.each {
+		def value = "${it.value.name}"
+		def key = "${it.value.mac}"
+		map["${key}"] = value
+	}
+	map
+}
+
+def getVerifiedDevices() {
+	getDevices().findAll{ it?.value?.verified == true }
+}
+
+private discoverDevices() {
+	sendHubCommand(new physicalgraph.device.HubAction("lan discovery urn:schemas-upnp-org:device:Basic:1", physicalgraph.device.Protocol.LAN))
+}
+
+def configured() {
+	
+}
+
+def buttonConfigured(idx) {
+	return settings["lights_$idx"]
+}
+
+def isConfigured(){
+   if(getChildDevices().size() > 0) return true else return false
+}
+
+def isVirtualConfigured(did){ 
+    def foundDevice = false
+    getChildDevices().each {
+       if(it.deviceNetworkId != null){
+       if(it.deviceNetworkId.startsWith("${did}/")) foundDevice = true
+       }
+    }
+    return foundDevice
+}
+
+private virtualCreated(number) {
+    if (getChildDevice(getDeviceID(number))) {
+        return true
+    } else {
+        return false
+    }
+}
+
+private getDeviceID(number) {
+    return "${state.currentDeviceId}/${app.id}/${number}"
+}
+
+def installed() {
+	initialize()
+}
+
+def updated() {
+	unsubscribe()
+    unschedule()
+	initialize()
+}
+
+def initialize() {
+    ssdpSubscribe()
+    runEvery5Minutes("ssdpDiscover")
+}
+
+void ssdpSubscribe() {
+    subscribe(location, "ssdpTerm.urn:schemas-upnp-org:device:Basic:1", ssdpHandler)
+}
+
+void ssdpDiscover() {
+    sendHubCommand(new physicalgraph.device.HubAction("lan discovery urn:schemas-upnp-org:device:Basic:1", physicalgraph.device.Protocol.LAN))
+}
+
+def ssdpHandler(evt) {
+    def description = evt.description
+    def hub = evt?.hubId
+    def parsedEvent = parseLanMessage(description)
+    parsedEvent << ["hub":hub]
+
+    def devices = getDevices()
+    
+    String ssdpUSN = parsedEvent.ssdpUSN.toString()
+    
+    if (devices."${ssdpUSN}") {
+        def d = devices."${ssdpUSN}"
+        def child = getChildDevice(parsedEvent.mac)
+        def childIP
+        def childPort
+        if (child) {
+            childIP = child.getDeviceDataByName("ip")
+            childPort = child.getDeviceDataByName("port").toString()
+            log.debug "Device data: ($childIP:$childPort) - reporting data: (${convertHexToIP(parsedEvent.networkAddress)}:${convertHexToInt(parsedEvent.deviceAddress)})."
+            if(childIP != convertHexToIP(parsedEvent.networkAddress) || childPort != convertHexToInt(parsedEvent.deviceAddress).toString()){
+               log.debug "Device data (${child.getDeviceDataByName("ip")}) does not match what it is reporting(${convertHexToIP(parsedEvent.networkAddress)}). Attempting to update."
+               child.sync(convertHexToIP(parsedEvent.networkAddress), convertHexToInt(parsedEvent.deviceAddress).toString())
+            }
+        }
+
+        if (d.networkAddress != parsedEvent.networkAddress || d.deviceAddress != parsedEvent.deviceAddress) {
+            d.networkAddress = parsedEvent.networkAddress
+            d.deviceAddress = parsedEvent.deviceAddress
+        }
+    } else {
+        devices << ["${ssdpUSN}": parsedEvent]
+    }
+}
+
+void verifyDevices() {
+    def devices = getDevices().findAll { it?.value?.verified != true }
+    devices.each {
+        def ip = convertHexToIP(it.value.networkAddress)
+        def port = convertHexToInt(it.value.deviceAddress)
+        String host = "${ip}:${port}"
+        sendHubCommand(new physicalgraph.device.HubAction("""GET ${it.value.ssdpPath} HTTP/1.1\r\nHOST: $host\r\n\r\n""", physicalgraph.device.Protocol.LAN, host, [callback: deviceDescriptionHandler]))
+    }
+}
+
+def getDevices() {
+    state.devices = state.devices ?: [:]
+}
+
+void deviceDescriptionHandler(physicalgraph.device.HubResponse hubResponse) {
+	log.trace "description.xml response (application/xml)"
+	def body = hubResponse.xml
+    log.debug body?.device?.friendlyName?.text()
+	if (body?.device?.modelName?.text().startsWith("Sonoff")) {
+		def devices = getDevices()
+		def device = devices.find {it?.key?.contains(body?.device?.UDN?.text())}
+		if (device) {
+			device.value << [name:body?.device?.friendlyName?.text() + " (" + convertHexToIP(hubResponse.ip) + ")", serialNumber:body?.device?.serialNumber?.text(), verified: true]
+		} else {
+			log.error "/description.xml returned a device that didn't exist"
+		}
+	}
+}
+
+def addDevices() {
+    def devices = getDevices()
+    def sectionText = ""
+
+    selectedDevices.each { dni ->bridgeLinking
+        def selectedDevice = devices.find { it.value.mac == dni }
+        def d
+        if (selectedDevice) {
+            d = getChildDevices()?.find {
+                it.deviceNetworkId == selectedDevice.value.mac
+            }
+        }
+
+        if (!d) {
+            log.debug selectedDevice
+            log.debug "Creating Sonoff Switch with dni: ${selectedDevice.value.mac}"
+
+            def deviceHandlerName
+            if (selectedDevice?.value?.name?.startsWith("Sonoff TH"))
+                deviceHandlerName = "Sonoff TH Wifi Switch"
+            else if (selectedDevice?.value?.name?.startsWith("Sonoff POW"))
+                deviceHandlerName = "Sonoff POW Wifi Switch"
+            else if (selectedDevice?.value?.name?.startsWith("Sonoff Dual"))
+                deviceHandlerName = "Sonoff Dual Wifi Switch"
+            else if (selectedDevice?.value?.name?.startsWith("Sonoff 4CH"))
+                deviceHandlerName = "Sonoff 4CH Wifi Switch"
+            else 
+                deviceHandlerName = "Sonoff Wifi Switch"
+            def newDevice = addChildDevice("erocm123", deviceHandlerName, selectedDevice.value.mac, selectedDevice?.value.hub, [
+                "label": selectedDevice?.value?.name ?: "Sonoff Wifi Switch",
+                "data": [
+                    "mac": selectedDevice.value.mac,
+                    "ip": convertHexToIP(selectedDevice.value.networkAddress),
+                    "port": "" + Integer.parseInt(selectedDevice.value.deviceAddress,16)
+                ]
+            ])
+            sectionText = sectionText + "Succesfully added Sonoff device with ip address ${convertHexToIP(selectedDevice.value.networkAddress)} \r\n"
+        }
+        
+	} 
+    log.debug sectionText
+        return dynamicPage(name:"addDevices", title:"Devices Added", nextPage:"mainPage",  uninstall: true) {
+        if(sectionText != ""){
+		section("Add Sonoff Results:") {
+			paragraph sectionText
+		}
+        }else{
+        section("No devices added") {
+			paragraph "All selected devices have previously been added"
+		}
+        }
+}
+    }
+
+def uninstalled() {
+    unsubscribe()
+    getChildDevices().each {
+        deleteChildDevice(it.deviceNetworkId)
+    }
+}
+
+
+
+private String convertHexToIP(hex) {
+	[convertHexToInt(hex[0..1]),convertHexToInt(hex[2..3]),convertHexToInt(hex[4..5]),convertHexToInt(hex[6..7])].join(".")
+}
+
+private Integer convertHexToInt(hex) {
+	Integer.parseInt(hex,16)
+}
+
+private String convertIPtoHex(ipAddress) { 
+    String hex = ipAddress.tokenize( '.' ).collect {  String.format( '%02x', it.toInteger() ) }.join()
+    return hex
+}
+
+private String convertPortToHex(port) {
+	String hexport = port.toString().format( '%04x', port.toInteger() )
+    return hexport
+}

smartapps/fortrezz/consumption-metering.src/consumption-metering.groovy

@@ -1,210 +0,0 @@
-/**
- *  Consumption Metering
- *
- *  Copyright 2016 FortrezZ, LLC
- *
- *  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: "Consumption Metering",
-    namespace: "FortrezZ",
-    author: "FortrezZ, LLC",
-    description: "Child SmartApp for Consumption Metering rules",
-    category: "Green Living",
-    parent: "FortrezZ:FortrezZ Water Consumption Metering",
-    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience.png",
-    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png",
-    iconX3Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png")
-
-preferences {
-	page(name: "prefsPage", title: "Choose the detector behavior", install: true, uninstall: true)
-
-    // Do something here like update a message on the screen,
-    // or introduce more inputs. submitOnChange will refresh
-    // the page and allow the user to see the changes immediately.
-    // For example, you could prompt for the level of the dimmers
-    // if dimmers have been selected:
-    //log.debug "Child Settings: ${settings}"
-}
-
-def prefsPage() {
-	def dailySchedule = 0
-	def daysOfTheWeek = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
-    dynamicPage(name: "prefsPage") {
-        section("Set Water Usage Goals") {
-            input(name: "type", type: "enum", title: "Set a new goal?", submitOnChange: true, options: ruleTypes())
-        }
-		def measurementType = "water"
-        if(type)
-        {
-            switch (type) {
-                case "Daily Goal":
-                	section("Water Measurement Preference"){
-        				input(name: "measurementType", type: "enum", title: "Press to change water measurement options", submitOnChange: true, options: waterTypes())}
-                
-                    section("Threshold settings") {
-                        input(name: "waterGoal", type: "decimal", title: "Daily ${measurementType} Goal", required: true, defaultValue: 0.5)
-                    }
-
-                                      
-                    break
-
-                case "Weekly Goal":
-                	section("Water Measurement Preference"){
-        				input(name: "measurementType", type: "enum", title: "Press to change water measurement options", submitOnChange: true, options: waterTypes())}
-                    section("Threshold settings") {
-                        input(name: "waterGoal", type: "decimal", title: "Weekly ${measurementType} Goal", required: true, defaultValue: 0.1)
-                    }
-
-                    
-                    break
-
-                case "Monthly Goal":
-                	section("Water Measurement Preference"){
-        				input(name: "measurementType", type: "enum", title: "Press to change water measurement options", submitOnChange: true, options: waterTypes())}
-                    section("Threshold settings") {
-                        input(name: "waterGoal", type: "decimal", title: "Monthly ${measurementType} Goal", required: true, defaultValue: 0.1)
-                    }
-
-                    
-                    break
-
-                default:
-                    break
-            }
-        }
-    }
-}
-
-def ruleTypes() {
-	def types = []
-    types << "Daily Goal"
-    types << "Weekly Goal"
-    types << "Monthly Goal"
-   
-    return types
-}
-
-def waterTypes()
-{
-	def watertype = []
-    
-    watertype << "Gallons"
-    watertype << "Cubic Feet"
-    watertype << "Liters"
-    watertype << "Cubic Meters"
-    return watertype
-}
-/*
-def setDailyGoal(measurementType3)
-{
-    return parent.setDailyGoal(measurementType3)
-} 
-def setWeeklyGoal()
-{
-    return parent.setWeeklyGoal(measurementType)
-} 
-def setMonthlyGoal()
-{
-    return parent.setMonthlyGoal(measurementType)
-} 
-*/
-
-def actionTypes() {
-	def types = []
-    types << [name: "Switch", capability: "capabilty.switch"]
-    types << [name: "Water Valve", capability: "capability.valve"]
-    
-    return types
-}
-
-def deviceCommands(dev)
-{
-	def cmds = []
-	dev.supportedCommands.each { command ->
-    	cmds << command.name
-    }
-    
-    return cmds
-}
-
-def installed() {
-	state.Daily = 0
-	log.debug "Installed with settings: ${settings}"
-	app.updateLabel("${type} - ${waterGoal} ${measurementType}")
-    //schedule("	0 0/1 * 1/1 * ? *", setDailyGoal())
-	initialize()
-}
-
-
-
-
-    
-def updated() {
-	log.debug "Updated with settings: ${settings}"
-	app.updateLabel("${type} - ${waterGoal} ${measurementType}")
-    
-
-	unsubscribe()
-	initialize()
-    //unschedule()
-}
-
-def settings() {
-	def set = settings
-    if (set["dev"] != null)
-    {
-    	log.debug("dev set: ${set.dev}")
-    	set.dev = set.dev.id
-    }
-    if (set["valve"] != null)
-    {
-    	log.debug("valve set: ${set.valve}")
-    	set.valve = set.valve.id
-    }
-    
-    log.debug(set)
-
-	return set
-}
-
-def devAction(action)
-{
-	if(dev)
-    {
-    	log.debug("device: ${dev}, action: ${action}")
-		dev."${action}"()
-    }
-}
-
-def isValveStatus(status)
-{
-	def result = false
-    log.debug("Water Valve ${valve} has status ${valve.currentState("contact").value}, compared to ${status.toLowerCase()}")
-	if(valve)
-    {
-    	if(valve.currentState("contact").value == status.toLowerCase())
-        {
-        	result = true
-        }
-    }
-    return result
-}
-
-def initialize() {
-    
-    
-    // TODO: subscribe to attributes, devices, locations, etc.
-}
-def uninstalled() {
-    // external cleanup. No need to unsubscribe or remove scheduled jobs
-}
-// TODO: implement event handlers

smartapps/fortrezz/fortrezz-water-consumption-metering.src/fortrezz-water-consumption-metering.groovy

@@ -1,388 +0,0 @@
-/**
- *  FortrezZ Water Consumption Metering
- *
- *  Copyright 2016 FortrezZ, LLC
- *
- *  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: "FortrezZ Water Consumption Metering",
-    namespace: "FortrezZ",
-    author: "FortrezZ, LLC",
-    description: "Use the FortrezZ Water Meter to efficiently use your homes water system.",
-    category: "Green Living",
-    iconUrl: "http://swiftlet.technology/wp-content/uploads/2016/05/logo-square-200-1.png",
-    iconX2Url: "http://swiftlet.technology/wp-content/uploads/2016/05/logo-square-500.png",
-    iconX3Url: "http://swiftlet.technology/wp-content/uploads/2016/05/logo-square.png")
-
-
-preferences {
-	page(name: "page2", title: "Select device and actions", install: true, uninstall: true)
-}
-
-def page2() {
-    dynamicPage(name: "page2") {
-        section("Choose a water meter to monitor:") {
-            input(name: "meter", type: "capability.energyMeter", title: "Water Meter", description: null, required: true, submitOnChange: true)
-        }
-
-        if (meter) {
-            section {
-                app(name: "childRules", appName: "Consumption Metering", namespace: "FortrezZ", title: "Create New Water Consumption Goal", multiple: true)
-            }
-        }
-        
-        section("Start/End time of all water usage goal periods") {
-        	input(name: "alertTime", type: "time", required: true)
-            }
-        
-        section("Billing info") {
-        	input(name: "unitType", type: "enum", title: "Water unit used in billing", description: null, defaultValue: "Gallons", required: true, submitOnChange: true, options: waterTypes())
-            input(name: "costPerUnit", type: "decimal", title: "Cost of water unit in billing", description: null, defaultValue: 0, required: true, submitOnChange: true)
-        	input(name: "fixedFee", type: "decimal", title: "Add a Fixed Fee?", description: null, defaultValue: 0, submitOnChange: true)}
-        
-        section("Send notifications through...") {
-        	input(name: "pushNotification", type: "bool", title: "SmartThings App", required: false)
-        	input(name: "smsNotification", type: "bool", title: "Text Message (SMS)", submitOnChange: true, required: false)
-            if (smsNotification)
-            {
-            	input(name: "phone", type: "phone", title: "Phone number?", required: true)
-            }
-            //input(name: "hoursBetweenNotifications", type: "number", title: "Hours between notifications", required: false)
-        }
-        
-
-
-
-		log.debug "there are ${childApps.size()} child smartapps"
-        
-        
-        def childRules = []
-        childApps.each {child ->
-            log.debug "child ${child.id}: ${child.settings()}"
-            childRules << [id: child.id, rules: child.settings()] //this section of code stores the long ID and settings (which contains several variables of the individual goal such as measurement type, water consumption goal, start cumulation, current cumulation.) into an array
-        }
-        
-        def match = false
-        def changeOfSettings = false
-        for (myItem in childRules) {
-        	def q = myItem.rules
-        	for (item2 in state.rules) {
-                def r = item2.rules
-                log.debug(r.alertType)
-            	if (myItem.id == item2.id) { //I am comparing the previous array to current array and checking to see if any new goals have been made.  
-                	match = true
-                    if (q.type == r.type){
-                    	changeOfSettings = true}
-                }                
-            }
-            if (match == false) { // if a new goal has been made, i need to do some first time things like set up a recurring schedule depending on goal duration
-                state["NewApp${myItem.id}"] = true
-                log.debug "Created a new ${q.type} with an ID of ${myItem.id}"}
-    
-            match = false
-        }
-        
-        for (myItem in childRules) {
-            if (state["NewApp${myItem.id}"] == true){
-                state["NewApp${myItem.id}"] = false
-                state["currentCumulation${myItem.id}"] = 0 // we create another object attached to our new goal called 'currentCumulation' which should hold the value for how much water has been used since the goal period has started
-                state["oneHundred${myItem.id}"] = false
-                state["ninety${myItem.id}"] = false
-                state["seventyFive${myItem.id}"] = false
-                state["fifty${myItem.id}"] = false
-                state["endOfGoalPeriod${myItem.id}"]  = false
-            }   
-        }
-
-        state.rules = childRules // storing the array we just made to state makes it persistent across the instances this smart app is used and global across the app ( this value cannot be implicitely shared to any child app unfortunately without making it a local variable FYI
-        log.debug "Parent Settings: ${settings}"
-             
-        if (costPerUnit != 0 && costPerUnit != null){//we ask the user in the main page for billing info which includes the price of the water and what water measurement unit is used. we combine convert the unit to gallons (since that is what the FMI uses to tick water usage) and then create a ratio that can be converted to any water measurement type
-            state.costRatio = costPerUnit/(convertToGallons(unitType))
-        	state.fixedFee = fixedFee
-        }
-    }
-}
-
-def parseAlerTimeAndStartNewSchedule(myAlert)
-        {
-        	def endTime = myAlert.split("T")
-            def endHour = endTime[1].split(":")[0] // parsing the time stamp which is of this format: 2016-12-13T16:25:00.000-0500
-            def endMinute = endTime[1].split(":")[1]
-            schedule("0 ${endMinute} ${endHour} 1/1 * ? *", goalSearch) // creating a schedule to launch goalSearch every day at a user defined time - default is at midnight
-            log.debug("new schedule created at ${endHour} : ${endMinute}")
-        }
-
-def convertToGallons(myUnit) // does what title says - takes whatever unit in string form and converts it to gallons to create a ratio. the result is returned
-{
-	switch (myUnit){
-    	case "Gallons":
-        	return 1
-            break
-        case "Cubic Feet":
-        	return 7.48052
-            break
-        case "Liters":
-        	return 0.264172
-            break
-        case "Cubic Meters":
-        	return 264.172
-            break
-        default:
-        	log.debug "value for water measurement doesn't fit into the 4 water measurement categories"
-            return 1
-            break
-       }
-}
-
-
-def goalSearch(){
-
-    def dateTime = new Date() // this section is where we get date in time within our timezone and split it into 2 arrays which carry the date and time
-    def fullDateTime = dateTime.format("yyyy-MM-dd HH:mm:ss", location.timeZone)
-    def mySplit = fullDateTime.split()
-
-	log.debug("goalSearch: ${fullDateTime}") // 2016-12-09 14:59:56
-
-	// ok, so I ran into a problem here. I wanted to simply do | state.dateSplit = mySplit[0].split("-") | but I kept getting this error in the log "java.lang.UnsupportedOperationException" So I split it to variables and then individually placed them into the state array
-    def dateSplit = mySplit[0].split("-")
-    def timeSplit = mySplit[1].split(":")
-    state.dateSplit = []
-    state.timeSplit = []
-    for (i in dateSplit){
-    	state.dateSplit << i} // unnecessary?
-    for (g in timeSplit){
-    	state.timeSplit << g}  
-    def dayOfWeek = Date.parse("yyyy-MM-dd", mySplit[0]).format("EEEE")
-    state.debug = false
-    dailyGoalSearch(dateSplit, timeSplit)
-    weeklyGoalSearch(dateSplit, timeSplit, dayOfWeek)
-    monthlyGoalSearch(dateSplit, timeSplit)
-
-}
-    
-    
-
-def dailyGoalSearch(dateSplit, timeSplit){ // because of our limitations of schedule() we had to create 3 separate methods for the existing goal period of day, month, and year. they are identical other than their time periods.
-	def myRules = state.rules // also, these methods are called when our goal period ends. we filter out the goals that we want and then invoke a separate method called schedulGoal to inform the user that the goal ended and produce some results based on their water usage.
-        for (it in myRules){
-            def r = it.rules
-            if (r.type == "Daily Goal") {
-				scheduleGoal(r.measurementType, it.id, r.waterGoal, r.type, 0.03333)
-            }
-        }    	
-}
-def weeklyGoalSearch(dateSplit, timeSplit, dayOfWeek){
-    def myRules = state.rules // also, these methods are called when our goal period ends. we filter out the goals that we want and then invoke a separate method called schedulGoal to inform the user that the goal ended and produce some results based on their water usage.
-        for (it in myRules){
-            def r = it.rules
-            if (r.type == "Weekly Goal") {
-            	if (dayOfWeek == "Sunday" || state.debug == true){ 
-                	scheduleGoal(r.measurementType, it.id, r.waterGoal, r.type, 0.23333)}
-            }
-        }    	
-}
-def monthlyGoalSearch(dateSplit, timeSplit){  
-	def myRules = state.rules // also, these methods are called when our goal period ends. we filter out the goals that we want and then invoke a separate method called schedulGoal to inform the user that the goal ended and produce some results based on their water usage.
-        for (it in myRules){
-            def r = it.rules
-            if (r.type == "Monthly Goal") {
-				if (dateSplit[2] == "01" || state.debug == true){ 
-                	scheduleGoal(r.measurementType, it.id, r.waterGoal, r.type, 0.23333)}
-            }
-        }    
-}
-def scheduleGoal(measureType, goalID, wGoal, goalType, fixedFeeRatio){ // this is where the magic happens. after a goal period has finished this method is invoked and the user gets a notification of the results of the water usage over their period.
-	def cost = 0
-    def f = 1.0f
-    def topCumulative = meter.latestValue("cumulative") // pulling the current cumulative value from the FMI for calculating  how much water we have used since starting the goal.
-     if (state["Start${goalID}"] == null){state["Start${goalID}"] = topCumulative} // we create another object attached to our goal called 'start' and store the existing cumulation on the FMI device so we know at what mileage we are starting at for this goal. this is useful for determining how much water is used during the goal period.
-    def curCumulation = waterConversionPreference(topCumulative, measureType) - waterConversionPreference(state["Start${goalID}"], measureType)
-	
-    
-	if (state.costRatio){
-    	cost = costConversionPreference(state.costRatio,measureType) * curCumulation * f + (state.fixedFee * fixedFeeRatio)// determining the cost of the water that they have used over the period ( i had to create a variable 'f' and make it a float and multiply it to make the result a float. this is because the method .round() requires it to be a float for some reasons and it was easier than typecasting the result to a float.
-    }
-    def percentage = (curCumulation / wGoal) * 100 * f
-    if (costPerUnit != 0) {
-        notify("Your ${goalType} period has ended. You have used ${(curCumulation * f).round(2)} ${measureType} of your goal of ${wGoal} ${measureType} (${(percentage * f).round(1)}%). Costing \$${cost.round(2)}")// notifies user of the type of goal that finished, the amount of water they used versus the goal of water they used, and the cost of the water used
-        log.debug "Your ${goalType} period has ended. You have used ${(curCumulation * f).round(2)} ${measureType} of your goal of ${wGoal} ${measureType} (${(percentage * f).round(1)}%). Costing \$${cost.round(2)}"
-        
-    }
-    if (costPerUnit == 0) // just in case the user didn't add any billing info, i created a second set of notification code to not include any billing info.
-    {
-    	notify("Your ${goalType} period has ended. You have you have used ${(curCumulation * f).round(2)} ${measureType} of your goal of ${wGoal} ${measureType} (${percentage.round(1)}%).")
-        log.debug "Your ${goalType} period has ended. You have you have used ${(curCumulation * f).round(2)} ${measureType} of your goal of ${wGoal} ${measureType} (${percentage.round(1)}%)."
-     }
-    state["Start${goalID}"] = topCumulative;
-    state["oneHundred${goalID}"] = false
-    state["ninety${goalID}"] = false
-    state["seventyFive${goalID}"] = false
-    state["fifty${goalID}"] = false
-    state["endOfGoalPeriod${goalID}"] = true // telling the app that the goal period is over.
-}
-	
-	
-
-def waterTypes() // holds the types of water measurement used in the main smartapp page for billing info and for setting goals
-{
-	def watertype = []
-    
-    watertype << "Gallons"
-    watertype << "Cubic Feet"
-    watertype << "Liters"
-    watertype << "Cubic Meters"
-    return watertype
-}
-
-def installed() { // when the app is first installed - do something
-	log.debug "Installed with settings: ${settings}"
-
-	initialize()
-}
-
-def updated() { // whevenever the app is updated in any way by the user and you press the 'done' button on the top right of the app - do something
-	log.debug "Updated with settings: ${settings}"
-    
-    if (alertTime != state.alertTime) // we created this 'if' statement to prevent another schedule being made whenever the user opens the smartapp
-    {
-        unschedule() //unscheduling is a good idea here because we don't want multiple schedules happening and this function cancles all schedules
-        parseAlerTimeAndStartNewSchedule(alertTime) // we use cron scheduling to use the function 'goalSearch' every minute
-        state.alarmTime = alarmTime // setting state.alarmTime prevents a new schedule being made whenever the user opens the smartapp
-    }
-
-	unsubscribe()
-	initialize()
-    //unschedule()
-}
-
-def initialize() { // whenever you open the smart app - do something
-	subscribe(meter, "cumulative", cumulativeHandler)
-	//subscribe(meter, "gpm", gpmHandler)
-    log.debug("Subscribing to events")
-}
-
-def cumulativeHandler(evt) { // every time a tick on the FMI happens this method is called. 'evt' contains the cumulative value of every tick that has happened on the FMI since it was last reset. each tick represents 1/10 of a gallon
-    def f = 1.0f
-	def gpm = meter.latestValue("gpm") // storing the current gallons per minute value
-    def cumulative = new BigDecimal(evt.value) // storing the current cumulation  value
-    log.debug "Cumulative Handler: [gpm: ${gpm}, cumulative: ${cumulative}]"
-    def rules = state.rules //storing the array of child apps to 'rules'
-    rules.each { it -> // looping through each app in the array but storing each app into the variable 'it'
-        def r = it.rules // each child app has a 2 immediate properties, one called 'id' and one called 'rules' - so 'r' contains the values of 'rules' in the child app
-        def childAppID = it.id // storing the child app ID to a variable 
-		if (state["Start${childAppID}"] == null) {state["Start${childAppID}"] = cumulative}// just for the first run of the app... start should be null. so we have to change that for the logic to work.
-
-
-        def newCumulative = waterConversionPreference(cumulative, r.measurementType) //each goal allows the user to choose a water measurement type. here we convert the value of 'cumulative' to whatever the user prefers for display and logic purposes
-        def goalStartCumulative = waterConversionPreference(state["Start${childAppID}"], r.measurementType)
-        
-        
-        def DailyGallonGoal = r.waterGoal // 'r.waterGoal' contains the number of units of water the user set as a goal. we then save that to 'DailyGallonGoal'
-        state.DailyGallonGoal = DailyGallonGoal // and then we make that value global and persistent for logic reasons
-        def currentCumulation = newCumulative - goalStartCumulative // earlier we created the value 'currentCumulation' and set it to 0, now we are converting both the 'cumulative' value and what 'cumulative' was when the goal perio was made and subtracting them to discover how much water has been used since the creation of the goal in the users prefered water measurement unit.
-		state["currentCumulation${childAppID}"] = currentCumulation
-        log.debug("Threshold:${DailyGallonGoal}, Value:${(currentCumulation * f).round(2)}")
-
-        if ( currentCumulation >= (0.5 * DailyGallonGoal) && currentCumulation < (0.75 * DailyGallonGoal) && state["fifty${childAppID}"] == false) // tell the user if they break certain use thresholds
-        {
-            notify("You have reached 50% of your ${r.type} use limit. (${(currentCumulation * f).round(2)} of ${DailyGallonGoal} ${r.measurementType})")
-            log.debug "You have reached 50% of your ${r.type} use limit. (${(currentCumulation * f).round(2)} of ${DailyGallonGoal} ${r.measurementType})"
-            state["fifty${childAppID}"] = true
-        }
-        if ( currentCumulation >= (0.75 * DailyGallonGoal) && currentCumulation < (0.9 * DailyGallonGoal) && state["seventyFive${childAppID}"] == false)
-        {
-            notify("You have reached 75% of your ${r.type} use limit. (${(currentCumulation * f).round(2)} of ${DailyGallonGoal} ${r.measurementType})")
-            log.debug "You have reached 75% of your ${r.type} use limit. (${(currentCumulation * f).round(2)} of ${DailyGallonGoal} ${r.measurementType})"
-            state["seventyFive${childAppID}"] = true
-        }
-        if ( currentCumulation >= (0.9 * DailyGallonGoal) && currentCumulation < (DailyGallonGoal) && state["ninety${childAppID}"] == false)
-        {
-            notify("You have reached 90% of your ${r.type} use limit. (${(currentCumulation * f).round(2)} of ${DailyGallonGoal} ${r.measurementType})")
-            log.debug "You have reached 90% of your ${r.type} use limit. (${(currentCumulation * f).round(2)} of ${DailyGallonGoal} ${r.measurementType})"
-            state["ninety${childAppID}"] = true
-        }
-        if (currentCumulation >= DailyGallonGoal && state["oneHundred${childAppID}"] == false)
-        {
-            notify("You have reached 100% of your ${r.type} use limit. (${(currentCumulation * f).round(2)} of ${DailyGallonGoal} ${r.measurementType})")
-            log.debug "You have reached 100% of your ${r.type} use limit. (${(currentCumulation * f).round(2)} of ${DailyGallonGoal} ${r.measurementType})"
-            state["oneHundred${childAppID}"] = true
-            //send command here like shut off the water
-            
-
-            
-        }
-        if (state["endOfGoalPeriod${childAppID}"] == true) // changing the start value to the most recent cumulative value for goal reset.
-            {state["Start${childAppID}"] = cumulative
-             state["endOfGoalPeriod${childAppID}"] = false
-            }
-    }
-}
-
-def waterConversionPreference(cumul, measurementType1) // convert the current cumulation to one of the four options below - since cumulative is initially in gallons, then the options to change them is easy
-{
-	switch (measurementType1)
-    {
-            case "Cubic Feet":
-            	return (cumul * 0.133681)
-            break
-            
-            case "Liters":
-            	return (cumul * 3.78541)
-            break
-            
-            case "Cubic Meters":
-            	return (cumul * 0.00378541)
-            break
-            
-            case "Gallons":
-            	return cumul
-            break
-        
-    }
-}
-
-def costConversionPreference(cumul, measurementType1) // convert the current cumulation to one of the four options below - since cumulative is initially in gallons, then the options to change them is easy
-{
-	switch (measurementType1)
-    {
-            case "Cubic Feet":
-            	return (cumul / 0.133681)
-            break
-            
-            case "Liters":
-            	return (cumul / 3.78541)
-            break
-            
-            case "Cubic Meters":
-            	return (cumul / 0.00378541)
-            break
-            
-            case "Gallons":
-            	return cumul
-            break
-        
-    }
-}
-
-def notify(myMsg) // method for both push notifications and for text messaging.
-{
-	log.debug("Sending Notification")
-    if (pushNotification)	{sendPush(myMsg)} else {sendNotificationEvent(myMsg)}
-    if (smsNotification)	{sendSms(phone, myMsg)}
-}
-
-def uninstalled() {
-    // external cleanup. No need to unsubscribe or remove scheduled jobs
-    unsubscribe()
-    unschedule()
-}

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

@@ -27,9 +27,10 @@ definition(
 
 preferences {
 	page(name: "selectButton")
-	for (def i=1; i<=8; i++) {
-		page(name: "configureButton$i")
-	}
+	page(name: "configureButton1")
+	page(name: "configureButton2")
+	page(name: "configureButton3")
+	page(name: "configureButton4")
 
 	page(name: "timeIntervalInput", title: "Only during a certain time") {
 		section {
@@ -59,45 +60,22 @@ def selectButton() {
 	}
 }
 
-def createPage(pageNum) {
-	if ((state.numButton == pageNum) || (pageNum == 8))
-		state.installCondition = true
-	dynamicPage(name: "configureButton$pageNum", title: "Set up button $pageNum here",
-			nextPage: "configureButton${pageNum+1}", install: state.installCondition, uninstall: configured(), getButtonSections(pageNum))
-}
-
 def configureButton1() {
-	state.numButton = buttonDevice.currentState("numberOfButtons")?.longValue ?: 4
-	log.debug "state variable numButton: ${state.numButton}"
-	state.installCondition = false
-	createPage(1)
+	dynamicPage(name: "configureButton1", title: "Now let's decide how to use the first button",
+		nextPage: "configureButton2", uninstall: configured(), getButtonSections(1))
 }
 def configureButton2() {
-	createPage(2)
+	dynamicPage(name: "configureButton2", title: "If you have a second button, set it up here",
+		nextPage: "configureButton3", uninstall: configured(), getButtonSections(2))
 }
 
 def configureButton3() {
-	createPage(3)
+	dynamicPage(name: "configureButton3", title: "If you have a third button, you can do even more here",
+		nextPage: "configureButton4", uninstall: configured(), getButtonSections(3))
 }
-
 def configureButton4() {
-	createPage(4)
-}
-
-def configureButton5() {
-	createPage(5)
-}
-
-def configureButton6() {
-	createPage(6)
-}
-
-def configureButton7() {
-	createPage(7)
-}
-
-def configureButton8() {
-	createPage(8)
+	dynamicPage(name: "configureButton4", title: "If you have a fourth button, you rule, and can set it up here",
+		install: true, uninstall: true, getButtonSections(4))
 }
 
 def getButtonSections(buttonNumber) {

smartapps/smartthings/examples/every-element.src/every-element.groovy

@@ -202,8 +202,7 @@ def inputSelectionPage() {
 
         section("options variations") {
             paragraph "tap these elements and look at the differences when selecting an option"
-            input(type: "enum", name: "selectionSimple", title: "Simple options", description: "no separators in the selectable options", options: ["Thing 1", "Thing 2", "(Complicated) Thing 3"])
-            input(type: "enum", name: "selectionSimpleGrouped", title: "Simple (Grouped) options", description: "no separators in the selectable options", groupedOptions: addGroup(englishOptions + spanishOptions))
+            input(type: "enum", name: "selectionSimple", title: "Simple options", description: "no separators in the selectable options", groupedOptions: addGroup(englishOptions + spanishOptions))
             input(type: "enum", name: "selectionGrouped", title: "Grouped options", description: "separate groups of options with headers", groupedOptions: groupedOptions)
         }
 
@@ -215,15 +214,15 @@ def inputSelectionPage() {
 
         section("segmented") {
             paragraph "segmented should only work if there are either 2 or 3 options to choose from"
-            input(type: "enum", name: "selectionSegmented1", style: "segmented", title: "1 option", options: ["One"])
-            input(type: "enum", name: "selectionSegmented4", style: "segmented", title: "4 options", options: ["One", "Two", "Three", "Four"])
+            input(type: "enum", name: "selectionSegmented1", style: "segmented", title: "1 option", groupedOptions: addGroup(["One"]))
+            input(type: "enum", name: "selectionSegmented4", style: "segmented", title: "4 options", groupedOptions: addGroup(["One", "Two", "Three", "Four"]))
 
             paragraph "multiple and required will have no effect on segmented selection elements. There will always be exactly 1 option selected"
             input(type: "enum", name: "selectionSegmented2", style: "segmented", title: "2 options", options: ["One", "Two"])
             input(type: "enum", name: "selectionSegmented3", style: "segmented", title: "3 options", options: ["One", "Two", "Three"])
 
             paragraph "specifying defaultValue still works with segmented selection elements"
-            input(type: "enum", name: "selectionSegmentedWithDefault", style: "segmented", title: "defaulted to 'two'", options: ["One", "Two", "Three"], defaultValue: "Two")
+            input(type: "enum", name: "selectionSegmentedWithDefault", title: "defaulted to 'two'", groupedOptions: addGroup(["One", "Two", "Three"]), defaultValue: "Two")
         }
 
         section("required: true") {
@@ -232,8 +231,6 @@ def inputSelectionPage() {
 
         section("multiple: true") {
             input(type: "enum", name: "selectionMultiple", title: "This allows multiple selections", description: "It should look different when nothing is selected", groupedOptions: addGroup(["an option", "another option", "no way, one more?"]), multiple: true)
-            input(type: "enum", name: "selectionMultipleDefault1", title: "This allows multiple selections with a single default", description: "It should look different when nothing is selected", groupedOptions: addGroup(["an option", "another option", "no way, one more?"]), multiple: true, defaultValue: "an option")
-            input(type: "enum", name: "selectionMultipleDefault2", title: "This allows multiple selections with multiple defaults", description: "It should look different when nothing is selected", groupedOptions: addGroup(["an option", "another option", "no way, one more?"]), multiple: true, defaultValue: ["an option", "another option"])
         }
 
         section("with image") {

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

@@ -72,7 +72,7 @@ def authPage() {
 		log.debug "have LIFX access token"
 
 		def options = locationOptions() ?: []
-		def count = options.size().toString()
+		def count = options.size()
 
 		return dynamicPage(name:"Credentials", title:"", nextPage:"", install:true, uninstall: true) {
 			section("Select your location") {