MSA-1483: Need these to program codes

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

@@ -87,27 +87,16 @@ def beep() {
 	up to this long from the time you send the message to the time you hear a sound.
 	*/
 
-	// Used source endpoint of 0x02 because we are using smartthings manufacturer specific cluster.
 	[
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 200",
-		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 200",
-		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 200",
-		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
 		"raw 0xFC05 {15 0A 11 00 00 15 01}",
-		"delay 200",
-		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 		"delay 7000",
-		"raw 0xFC05 {15 0A 11 00 00 15 01}",
+		"raw 0xFC05 {15 0A 11 00 00 15 01}"
-		"delay 200",
-		"send 0x$zigbee.deviceNetworkId 0x02 0x$zigbee.endpointId",
 	]
 }
 

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

@@ -105,21 +105,11 @@ def parseDescriptionAsMap(description) {
 
 // Commands to device
 def on() {
-	[
+	'zcl on-off on'
-			'zcl on-off on',
-			'delay 200',
-			"send 0x${zigbee.deviceNetworkId} 0x01 0x${zigbee.endpointId}",
-			'delay 500'
-	]
 }
 
 def off() {
-	[
+	'zcl on-off off'
-			'zcl on-off off',
-			'delay 200',
-			"send 0x${zigbee.deviceNetworkId} 0x01 0x${zigbee.endpointId}",
-			'delay 500'
-	]
 }
 
 def setLevel(value) {

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

@@ -31,13 +31,13 @@ metadata {
 		command "switchMode"
 		command "switchFanMode"
 
-		attribute "thermostatSetpoint", "number"
+		attribute "thermostatSetpoint","number"
-		attribute "thermostatStatus", "string"
+		attribute "thermostatStatus","string"
 		attribute "maxHeatingSetpoint", "number"
 		attribute "minHeatingSetpoint", "number"
 		attribute "maxCoolingSetpoint", "number"
 		attribute "minCoolingSetpoint", "number"
-		attribute "deviceTemperatureUnit", "string"
+		attribute "deviceTemperatureUnit", "number"
 	}
 
 	tiles {

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

@@ -7,11 +7,9 @@
 metadata {
 	// Automatically generated. Make future change here.
 	definition (name: "Hue Bridge", namespace: "smartthings", author: "SmartThings") {
-		capability "Health Check"
-
 		attribute "networkAddress", "string"
-		// Used to indicate if bridge is reachable or not, i.e. is the bridge connected to the network
+        // Used to indicate if bridge is reachable or not, i.e. is the bridge connected to the network
-		// Possible values "Online" or "Offline"
+        // Possible values "Online" or "Offline"
 		attribute "status", "string"
 		// Id is the number on the back of the hub, Hue uses last six digits of Mac address
 		// This is also used in the Hue application as ID
@@ -44,10 +42,6 @@ metadata {
 	}
 }
 
-void installed() {
-	sendEvent(name: "checkInterval", value: 60 * 12, data: [protocol: "lan"], displayed: false)
-}
-
 // parse events into attributes
 def parse(description) {
 	log.debug "Parsing '${description}'"
@@ -76,8 +70,13 @@ def parse(description) {
 					def bulbs = new groovy.json.JsonSlurper().parseText(msg.body)
 					if (bulbs.state) {
 						log.info "Bridge response: $msg.body"
+					} else {
+						// Sending Bulbs List to parent"
+						if (parent.isInBulbDiscovery())
+							log.info parent.bulbListHandler(device.hub.id, msg.body)
 					}
-				} else if (contentType?.contains("xml")) {
+				}
+				else if (contentType?.contains("xml")) {
 					log.debug "HUE BRIDGE ALREADY PRESENT"
 					parent.hubVerification(device.hub.id, msg.body)
 				}
@@ -86,7 +85,3 @@ def parse(description) {
 	}
 	results
 }
-
-def ping() {
-	log.debug "${parent.ping(this)}"
-}

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

@@ -174,7 +174,7 @@ void setColorTemperature(value) {
 
 void refresh() {
     log.debug "Executing 'refresh'"
-    parent?.manualRefresh()
+    parent.manualRefresh()
 }
 
 def verifyPercent(percent) {

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

@@ -47,21 +47,9 @@ def parse(String description) {
 
 // Commands to device
 def on() {
-	[
+	'zcl on-off on'
-			'zcl on-off on',
-			'delay 200',
-			"send 0x${zigbee.deviceNetworkId} 0x01 0x${zigbee.endpointId}",
-			'delay 500'
-
-	]
-
 }
 
 def off() {
-	[
+	'zcl on-off off'
-			'zcl on-off off',
-			'delay 200',
-			"send 0x${zigbee.deviceNetworkId} 0x01 0x${zigbee.endpointId}",
-			'delay 500'
-	]
 }

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

@@ -180,9 +180,9 @@ private Map parseIasMessage(String description) {
 def getTemperature(value) {
 	def celsius = Integer.parseInt(value, 16).shortValue() / 100
 	if(getTemperatureScale() == "C"){
-		return Math.round(celsius)
+		return celsius
 	} else {
-		return Math.round(celsiusToFahrenheit(celsius))
+		return celsiusToFahrenheit(celsius) as Integer
 	}
 }
 

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

@@ -194,9 +194,9 @@ private Map parseIasMessage(String description) {
 def getTemperature(value) {
 	def celsius = Integer.parseInt(value, 16).shortValue() / 100
 	if(getTemperatureScale() == "C"){
-		return Math.round(celsius)
+		return celsius
 	} else {
-		return Math.round(celsiusToFahrenheit(celsius))
+		return celsiusToFahrenheit(celsius) as Integer
 	}
 }
 

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

@@ -261,9 +261,9 @@ def updated() {
 def getTemperature(value) {
 	def celsius = Integer.parseInt(value, 16).shortValue() / 100
 	if(getTemperatureScale() == "C"){
-		return Math.round(celsius)
+		return celsius
 		} else {
-			return Math.round(celsiusToFahrenheit(celsius))
+			return celsiusToFahrenheit(celsius) as Integer
 		}
 	}
 

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

@@ -31,8 +31,7 @@
         fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD210 PB DB", deviceJoinName: "Yale Push Button Deadbolt Lock"
         fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD220/240 TSDB", deviceJoinName: "Yale Touch Screen Deadbolt Lock"
         fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRL210 PB LL", deviceJoinName: "Yale Push Button Lever Lock"
-	fingerprint profileId: "0104", inClusters: "0000,0001,0003,0009,000A,0101,0020", outClusters: "000A,0019", manufacturer: "Yale", model: "YRD226/246 TSDB", deviceJoinName: "Yale Touch Screen Deadbolt Lock"
+    }
-	}
 
     tiles(scale: 2) {
 		multiAttributeTile(name:"toggle", type:"generic", width:6, height:4){

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

@@ -0,0 +1,683 @@
+/**
+ *  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/egid/smart-windows.src/smart-windows.groovy

@@ -1,7 +1,7 @@
 /**
  *  Smart Windows
  *	Compares two temperatures – indoor vs outdoor, for example – then sends an alert if windows are open (or closed!).
- *
+ * 
  *  Copyright 2014 Eric Gideon
  *
  * 	Based in part on the "When it's going to rain" SmartApp by the SmartThings team,
@@ -21,18 +21,13 @@ definition(
 	name: "Smart Windows",
 	namespace: "egid",
 	author: "Eric Gideon",
-	description: "Compares two temperatures – indoor vs outdoor, for example – then sends an alert if windows are open (or closed!). If you don't use an external temperature device, your location will be used instead.",
+	description: "Compares two temperatures – indoor vs outdoor, for example – then sends an alert if windows are open (or closed!). If you don't use an external temperature device, your zipcode will be used instead.",
 	iconUrl: "https://s3.amazonaws.com/smartthings-device-icons/Home/home9-icn.png",
 	iconX2Url: "https://s3.amazonaws.com/smartthings-device-icons/Home/home9-icn@2x.png"
 )
 
 
 preferences {
-
-  if (!(location.zipCode || ( location.latitude && location.longitude )) && location.channelName == 'samsungtv') {
-		section { paragraph title: "Note:", "Location is required for this SmartApp. Go to 'Location Name' settings to setup your correct location." }
-	}
-
 	section( "Set the temperature range for your comfort zone..." ) {
 		input "minTemp", "number", title: "Minimum temperature"
 		input "maxTemp", "number", title: "Maximum temperature"
@@ -44,11 +39,9 @@ preferences {
 		input "inTemp", "capability.temperatureMeasurement", title: "Indoor"
 		input "outTemp", "capability.temperatureMeasurement", title: "Outdoor (optional)", required: false
 	}
-
+	section( "Set your location" ) {
-	if (location.channelName != 'samsungtv') {
+		input "zipCode", "text", title: "Zip code"
-		section( "Set your location" ) { input "zipCode", "text", title: "Zip code" }
+	}
-  }
-
 	section( "Notifications" ) {
 		input "sendPushMessage", "enum", title: "Send a push notification?", metadata:[values:["Yes","No"]], required:false
 		input "retryPeriod", "number", title: "Minutes between notifications:"
@@ -79,7 +72,7 @@ def temperatureHandler(evt) {
 
 	def currentInTemp = evt.doubleValue
 	def openWindows = sensors.findAll { it?.latestValue("contact") == 'open' }
-
+	
 	log.trace "Temp event: $evt"
 	log.info "In: $currentInTemp; Out: $currentOutTemp"
 
@@ -105,7 +98,7 @@ def temperatureHandler(evt) {
 			if ( currentOutTemp < maxTemp && !openWindows ) {
 				send( "Open some windows to cool down the house! Currently ${currentInTemp}°F inside and ${currentOutTemp}°F outside." )
 			} else if ( currentOutTemp > maxTemp && openWindows ) {
-				send( "It's gotten warmer outside! You should close these windows: ${openWindows.join(', ')}. Currently ${currentInTemp}°F inside and ${currentOutTemp}°F outside." )
+				send( "It's gotten warmer outside! You should close these windows: ${openWindows.join(', ')}. Currently ${currentInTemp}°F inside and ${currentOutTemp}°F outside." )				
 			} else {
 				log.debug "No notifications sent. Everything is in the right place."
 			}
@@ -132,11 +125,7 @@ def temperatureHandler(evt) {
 }
 
 def weatherCheck() {
-	def json 
+	def json = getWeatherFeature("conditions", zipCode)
-	if (location.channelName != 'samsungtv')
-		json = getWeatherFeature("conditions", zipCode)
-	else
-		json = getWeatherFeature("conditions")
 	def currentTemp = json?.current_observation?.temp_f
 
 	if ( currentTemp ) {
@@ -161,4 +150,4 @@ private send(msg) {
 	}
 
 	log.info msg
-}
+}

smartapps/gideon-api/gideon.src/gideon.groovy

@@ -1,253 +0,0 @@
-/**
- *  Gideon
- *
- *  Copyright 2016 Nicola Russo
- *
- *  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: "Gideon",
-    namespace: "gideon.api",
-    author: "Braindrain Solutions",
-    description: "Gideon AI Smart app allows you to connect and control all of your SmartThings devices through the Gideon AI app, making your SmartThings devices even smarter.",
-    category: "Family",
-    iconUrl: "http://s33.postimg.org/t77u7y7v3/logo.png",
-    iconX2Url: "http://s33.postimg.org/t77u7y7v3/logo.png",
-    iconX3Url: "http://s33.postimg.org/t77u7y7v3/logo.png",
-    oauth: [displayName: "Gideon AI API", displayLink: "gideon.ai"])
-
-
-preferences {
-	section("Control these switches...") {
-        input "switches", "capability.switch", multiple:true
-    }
-    section("Control these motion sensors...") {
-        input "motions", "capability.motionSensor", multiple:true
-    }
-    section("Control these presence sensors...") {
-    	input "presence_sensors", "capability.presenceSensor", multiple:true
-    }
-    section("Control these outlets...") {
-    	input "outlets", "capability.switch", multiple:true
-    }
-    section("Control these locks...") {
-    	input "locks", "capability.lock", multiple:true
-    }
-    section("Control these locks...") {
-	    input "temperature_sensors", "capability.temperatureMeasurement"
-    }
-}
-
-def installed() {
-	log.debug "Installed with settings: ${settings}"
-
-	initialize()
-}
-
-def updated() {
-	log.debug "Updated with settings: ${settings}"
-
-	unsubscribe()
-	initialize()
-}
-
-def initialize() {
-	// TODO: subscribe to attributes, devices, locations, etc.
-    subscribe(outlet, "energy", outletHandler)
-  	subscribe(outlet, "switch", outletHandler)
-}
-
-// TODO: implement event handlers
-def outletHandler(evt) {
-	log.debug "$outlet.currentEnergy"
-	//TODO call G API  
-}
-
-
-private device(it, type) {
-	it ? [id: it.id, label: it.label, type: type] : null
-}
-
-//API Mapping
-mappings {
-	path("/getalldevices") {
-    action: [
-      			GET: "getAllDevices"
-    		]
-  	}
-	path("/doorlocks/:id/:command") {
-    action: [
-      GET: "updateDoorLock"
-    ]
-  }
-  	path("/doorlocks/:id") {
-    action: [
-      			GET: "getDoorLockStatus"
-    		]
-  	}
-  	path("/tempsensors/:id") {
-    action: [
-      GET: "getTempSensorsStatus"
-    ]
-  }
-  	path("/presences/:id") {
-    action: [
-      GET: "getPresenceStatus"
-    ]
-  }
-  	path("/motions/:id") {
-    action: [
-      GET: "getMotionStatus"
-    ]
-  }
-  	path("/outlets/:id") {
-    action: [
-      GET: "getOutletStatus"
-    ]
-  }
-  	path("/outlets/:id/:command") {
-    action: [
-      GET: "updateOutlet"
-    ]
-  }
-  	path("/switches/:command") {
-    action: [
-      PUT: "updateSwitch"
-    ]
-  }
-}
-
-//API Methods
-def getAllDevices() {
-	def locks_list = locks.collect{device(it,"Lock")}
-    def presences_list = presence_sensors.collect{device(it,"Presence")}
-    def motions_list = motions.collect{device(it,"Motion")}
-    def outlets_list = outlets.collect{device(it,"Outlet")}
-    def switches_list = switches.collect{device(it,"Switch")}
-    def temp_list = temperature_sensors.collect{device(it,"Temperature")}
-    return [Locks: locks_list, Presences: presences_list, Motions: motions_list, Outlets: outlets_list, Switches: switches_list, Temperatures: temp_list]
-}
-
-//LOCKS
-def getDoorLockStatus() {
-	def device = locks.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Device_state: device.currentValue('lock')]
-        }
-}
-
-def updateDoorLock() {
-	def command = params.command
-    def device = locks.find { it.id == params.id }
-    if (command){
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            if(command == "toggle")
-            {
-                if(device.currentValue('lock') == "locked")
-                  device.unlock();
-                else
-                  device.lock();
-                  
-                return [Device_id: params.id, result_action: "200"]
-            }
-        }
-    }
-}
-
-//PRESENCE
-def getPresenceStatus() {
-
-	def device = presence_sensors.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Device_state: device.currentValue('presence')]
-   }
-}
-
-//MOTION
-def getMotionStatus() {
-
-	def device = motions.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Device_state: device.currentValue('motion')]
-   }
-}
-
-//OUTLET
-def getOutletStatus() {
-	
-    def device = outlets.find { it.id == params.id }
-   	if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Device_state: device.currentSwitch, Current_watt: device.currentValue("energy")]
-  }
-}
-
-def updateOutlet() {
-	
-    def command = params.command
-    def device = outlets.find { it.id == params.id }
-    if (command){
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            if(command == "toggle")
-            {
-                if(device.currentSwitch == "on")
-                  device.off();
-                else
-                  device.on();
-                  
-                return [Device_id: params.id, result_action: "200"]
-            }
-        }
-    }
-}                
-
-//SWITCH
-def updateSwitch() {
-    def command = params.command
-    def device = switches.find { it.id == params.id }
-    if (command){
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            if(command == "toggle")
-            {
-                if(device.currentSwitch == "on")
-                  device.off();
-                else
-                  device.on();
-                  
-                return [Device_id: params.id, result_action: "200"]
-            }
-        }
-    }
-}
-
-//TEMPERATURE
-def getTempSensorsStatus() {
-	
-    def device = temperature_sensors.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Device_state: device.currentValue('temperature')]
-   }
-}

smartapps/imbrianj/ready-for-rain.src/ready-for-rain.groovy

@@ -18,13 +18,8 @@ definition(
 )
 
 preferences {
-
+  section("Zip code?") {
-  if (!(location.zipCode || ( location.latitude && location.longitude )) && location.channelName == 'samsungtv') {
+    input "zipcode", "text", title: "Zipcode?"
-		section { paragraph title: "Note:", "Location is required for this SmartApp. Go to 'Location Name' settings to setup your correct location." }
-	}
-
-  if (location.channelName != 'samsungtv') {
-		section( "Set your location" ) { input "zipCode", "text", title: "Zip code" }
   }
 
   section("Things to check?") {
@@ -65,11 +60,7 @@ def scheduleCheck(evt) {
   // Only need to poll if we haven't checked in a while - and if something is left open.
   if((now() - (30 * 60 * 1000) > state.lastCheck["time"]) && open) {
     log.info("Something's open - let's check the weather.")
-    def response
+    def response = getWeatherFeature("forecast", zipcode)
-    if (location.channelName != 'samsungtv')
-      response = getWeatherFeature("forecast", zipCode)
-    else
-      response = getWeatherFeature("forecast")
     def weather  = isStormy(response)
 
     if(weather) {

smartapps/juano2310/jawbone-up-connect.src/jawbone-up-connect.groovy

@@ -4,9 +4,6 @@
  *  Author: Juan Risso
  *  Date: 2013-12-19
  */
-
-include 'asynchttp_v1'
-
 definition(
 	name: "Jawbone UP (Connect)",
 	namespace: "juano2310",
@@ -306,8 +303,7 @@ def setup() {
 			  	def childDevice = addChildDevice('juano2310', "Jawbone User", "${app.id}.${member.xid}",null,[name:"Jawbone UP - " + member.first, completedSetup: true])
 			    if (childDevice) {
 			       	log.debug "Child Device Successfully Created"
-			        childDevice?.generateSleepingEvent(false)
+			        generateInitialEvent (member, childDevice)
-                    pollChild(childDevice)
 			    }
 			}
 		}
@@ -353,67 +349,67 @@ def uninstalled() {
 }
 
 def pollChild(childDevice) {
-		def childMap = [ value: "$childDevice.device.deviceNetworkId}"]
+    def member = state.member
-
+    generatePollingEvents (member, childDevice)
-		def params = [
-				uri: 'https://jawbone.com',
-				path: '/nudge/api/users/@me/goals',
-				headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ],
-				contentType: 'application/json'
-		]
-
-		asynchttp_v1.get('responseGoals', params, childMap)
-
-		def params2 = [
-				uri: 'https://jawbone.com',
-				path: '/nudge/api/users/@me/moves',
-				headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ],
-				contentType: 'application/json'
-		]
-
-		asynchttp_v1.get('responseMoves', params2, childMap)
 }
 
-def responseGoals(response, dni) {
+def generatePollingEvents (member, childDevice) {
-	if (response.hasError()) {
+    // lets figure out if the member is currently "home" (At the place)
-			log.error "response has error: $response.errorMessage"
+    def urlgoals = "https://jawbone.com/nudge/api/users/@me/goals"
-	} else {
+    def urlmoves = "https://jawbone.com/nudge/api/users/@me/moves"
-			def goals
+    def urlsleeps = "https://jawbone.com/nudge/api/users/@me/sleeps"
-			try {
+    def goals = null
-					// json response already parsed into JSONElement object
+    def moves = null
-					goals = response.json.data
+ 	def sleeps = null
-			} catch (e) {
+    httpGet(uri: urlgoals, headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ]) {response ->
-					log.error "error parsing json from response: $e"
+        goals = response.data.data
-			}
+    }
-			if (goals) {
+    httpGet(uri: urlmoves, headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ]) {response ->
-				def childDevice = getChildDevice(dni.value)
+        moves = response.data.data.items[0]
-				log.debug "Goal = ${goals.move_steps} Steps"
+    }
-				childDevice?.sendEvent(name:"goal", value: goals.move_steps)
+
-			} else {
+    try { // we are going to just ignore any errors
-					log.debug "did not get json results from response body: $response.data"
+        log.debug "Member = ${member.first}"
-			}
+        log.debug "Moves Goal = ${goals.move_steps} Steps"
-	}
+        log.debug "Moves = ${moves.details.steps} Steps"
+
+        childDevice?.sendEvent(name:"steps", value: moves.details.steps)
+        childDevice?.sendEvent(name:"goal", value: goals.move_steps)
+    	//setColor(moves.details.steps,goals.move_steps,childDevice)
+    }
+    catch (e) {
+            // eat it
+    }
 }
 
-def responseMoves(response, dni) {
+def generateInitialEvent (member, childDevice) {
-	if (response.hasError()) {
+    // lets figure out if the member is currently "home" (At the place)
-			log.error "response has error: $response.errorMessage"
+    def urlgoals = "https://jawbone.com/nudge/api/users/@me/goals"
-	} else {
+    def urlmoves = "https://jawbone.com/nudge/api/users/@me/moves"
-			def moves
+    def urlsleeps = "https://jawbone.com/nudge/api/users/@me/sleeps"
-			try {
+    def goals = null
-					// json response already parsed into JSONElement object
+    def moves = null
-					moves = response.json.data.items[0]
+ 	def sleeps = null
-			} catch (e) {
+    httpGet(uri: urlgoals, headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ]) {response ->
-					log.error "error parsing json from response: $e"
+        goals = response.data.data
-			}
+    }
-			if (moves) {
+    httpGet(uri: urlmoves, headers: ["Authorization": "Bearer ${state.JawboneAccessToken}" ]) {response ->
-				def childDevice = getChildDevice(dni.value)
+        moves = response.data.data.items[0]
-				log.debug "Moves = ${moves.details.steps} Steps"
+    }
-				childDevice?.sendEvent(name:"steps", value: moves.details.steps)
+
-			} else {
+    try { // we are going to just ignore any errors
-					log.debug "did not get json results from response body: $response.data"
+        log.debug "Member = ${member.first}"
-			}
+        log.debug "Moves Goal = ${goals.move_steps} Steps"
-	}
+        log.debug "Moves = ${moves.details.steps} Steps"
+        log.debug "Sleeping state = false"
+        childDevice?.generateSleepingEvent(false)
+        childDevice?.sendEvent(name:"steps", value: moves.details.steps)
+        childDevice?.sendEvent(name:"goal", value: goals.move_steps)
+    	//setColor(moves.details.steps,goals.move_steps,childDevice)
+    }
+    catch (e) {
+            // eat it
+    }
 }
 
 def setColor (steps,goal,childDevice) {
@@ -437,7 +433,7 @@ def hookEventHandler() {
     // get some stuff we need
     def userId = json.events.user_xid[0]
     def	json_type = json.events.type[0]
-	  def json_action = json.events.action[0]
+	def json_action = json.events.action[0]
 
     //log.debug json
     log.debug "Userid = ${userId}"

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

@@ -454,23 +454,17 @@ def sendStopEvent(source) {
 		eventData.value += "cancelled"
 	}
 
-	// send 100% completion event
-	sendTimeRemainingEvent(100)
-
-	// send a non-displayed 0% completion to reset tiles
-	sendTimeRemainingEvent(0, false)
-
-	// send sessionStatus event last so the event feed is ordered properly
 	sendControllerEvent(eventData)
+	sendTimeRemainingEvent(0)
 }
 
-def sendTimeRemainingEvent(percentComplete, displayed = true) {
+def sendTimeRemainingEvent(percentComplete) {
 	log.trace "sendTimeRemainingEvent(${percentComplete})"
 
 	def percentCompleteEventData = [
 			name: "percentComplete",
 			value: percentComplete as int,
-			displayed: displayed,
+			displayed: true,
 			isStateChange: true
 	]
 	sendControllerEvent(percentCompleteEventData)
@@ -480,7 +474,7 @@ def sendTimeRemainingEvent(percentComplete, displayed = true) {
 	def timeRemainingEventData = [
 			name: "timeRemaining",
 			value: displayableTime(timeRemaining),
-			displayed: displayed,
+			displayed: true,
 			isStateChange: true
 	]
 	sendControllerEvent(timeRemainingEventData)
@@ -614,6 +608,8 @@ private completion() {
 	handleCompletionMessaging()
 
 	handleCompletionModesAndPhrases()
+
+	sendTimeRemainingEvent(100)
 }
 
 private handleCompletionSwitches() {

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

@@ -83,7 +83,7 @@ def bridgeDiscovery(params=[:])
 
 	return dynamicPage(name:"bridgeDiscovery", title:"Discovery Started!", nextPage:"bridgeBtnPush", refreshInterval:refreshInterval, uninstall: true) {
 		section("Please wait while we discover your Hue Bridge. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
-			input "selectedHue", "enum", required:false, title:"Select Hue Bridge (${numFound} found)", multiple:false, options:options, submitOnChange: true
+			input "selectedHue", "enum", required:false, title:"Select Hue Bridge (${numFound} found)", multiple:false, options:options
 		}
 	}
 }
@@ -131,7 +131,10 @@ def bulbDiscovery() {
 	def refreshInterval = 3
 	state.inBulbDiscovery = true
 	def bridge = null
-
+	if (selectedHue) {
+		bridge = getChildDevice(selectedHue)
+		subscribe(bridge, "bulbList", bulbListData)
+	}
 	state.bridgeRefreshCount = 0
 	def allLightsFound = bulbsDiscovered() ?: [:]
 
@@ -256,6 +259,10 @@ Map bulbsDiscovered() {
 	return bulbmap
 }
 
+def bulbListData(evt) {
+	state.bulbs = evt.jsonData
+}
+
 Map getHueBulbs() {
 	state.bulbs = state.bulbs ?: [:]
 }
@@ -309,6 +316,29 @@ def uninstalled(){
 	state.username = null
 }
 
+// Handles events to add new bulbs
+def bulbListHandler(hub, data = "") {
+	def msg = "Bulbs list not processed. Only while in settings menu."
+    def bulbs = [:]
+	if (state.inBulbDiscovery) {
+        def logg = ""
+        log.trace "Adding bulbs to state..."
+        state.bridgeProcessedLightList = true
+        def object = new groovy.json.JsonSlurper().parseText(data)
+        object.each { k,v ->
+            if (v instanceof Map)
+                bulbs[k] = [id: k, name: v.name, type: v.type, modelid: v.modelid, hub:hub, online: v.state?.reachable]
+        }
+    }
+    def bridge = null
+	if (selectedHue) {
+		bridge = getChildDevice(selectedHue)
+	}
+    bridge.sendEvent(name: "bulbList", value: hub, data: bulbs, isStateChange: true, displayed: false)
+    msg = "${bulbs.size()} bulbs found. ${bulbs}"
+	return msg
+}
+
 private upgradeDeviceType(device, newHueType) {
 	def deviceType = getDeviceType(newHueType)
 
@@ -460,25 +490,24 @@ def ssdpBridgeHandler(evt) {
 		def host = ip + ":" + port
 		log.debug "Device ($parsedEvent.mac) was already found in state with ip = $host."
 		def dstate = bridges."${parsedEvent.ssdpUSN.toString()}"
-		def dniReceived = "${parsedEvent.mac}"
+		def dni = "${parsedEvent.mac}"
-		def currentDni = dstate.mac
+		def d = getChildDevice(dni)
-		def d = getChildDevice(dniReceived)
 		def networkAddress = null
 		if (!d) {
-			// There might be a mismatch between bridge DNI and the actual bridge mac address, correct that
+			childDevices.each {
-			log.debug "Bridge with $dniReceived not found"
+				if (it.getDeviceDataByName("mac")) {
-			def bridge = childDevices.find { it.deviceNetworkId == currentDni }
+					def newDNI = "${it.getDeviceDataByName("mac")}"
-			if (bridge != null) {
+					d = it
-				log.warn "Bridge is set to ${bridge.deviceNetworkId}, updating to $dniReceived"
+					if (newDNI != it.deviceNetworkId) {
-				bridge.setDeviceNetworkId("${dniReceived}")
+						def oldDNI = it.deviceNetworkId
-				dstate.mac = dniReceived
+						log.debug "updating dni for device ${it} with $newDNI - previous DNI = ${it.deviceNetworkId}"
-				// Check to see if selectedHue is a valid bridge, otherwise update it
+						it.setDeviceNetworkId("${newDNI}")
-				def isSelectedValid = bridges?.find {it.value?.mac == selectedHue}
+						if (oldDNI == selectedHue) {
-				if (isSelectedValid == null) {
+							app.updateSetting("selectedHue", newDNI)
-					log.warn "Correcting selectedHue in state"
+						}
-					app.updateSetting("selectedHue", dniReceived)
+						doDeviceSync()
+					}
 				}
-				doDeviceSync()
 			}
 		} else {
 			updateBridgeStatus(d)
@@ -496,18 +525,6 @@ def ssdpBridgeHandler(evt) {
 				d.sendEvent(name:"networkAddress", value: host)
 				d.updateDataValue("networkAddress", host)
 			}
-			if (dstate.mac != dniReceived) {
-				log.warn "Correcting bridge mac address in state"
-				dstate.mac = dniReceived
-			}
-			if (selectedHue != dniReceived) {
-				// Check to see if selectedHue is a valid bridge, otherwise update it
-				def isSelectedValid = bridges?.find {it.value?.mac == selectedHue}
-				if (isSelectedValid == null) {
-					log.warn "Correcting selectedHue in state"
-					app.updateSetting("selectedHue", dniReceived)
-				}
-			}
 		}
 	}
 }
@@ -540,8 +557,11 @@ void lightsHandler(physicalgraph.device.HubResponse hubResponse) {
 	if (isValidSource(hubResponse.mac)) {
 		def body = hubResponse.json
 		if (!body?.state?.on) { //check if first time poll made it here by mistake
+			def bulbs = getHueBulbs()
 			log.debug "Adding bulbs to state!"
-			updateBulbState(body, hubResponse.hubId)
+			body.each { k, v ->
+				bulbs[k] = [id: k, name: v.name, type: v.type, modelid: v.modelid, hub: hubResponse.hubId]
+			}
 		}
 	}
 }
@@ -657,8 +677,11 @@ def locationHandler(evt) {
 			} else {
 				//GET /api/${state.username}/lights response (application/json)
 				if (!body?.state?.on) { //check if first time poll made it here by mistake
+					def bulbs = getHueBulbs()
 					log.debug "Adding bulbs to state!"
-					updateBulbState(body, parsedEvent.hub)
+					body.each { k,v ->
+						bulbs[k] = [id: k, name: v.name, type: v.type, modelid: v.modelid, hub:parsedEvent.hub]
+					}
 				}
 			}
 		}
@@ -718,7 +741,7 @@ private void checkBridgeStatus() {
 		    }
 
 			if (it.value.lastActivity < time) { // it.value.lastActivity != null &&
-				log.warn "Bridge $it.value.idNumber is Offline"
+				log.warn "Bridge $it.key is Offline"
 				d.sendEvent(name: "status", value: "Offline")
 
 				state.bulbs?.each {
@@ -743,31 +766,6 @@ def isInBulbDiscovery() {
 	return state.inBulbDiscovery
 }
 
-private updateBulbState(messageBody, hub) {
-	def bulbs = getHueBulbs()
-
-	// Copy of bulbs used to locate old lights in state that are no longer on bridge
-	def toRemove = [:]
-	toRemove << bulbs
-
-	messageBody.each { k,v ->
-
-		if (v instanceof Map) {
-			if (bulbs[k] == null) {
-				bulbs[k] = [:]
-			}
-			bulbs[k] << [id: k, name: v.name, type: v.type, modelid: v.modelid, hub:hub, remove: false]
-			toRemove.remove(k)
-		}
-	}
-
-	// Remove bulbs from state that are no longer discovered
-	toRemove.each { k,v ->
-		log.warn "${bulbs[k].name} no longer exists on bridge, removing"
-		bulbs.remove(k)
-	}
-}
-
 /////////////////////////////////////
 //CHILD DEVICE METHODS
 /////////////////////////////////////
@@ -952,14 +950,6 @@ private handleCommandResponse(body) {
  * @return empty array
  */
 private handlePoll(body) {
-	// Used to track "unreachable" time
-	// Device is considered "offline" if it has been in the "unreachable" state for
-	// 11 minutes (e.g. two poll intervals)
-	// Note, Hue Bridge marks devices as "unreachable" often even when they accept commands
-	Calendar time11 = Calendar.getInstance()
-	time11.add(Calendar.MINUTE, -11)
-	Calendar currentTime = Calendar.getInstance()
-
 	def bulbs = getChildDevices()
 	for (bulb in body) {
 		def device = bulbs.find{it.deviceNetworkId == "${app.id}/${bulb.key}"}
@@ -969,10 +959,7 @@ private handlePoll(body) {
 					// light just came back online, notify device watch
 					def lastActivity = now()
 					device.sendEvent(name: "deviceWatch-status", value: "ONLINE", description: "Last Activity is on ${new Date((long) lastActivity)}", displayed: false, isStateChange: true)
-					log.debug "$device is Online"
 				}
-				// Mark light as "online"
-				state.bulbs[bulb.key]?.unreachableSince = null
 				state.bulbs[bulb.key]?.online = true
 
 				// If user just executed commands, then do not send events to avoid confusing the turning on/off state
@@ -982,18 +969,9 @@ private handlePoll(body) {
 					sendColorEvents(device, bulb.value?.state?.xy, bulb.value?.state?.hue, bulb.value?.state?.sat, bulb.value?.state?.ct, bulb.value?.state?.colormode)
 				}
 			} else {
-				if (state.bulbs[bulb.key]?.unreachableSince == null) {
+				state.bulbs[bulb.key]?.online = false
-					// Store the first time where device was reported as "unreachable"
+				log.warn "$device is not reachable by Hue bridge"
-					state.bulbs[bulb.key]?.unreachableSince = currentTime.getTimeInMillis()
+				device.sendEvent(name: "DeviceWatch-DeviceOffline", value: "offline", displayed: false, isStateChange: true)
-				} else if (state.bulbs[bulb.key]?.online) {
-					// Check if device was "unreachable" for more than 11 minutes and mark "offline" if necessary
-					if (state.bulbs[bulb.key]?.unreachableSince < time11.getTimeInMillis()) {
-						log.warn "$device went Offline"
-						state.bulbs[bulb.key]?.online = false
-						device.sendEvent(name: "DeviceWatch-DeviceOffline", value: "offline", displayed: false, isStateChange: true)
-					}
-				}
-				log.warn "$device may not reachable by Hue bridge"
 			}
 		}
 	}
@@ -1028,6 +1006,9 @@ def hubVerification(bodytext) {
 def on(childDevice) {
 	log.debug "Executing 'on'"
 	def id = getId(childDevice)
+	if (!isOnline(id)) {
+		return "Bulb is unreachable"
+	}
 	updateInProgress()
 	createSwitchEvent(childDevice, "on")
 	put("lights/$id/state", [on: true])
@@ -1037,6 +1018,9 @@ def on(childDevice) {
 def off(childDevice) {
 	log.debug "Executing 'off'"
 	def id = getId(childDevice)
+	if (!isOnline(id)) {
+		return "Bulb is unreachable"
+	}
 	updateInProgress()
 	createSwitchEvent(childDevice, "off")
 	put("lights/$id/state", [on: false])
@@ -1046,6 +1030,9 @@ def off(childDevice) {
 def setLevel(childDevice, percent) {
 	log.debug "Executing 'setLevel'"
 	def id = getId(childDevice)
+	if (!isOnline(id)) {
+		return "Bulb is unreachable"
+	}
     updateInProgress()
 	// 1 - 254
     def level
@@ -1070,6 +1057,10 @@ def setLevel(childDevice, percent) {
 def setSaturation(childDevice, percent) {
 	log.debug "Executing 'setSaturation($percent)'"
 	def id = getId(childDevice)
+	if (!isOnline(id)) {
+		return "Bulb is unreachable"
+	}
+
 	updateInProgress()
 	// 0 - 254
 	def level = Math.min(Math.round(percent * 254 / 100), 254)
@@ -1082,6 +1073,9 @@ def setSaturation(childDevice, percent) {
 def setHue(childDevice, percent) {
 	log.debug "Executing 'setHue($percent)'"
 	def id = getId(childDevice)
+	if (!isOnline(id)) {
+		return "Bulb is unreachable"
+	}
     updateInProgress()
 	// 0 - 65535
 	def level =	Math.min(Math.round(percent * 65535 / 100), 65535)
@@ -1094,6 +1088,9 @@ def setHue(childDevice, percent) {
 def setColorTemperature(childDevice, huesettings) {
 	log.debug "Executing 'setColorTemperature($huesettings)'"
 	def id = getId(childDevice)
+	if (!isOnline(id)) {
+		return "Bulb is unreachable"
+	}
     updateInProgress()
 	// 153 (6500K) to 500 (2000K)
 	def ct = hueSettings == 6500 ? 153 : Math.round(1000000/huesettings)
@@ -1105,6 +1102,9 @@ def setColorTemperature(childDevice, huesettings) {
 def setColor(childDevice, huesettings) {
     log.debug "Executing 'setColor($huesettings)'"
 	def id = getId(childDevice)
+	if (!isOnline(id)) {
+		return "Bulb is unreachable"
+	}
     updateInProgress()
 
     def value = [:]
@@ -1120,7 +1120,7 @@ def setColor(childDevice, huesettings) {
 			value.hue = Math.min(Math.round(huesettings.hue * 65535 / 100), 65535)
 		if (huesettings.saturation != null)
 			value.sat = Math.min(Math.round(huesettings.saturation * 254 / 100), 254)
-	} else if (huesettings.hex != null) {
+	} else if (huesettings.hex != null && false) {
 		// For now ignore model to get a consistent color if same color is set across multiple devices
 		// def model = state.bulbs[getId(childDevice)]?.modelid
 		// value.xy = calculateXY(huesettings.hex, model)
@@ -1162,14 +1162,7 @@ def setColor(childDevice, huesettings) {
 }
 
 def ping(childDevice) {
-	if (childDevice.device?.deviceNetworkId?.equalsIgnoreCase(selectedHue)) {
+	if (isOnline(getId(childDevice))) {
-		if (childDevice.device?.currentValue("status")?.equalsIgnoreCase("Online")) {
-			childDevice.sendEvent(name: "deviceWatch-ping", value: "ONLINE", description: "Hue Bridge is reachable", displayed: false, isStateChange: true)
-			return "Bridge is Online"
-		} else {
-			return "Bridge is Offline"
-		}
-	} else if (isOnline(getId(childDevice))) {
 		childDevice.sendEvent(name: "deviceWatch-ping", value: "ONLINE", description: "Hue Light is reachable", displayed: false, isStateChange: true)
 		return "Device is Online"
 	} else {
@@ -1231,7 +1224,7 @@ private getBridgeIP() {
     	if (d) {
         	if (d.getDeviceDataByName("networkAddress"))
             	host =  d.getDeviceDataByName("networkAddress")
-        else
+            else
         		host = d.latestState('networkAddress').stringValue
         }
         if (host == null || host == "") {
@@ -1670,7 +1663,7 @@ private boolean checkPointInLampsReach(p, colorPoints) {
 }
 
 /**
- * Converts an RGB color in hex to HSV/HSB.
+ * Converts an RGB color in hex to HSV.
  * Algorithm based on http://en.wikipedia.org/wiki/HSV_color_space.
  *
  * @param colorStr color value in hex (#ff03d3)
@@ -1680,32 +1673,32 @@ private boolean checkPointInLampsReach(p, colorPoints) {
 def hexToHsv(colorStr){
 	def r = Integer.valueOf( colorStr.substring( 1, 3 ), 16 ) / 255
 	def g = Integer.valueOf( colorStr.substring( 3, 5 ), 16 ) / 255
-	def b = Integer.valueOf( colorStr.substring( 5, 7 ), 16 ) / 255
+	def b = Integer.valueOf( colorStr.substring( 5, 7 ), 16 ) / 255;
 
 	def max = Math.max(Math.max(r, g), b)
 	def min = Math.min(Math.min(r, g), b)
 
-	def h, s, v = max
+	def h, s, v = max;
 
-	def d = max - min
+	def d = max - min;
-	s = max == 0 ? 0 : d / max
+	s = max == 0 ? 0 : d / max;
 
 	if(max == min){
-		h = 0
+		h = 0;
 	}else{
 		switch(max){
-			case r: h = (g - b) / d + (g < b ? 6 : 0); break
+			case r: h = (g - b) / d + (g < b ? 6 : 0); break;
-			case g: h = (b - r) / d + 2; break
+			case g: h = (b - r) / d + 2; break;
-			case b: h = (r - g) / d + 4; break
+			case b: h = (r - g) / d + 4; break;
 		}
 		h /= 6;
 	}
 
-	return [Math.round(h * 100), Math.round(s * 100), Math.round(v * 100)]
+	return [(h * 100).round(), (s * 100).round(), (v * 100).round()];
 }
 
 /**
- * Converts HSV/HSB color to RGB in hex.
+ * Converts HSV color to RGB in hex.
  * Algorithm based on http://en.wikipedia.org/wiki/HSV_color_space.
  *
  * @param  hue hue 0-100
@@ -1720,11 +1713,11 @@ def hsvToHex(hue, sat, value = 100){
 	def s = sat / 100
 	def v = value / 100
 
-	def i = Math.floor(h * 6)
+	def i = Math.floor(h * 6);
-	def f = h * 6 - i
+	def f = h * 6 - i;
-	def p = v * (1 - s)
+	def p = v * (1 - s);
-	def q = v * (1 - f * s)
+	def q = v * (1 - f * s);
-	def t = v * (1 - (1 - f) * s)
+	def t = v * (1 - (1 - f) * s);
 
 	switch (i % 6) {
 		case 0:
@@ -1760,9 +1753,9 @@ def hsvToHex(hue, sat, value = 100){
 	}
 
 	// Converting float components to int components.
-	def r1 = String.format("%02X", (int) (r * 255.0f))
+	def r1 = String.format("%02X", (int) (r * 255.0f));
-	def g1 = String.format("%02X", (int) (g * 255.0f))
+	def g1 = String.format("%02X", (int) (g * 255.0f));
-	def b1 = String.format("%02X", (int) (b * 255.0f))
+	def b1 = String.format("%02X", (int) (b * 255.0f));
 
 	return "#$r1$g1$b1"
 }

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

@@ -34,7 +34,6 @@
  *  locks                | lock              | lock, unlock                | locked, unlocked
  *  ---------------------+-------------------+-----------------------------+------------------------------------
  */
-include 'asynchttp_v1'
 
 definition(
     name: "Logitech Harmony (Connect)",
@@ -110,28 +109,26 @@ def authPage() {
 		//device discovery request every 5 //25 seconds
 		int deviceRefreshCount = !state.deviceRefreshCount ? 0 : state.deviceRefreshCount as int
 		state.deviceRefreshCount = deviceRefreshCount + 1
-		def refreshInterval = 5
+		def refreshInterval = 3
 
 		def huboptions = state.HarmonyHubs ?: []
 		def actoptions = state.HarmonyActivities ?: []
 
 		def numFoundHub = huboptions.size() ?: 0
-    def numFoundAct = actoptions.size() ?: 0
+        def numFoundAct = actoptions.size() ?: 0
-
 		if((deviceRefreshCount % 5) == 0) {
 			discoverDevices()
 		}
-
 		return dynamicPage(name:"Credentials", title:"Discovery Started!", nextPage:"", refreshInterval:refreshInterval, install:true, uninstall: true) {
 			section("Please wait while we discover your Harmony Hubs and Activities. Discovery can take five minutes or more, so sit back and relax! Select your device below once discovered.") {
-				input "selectedhubs", "enum", required:false, title:"Select Harmony Hubs (${numFoundHub} found)", multiple:true, submitOnChange: true, options:huboptions
+				input "selectedhubs", "enum", required:false, title:"Select Harmony Hubs (${numFoundHub} found)", multiple:true, options:huboptions
 			}
-      // Virtual activity flag
+            // Virtual activity flag
-      if (numFoundHub > 0 && numFoundAct > 0 && true)
+            if (numFoundHub > 0 && numFoundAct > 0 && true)
 			section("You can also add activities as virtual switches for other convenient integrations") {
-				input "selectedactivities", "enum", required:false, title:"Select Harmony Activities (${numFoundAct} found)", multiple:true, submitOnChange: true, options:actoptions
+				input "selectedactivities", "enum", required:false, title:"Select Harmony Activities (${numFoundAct} found)", multiple:true, options:actoptions
 			}
-    if (state.resethub)
+            if (state.resethub)
 			section("Connection to the hub timed out. Please restart the hub and try again.") {}
 		}
     }
@@ -383,6 +380,8 @@ def discovery() {
             	log.debug "valid Token"
                 state.Harmonydevices = response.data
                 state.resethub = false
+                getActivityList()
+                poll()
 	        } else {
             	log.debug "Error: $response.status"
             }
@@ -431,182 +430,142 @@ def addDevice() {
 }
 
 def activity(dni,mode) {
-    def tokenParam = [auth: state.HarmonyAccessToken]
+    def Params = [auth: state.HarmonyAccessToken]
-    def url
+    def msg = "Command failed"
+    def url = ''
     if (dni == "all") {
-        url = "https://home.myharmony.com/cloudapi/activity/off?${toQueryString(tokenParam)}"
+        url = "https://home.myharmony.com/cloudapi/activity/off?${toQueryString(Params)}"
     } else {
         def aux = dni.split('-')
         def hubId = aux[1]
         if (mode == "hub" || (aux.size() <= 2) || (aux[2] == "off")){
-        	url = "https://home.myharmony.com/cloudapi/hub/${hubId}/activity/off?${toQueryString(tokenParam)}"
+        	url = "https://home.myharmony.com/cloudapi/hub/${hubId}/activity/off?${toQueryString(Params)}"
         } else {
-          def activityId = aux[2]
+            def activityId = aux[2]
-        	url = "https://home.myharmony.com/cloudapi/hub/${hubId}/activity/${activityId}/${mode}?${toQueryString(tokenParam)}"
+        	url = "https://home.myharmony.com/cloudapi/hub/${hubId}/activity/${activityId}/${mode}?${toQueryString(Params)}"
         }
 	}
-  def params = [
+	try {
-      uri: url,
+    	httpPostJson(uri: url) { response ->
-      contentType: 'application/json'
+        	if (response.data.code == 200 || dni == "all") {
-  ]
+            	msg = "Command sent succesfully"
-  asynchttp_v1.post('activityResponse', params)
+            	state.aux = 0
-  return "Command Sent"
+            } else {
-}
+            	msg = "Command failed. Error: $response.data.code"
-
+            }
-def activityResponse(response, data) {
+		}
-  if (response.hasError()) {
+    } catch (groovyx.net.http.HttpResponseException ex) {
-    log.error "Logitech Harmony - response has error: $response.errorMessage"
+        log.error ex
-    if (response.status == 401) { // token is expired
+        if (state.aux == 0) {
-      state.remove("HarmonyAccessToken")
+        	state.aux = 1
-      log.warn "Logitech Harmony - Access token has expired"
+        	activity(dni,mode)
+        } else {
+        	msg = ex
+            state.aux = 0
+        }
+    } catch(Exception ex) {
+    	msg = ex
     }
-  } else {
+    runIn(10, "poll", [overwrite: true])
-    def ResponseValues
+    return msg
-    try {
-      // json response already parsed into JSONElement object
-      ResponseValues = response.json
-    } catch (e) {
-      log.error "Logitech Harmony - error parsing json from response: $e"
-    }
-    if (ResponseValues) {
-      if (ResponseValues.code == 200) {
-        log.trace "Command sent succesfully"
-        poll()
-      } else {
-        log.trace "Command failed. Error: $response.data.code"
-      }
-    } else {
-      log.debug "Logitech Harmony - did not get json results from response body: $response.data"
-    }
-  }
 }
 
 def poll() {
 	// GET THE LIST OF ACTIVITIES
     if (state.HarmonyAccessToken) {
     	  getActivityList()
-        def tokenParam = [auth: state.HarmonyAccessToken]
+        def Params = [auth: state.HarmonyAccessToken]
-        def params = [
+        def url = "https://home.myharmony.com/cloudapi/state?${toQueryString(Params)}"
-            uri: "https://home.myharmony.com/cloudapi/state?${toQueryString(tokenParam)}",
+        try {
-            headers: ["Accept": "application/json"],
+            httpGet(uri: url, headers: ["Accept": "application/json"]) {response ->
-            contentType: 'application/json'
+                def map = [:]
-        ]
+                response.data.hubs.each {
-        asynchttp_v1.get('pollResponse', params)
+		            if (it.value.message == "OK") {
-      } else {
+	                    map["${it.key}"] = "${it.value.response.data.currentAvActivity},${it.value.response.data.activityStatus}"
-          log.warn "Logitech Harmony - Access token has expired"
+	                    def hub = getChildDevice("harmony-${it.key}")
-      }
+	                    if (hub) {
-}
+	                        if (it.value.response.data.currentAvActivity == "-1") {
-
+	                            hub.sendEvent(name: "currentActivity", value: "--", descriptionText: "There isn't any activity running", display: false)
-def pollResponse(response, data) {
+	                        } else {
-	if (response.hasError()) {
+	                            def currentActivity = getActivityName(it.value.response.data.currentAvActivity,it.key)
-    log.error "Logitech Harmony - response has error: $response.errorMessage"
+	                            hub.sendEvent(name: "currentActivity", value: currentActivity, descriptionText: "Current activity is ${currentActivity}", display: false)
-    if (response.status == 401) { // token is expired
+	                        }
-      state.remove("HarmonyAccessToken")
+	                    }
-      log.warn "Logitech Harmony - Access token has expired"
+	                } else {
-    }
+		                log.trace it.value.message
-	} else {
+	                }
-			def ResponseValues
+                }
-			try {
+                def activities = getChildDevices()
-					// json response already parsed into JSONElement object
+                def activitynotrunning = true
-					ResponseValues = response.json
+                activities.each { activity ->
-			} catch (e) {
+                    def act = activity.deviceNetworkId.split('-')
-					log.error "Logitech Harmony - error parsing json from response: $e"
+                    if (act.size() > 2) {
-			}
+                        def aux = map.find { it.key == act[1] }
-			if (ResponseValues) {
+                        if (aux) {
-        def map = [:]
+                            def aux2 = aux.value.split(',')
-        ResponseValues.hubs.each {
+                            def childDevice = getChildDevice(activity.deviceNetworkId)
-        if (it.value.message == "OK") {
+                            if ((act[2] == aux2[0]) && (aux2[1] == "1" || aux2[1] == "2")) {
-              map["${it.key}"] = "${it.value.response.data.currentAvActivity},${it.value.response.data.activityStatus}"
+                                childDevice?.sendEvent(name: "switch", value: "on")
-              def hub = getChildDevice("harmony-${it.key}")
+                                if (aux2[1] == "1")
-              if (hub) {
+                                    runIn(5, "poll", [overwrite: true])
-                  if (it.value.response.data.currentAvActivity == "-1") {
+                            } else {
-                      hub.sendEvent(name: "currentActivity", value: "--", descriptionText: "There isn't any activity running", display: false)
+                                childDevice?.sendEvent(name: "switch", value: "off")
-                  } else {
+                                if (aux2[1] == "3")
-                      def currentActivity = getChildDevice("harmony-${it.key}-${it.value.response.data.currentAvActivity}").device.displayName
+                                    runIn(5, "poll", [overwrite: true])
-                      hub.sendEvent(name: "currentActivity", value: currentActivity, descriptionText: "Current activity is ${currentActivity}", display: false)
+                            }
-                  }
+                        }
-              }
-          } else {
-            log.trace "Logitech Harmony - error response: $it.value.message"
-          }
-        }
-        def activities = getChildDevices()
-        def activitynotrunning = true
-        activities.each { activity ->
-            def act = activity.deviceNetworkId.split('-')
-            if (act.size() > 2) {
-                def aux = map.find { it.key == act[1] }
-                if (aux) {
-                    def aux2 = aux.value.split(',')
-                    def childDevice = getChildDevice(activity.deviceNetworkId)
-                    if ((act[2] == aux2[0]) && (aux2[1] == "1" || aux2[1] == "2")) {
-                        childDevice?.sendEvent(name: "switch", value: "on")
-                        if (aux2[1] == "1")
-                            runIn(5, "poll", [overwrite: true])
-                    } else {
-                        childDevice?.sendEvent(name: "switch", value: "off")
-                        if (aux2[1] == "3")
-                            runIn(5, "poll", [overwrite: true])
                     }
                 }
+                return "Poll completed $map - $state.hubs"
             }
+        } catch (groovyx.net.http.HttpResponseException e) {
+              if (e.statusCode == 401) { // token is expired
+                  state.remove("HarmonyAccessToken")
+                  log.warn "Harmony Access token has expired"
+              }
+        } catch (java.net.SocketTimeoutException e) {
+        	log.warn "Connection to the hub timed out. Please restart the hub and try again."
+              state.resethub = true
+        } catch (e) {
+        	log.info "Logitech Harmony - Error: $e"
         }
-			} else {
-					log.debug "Logitech Harmony - did not get json results from response body: $response.data"
-			}
-	}
-}
-
-def getActivityList() {
-    if (state.HarmonyAccessToken) {
-      def tokenParam = [auth: state.HarmonyAccessToken]
-      def params = [
-  				uri: "https://home.myharmony.com/cloudapi/activity/all?${toQueryString(tokenParam)}",
-  				headers: ["Accept": "application/json"],
-  				contentType: 'application/json'
-  		]
-  		asynchttp_v1.get('activityListResponse', params)
-    } else {
-        log.warn "Logitech Harmony - Access token has expired"
     }
 }
 
-def activityListResponse(response, data) {
+
-	if (response.hasError()) {
+def getActivityList() {
-			log.error "Logitech Harmony - response has error: $response.errorMessage"
+	// GET ACTIVITY'S NAME
-      if (response.status == 401) { // token is expired
+    if (state.HarmonyAccessToken) {
-          state.remove("HarmonyAccessToken")
+        def Params = [auth: state.HarmonyAccessToken]
-          log.warn "Logitech Harmony - Access token has expired"
+        def url = "https://home.myharmony.com/cloudapi/activity/all?${toQueryString(Params)}"
-      }
+        try {
-	} else {
+            httpGet(uri: url, headers: ["Accept": "application/json"]) {response ->
-			def ResponseValues
+                response.data.hubs.each {
-			try {
+                    def hub = getChildDevice("harmony-${it.key}")
-					// json response already parsed into JSONElement object
+                    if (hub) {
-					ResponseValues = response.json
+                    	def hubname = getHubName("${it.key}")
-			} catch (e) {
+                        def activities = []
-					log.error "Logitech Harmony - error parsing json from response: $e"
+                        def aux = it.value.response.data.activities.size()
-			}
+                        if (aux >= 1) {
-			if (ResponseValues) {
+                            activities = it.value.response.data.activities.collect {
-          	  ResponseValues.hubs.each {
+                                [id: it.key, name: it.value['name'], type: it.value['type']]
-              def hub = getChildDevice("harmony-${it.key}")
+                            }
-              if (hub) {
+                            activities += [id: "off", name: "Activity OFF", type: "0"]
-                def hubname = getHubName("${it.key}")
+                            log.trace activities
-                  def activities = []
+                        }
-                  def aux = it.value.response?.data.activities.size()
+                        hub.sendEvent(name: "activities", value: new groovy.json.JsonBuilder(activities).toString(), descriptionText: "Activities are ${activities.collect { it.name }?.join(', ')}", display: false)
-                  if (aux >= 1) {
+					}
-                      activities = it.value.response.data.activities.collect {
+                }
-                          [id: it.key, name: it.value['name'], type: it.value['type']]
+            }
-                      }
+        } catch (groovyx.net.http.HttpResponseException e) {
-                      activities += [id: "off", name: "Activity OFF", type: "0"]
+        	log.trace e
-                      log.trace activities
+        } catch (java.net.SocketTimeoutException e) {
-                  }
+        	log.trace e
-                  hub.sendEvent(name: "activities", value: new groovy.json.JsonBuilder(activities).toString(), descriptionText: "Activities are ${activities.collect { it.name }?.join(', ')}", display: false)
+		} catch(Exception e) {
-              }
+        	log.trace e
-          }
+		}
-			} else {
+    }
-					log.debug "Logitech Harmony - did not get json results from response body: $response.data"
+	return activity
-			}
-	}
 }
 
 def getActivityName(activity,hubId) {
@@ -787,7 +746,7 @@ def addSubscription() {
 	def attribute = data.attributeName
 	def callbackUrl = data.callbackUrl
 
-	log.debug "Logitech Harmony - addSubscription, params: ${params}, request: ${data}"
+	log.debug "addSubscription, params: ${params}, request: ${data}"
 	if (!attribute) {
 		render status: 400, data: '{"msg": "attributeName is required"}'
 	} else {
@@ -849,7 +808,6 @@ def deviceHandler(evt) {
 	def deviceInfo = state[evt.deviceId]
 	if (state.harmonyHubs) {
 		state.harmonyHubs.each { harmonyHub ->
-      log.trace "Logitech Harmony - Sending data to $harmonyHub.name"
 			sendToHarmony(evt, harmonyHub.callbackUrl)
 		}
 	} else if (deviceInfo) {

smartapps/smartthings/severe-weather-alert.src/severe-weather-alert.groovy

@@ -26,22 +26,17 @@ definition(
 )
 
 preferences {
-
+	section ("In addition to push notifications, send text alerts to...") {
-  if (!(location.zipCode || ( location.latitude && location.longitude )) && location.channelName == 'samsungtv') {
+        input("recipients", "contact", title: "Send notifications to") {
-		section { paragraph title: "Note:", "Location is required for this SmartApp. Go to 'Location Name' settings to setup your correct location." }
+            input "phone1", "phone", title: "Phone Number 1", required: false
+            input "phone2", "phone", title: "Phone Number 2", required: false
+            input "phone3", "phone", title: "Phone Number 3", required: false
+        }
 	}
 
-  if (location.channelName != 'samsungtv') {
+	section ("Zip code (optional, defaults to location coordinates)...") {
-		section( "Set your location" ) { input "zipCode", "text", title: "Zip code" }
+		input "zipcode", "text", title: "Zip Code", required: false
-  }
+	}
-
-	section ("In addition to push notifications, send text alerts to...") {
-      input("recipients", "contact", title: "Send notifications to") {
-          input "phone1", "phone", title: "Phone Number 1", required: false
-          input "phone2", "phone", title: "Phone Number 2", required: false
-          input "phone3", "phone", title: "Phone Number 3", required: false
-      }
-	 }
 }
 
 def installed() {
@@ -66,7 +61,7 @@ def checkForSevereWeather() {
 	def alerts
 	if(locationIsDefined()) {
 		if(zipcodeIsValid()) {
-			alerts = getWeatherFeature("alerts", zipCode)?.alerts
+			alerts = getWeatherFeature("alerts", zipcode)?.alerts
 		} else {
 			log.warn "Severe Weather Alert: Invalid zipcode entered, defaulting to location's zipcode"
 			alerts = getWeatherFeature("alerts")?.alerts