MSA-1488: mu home automation

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

@@ -0,0 +1,320 @@
+/**
+ *  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 2.0
+ *
+ *  Author: Eric Maycock (erocm123)
+ *  Date: 2016-01-27
+ */
+ 
+import groovy.json.JsonSlurper
+import groovy.util.XmlSlurper
+
+metadata {
+	definition (name: "Sonoff Wifi Switch 2.0", namespace: "erocm123", author: "Eric Maycock") {
+        capability "Actuator"
+		capability "Switch"
+		capability "Refresh"
+		capability "Sensor"
+        capability "Configuration"
+        
+        command "reboot"
+	}
+
+	simulator {
+	}
+    
+    preferences {
+        input("ip", "string", title:"IP Address", description: "192.168.1.150" ,required: true, displayDuringSetup: true)
+        // Port should always be 80
+        //input("port", "string", title:"Port", description: "80" , required: true, displayDuringSetup: true)
+	}
+
+	tiles (scale: 2){      
+		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
+			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+				attributeState "on", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "off", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.lights.philips.hue-single", backgroundColor:"#79b821", nextState:"turningOff"
+				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.lights.philips.hue-single", backgroundColor:"#ffffff", nextState:"turningOn"
+			}
+        }
+
+		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.configure", inactiveLabel: false, width: 2, height: 2, decoration: "flat") {
+			state "configure", label:'', action:"configuration.configure", icon:"st.secondary.configure"
+		}
+        valueTile("reboot", "device.reboot", decoration: "flat", height: 2, width: 2, inactiveLabel: false, canChangeIcon: false) {
+            state "default", label:"Reboot", action:"reboot", icon:"", backgroundColor:"#FFFFFF"
+        }
+        valueTile("hubInfo", "device.hubInfo", decoration: "flat", height: 2, width: 6, inactiveLabel: false, canChangeIcon: false) {
+            state "hubInfo", label:'${currentValue}' //backgroundColor:"#FFFFFF"
+        }
+        
+    }
+
+	main(["switch"])
+	details(["switch",
+             "refresh","configure","reboot",
+             "hubInfo"])
+}
+
+def installed() {
+	log.debug "installed()"
+	configure()
+}
+
+def updated() {
+	log.debug "updated()"
+    configure()
+}
+
+def configure() {
+	log.debug "configure()"
+	log.debug "Configuring Device For SmartThings Use"
+    state.ruleConfigured = false
+    state.switchConfigured = false
+    state.buttonConfigured = false
+    sendEvent(name:"hubInfo", value:"Sonoff switch still being configured")
+    if (state.MAC != null) state.dni = setDeviceNetworkId(state.MAC)
+    else 
+    if (ip != null) state.dni = setDeviceNetworkId(ip, "80")
+    state.hubIP = device.hub.getDataValue("localIP")
+    response(setupDevices() + setupRules() + refresh())
+}
+
+def setupDevices() {
+    def cmds = []
+    cmds << postAction("/devices?index=1&page=1", "taskdevicenumber=1&edit=1&page=1")
+    cmds << postAction("/devices?index=1&page=1", "taskdevicenumber=1&taskdevicename=BUTTON&taskdevicetimer=0&taskdeviceid=1&taskdevicepin1=0&taskdevicepin1pullup=on&plugin_001_type=1&plugin_001_button=2&taskdevicevaluename1=Switch&edit=1&page=1")
+    cmds << postAction("/devices?index=2&page=1", "taskdevicenumber=1&edit=1&page=1")
+    cmds << postAction("/devices?index=2&page=1", "taskdevicenumber=1&taskdevicename=SWITCH&taskdevicetimer=0&taskdeviceid=2&taskdevicepin1=12&taskdevicepin1pullup=on&plugin_001_type=1&plugin_001_button=0&taskdevicesenddata=on&taskdevicevaluename1=Switch&edit=1&page=1")
+    return delayBetween(cmds, 1000)
+}
+
+def setupRules() {
+    def cmds = []
+    cmds << postAction("/advanced", "mqttsubscribe=&mqttpublish=&messagedelay=1000&ip=0&ntphost=&timezone=0&syslogip=0.0.0.0&sysloglevel=0&udpport=0&useserial=on&serialloglevel=0&webloglevel=0&baudrate=115200&wdi2caddress=0&wireclockstretchlimit=0&userules=on&edit=1")
+    cmds << postAction("/rules", "rules=On+BUTTON%23Switch+do%0D%0A++if+%5BSWITCH%23Switch%5D%3D0%0D%0A++++gpio%2C12%2C1%0D%0A++else%0D%0A++++gpio%2C12%2C0%0D%0A++endif%0D%0Aendon%0D%0A%0D%0AOn+SWITCH%23Switch+do%0D%0A+if+%5BSWITCH%23Switch%5D%3D1%0D%0A++++gpio%2C13%2C0%0D%0A++else%0D%0A++++gpio%2C13%2C1%0D%0A++endif%0D%0Aendon")
+    return delayBetween(cmds, 1000)
+}
+
+def setupConfig() {
+    // Automatic config page submit not working at this time. Has to be done manually
+    /*def hubIP = device.hub.getDataValue("localIP")
+    log.debug "Hub IP: ${hubIP}"
+    def cmds = []
+    //cmds << postAction("/config", "protocol=1&usedns=0&controllerip=$hubIP&controllerport=39500&controlleruser=&controllerpassword=&delay=60")
+    return delayBetween(cmds, 1000)*/
+}
+
+def parse(description) {
+	//log.debug "Parsing: ${description}"
+    def events = []
+    def cmds
+    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("Sensors")) {
+        def mySwitch = result.Sensors.find { it.TaskName == "SWITCH" }
+        def myButton = result.Sensors.find { it.TaskName == "BUTTON" }
+        def myLED = result.Sensors.find { it.TaskName == "LED" }
+        if (mySwitch) { 
+            events << createEvent(name:"switch", value: (mySwitch.Switch.toInteger() == 0 ? 'off' : 'on'))
+            state.switchConfigured = true
+        }
+        if (myButton) state.buttonConfigured = true
+        //if (myLED) log.debug "LED is ${(myLED.Switch.toInteger() == 0 ? 'off' : 'on')}"
+    }
+    if (result.containsKey("pin")) {
+        if (result.pin == 12) events << createEvent(name:"switch", value: (result.state.toInteger() == 0 ? 'off' : 'on'))
+    }
+
+    if (result.containsKey("System")) {
+        if (result.System.containsKey("Uptime")) log.debug "System has been up ${result.System.Uptime.toInteger() / 60} hours"
+    }
+    } else {
+        //log.debug "Response is not JSON: $body"
+        def ruleSearch = "OnBUTTONSwitchdoifSWITCHSwitch0gpio121elsegpio120endifendonOnSWITCHSwitchdoifSWITCHSwitch1gpio130elsegpio131endifendon"
+        if (body.replaceAll("\\W", "").indexOf(ruleSearch) > 0) state.ruleConfigured = true
+
+    }
+    } else {
+        cmds = refresh()
+    }
+    
+    if (settings.ip) {
+        //log.debug "switch: $state.switchConfigured, button: $state.buttonConfigured, rule: $state.ruleConfigured"
+        if (state.switchConfigured == true && state.buttonConfigured == true && state.ruleConfigured == true) {
+            events << createEvent(name:"hubInfo", value:"For instant status updates, configure switch at http://$settings.ip/config | Hub Info - IP: ${device.hub.getDataValue("localIP")}, Port: 39500")
+        } else {
+            events << createEvent(name:"hubInfo", value:"Sonoff switch still being configured")
+        }
+    }
+    else { 
+        events << createEvent(name:"hubInfo", value:"IP address of the switch not entered. Please do so in device preferences.") 
+    }
+
+    if (cmds) return cmds else 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()):""]
+	}
+}
+
+private parseHTML(html) {
+   //log.debug html
+   def myHtml = html.split("<")
+   def result = []
+   switch (myHtml[0]) {
+      case "GPIO 12 Set to 0":
+      result = [name: "switch", value: "off"]
+      break
+      case "GPIO 12 Set to 1":
+      result = [name: "switch", value: "on"]
+      break
+      case "GPIO 13 Set to 0":
+      log.debug "LED is on"
+      break
+      case "GPIO 13 Set to 1":
+      log.debug "LED is off"
+      break
+      default:
+      break
+   }
+   return result
+}
+
+private ledOn() {
+   return getAction("/control?cmd=GPIO,13,0")
+}
+
+private ledOff() {
+   return getAction("/control?cmd=GPIO,13,1")
+}
+
+def on() {
+	log.debug "on()"
+    def cmds = []
+    cmds << getAction("/control?cmd=GPIO,12,1")
+    return cmds
+}
+
+def off() {
+    log.debug "off()"
+	def cmds = []
+    cmds << getAction("/control?cmd=GPIO,12,0")
+    return cmds
+}
+
+def refresh() {
+	log.debug "refresh()"
+    def cmds = []
+    cmds << getAction("/json")
+    return cmds
+}
+
+private getAction(uri){ 
+  updateDNI()
+  def headers = getHeader()
+  def hubAction = new physicalgraph.device.HubAction(
+    method: "GET",
+    path: uri,
+    headers: headers
+  )
+  return hubAction    
+}
+
+private postAction(uri, data){ 
+  updateDNI()
+  def headers = getHeader()
+  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 (device.deviceNetworkId != state.dni) {
+        device.deviceNetworkId = state.dni
+    }
+}
+
+private getHostAddress() {
+	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 getHeader(){
+    def headers = [:]
+    headers.put("Host", getHostAddress())
+    headers.put("Content-Type", "application/x-www-form-urlencoded")
+    return headers
+}
+
+def reboot() {
+	log.debug "reboot()"
+    def uri = "/?cmd=reboot"
+    getAction(uri)
+}

devicetypes/smartthings/zwave-lock-reporting.src/zwave-lock-reporting.groovy

@@ -1,683 +0,0 @@
-/**
- *  Copyright 2015 SmartThings
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-metadata {
-	definition (name: "Z-Wave Lock Reporting", namespace: "smartthings", author: "SmartThings") {
-		capability "Actuator"
-		capability "Lock"
-		capability "Polling"
-		capability "Refresh"
-		capability "Sensor"
-		capability "Lock Codes"
-		capability "Battery"
-
-		command "unlockwtimeout"
-
-		fingerprint deviceId: "0x4003", inClusters: "0x98"
-		fingerprint deviceId: "0x4004", inClusters: "0x98"
-	}
-
-	simulator {
-		status "locked": "command: 9881, payload: 00 62 03 FF 00 00 FE FE"
-		status "unlocked": "command: 9881, payload: 00 62 03 00 00 00 FE FE"
-
-		reply "9881006201FF,delay 4200,9881006202": "command: 9881, payload: 00 62 03 FF 00 00 FE FE"
-		reply "988100620100,delay 4200,9881006202": "command: 9881, payload: 00 62 03 00 00 00 FE FE"
-	}
-
-	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"])
-	}
-}
-
-import physicalgraph.zwave.commands.doorlockv1.*
-import physicalgraph.zwave.commands.usercodev1.*
-
-def updated() {
-	try {
-		if (!state.init) {
-			state.init = true
-			response(secureSequence([zwave.doorLockV1.doorLockOperationGet(), zwave.batteryV1.batteryGet()]))
-		}
-	} catch (e) {
-		log.warn "updated() threw $e"
-	}
-}
-
-def parse(String description) {
-	def result = null
-	if (description.startsWith("Err 106")) {
-		if (state.sec) {
-			result = createEvent(descriptionText:description, displayed:false)
-		} else {
-			result = createEvent(
-				descriptionText: "This lock 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.",
-				eventType: "ALERT",
-				name: "secureInclusion",
-				value: "failed",
-				displayed: true,
-			)
-		}
-	} else if (description == "updated") {
-		return null
-	} else {
-		def cmd = zwave.parse(description, [ 0x98: 1, 0x72: 2, 0x85: 2, 0x86: 1 ])
-		if (cmd) {
-			result = zwaveEvent(cmd)
-		}
-	}
-	log.debug "\"$description\" parsed to ${result.inspect()}"
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
-	def encapsulatedCommand = cmd.encapsulatedCommand([0x62: 1, 0x71: 2, 0x80: 1, 0x85: 2, 0x63: 1, 0x98: 1, 0x86: 1])
-	// log.debug "encapsulated: $encapsulatedCommand"
-	if (encapsulatedCommand) {
-		zwaveEvent(encapsulatedCommand)
-	}
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.NetworkKeyVerify cmd) {
-	createEvent(name:"secureInclusion", value:"success", descriptionText:"Secure inclusion was successful")
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityCommandsSupportedReport cmd) {
-	state.sec = cmd.commandClassSupport.collect { String.format("%02X ", it) }.join()
-	if (cmd.commandClassControl) {
-		state.secCon = cmd.commandClassControl.collect { String.format("%02X ", it) }.join()
-	}
-	log.debug "Security command classes: $state.sec"
-	createEvent(name:"secureInclusion", value:"success", descriptionText:"Lock is securely included")
-}
-
-def zwaveEvent(DoorLockOperationReport cmd) {
-	def result = []
-	def map = [ name: "lock" ]
-	if (cmd.doorLockMode == 0xFF) {
-		map.value = "locked"
-	} else if (cmd.doorLockMode >= 0x40) {
-		map.value = "unknown"
-	} else if (cmd.doorLockMode & 1) {
-		map.value = "unlocked with timeout"
-	} else {
-		map.value = "unlocked"
-		if (state.assoc != zwaveHubNodeId) {
-			log.debug "setting association"
-			result << response(secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId)))
-			result << response(zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId))
-			result << response(secure(zwave.associationV1.associationGet(groupingIdentifier:1)))
-		}
-	}
-	result ? [createEvent(map), *result] : createEvent(map)
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.alarmv2.AlarmReport cmd) {
-	def result = []
-	def map = null
-	if (cmd.zwaveAlarmType == 6) {
-		if (1 <= cmd.zwaveAlarmEvent && cmd.zwaveAlarmEvent < 10) {
-			map = [ name: "lock", value: (cmd.zwaveAlarmEvent & 1) ? "locked" : "unlocked" ]
-		}
-		switch(cmd.zwaveAlarmEvent) {
-			case 1:
-				map.descriptionText = "$device.displayName was manually locked"
-				break
-			case 2:
-				map.descriptionText = "$device.displayName was manually unlocked"
-				break
-			case 5:
-				if (cmd.eventParameter) {
-					map.descriptionText = "$device.displayName was locked with code ${cmd.eventParameter.first()}"
-					map.data = [ usedCode: cmd.eventParameter[0] ]
-				}
-				break
-			case 6:
-				if (cmd.eventParameter) {
-					map.descriptionText = "$device.displayName was unlocked with code ${cmd.eventParameter.first()}"
-					map.data = [ usedCode: cmd.eventParameter[0] ]
-				}
-				break
-			case 9:
-				map.descriptionText = "$device.displayName was autolocked"
-				break
-			case 7:
-			case 8:
-			case 0xA:
-				map = [ name: "lock", value: "unknown", descriptionText: "$device.displayName was not locked fully" ]
-				break
-			case 0xB:
-				map = [ name: "lock", value: "unknown", descriptionText: "$device.displayName is jammed" ]
-				break
-			case 0xC:
-				map = [ name: "codeChanged", value: "all", descriptionText: "$device.displayName: all user codes deleted", isStateChange: true ]
-				allCodesDeleted()
-				break
-			case 0xD:
-				if (cmd.eventParameter) {
-					map = [ name: "codeReport", value: cmd.eventParameter[0], data: [ code: "" ], isStateChange: true ]
-					map.descriptionText = "$device.displayName code ${map.value} was deleted"
-					map.isStateChange = (state["code$map.value"] != "")
-					state["code$map.value"] = ""
-				} else {
-					map = [ name: "codeChanged", descriptionText: "$device.displayName: user code deleted", isStateChange: true ]
-				}
-				break
-			case 0xE:
-				map = [ name: "codeChanged", value: cmd.alarmLevel,  descriptionText: "$device.displayName: user code added", isStateChange: true ]
-				if (cmd.eventParameter) {
-					map.value = cmd.eventParameter[0]
-					result << response(requestCode(cmd.eventParameter[0]))
-				}
-				break
-			case 0xF:
-				map = [ name: "codeChanged", descriptionText: "$device.displayName: user code not added, duplicate", isStateChange: true ]
-				break
-			case 0x10:
-				map = [ name: "tamper", value: "detected", descriptionText: "$device.displayName: keypad temporarily disabled", displayed: true ]
-				break
-			case 0x11:
-				map = [ descriptionText: "$device.displayName: keypad is busy" ]
-				break
-			case 0x12:
-				map = [ name: "codeChanged", descriptionText: "$device.displayName: program code changed", isStateChange: true ]
-				break
-			case 0x13:
-				map = [ name: "tamper", value: "detected", descriptionText: "$device.displayName: code entry attempt limit exceeded", displayed: true ]
-				break
-			default:
-				map = map ?: [ descriptionText: "$device.displayName: alarm event $cmd.zwaveAlarmEvent", displayed: false ]
-				break
-		}
-	} else if (cmd.zwaveAlarmType == 7) {
-		map = [ name: "tamper", value: "detected", displayed: true ]
-		switch (cmd.zwaveAlarmEvent) {
-			case 0:
-				map.value = "clear"
-				map.descriptionText = "$device.displayName: tamper alert cleared"
-				break
-			case 1:
-			case 2:
-				map.descriptionText = "$device.displayName: intrusion attempt detected"
-				break
-			case 3:
-				map.descriptionText = "$device.displayName: covering removed"
-				break
-			case 4:
-				map.descriptionText = "$device.displayName: invalid code"
-				break
-			default:
-				map.descriptionText = "$device.displayName: tamper alarm $cmd.zwaveAlarmEvent"
-				break
-		}
-	} else switch(cmd.alarmType) {
-		case 21:  // Manually locked
-		case 18:  // Locked with keypad
-		case 24:  // Locked by command (Kwikset 914)
-		case 27:  // Autolocked
-			map = [ name: "lock", value: "locked" ]
-			break
-		case 16:  // Note: for levers this means it's unlocked, for non-motorized deadbolt, it's just unsecured and might not get unlocked
-		case 19:
-			map = [ name: "lock", value: "unlocked" ]
-			if (cmd.alarmLevel) {
-				map.descriptionText = "$device.displayName was unlocked with code $cmd.alarmLevel"
-				map.data = [ usedCode: cmd.alarmLevel ]
-			}
-			break
-		case 22:
-		case 25:  // Kwikset 914 unlocked by command
-			map = [ name: "lock", value: "unlocked" ]
-			break
-		case 9:
-		case 17:
-		case 23:
-		case 26:
-			map = [ name: "lock", value: "unknown", descriptionText: "$device.displayName bolt is jammed" ]
-			break
-		case 13:
-			map = [ name: "codeChanged", value: cmd.alarmLevel, descriptionText: "$device.displayName code $cmd.alarmLevel was added", isStateChange: true ]
-			result << response(requestCode(cmd.alarmLevel))
-			break
-		case 32:
-			map = [ name: "codeChanged", value: "all", descriptionText: "$device.displayName: all user codes deleted", isStateChange: true ]
-			allCodesDeleted()
-			break
-		case 33:
-			map = [ name: "codeReport", value: cmd.alarmLevel, data: [ code: "" ], isStateChange: true ]
-			map.descriptionText = "$device.displayName code $cmd.alarmLevel was deleted"
-			map.isStateChange = (state["code$cmd.alarmLevel"] != "")
-			state["code$cmd.alarmLevel"] = ""
-			break
-		case 112:
-			map = [ name: "codeChanged", value: cmd.alarmLevel, descriptionText: "$device.displayName code $cmd.alarmLevel changed", isStateChange: true ]
-			result << response(requestCode(cmd.alarmLevel))
-			break
-		case 130:  // Yale YRD batteries replaced
-			map = [ descriptionText: "$device.displayName batteries replaced", isStateChange: true ]
-			break
-		case 131:
-			map = [ /*name: "codeChanged", value: cmd.alarmLevel,*/ descriptionText: "$device.displayName code $cmd.alarmLevel is duplicate", isStateChange: false ]
-			break
-		case 161:
-			if (cmd.alarmLevel == 2) {
-				map = [ descriptionText: "$device.displayName front escutcheon removed", isStateChange: true ]
-			} else {
-				map = [ descriptionText: "$device.displayName detected failed user code attempt", isStateChange: true ]
-			}
-			break
-		case 167:
-			if (!state.lastbatt || now() - state.lastbatt > 12*60*60*1000) {
-				map = [ descriptionText: "$device.displayName: battery low", isStateChange: true ]
-				result << response(secure(zwave.batteryV1.batteryGet()))
-			} else {
-				map = [ name: "battery", value: device.currentValue("battery"), descriptionText: "$device.displayName: battery low", displayed: true ]
-			}
-			break
-		case 168:
-			map = [ name: "battery", value: 1, descriptionText: "$device.displayName: battery level critical", displayed: true ]
-			break
-		case 169:
-			map = [ name: "battery", value: 0, descriptionText: "$device.displayName: battery too low to operate lock", isStateChange: true ]
-			break
-		default:
-			map = [ displayed: false, descriptionText: "$device.displayName: alarm event $cmd.alarmType level $cmd.alarmLevel" ]
-			break
-	}
-	result ? [createEvent(map), *result] : createEvent(map)
-}
-
-def zwaveEvent(UserCodeReport cmd) {
-	def result = []
-	def name = "code$cmd.userIdentifier"
-	def code = cmd.code
-	def map = [:]
-	if (cmd.userIdStatus == UserCodeReport.USER_ID_STATUS_OCCUPIED ||
-		(cmd.userIdStatus == UserCodeReport.USER_ID_STATUS_STATUS_NOT_AVAILABLE && cmd.user && code != "**********"))
-	{
-		if (code == "**********") {  // Schlage locks send us this instead of the real code
-			state.blankcodes = true
-			code = state["set$name"] ?: decrypt(state[name]) ?: code
-			state.remove("set$name".toString())
-		}
-		if (!code && cmd.userIdStatus == 1) {  // Schlage touchscreen sends blank code to notify of a changed code
-			map = [ name: "codeChanged", value: cmd.userIdentifier, displayed: true, isStateChange: true ]
-			map.descriptionText = "$device.displayName code $cmd.userIdentifier " + (state[name] ? "changed" : "was added")
-			code = state["set$name"] ?: decrypt(state[name]) ?: "****"
-			state.remove("set$name".toString())
-		} else {
-			map = [ name: "codeReport", value: cmd.userIdentifier, data: [ code: code ] ]
-			map.descriptionText = "$device.displayName code $cmd.userIdentifier is set"
-			map.displayed = (cmd.userIdentifier != state.requestCode && cmd.userIdentifier != state.pollCode)
-			map.isStateChange = true
-		}
-		result << createEvent(map)
-	} else {
-		map = [ name: "codeReport", value: cmd.userIdentifier, data: [ code: "" ] ]
-		if (state.blankcodes && state["reset$name"]) {  // we deleted this code so we can tell that our new code gets set
-			map.descriptionText = "$device.displayName code $cmd.userIdentifier was reset"
-			map.displayed = map.isStateChange = true
-			result << createEvent(map)
-			state["set$name"] = state["reset$name"]
-			result << response(setCode(cmd.userIdentifier, state["reset$name"]))
-			state.remove("reset$name".toString())
-		} else {
-			if (state[name]) {
-				map.descriptionText = "$device.displayName code $cmd.userIdentifier was deleted"
-			} else {
-				map.descriptionText = "$device.displayName code $cmd.userIdentifier is not set"
-			}
-			map.displayed = (cmd.userIdentifier != state.requestCode && cmd.userIdentifier != state.pollCode)
-			map.isStateChange = true
-			result << createEvent(map)
-		}
-		code = ""
-	}
-	state[name] = code ? encrypt(code) : code
-
-	if (cmd.userIdentifier == state.requestCode) {  // reloadCodes() was called, keep requesting the codes in order
-		if (state.requestCode + 1 > state.codes || state.requestCode >= 30) {
-			state.remove("requestCode")  // done
-		} else {
-			state.requestCode = state.requestCode + 1  // get next
-			result << response(requestCode(state.requestCode))
-		}
-	}
-	if (cmd.userIdentifier == state.pollCode) {
-		if (state.pollCode + 1 > state.codes || state.pollCode >= 30) {
-			state.remove("pollCode")  // done
-		} else {
-			state.pollCode = state.pollCode + 1
-		}
-	}
-	log.debug "code report parsed to ${result.inspect()}"
-	result
-}
-
-def zwaveEvent(UsersNumberReport cmd) {
-	def result = []
-	state.codes = cmd.supportedUsers
-	if (state.requestCode && state.requestCode <= cmd.supportedUsers) {
-		result << response(requestCode(state.requestCode))
-	}
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.associationv2.AssociationReport cmd) {
-	def result = []
-	if (cmd.nodeId.any { it == zwaveHubNodeId }) {
-		state.remove("associationQuery")
-		log.debug "$device.displayName is associated to $zwaveHubNodeId"
-		result << createEvent(descriptionText: "$device.displayName is associated")
-		state.assoc = zwaveHubNodeId
-		if (cmd.groupingIdentifier == 2) {
-			result << response(zwave.associationV1.associationRemove(groupingIdentifier:1, nodeId:zwaveHubNodeId))
-		}
-	} else if (cmd.groupingIdentifier == 1) {
-		result << response(secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId)))
-	} else if (cmd.groupingIdentifier == 2) {
-		result << response(zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId))
-	}
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.timev1.TimeGet cmd) {
-	def result = []
-	def now = new Date().toCalendar()
-	if(location.timeZone) now.timeZone = location.timeZone
-	result << createEvent(descriptionText: "$device.displayName requested time update", displayed: false)
-	result << response(secure(zwave.timeV1.timeReport(
-		hourLocalTime: now.get(Calendar.HOUR_OF_DAY),
-		minuteLocalTime: now.get(Calendar.MINUTE),
-		secondLocalTime: now.get(Calendar.SECOND)))
-	)
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
-	// The old Schlage locks use group 1 for basic control - we don't want that, so unsubscribe from group 1
-	def result = [ createEvent(name: "lock", value: cmd.value ? "unlocked" : "locked") ]
-	result << response(zwave.associationV1.associationRemove(groupingIdentifier:1, nodeId:zwaveHubNodeId))
-	if (state.assoc != zwaveHubNodeId) {
-		result << response(zwave.associationV1.associationGet(groupingIdentifier:2))
-	}
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
-	def map = [ name: "battery", unit: "%" ]
-	if (cmd.batteryLevel == 0xFF) {
-		map.value = 1
-		map.descriptionText = "$device.displayName has a low battery"
-	} else {
-		map.value = cmd.batteryLevel
-	}
-	state.lastbatt = now()
-	createEvent(map)
-}
-
-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)
-
-	result << createEvent(descriptionText: "$device.displayName MSR: $msr", isStateChange: false)
-	result
-}
-
-def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {
-	def fw = "${cmd.applicationVersion}.${cmd.applicationSubVersion}"
-	updateDataValue("fw", fw)
-	if (state.MSR == "003B-6341-5044") {
-		updateDataValue("ver", "${cmd.applicationVersion >> 4}.${cmd.applicationVersion & 0xF}")
-	}
-	def text = "$device.displayName: firmware version: $fw, Z-Wave version: ${cmd.zWaveProtocolVersion}.${cmd.zWaveProtocolSubVersion}"
-	createEvent(descriptionText: text, isStateChange: false)
-}
-
-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.Command cmd) {
-	createEvent(displayed: false, descriptionText: "$device.displayName: $cmd")
-}
-
-def lockAndCheck(doorLockMode) {
-	secureSequence([
-		zwave.doorLockV1.doorLockOperationSet(doorLockMode: doorLockMode),
-		zwave.doorLockV1.doorLockOperationGet()
-	], 4200)
-}
-
-def lock() {
-	lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_SECURED)
-}
-
-def unlock() {
-	lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_UNSECURED)
-}
-
-def unlockwtimeout() {
-	lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_UNSECURED_WITH_TIMEOUT)
-}
-
-def refresh() {
-	def cmds = [secure(zwave.doorLockV1.doorLockOperationGet())]
-	if (state.assoc == zwaveHubNodeId) {
-		log.debug "$device.displayName is associated to ${state.assoc}"
-	} else if (!state.associationQuery) {
-		log.debug "checking association"
-		cmds << "delay 4200"
-		cmds << zwave.associationV1.associationGet(groupingIdentifier:2).format()  // old Schlage locks use group 2 and don't secure the Association CC
-		cmds << secure(zwave.associationV1.associationGet(groupingIdentifier:1))
-		state.associationQuery = now()
-	} else if (secondsPast(state.associationQuery, 9)) {
-		cmds << "delay 6000"
-		cmds << zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId).format()
-		cmds << secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId))
-		cmds << zwave.associationV1.associationGet(groupingIdentifier:2).format()
-		cmds << secure(zwave.associationV1.associationGet(groupingIdentifier:1))
-		state.associationQuery = now()
-	}
-	log.debug "refresh sending ${cmds.inspect()}"
-	cmds
-}
-
-def poll() {
-	def cmds = []
-	// Only check lock state if it changed recently or we haven't had an update in an hour
-	def latest = device.currentState("lock")?.date?.time
-	if (!latest || !secondsPast(latest, 6 * 60) || secondsPast(state.lastPoll, 55 * 60)) {
-		cmds << secure(zwave.doorLockV1.doorLockOperationGet())
-		state.lastPoll = now()
-	} else if (!state.lastbatt || now() - state.lastbatt > 53*60*60*1000) {
-		cmds << secure(zwave.batteryV1.batteryGet())
-		state.lastbatt = now()  //inside-214
-	}
-	if (cmds) {
-		log.debug "poll is sending ${cmds.inspect()}"
-		cmds
-	} else {
-		// workaround to keep polling from stopping due to lack of activity
-		sendEvent(descriptionText: "skipping poll", isStateChange: true, displayed: false)
-		null
-	}
-
-    reportAllCodes(state)
-}
-
-def requestCode(codeNumber) {
-	secure(zwave.userCodeV1.userCodeGet(userIdentifier: codeNumber))
-}
-
-def reloadAllCodes() {
-	def cmds = []
-	if (!state.codes) {
-		state.requestCode = 1
-		cmds << secure(zwave.userCodeV1.usersNumberGet())
-	} else {
-		if(!state.requestCode) state.requestCode = 1
-		cmds << requestCode(codeNumber)
-	}
-	cmds
-}
-
-def setCode(codeNumber, code) {
-	def strcode = code
-	log.debug "setting code $codeNumber to $code"
-	if (code instanceof String) {
-		code = code.toList().findResults { if(it > ' ' && it != ',' && it != '-') it.toCharacter() as Short }
-	} else {
-		strcode = code.collect{ it as Character }.join()
-	}
-	if (state.blankcodes) {
-		// Can't just set, we won't be able to tell if it was successful
-		if (state["code$codeNumber"] != "") {
-			if (state["setcode$codeNumber"] != strcode) {
-				state["resetcode$codeNumber"] = strcode
-				return deleteCode(codeNumber)
-			}
-		} else {
-			state["setcode$codeNumber"] = strcode
-		}
-	}
-	secureSequence([
-		zwave.userCodeV1.userCodeSet(userIdentifier:codeNumber, userIdStatus:1, user:code),
-		zwave.userCodeV1.userCodeGet(userIdentifier:codeNumber)
-	], 7000)
-}
-
-def deleteCode(codeNumber) {
-	log.debug "deleting code $codeNumber"
-	secureSequence([
-		zwave.userCodeV1.userCodeSet(userIdentifier:codeNumber, userIdStatus:0),
-		zwave.userCodeV1.userCodeGet(userIdentifier:codeNumber)
-	], 7000)
-}
-
-def updateCodes(codeSettings) {
-	if(codeSettings instanceof String) codeSettings = util.parseJson(codeSettings)
-	def set_cmds = []
-	def get_cmds = []
-	codeSettings.each { name, updated ->
-		def current = decrypt(state[name])
-		if (name.startsWith("code")) {
-			def n = name[4..-1].toInteger()
-			log.debug "$name was $current, set to $updated"
-			if (updated?.size() >= 4 && updated != current) {
-				def cmds = setCode(n, updated)
-				set_cmds << cmds.first()
-				get_cmds << cmds.last()
-			} else if ((current && updated == "") || updated == "0") {
-				def cmds = deleteCode(n)
-				set_cmds << cmds.first()
-				get_cmds << cmds.last()
-			} else if (updated && updated.size() < 4) {
-				// Entered code was too short
-				codeSettings["code$n"] = current
-			}
-		} else log.warn("unexpected entry $name: $updated")
-	}
-	if (set_cmds) {
-		return response(delayBetween(set_cmds, 2200) + ["delay 2200"] + delayBetween(get_cmds, 4200))
-	}
-}
-
-def getCode(codeNumber) {
-	decrypt(state["code$codeNumber"])
-}
-
-def getAllCodes() {
-	state.findAll { it.key.startsWith 'code' }.collectEntries {
-		[it.key, (it.value instanceof String && it.value.startsWith("~")) ? decrypt(it.value) : it.value]
-	}
-}
-
-private secure(physicalgraph.zwave.Command cmd) {
-	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
-}
-
-private secureSequence(commands, delay=4200) {
-	delayBetween(commands.collect{ secure(it) }, delay)
-}
-
-private Boolean secondsPast(timestamp, seconds) {
-	if (!(timestamp instanceof Number)) {
-		if (timestamp instanceof Date) {
-			timestamp = timestamp.time
-		} else if ((timestamp instanceof String) && timestamp.isNumber()) {
-			timestamp = timestamp.toLong()
-		} else {
-			return true
-		}
-	}
-	return (now() - timestamp) > (seconds * 1000)
-}
-
-private allCodesDeleted() {
-	if (state.codes instanceof Integer) {
-		(1..state.codes).each { n ->
-			if (state["code$n"]) {
-				result << createEvent(name: "codeReport", value: n, data: [ code: "" ], descriptionText: "code $n was deleted",
-					displayed: false, isStateChange: true)
-			}
-			state["code$n"] = ""
-		}
-	}
-}
-
-def reportAllCodes(state) {
-  def map = [ name: "reportAllCodes", data: [:], displayed: false, isStateChange: false, type: "physical" ]
-  state.each { entry ->
-    //iterate through all the state entries and add them to the event data to be handled by application event handlers
-    if ( entry.key ==~ /^code\d{1,}/ && entry.value.startsWith("~") ) {
-      map.data.put(entry.key, decrypt(entry.value))
-    } else {
-      map.data.put(entry.key, entry.value)
-    }
-  }
-  sendEvent(map)
-}

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

