MSA-1338: I believe this should replace the current app on the app store "TCP Bulbs (connect)" as it's a more reliable integration.

I did a couple of things to make this more reliable:
1.  I re-fetch the authorization token every 5 minutes
2.  If a request fails, I again re-try to fetch the token and re-submit the request
3.  I try again on 400 errors in addition to 500 and 401 errors.

Code is all open source under Apache 2.0 license hosted at github at https://github.com/mmacaula/tcp-bulbs

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

@@ -403,21 +403,39 @@ def refresh() {
 
 	if (device.getDataValue("manufacturer") == "SmartThings") {
 		log.debug "Refreshing Values for manufacturer: SmartThings "
-		/* These values of Motion Threshold Multiplier(0x01) and Motion Threshold (0x0276)
-            seem to be giving pretty accurate results for the XYZ co-ordinates for this manufacturer.
-            Separating these out in a separate if-else because I do not want to touch Centralite part
-            as of now.
-        */
-		refreshCmds += zigbee.writeAttribute(0xFC02, 0x0000, 0x20, 0x01, [mfgCode: manufacturerCode])
-		refreshCmds += zigbee.writeAttribute(0xFC02, 0x0002, 0x21, 0x0276, [mfgCode: manufacturerCode])
+		refreshCmds = refreshCmds + [
+			/* These values of Motion Threshold Multiplier(01) and Motion Threshold (7602)
+				seem to be giving pretty accurate results for the XYZ co-ordinates for this manufacturer.
+				Separating these out in a separate if-else because I do not want to touch Centralite part
+				as of now.
+			*/
+
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 0 0x20 {01}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 2 0x21 {7602}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+		]
 	} else {
-		refreshCmds += zigbee.writeAttribute(0xFC02, 0x0000, 0x20, 0x02, [mfgCode: manufacturerCode])
+		refreshCmds = refreshCmds + [
+			/* sensitivity - default value (8) */
+			"zcl mfg-code ${manufacturerCode}", "delay 200",
+			"zcl global write 0xFC02 0 0x20 {02}", "delay 200",
+			"send 0x${device.deviceNetworkId} 1 1", "delay 400",
+		]
 	}
 
 	//Common refresh commands
-	refreshCmds += zigbee.readAttribute(0x0402, 0x0000) +
-			zigbee.readAttribute(0x0001, 0x0020) +
-			zigbee.readAttribute(0xFC02, 0x0010, [mfgCode: manufacturerCode])
+	refreshCmds = refreshCmds + [
+		"st rattr 0x${device.deviceNetworkId} 1 0x402 0", "delay 200",
+		"st rattr 0x${device.deviceNetworkId} 1 1 0x20", "delay 200",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global read 0xFC02 0x0010",
+		"send 0x${device.deviceNetworkId} 1 1","delay 400"
+	]
 
 	return refreshCmds + enrollResponse()
 }
@@ -425,15 +443,38 @@ def refresh() {
 def configure() {
 	sendEvent(name: "checkInterval", value: 7200, displayed: false)
 
+	String zigbeeEui = swapEndianHex(device.hub.zigbeeEui)
 	log.debug "Configuring Reporting"
 
-	def configCmds = enrollResponse() +
-			zigbee.batteryConfig() +
-			zigbee.temperatureConfig() +
-			zigbee.configureReporting(0xFC02, 0x0010, 0x18, 10, 3600, 0x01, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0012, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0013, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode]) +
-			zigbee.configureReporting(0xFC02, 0x0014, 0x29, 1, 3600, 0x0001, [mfgCode: manufacturerCode])
+	def configCmds = [
+		"zcl global write 0x500 0x10 0xf0 {${zigbeeEui}}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 1 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 1 0x20 0x20 30 21600 {01}", "delay 200",		//checkin time 6 hrs
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0x402 {${device.zigbeeId}} {}", "delay 200",
+		"zcl global send-me-a-report 0x402 0 0x29 30 3600 {6400}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zdo bind 0x${device.deviceNetworkId} ${endpointId} 1 0xFC02 {${device.zigbeeId}} {}", "delay 200",
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0010 0x18 10 3600 {01}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0012 0x29 1 3600 {0100}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0013 0x29 1 3600 {0100}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500",
+
+		"zcl mfg-code ${manufacturerCode}", "delay 200",
+		"zcl global send-me-a-report 0xFC02 0x0014 0x29 1 3600 {0100}", "delay 200",
+		"send 0x${device.deviceNetworkId} 1 ${endpointId}", "delay 500"
+		]
 
 	return configCmds + refresh()
 }

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

@@ -21,13 +21,6 @@ metadata {
 		capability "Motion Sensor"
 		capability "Sensor"
 		capability "Battery"
-
-		fingerprint mfr: "011F", prod: "0001", model: "0001", deviceJoinName: "Schlage Motion Sensor"  // Schlage motion
-		fingerprint mfr: "014A", prod: "0001", model: "0001", deviceJoinName: "Ecolink Motion Sensor"  // Ecolink motion
-		fingerprint mfr: "014A", prod: "0004", model: "0001", deviceJoinName: "Ecolink Motion Sensor"  // Ecolink motion +
-		fingerprint mfr: "0060", prod: "0001", model: "0002", deviceJoinName: "Everspring Motion Sensor"  // Everspring SP814
-		fingerprint mfr: "0060", prod: "0001", model: "0003", deviceJoinName: "Everspring Motion Sensor"  // Everspring HSP02
-		fingerprint mfr: "011A", prod: "0601", model: "0901", deviceJoinName: "Enerwave Motion Sensor"  // Enerwave ZWN-BPC
 	}
 
 	simulator {
@@ -132,9 +125,9 @@ def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd)
 	}
 	if (!state.lastbat || (new Date().time) - state.lastbat > 53*60*60*1000) {
 		result << response(zwave.batteryV1.batteryGet())
-	} else {
-		result << response(zwave.wakeUpV1.wakeUpNoMoreInformation())
+		result << response("delay 1200")
 	}
+	result << response(zwave.wakeUpV1.wakeUpNoMoreInformation())
 	result
 }
 

devicetypes/wackford/tcp-bulb.src/tcp-bulb.groovy

@@ -13,14 +13,14 @@
  *				Documented Header
  *
  *  Change 2:	2014-03-15
- *				Fixed bug where we weren't coming on when changing
+ *				Fixed bug where we weren't coming on when changing 
  *				levels down.
  *
- *  Change 3:   2014-04-02 (lieberman)
+ *  Change 3:   2014-04-02 (lieberman)	
  *              Changed sendEvent() to createEvent() in parse()
  *
  *  Change 4:	2014-04-12 (wackford)
- *				Added current power usage tile
+ *				Added current power usage tile 
  *
  *  Change 5:	2014-09-14 (wackford)
  *				a. Changed createEvent() to sendEvent() in parse() to