@@ -0,0 +1,348 @@
+/**
+ *  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: "deviceDiscovery")
+}
+
+def mainPage() {
+	dynamicPage(name: "mainPage", title: "Manage your Sonoff switches", nextPage: null, uninstall: true, install: true) {
+        section("Configure"){
+           href "deviceDiscovery", title:"Discover Sonoff Devices", 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){
+   def currentDevice
+   getChildDevices().each {
+       if(it.deviceNetworkId == params.did){
+           state.currentDeviceId = it.deviceNetworkId
+           state.currentDisplayName = it.displayName
+       }      
+   }
+   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", params: [did: state.currentDeviceId]
+        }
+        section {
+              href "deletePDevice", title:"Delete $state.currentDisplayName", description: "", params: [did: state.currentDeviceId]
+        }
+   }
+}
+
+def deletePDevice(params){
+    try {
+        unsubscribe()
+        getChildDevices().each {
+            if(it.deviceNetworkId.startsWith("${params.did}/")) deleteChildDevice(it.deviceNetworkId)
+        } 
+        deleteChildDevice(params.did)
+        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(params){
+    def thisDevice = getChildDevice(params.did)
+    thisDevice.label = settings["${params.did}_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
+	if (body?.device?.modelName?.text().startsWith("Sonoff Wifi Switch")) {
+		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 "Creating Sonoff Switch with dni: ${selectedDevice.value.mac}"
+            log.debug Integer.parseInt(selectedDevice.value.deviceAddress,16)
+            addChildDevice("erocm123", "Sonoff Wifi Switch", 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 Wifi Switch 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)
+}
+
+def log(message){
+    
+}