@@ -33,7 +33,7 @@
  *				b. added refresh on udate
  *				c. added uninstallFromChildDevice to handle removing from settings
  *				d. Changed to allow bulb to 100%, was possible to get past logic at 99
- *
+ * 
  *  Change 7:	2014-11-09 (wackford)
  *				a. Added bulbpower calcs to device. TCP is broken
  *				b. Changed to set dim level first then on. Much easier on the eys coming from bright.
@@ -42,7 +42,7 @@
  *                       Code
  *****************************************************************
  */
-// for the UI
+ // for the UI
 metadata {
 	definition (name: "TCP Bulb", namespace: "wackford", author: "Todd Wackford") {
 		capability "Switch"
@@ -52,28 +52,26 @@ metadata {
 		capability "Switch Level"
 
 		attribute "stepsize", "string"
-
+        
 		command "levelUp"
 		command "levelDown"
-		command "on"
-		command "off"
-		command "setBulbPower"
+        command "on"
+        command "off"
+        command "setBulbPower"
 	}
 
 	simulator {
 		// TODO: define status and reply messages here
 	}
-
-	preferences {
+    
+    preferences {
 		input "stepsize", "number", title: "Step Size", description: "Dimmer Step Size", defaultValue: 5
 	}
-
+    
 	tiles {
 		standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
-			state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-			state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
-			state "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
-			state "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
+			state "on", label:'${name}', action:"off", icon:"st.switches.light.on", backgroundColor:"#79b821"
+			state "off", label:'${name}', action:"on", icon:"st.switches.light.off", backgroundColor:"#ffffff"
 		}
 		controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 2, inactiveLabel: false) {
 			state "level", action:"switch level.setLevel"
@@ -84,15 +82,15 @@ metadata {
 		valueTile("level", "device.level", inactiveLabel: false, decoration: "flat") {
 			state "level", label: 'Level ${currentValue}%'
 		}
-		standardTile("lUp", "device.switchLevel", inactiveLabel: false,decoration: "flat", canChangeIcon: false) {
-			state "default", action:"levelUp", icon:"st.illuminance.illuminance.bright"
-		}
-		standardTile("lDown", "device.switchLevel", inactiveLabel: false,decoration: "flat", canChangeIcon: false) {
-			state "default", action:"levelDown", icon:"st.illuminance.illuminance.light"
-		}
-		valueTile( "power", "device.power", inactiveLabel: false, decoration: "flat") {
-			state "power", label: '${currentValue} Watts'
-		}
+        standardTile("lUp", "device.switchLevel", inactiveLabel: false,decoration: "flat", canChangeIcon: false) {
+            state "default", action:"levelUp", icon:"st.illuminance.illuminance.bright"
+        }
+        standardTile("lDown", "device.switchLevel", inactiveLabel: false,decoration: "flat", canChangeIcon: false) {
+            state "default", action:"levelDown", icon:"st.illuminance.illuminance.light"
+        }
+        valueTile( "power", "device.power", inactiveLabel: false, decoration: "flat") {
+            state "power", label: '${currentValue} Watts'
+        }
 
 		main(["switch"])
 		details(["switch", "lUp", "lDown", "levelSliderControl", "level" , "power", "refresh" ])
@@ -103,10 +101,10 @@ metadata {
 def parse(description) {
 	//log.debug "parse() - $description"
 	def results = []
-
-	if ( description == "updated" )
-		return
-
+	
+    if ( description == "updated" )
+    	return
+        
 	if (description?.name && description?.value)
 	{
 		results << createEvent(name: "${description?.name}", value: "${description?.value}")
@@ -116,73 +114,73 @@ def parse(description) {
 // handle commands
 def setBulbPower(value) {
 	state.bulbPower = value
-	log.debug "In child with bulbPower of ${state.bulbPower}"
+    log.debug "In child with bulbPower of ${state.bulbPower}"
 }
 
 def on() {
 	log.debug "Executing 'on'"
-	sendEvent(name:"switch",value:on)
+    sendEvent(name:"switch",value:on)
 	parent.on(this)
 
 	def levelSetting = device.latestValue("level") as Float ?: 1.0
-	def bulbPowerMax = device.latestValue("setBulbPower") as Float
-	def calculatedPower = bulbPowerMax * (levelSetting / 100)
-	sendEvent(name: "power", value: calculatedPower.round(1))
-
-	if (device.latestValue("level") == null) {
+    //def bulbPowerMax = device.latestValue("setBulbPower") as Float
+    //def calculatedPower = bulbPowerMax * (levelSetting / 100)
+    //sendEvent(name: "power", value: calculatedPower.round(1))
+    
+    if (device.latestValue("level") == null) {
 		sendEvent( name: "level", value: 1.0 )
-	}
+    }
 }
 
 def off() {
 	log.debug "Executing 'off'"
-	sendEvent(name:"switch",value:off)
+    sendEvent(name:"switch",value:off)
 	parent.off(this)
-	sendEvent(name: "power", value: 0.0)
+    sendEvent(name: "power", value: 0.0)
 }
 
 def levelUp() {
 	def level = device.latestValue("level") as Integer ?: 0
-	def step = state.stepsize as float
-
-	level+= step
-
-	if ( level > 100 )
-		level = 100
-
-	setLevel(level)
+    def step = state.stepsize as float
+    
+    level+= step
+    
+    if ( level > 100 )
+    	level = 100
+    
+    setLevel(level)
 }
 
 def levelDown() {
 	def level = device.latestValue("level") as Integer ?: 0
-	def step = state.stepsize as float
-
-	level-= step
-
+    def step = state.stepsize as float
+    
+    level-= step
+    
 	if ( level <  1 )
-		level = 1
-
-	setLevel(level)
+    	level = 1
+    
+    setLevel(level)
 }
 
 def setLevel(value) {
 	log.debug "in setLevel with value: ${value}"
 	def level = value as Integer
-
-	sendEvent( name: "level", value: level )
-	sendEvent( name: "switch.setLevel", value:level )
+    
+    sendEvent( name: "level", value: level )
+    sendEvent( name: "switch.setLevel", value:level )
 	parent.setLevel( this, level )
+    
 
-
-	if (( level > 0 ) && ( level <= 100 ))
-		on()
-	else
-		off()
-
-	def levelSetting = level as float
-	def bulbPowerMax = device.latestValue("setBulbPower") as float
-	def calculatedPower = bulbPowerMax * (levelSetting / 100)
-	sendEvent(name: "power", value: calculatedPower.round(1))
+    if (( level > 0 ) && ( level <= 100 ))
+    	on()
+    else
+    	off()
+    
+    //def levelSetting = level as float
+    //def bulbPowerMax = device.latestValue("setBulbPower") as float
+    //def calculatedPower = bulbPowerMax * (levelSetting / 100)
+    //sendEvent(name: "power", value: calculatedPower.round(1))
 }
 
 def poll() {
@@ -200,29 +198,29 @@ def installed() {
 }
 
 def updated() {
-	initialize()
-	refresh()
+    initialize()
+    refresh()
 }
 
 def initialize() {
 	if ( !settings.stepsize )
-		state.stepsize = 10 //set the default stepsize
-	else
-		state.stepsize = settings.stepsize
+        state.stepsize = 10 //set the default stepsize
+    else
+    	state.stepsize = settings.stepsize
 }
 
 /*******************************************************************************
- Method :uninstalled(args)
- (args) :none
- returns:Nothing
- ERRORS :No error handling is done
-
- Purpose:This is standard ST method.
- Gets called when "remove" is selected in child device "preferences"
- tile. It also get's called when "deleteChildDevice(child)" is
- called from parent service manager app.
- *******************************************************************************/
+	Method :uninstalled(args)
+    (args) :none
+    returns:Nothing
+    ERRORS :No error handling is done
+    
+    Purpose:This is standard ST method.
+    		Gets called when "remove" is selected in child device "preferences" 
+    		tile. It also get's called when "deleteChildDevice(child)" is 
+            called from parent service manager app.
+*******************************************************************************/
 def uninstalled() {
 	log.debug "Executing 'uninstall' in device type"
-	parent.uninstallFromChildDevice(this)
+    parent.uninstallFromChildDevice(this)
 }

smartapps/mmacaula/tcp-bulbs-more-reliable.src/tcp-bulbs-more-reliable.groovy

@@ -0,0 +1,679 @@
+/**
+ *  TCP Bulbs (Connect)
+ *
+ *  Copyright 2014 Todd Wackford
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ */
+
+import java.security.MessageDigest;
+
+private apiUrl() { "https://tcp.greenwavereality.com/gwr/gop.php?" }
+
+definition(
+    name: "TCP Bulbs - more reliable",
+    namespace: "mmacaula",
+    author: "Mike Macaulay",
+    description: "Connect your TCP bulbs to SmartThings using Cloud to Cloud integration. You must create a remote login acct on TCP Mobile App.",
+    category: "SmartThings Labs",
+    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Partner/tcp.png",
+    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Partner/tcp@2x.png",
+    singleInstance: true
+)
+
+
+preferences {
+    def msg = """Tap 'Next' after you have entered in your TCP Mobile remote credentials.
+
+Once your credentials are accepted, SmartThings will scan your TCP installation for Bulbs."""
+
+    page(name: "selectDevices", title: "Connect Your TCP Lights to SmartThings", install: false, uninstall: true, nextPage: "chooseBulbs") {
+        section("TCP Connected Remote Credentials") {
+            input "username", "text", title: "Enter TCP Remote Email/UserName", required: true
+            input "password", "password", title: "Enter TCP Remote Password", required: true
+            paragraph msg
+        }
+    }
+
+    page(name: "chooseBulbs", title: "Choose Bulbs to Control With SmartThings", content: "initialize")
+}
+
+def installed() {
+    debugOut "Installed with settings: ${settings}"
+
+    unschedule()
+    unsubscribe()
+
+    setupBulbs()
+
+    log.debug "schedule every 5 minutes syncronizeDevices)"
+    runEvery5Minutes(syncronizeDevices)
+}
+
+def updated() {
+    debugOut "Updated with settings: ${settings}"
+
+    unschedule()
+
+    setupBulbs()
+
+    log.debug "schedule update every 5 minutes syncronizeDevices)"
+    runEvery5Minutes(syncronizeDevices)
+}
+
+def uninstalled()
+{
+    unschedule() //in case we have hanging runIn()'s
+}
+
+private removeChildDevices(delete)
+{
+    debugOut "deleting ${delete.size()} bulbs"
+    debugOut "deleting ${delete}"
+    delete.each {
+        deleteChildDevice(it.device.deviceNetworkId)
+    }
+}
+
+def uninstallFromChildDevice(childDevice)
+{
+    def errorMsg = "uninstallFromChildDevice was called and "
+    if (!settings.selectedBulbs) {
+        debugOut errorMsg += "had empty list passed in"
+        return
+    }
+
+    def dni = childDevice.device.deviceNetworkId
+
+    if ( !dni ) {
+        debugOut errorMsg += "could not find dni of device"
+        return
+    }
+
+    def newDeviceList = settings.selectedBulbs - dni
+    app.updateSetting("selectedBulbs", newDeviceList)
+
+    debugOut errorMsg += "completed succesfully"
+}
+
+
+def setupBulbs() {
+    debugOut "In setupBulbs"
+
+    def bulbs = state.devices
+    def deviceFile = "TCP Bulb"
+
+    selectedBulbs.each { did ->
+        //see if this is a selected bulb and install it if not already
+        def d = getChildDevice(did)
+
+        if(!d) {
+            def newBulb = bulbs.find { (it.did) == did }
+            d = addChildDevice("wackford", deviceFile, did, null, [name: "${newBulb?.name}", label: "${newBulb?.name}", completedSetup: true])
+
+            /*if ( isRoom(did) ) { //change to the multi light group icon for a room device
+                d.setIcon("switch", "on",  "st.lights.multi-light-bulb-on")
+                d.setIcon("switch", "off",  "st.lights.multi-light-bulb-off")
+                d.save()
+            }*/
+
+        } else {
+            debugOut "We already added this device"
+        }
+    }
+
+    // Delete any that are no longer in settings
+    def delete = getChildDevices().findAll { !selectedBulbs?.contains(it.deviceNetworkId) }
+    removeChildDevices(delete)
+
+    //we want to ensure syncronization between rooms and bulbs
+    //syncronizeDevices()
+}
+
+def initialize() {
+
+    atomicState.token = ""
+
+    getToken()
+
+    if ( atomicState.token == "error" ) {
+        return dynamicPage(name:"chooseBulbs", title:"TCP Login Failed!\r\nTap 'Done' to try again", nextPage:"", install:false, uninstall: false) {
+            section("") {}
+        }
+    } else {
+        "we're good to go"
+        debugOut "We have Token."
+    }
+
+    //getGatewayData() //we really don't need anything from the gateway
+
+    deviceDiscovery()
+
+    def options = devicesDiscovered() ?: []
+
+    def msg = """Tap 'Done' after you have selected the desired devices."""
+
+    return dynamicPage(name:"chooseBulbs", title:"TCP and SmartThings Connected!", nextPage:"", install:true, uninstall: true) {
+        section("Tap Below to View Device List") {
+            input "selectedBulbs", "enum", required:false, title:"Select Bulb/Fixture", multiple:true, options:options
+            paragraph msg
+        }
+    }
+}
+
+def deviceDiscovery() {
+    def data = "<gip><version>1</version><token>${atomicState.token}</token></gip>"
+
+    def Params = [
+        cmd: "RoomGetCarousel",
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    def cmd = toQueryString(Params)
+
+    def rooms = ""
+    log.debug 'trying to discover devices'
+    apiPost(cmd) { response ->
+        rooms = response.data.gip.room
+    }
+
+    debugOut "rooms data = ${rooms}"
+
+    def devices = []
+    def bulbIndex = 1
+    def lastRoomName = null
+    def deviceList = []
+
+    if ( rooms[1] == null ) {
+        def roomId = rooms.rid
+        def roomName = rooms.name
+        devices  = rooms.device
+        if ( devices[1] != null ) {
+            debugOut "Room Device Data: did:${roomId} roomName:${roomName}"
+            //deviceList += ["name" : "${roomName}", "did" : "${roomId}", "type" : "room"]
+            devices.each({
+                debugOut "Bulb Device Data: did:${it?.did} room:${roomName} BulbName:${it?.name}"
+                deviceList += ["name" : "${roomName} ${it?.name}", "did" : "${it?.did}", "type" : "bulb"]
+            })
+        } else {
+            debugOut "Bulb Device Data: did:${it?.did} room:${roomName} BulbName:${it?.name}"
+            deviceList += ["name" : "${roomName} ${it?.name}", "did" : "${it?.did}", "type" : "bulb"]
+        }
+    } else {
+        rooms.each({
+            devices  = it.device
+            def roomName = it.name
+            if ( devices[1] != null ) {
+                def roomId = it?.rid
+                debugOut "Room Device Data: did:${roomId} roomName:${roomName}"
+                //deviceList += ["name" : "${roomName}", "did" : "${roomId}", "type" : "room"]
+                devices.each({
+                    debugOut "Bulb Device Data: did:${it?.did} room:${roomName} BulbName:${it?.name}"
+                    deviceList += ["name" : "${roomName} ${it?.name}", "did" : "${it?.did}", "type" : "bulb"]
+                })
+            } else {
+                debugOut "Bulb Device Data: did:${devices?.did} room:${roomName} BulbName:${devices?.name}"
+                deviceList += ["name" : "${roomName} ${devices?.name}", "did" : "${devices?.did}", "type" : "bulb"]
+            }
+        })
+    }
+    devices = ["devices" : deviceList]
+    state.devices = devices.devices
+}
+
+Map devicesDiscovered() {
+    def devices =  state.devices
+    def map = [:]
+    if (devices instanceof java.util.Map) {
+        devices.each {
+            def value = "${it?.name}"
+            def key = it?.did
+            map["${key}"] = value
+        }
+    } else { //backwards compatable
+        devices.each {
+            def value = "${it?.name}"
+            def key = it?.did
+            map["${key}"] = value
+        }
+    }
+    map
+}
+
+def getGatewayData() {
+    debugOut "In getGatewayData"
+
+    def data = "<gip><version>1</version><token>${atomicState.token}</token></gip>"
+
+    def qParams = [
+        cmd: "GatewayGetInfo",
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    def cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        debugOut "the gateway reponse is ${response.data.gip.gateway}"
+    }
+
+}
+
+def getToken(Closure callback) {
+
+    atomicState.token = ""
+
+    if (password) {
+        def hashedPassword = generateMD5(password)
+
+        def data = "<gip><version>1</version><email>${username}</email><password>${hashedPassword}</password></gip>"
+
+        def qParams = [
+            cmd : "GWRLogin",
+            data: "${data}",
+            fmt : "json"
+        ]
+
+        def cmd = toQueryString(qParams)
+
+        apiPost(cmd) { response ->
+            def status = response.data.gip.rc
+
+            //sendNotificationEvent("Get token status ${status}")
+
+            if (status != "200") {//success code = 200
+                def errorText = response.data.gip.error
+                debugOut "Error logging into TCP Gateway. Error = ${errorText}"
+                atomicState.token = "error"
+            } else {
+                atomicState.token = response.data.gip.token
+                if(callback){
+                    callback.call()
+                }
+            }
+        }
+    } else {
+        log.warn "Unable to log into TCP Gateway. Error = Password is null"
+        atomicState.token = "error"
+    }
+}
+
+def apiPost(String data, Integer retryCount = 0, Closure callback) {
+    debugOut "In apiPost with data: ${data}"
+    def params = [
+        uri: apiUrl(),
+        body: data
+    ]
+
+    httpPost(params) {
+        response ->
+            def rc = response.data.gip.rc
+
+            if ( rc == "200" ) {
+                debugOut ("Return Code = ${rc} = Command Succeeded.")
+                callback.call(response)
+
+            }  else if ( rc.startsWith("4") || rc.startsWith("5") ) {
+                debugOut "Return Code = ${rc} = Error: Something happened!" //Error code from gateway
+                sendNotificationEvent("Return Code = ${rc} = Error: Something happened!  Retry # ${retryCount}" )
+                log.debug "Refreshing Token"
+                 if(retryCount > 5){
+                    // give up, send a notification
+                    sendNotificationEvent("TCP Lighting is having Communication Errors. Error code = ${rc}. Gave up after ${retryCount} tries")
+                }
+                getToken({  ->
+                    def updatedTokenData = data.replaceFirst("<token>[^<]*</token>", '<token>${atomicState.token}</token>')
+                    // try again if we got our token
+                    sendNotificationEvent('re-fetched token, trying again')
+
+                    apiPost(updatedTokenData, retryCount++, callback)
+                })
+                //callback.call(response) //stubbed out so getToken works (we had race issue)
+
+            } else {
+                log.error "Return Code = ${rc} = Error!" //Error code from gateway
+                sendNotificationEvent("TCP Lighting is having Communication Errors. Error code = ${rc}. Check that TCP Gateway is online")
+                callback.call(response)
+            }
+    }
+}
+
+
+//this is not working. TCP power reporting is broken. Leave it here for future fix
+def calculateCurrentPowerUse(deviceCapability, usePercentage) {
+    debugOut "In calculateCurrentPowerUse()"
+
+    debugOut "deviceCapability: ${deviceCapability}"
+    debugOut "usePercentage: ${usePercentage}"
+
+    def calcPower = usePercentage * 1000
+    def reportPower = calcPower.round(1) as String
+
+    debugOut "report power = ${reportPower}"
+
+    return reportPower
+}
+
+def generateSha256(String s) {
+
+    MessageDigest digest = MessageDigest.getInstance("SHA-256")
+    digest.update(s.bytes)
+    new BigInteger(1, digest.digest()).toString(16).padLeft(40, '0')
+}
+
+def generateMD5(String s) {
+    MessageDigest digest = MessageDigest.getInstance("MD5")
+    digest.update(s.bytes);
+    new BigInteger(1, digest.digest()).toString(16).padLeft(32, '0')
+}
+
+String toQueryString(Map m) {
+    return m.collect { k, v -> "${k}=${URLEncoder.encode(v.toString())}" }.sort().join("&")
+}
+
+def checkDevicesOnline(bulbs) {
+    debugOut "In checkDevicesOnline()"
+
+    def onlineBulbs = []
+    def thisBulb = []
+
+    bulbs.each {
+        def dni = it?.did
+        thisBulb = it
+
+        def data = "<gip><version>1</version><token>${atomicState.token}</token><did>${dni}</did></gip>"
+
+        def qParams = [
+            cmd: "DeviceGetInfo",
+            data: "${data}",
+            fmt: "json"
+        ]
+
+        def cmd = toQueryString(qParams)
+
+        def bulbData = []
+
+        apiPost(cmd) { response ->
+            bulbData = response.data.gip
+        }
+
+        if ( bulbData?.offline == "1" ) {
+            debugOut "${it?.name} is offline with offline value of ${bulbData?.offline}"
+
+        } else {
+            debugOut "${it?.name} is online with offline value of ${bulbData?.offline}"
+            onlineBulbs += thisBulb
+        }
+    }
+    return onlineBulbs
+}
+
+def syncronizeDevices() {
+    debugOut "In syncronizeDevices"
+
+    def update = getChildDevices().findAll { selectedBulbs?.contains(it.deviceNetworkId) }
+
+    update.each {
+        def dni = getChildDevice( it.deviceNetworkId )
+        debugOut "dni = ${dni}"
+
+        if (isRoom(dni)) {
+            pollRoom(dni)
+        } else {
+            poll(dni)
+        }
+    }
+    getToken()
+
+}
+
+boolean isRoom(dni) {
+    def device = state.devices.find() {(( it.type == 'room') && (it.did == "${dni}"))}
+}
+
+boolean isBulb(dni) {
+    def device = state.devices.find() {(( it.type == 'bulb') && (it.did == "${dni}"))}
+}
+
+def debugEvent(message, displayEvent) {
+
+    def results = [
+        name: "appdebug",
+        descriptionText: message,
+        displayed: displayEvent
+    ]
+    log.debug "Generating AppDebug Event: ${results}"
+    sendEvent (results)
+
+}
+
+def debugOut(msg) {
+    log.debug msg
+    //sendNotificationEvent(msg) //Uncomment this for troubleshooting only
+}
+
+
+/**************************************************************************
+ Child Device Call In Methods
+ **************************************************************************/
+def on(childDevice) {
+    debugOut "On request from child device"
+
+    def dni = childDevice.device.deviceNetworkId
+    def data = ""
+    def cmd = ""
+
+    if ( isRoom(dni) ) { // this is a room, not a bulb
+        data = "<gip><version>1</version><token>$atomicState.token</token><rid>${dni}</rid><type>power</type><value>1</value></gip>"
+        cmd = "RoomSendCommand"
+    } else {
+        data = "<gip><version>1</version><token>$atomicState.token</token><did>${dni}</did><type>power</type><value>1</value></gip>"
+        cmd = "DeviceSendCommand"
+    }
+
+    def qParams = [
+        cmd: cmd,
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        debugOut "ON result: ${response.data}"
+    }
+
+    //we want to ensure syncronization between rooms and bulbs
+    //runIn(2, "syncronizeDevices")
+}
+
+def off(childDevice) {
+    debugOut "Off request from child device"
+
+    def dni = childDevice.device.deviceNetworkId
+    def data = ""
+    def cmd = ""
+
+    if ( isRoom(dni) ) { // this is a room, not a bulb
+        data = "<gip><version>1</version><token>$atomicState.token</token><rid>${dni}</rid><type>power</type><value>0</value></gip>"
+        cmd = "RoomSendCommand"
+    } else {
+        data = "<gip><version>1</version><token>$atomicState.token</token><did>${dni}</did><type>power</type><value>0</value></gip>"
+        cmd = "DeviceSendCommand"
+    }
+
+    def qParams = [
+        cmd: cmd,
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        debugOut "${response.data}"
+    }
+
+    //we want to ensure syncronization between rooms and bulbs
+    //runIn(2, "syncronizeDevices")
+}
+
+def setLevel(childDevice, value) {
+    debugOut "setLevel request from child device"
+
+    def dni = childDevice.device.deviceNetworkId
+    def data = ""
+    def cmd = ""
+
+    if ( isRoom(dni) ) { // this is a room, not a bulb
+        data = "<gip><version>1</version><token>${atomicState.token}</token><rid>${dni}</rid><type>level</type><value>${value}</value></gip>"
+        cmd = "RoomSendCommand"
+    } else {
+        data = "<gip><version>1</version><token>${atomicState.token}</token><did>${dni}</did><type>level</type><value>${value}</value></gip>"
+        cmd = "DeviceSendCommand"
+    }
+
+    def qParams = [
+        cmd: cmd,
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        debugOut "${response.data}"
+    }
+
+    //we want to ensure syncronization between rooms and bulbs
+    //runIn(2, "syncronizeDevices")
+}
+
+// Really not called from child, but called from poll() if it is a room
+def pollRoom(dni) {
+    debugOut "In pollRoom"
+    def data = ""
+    def cmd = ""
+    def roomDeviceData = []
+
+    data = "<gip><version>1</version><token>${atomicState.token}</token><rid>${dni}</rid><fields>name,power,control,status,state</fields></gip>"
+    cmd = "RoomGetDevices"
+
+    def qParams = [
+        cmd: cmd,
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        roomDeviceData = response.data.gip
+    }
+
+    debugOut "Room Data: ${roomDeviceData}"
+
+    def totalPower = 0
+    def totalLevel = 0
+    def cnt = 0
+    def onCnt = 0 //used to tally on/off states
+
+    roomDeviceData.device.each({
+        if ( getChildDevice(it.did) ) {
+            totalPower += it.other.bulbpower.toInteger()
+            totalLevel += it.level.toInteger()
+            onCnt += it.state.toInteger()
+            cnt += 1
+        }
+    })
+
+    def avgLevel = totalLevel/cnt
+    def usingPower = totalPower * (avgLevel / 100) as float
+    def room = getChildDevice( dni )
+
+    //the device is a room but we use same type file
+    sendEvent( dni, [name: "setBulbPower",value:"${totalPower}"] ) //used in child device calcs
+
+    //if all devices in room are on, room is on
+    if ( cnt == onCnt ) { // all devices are on
+        sendEvent( dni, [name: "switch",value:"on"] )
+        sendEvent( dni, [name: "power",value:usingPower.round(1)] )
+
+    } else { //if any device in room is off, room is off
+        sendEvent( dni, [name: "switch",value:"off"] )
+        sendEvent( dni, [name: "power",value:0.0] )
+    }
+
+    debugOut "Room Using Power: ${usingPower.round(1)}"
+}
+
+def poll(childDevice) {
+    debugOut "In poll() with ${childDevice}"
+
+
+    def dni = childDevice.device.deviceNetworkId
+
+    def bulbData = []
+    def data = ""
+    def cmd = ""
+
+    if ( isRoom(dni) ) { // this is a room, not a bulb
+        pollRoom(dni)
+        return
+    }
+
+    data = "<gip><version>1</version><token>${atomicState.token}</token><did>${dni}</did></gip>"
+    cmd = "DeviceGetInfo"
+
+    def qParams = [
+        cmd: cmd,
+        data: "${data}",
+        fmt: "json"
+    ]
+
+    cmd = toQueryString(qParams)
+
+    apiPost(cmd) { response ->
+        bulbData = response.data.gip
+        debugOut "This Bulbs Data Return = ${bulbData}"
+
+        def bulb = getChildDevice( dni )
+
+        //set the devices power max setting to do calcs within the device type
+        if ( bulbData.other.bulbpower )
+            sendEvent( dni, [name: "setBulbPower",value:"${bulbData.other.bulbpower}"] )
+
+        if (( bulbData.state == "1" ) && ( bulb?.currentValue("switch") != "on" ))
+            sendEvent( dni, [name: "switch",value:"on"] )
+
+        if (( bulbData.state == "0" ) && ( bulb?.currentValue("switch") != "off" ))
+            sendEvent( dni, [name: "switch",value:"off"] )
+
+        //if ( bulbData.level != bulb?.currentValue("level")) {
+        //    sendEvent( dni, [name: "level",value: "${bulbData.level}"] )
+        //    sendEvent( dni, [name: "setLevel",value: "${bulbData.level}"] )
+        //}
+
+        if (( bulbData.state == "1" ) && ( bulbData.other.bulbpower )) {
+            def levelSetting = bulbData.level as float
+            def bulbPowerMax = bulbData.other.bulbpower as float
+            def calculatedPower = bulbPowerMax * (levelSetting / 100)
+            sendEvent( dni, [name: "power", value: calculatedPower.round(1)] )
+        }
+
+        if (( bulbData.state == "0" ) && ( bulbData.other.bulbpower ))
+            sendEvent( dni, [name: "power", value: 0.0] )
+
+    }
+
+
+}

smartapps/smartthings/programmable-thermostat.src/programmable-thermostat.groovy

@@ -1,369 +0,0 @@
-/**
- *  Programmable Thermostat
- *
- *  Copyright 2016 Raymond Ciarcia
- *
- *  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: "Programmable Thermostat",
-    namespace: "smartthings",
-    author: "Raymond Ciarcia",
-    description: "A full-featured, easy to use interface for programming your thermostat based on schedule setpoints and mode changes",
-    category: "Convenience",
-    iconUrl: "http://cdn.device-icons.smartthings.com/Home/home1-icn@2x.png",
-    iconX2Url: "http://cdn.device-icons.smartthings.com/Home/home1-icn@2x.png",
-    iconX3Url: "http://cdn.device-icons.smartthings.com/Home/home1-icn@2x.png"
-)
-
-preferences {
-	page(name:"Settings", title:"Settings", uninstall:true, install:true ) {
-		section() {
-			input (name:"thermostat", type: "capability.thermostat", title: "Select thermostat", required: true, multiple: false)
-		}
-    	section ("Scheduled Setpoints") {
-	    	input (name: "son", type: "bool", title: "Run scheduled setpoints", required:true)
-			input (name:"numscheduled", title: "Number of scheduled setpoints", type: "number",refreshAfterSelection: true)
-			href(title: "Schedule Setpoints", page: "ScheduledChanges")
-		}
-    	section ("Mode-Based Setpoints") {
-			input (name: "eon", type: "bool", title: "Run mode-based setpoints", required:true)
-			input (name:"numevent", title: "Number of mode-based setpoints", type: "number",refreshAfterSelection: true)
-			href(title: "Mode-Based Setpoints Setpoints", page: "EventBasedChanges")
-		}
-    	section("Auto Thermostat Mode Control") {
-        	input (name: "auto", type: "enum", title: "Adjust thermostat heating/cooling mode based on current temperature and setpoint", required:true, multiple: false, options: ['Never','When setpoints are executed','Any time']) 
-		}
-    	section("Notifications") {
-			input (name: "snotifications", type: "bool", title: "Notify when scheduled setpoints execute", required:true)
-            input (name: "enotifications", type: "bool", title: "Notify when mode-based setpoints execute", required:true)
-            input (name: "eventlogging", type: "enum", title: "Set the level of event logging in the notification feed", required:true, multiple: false, options: ['None','Normal','Detailed'])
-		}
-       section("Command Acknowledgement Failure Response and Notification") {
-			input (name: "fnotifications", type: "bool", title: "Resend commands not acknowledged by the theromstat and notify after multiple failed attempts.  Increases thermostat reliability but may not be compatible with all thermostats; disable if every command results in a failure notification.", required:true)
-       }
-    }
-    page(name: "ScheduledChanges")
-    page(name: "EventBasedChanges")
-}
-
-def ScheduledChanges() {
-	dynamicPage(name: "ScheduledChanges", uninstall: true, install: false) {
-		for (int i = 1; i <= settings.numscheduled; i++) {
-			section("Scheduled Setpoint $i") {
-				input "stime${i}", "time", title: "At this time:", required: true
-       			input "sheatset${i}", "decimal", title: "Set this heating temperature:", required: true
-        		input "scoolset${i}", "decimal", title: "Set this cooling temperature:", required: true
-        		input "sdays${i}", "enum", title: "Only on these days (no selection is equivalent to selecting all):", required: false, multiple: true, options: ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
-        		input "smodes${i}", "mode", title: "Only in these modes (no selection is equivalent to selecting all):", multiple: true, required: false       
-			}
-    	}
-	}
-}
-
-def EventBasedChanges() {
-	dynamicPage(name: "EventBasedChanges", uninstall: true, install: false) {
-		for (int i = 1; i <= settings.numevent; i++) {
-			section("Mode-Based Setpoint $i") {
-				input "emodes${i}", "mode", title: "On transition to this mode:", multiple: false, required: true
-				input "eheatset${i}", "decimal", title: "Set this heating temperature:", required: true
-	    		input "ecoolset${i}", "decimal", title: "Set this cooling temperature:", required: true
-                input "edays${i}", "enum", title: "Only on these days (no selection is equivalent to selecting all):", required: false, multiple: true, options: ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
-			}
-		}
-	}
-}
-
-
-//---- INSTALL AND UPDATE
-
-def installed() {initialize()}
-
-def updated() {initialize()}
-
-def initialize() {
-	try {
-    	unschedule()
-    } catch(e) {
-    	try {
-       		unschedule(SchedulerIntegrityChecker)
-    		unschedule(MidnightRunner)        
-        } catch(ev) {}    
-    }    
-    
-    unsubscribe()
-    subscribe(settings.thermostat, "temperature", tempChangeHandler)
-    if ((settings.numevent > 0) && (settings.eon)) {subscribe(location, modeChangeHandler)}
-
-    state.scheduledindex = 0
-    state.pendingindex = 0
-	state.dayoflastrun = TodayAsString()
-    state.timeoflastevent = now()
-    state.nextscheduledtime = now()
-    state.failedcommandcount = 0
-    state.schedulestring = ""
-    state.checkcommandstring = ""
-    
-    state.eventlogging = 0
-    if (settings.eventlogging == "Normal"){state.notificationlevel = 1}
-    if (settings.eventlogging == "Detailed"){state.notificationlevel = 2}
-    
-    if ((settings.numscheduled > 0) && (settings.son)) {
-    	schedule(timeToday("2015-08-04T00:00:00.000",location.timeZone), MidnightRunner)
-    	SchedulerFunction()
-    }
-	log.debug "Programmable Thermostat: successfully initialized."
-    if (state.notificationlevel>0) {sendNotificationEvent("Programmable Thermostat successfully initialized.$state.schedulestring.")}
-	state.schedulestring = ""
-}
-
-//---- SCHEDULING FUNCTIONS
-
-//At midnight, runs scheduler function to set the first scheduled event of the new day
-def MidnightRunner() {
-	state.dayoflastrun = TodayAsString()
-    state.timeoflastevent = now()
-    SchedulerFunction()
-    def i = SearchSchedulePoints("2015-08-04T00:00:00.000")
-    if (i>0) {ThermostatCommander(settings."sheatset${i}", settings."scoolset${i}", settings.snotifications, "per scheduled setpoint.$state.schedulestring")}
-}
-
-//Determines and schedules the next scheduled setpoint
-def SchedulerFunction(){
-	def mindiff = 60*60*1000*24*7 
-    def timeNow = now()
-   	def todaystring = TodayAsString()
-	for (int i = 1; i <= settings.numscheduled; i++) {
-        def ScheduledTime = timeToday(settings["stime$i"],location.timeZone)
-        def ScheduledDays = settings["sdays$i"]
-        if (ScheduledDays == null) {ScheduledDays = TodayAsString()}
- 		if (ScheduledTime != null) {
-        	if ((ScheduledTime.time >= timeNow) && (ScheduledDays.contains(TodayAsString())) && (ScheduledTime.time - timeNow < mindiff)){
-                mindiff = ScheduledTime.time - timeNow
-                state.scheduledindex = i
-    		} 
-    	}
-	}
-    if (mindiff < 60*60*1000*24*7) {
-    	int i = state.scheduledindex
-    	def nextrun = timeToday(settings["stime$i"],location.timeZone)
-        state.nextscheduledtime = nextrun.time
-        def nextrunstring = DisplayTime(nextrun)
-        runOnce(nextrun, ScheduleExecuter)
-		if (state.notificationlevel>1) {state.schedulestring=" Next scheduled setpoint for $thermostat.label is today at $nextrunstring"}
-	} else {
-        state.nextscheduledtime = -1
-		if (state.notificationlevel>1) {state.schedulestring=" There are no remaining scheduled setpoints for $thermostat.label today"}
-	}
-	state.timeoflastevent = now()
-}
-
-def SearchSchedulePoints(time) {
-    for (int i = 1; i <= settings.numscheduled; i++) {
-    	def Modes = settings["smodes$i"]
-        if (Modes == null) {Modes = location.mode}
-        def Days = settings["sdays$i"]
-        if (Days == null) {Days = TodayAsString()}
-    	if(timeToday(settings["stime$i"],location.timeZone) == timeToday(time,location.timeZone) && Modes.contains(location.mode) && Days.contains(TodayAsString())) {
-            return i
-        }
-    }
-	return 0
-}
-
-
-//---- EXECUTION FUNCTIONS
-
-//Runs at scheduled setpoints to determine whether a setpoint should be executed; if yes, calls thermostat commander to execute command
-def ScheduleExecuter() {
-	int i = state.scheduledindex
-	SchedulerFunction()
-    state.timeoflastevent = now()
-	def valid = false
-    def Modes = settings["smodes$i"]
-    if (Modes == null) {Modes = location.mode}    
-	if(Modes.contains(location.mode)){
-    	valid = true
-    } else {
-    	i = SearchSchedulePoints(settings["stime$i"]) 
-        if (i > 0) {valid = true}
-	}
-	if (valid) {
-    	state.failedcommandcount = 0
-        state.pendingindex = i
-        ThermostatCommander(settings."sheatset${i}", settings."scoolset${i}", settings.snotifications, "per scheduled setpoint.$state.schedulestring")
-	} else {
-		if (state.notificationlevel>1) {sendNotificationEvent("Scheduled setpoint for $thermostat.label not executed because the current home mode, $location.mode, does not match a setpoint mode.$state.schedulestring.")}
-    }
-    state.schedulestring = ""
-}
-
-//Sends commands to the thermostat
-def ThermostatCommander(hvalue, cvalue, notifications, notificationphrase) { 
-	state.timeoflastevent = now()
-	if((hvalue == null) || (cvalue == null)) {return}
-    if (settings.auto != "Never") {ThermostatModeSetter(hvalue, cvalue, 0)}   
-
-	def notificationstring = "" 
-    state.checkcommandstring = ""
-    def thermMode = thermostat.currentValue("thermostatMode")
-    def name = thermostat.label
-    
-    def currentheatsetpoint = settings.thermostat.currentValue("heatingSetpoint")
-    def currentcoolsetpoint = settings.thermostat.currentValue("coolingSetpoint")  
-
-    if ("$currentcoolsetpoint" != "$cvalue") {state.checkcommandstring = "c"}
-    if ("$currentheatsetpoint" != "$hvalue") {state.checkcommandstring = "h$state.checkcommandstring"}
-    log.debug "Programmable Thermostat: check string is $state.checkcommandstring; values are $currentcoolsetpoint and $currentheatsetpoint"
-
-    def primarysetpoint = hvalue
-    if (thermMode == "cool") {primarysetpoint = cvalue}
-	if (thermMode == "heat" || thermMode == "cool") {notificationstring = "$name set to $primarysetpoint in $thermMode mode $notificationphrase."}
-    else {notificationstring = "$name set to $hvalue / $cvalue $notificationphrase."}
-    
-    if (settings.fnotifications && state.checkcommandstring != "") (runIn(10 + state.failedcommandcount*30, CommandIntegrityChecker))
-
-    if (hvalue!=0) {
-		log.debug "Programmable Thermostat: Heat command set to $hvalue"
-		thermostat.setHeatingSetpoint(hvalue)
-    }
-    if (cvalue!=0) {
-		log.debug "Programmable Thermostat: Cool command set to $cvalue"
-		thermostat.setCoolingSetpoint(cvalue)
-    }
-    if (notifications && state.failedcommandcount==0) {
-    	sendPush(notificationstring)
-    } else if (state.notificationlevel>0 && state.failedcommandcount==0) {
-    	sendNotificationEvent(notificationstring)
-        if (state.checkcommandstring == "" && state.notificationlevel>2) {sendNotificationEvent("$name confirmed that it was already set to $primarysetpoint in $thermMode mode.")}
-    }
-    if (state.checkcommandstring == "") {log.debug "Programmable Thermostat: $name confirmed that it was already set to $primarysetpoint in $thermMode mode"}
-}
-
-//Auto Sets Thermostat Mode
-def ThermostatModeSetter(hvalue, cvalue, notifications) {
-	if (hvalue==0 || cvalue==0) {return}
-    def currentTemp = settings.thermostat.latestValue("temperature")
-    if (currentTemp > cvalue && settings.thermostat.currentValue("thermostatMode") != "cool") {
-		thermostat.cool()
-		if (notifications > 0) {sendNotificationEvent("$thermostat.label mode changed to cooling when temperature reached $currentTemp")}
-	} else if (currentTemp < hvalue && settings.thermostat.currentValue("thermostatMode") != "heat") {
-		thermostat.heat()
-		if (notifications > 0) {sendNotificationEvent("$thermostat.label mode changed to heating when temperature fell to $currentTemp")}
-	}        
-}
-
-
-//---- INTEGRITY CHECKERS
-
-//Determines whether the last scheduled setpoint was executed; if not, reinitializes or sends missed command
-def SchedulerIntegrityChecker() {
-	def i = state.scheduledindex
-	if ((settings.numscheduled == 0) || (settings.son == false)) {return}
-	if (state.dayoflastrun != TodayAsString()) {initialize()}
-}
-
-//Determines whether commands sent to the thermostat have been properly acknowledged; if not, calls thermostat commander to reissue failed command(s)
-def CommandIntegrityChecker() {
-	state.timeoflastevent = now()
-	if (state.pendingindex == 0) {return}
-	def currentheatsetpoint = settings.thermostat.currentValue("heatingSetpoint")
-    def currentcoolsetpoint = settings.thermostat.currentValue("coolingSetpoint")
-	def thermMode = thermostat.currentValue("thermostatMode")
-    def lastheatcommand = IndexLookUp("heat")
-	def lastcoolcommand = IndexLookUp("cool")
-    def failedstring = ""
-    log.debug "Programmable Thermostat: $thermostat.label heating setpoint was commanded to $lastheatcommand and is currently $currentheatsetpoint; cooling setpoint was commanded to $lastcoolcommand and is currently $currentcoolsetpoint"    
-  
-	if (("$currentheatsetpoint" == "$lastheatcommand") && ("$currentcoolsetpoint" == "$lastcoolcommand")) {return}
-    
-    state.failedcommandcount = state.failedcommandcount + 1
-	if ("$currentheatsetpoint" != "$lastheatcommand" && "$currentcoolsetpoint" != "$lastcoolcommand" && state.checkcommandstring == "hc") {
-		failedstring = "$thermostat.label is non-responsive to setpoint commands."
-		ThermostatCommander(lastheatcommand, lastcoolcommand, false, "")
-	} else if ("$currentheatsetpoint" != "$lastheatcommand" && (state.checkcommandstring == "hc" || state.checkcommandstring == "h")) {
-		if (thermMode == "heat") {failedstring = "$thermostat.label is non-responsive to heat setpoint commands."}
-		ThermostatCommander(lastheatcommand, 0, false, "")    
-    } else if ("$currentcoolsetpoint" != "$lastcoolcommand" && (state.checkcommandstring == "hc" || state.checkcommandstring == "c")) {
-		if (thermMode == "cool") failedstring = "$thermostat.label is non-responsive to cool setpoint commands."
-		ThermostatCommander(0, lastcoolcommand, false, "")
-	}
-
-	if (state.failedcommandcount == 4) {
-		state.failedcommandcount = 0
-        state.pendingindex = 0
-    	if (failedstring != "") {sendPush(failedstring)}
-	}
-}
-
-
-//---- EVENT HANDLERS
-
-//Runs every time a mode change is detected.  Used to execute mode-based setpoints; also used to trigger schedule integrity checks in case all scheduled functions have failed
-def modeChangeHandler(evt) {
-    if (state.notificationlevel>2) {sendNotificationEvent("Programmable Thermostat detected home mode change to $evt.value.")}	
-	for (int i = 1; i <= settings.numevent; i++) {
-        def ScheduledDays = settings["edays$i"]
-        if (ScheduledDays == null) {ScheduledDays = TodayAsString()}
-        if ((evt.value == settings["emodes$i"]) && (ScheduledDays.contains(TodayAsString()))) {
-			state.failedcommandcount = 0
-            state.pendingindex = -i
-            ThermostatCommander(settings."eheatset${i}", settings."ecoolset${i}", settings.enotifications, "with change to $evt.value")
-        	i = settings.numevent + 1
-        }        
-	}
-	SchedulerIntegrityChecker()
-}
-
-//Runs every time the temperature reported by the thermostat changes.  Used to trigger schedule integrity checks in case all scheduled functions have failed.
-def tempChangeHandler(evt) {
-	SchedulerIntegrityChecker()
-    if (settings.auto == "Any time") {ThermostatModeSetter(settings.thermostat.latestValue("heatingSetpoint"), settings.thermostat.latestValue("coolingSetpoint"), state.notificationlevel)}
-}
-
-//---- OTHER
-
-//Returns the setpoint temperature associated with a settings index
-def IndexLookUp(mode) {
-	def result = 0
-	if (mode == "cool") {
-		if (state.pendingindex > 0) {result = settings."scoolset${state.pendingindex}"}
-    	if (state.pendingindex < 0) {result = settings."ecoolset${-state.pendingindex}"}
-	} else if (mode == "heat") {
-		if (state.pendingindex > 0) {result = settings."sheatset${state.pendingindex}"}
-   		if (state.pendingindex < 0) {result = settings."eheatset${-state.pendingindex}"}
-    }
-	return result
-}
-
-//Returns the current day of the week as a string
-def TodayAsString() {
-	return (new Date(now())).format("EEEEEEE", location.timeZone)
-}
-
-//Returns time as a string in 12 hour format
-def DisplayTime(time) {
-	def tz = location.timeZone
-    def hour = time.format("H",tz)
-	def min = time.format("m",tz)
-	def sec = time.format("s",tz)
-	def ampm = "am"        
-	def hournum = hour.toInteger()
-	def minnum = min.toInteger()
-	if (hournum == 0) {hournum = 12}
-	if (hournum > 12) {
-		hournum = hournum - 12
-		ampm = "pm"
-	}   
-	if (minnum < 10) {min = "0$min"}   
-	return "$hournum:$min $ampm"
-}