MSA-2122: Logs SmartThings data to an InfluxDB for graphing via grafana

Rolling down staging to master

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

smartapps/codersaur/influxdb-logger.src/influxdb-logger.groovy

@@ -0,0 +1,797 @@
+/*****************************************************************************************************************
+ *  Copyright David Lomas (codersaur)
+ *
+ *  Name: InfluxDB Logger
+ *
+ *  Date: 2017-04-03
+ *
+ *  Version: 1.11
+ *
+ *  Source: https://github.com/codersaur/SmartThings/tree/master/smartapps/influxdb-logger
+ *
+ *  Author: David Lomas (codersaur)
+ *
+ *  Description: A SmartApp to log SmartThings device states to an InfluxDB database.
+ *
+ *  For full information, including installation instructions, exmples, and version history, see:
+ *   https://github.com/codersaur/SmartThings/tree/master/smartapps/influxdb-logger
+ *
+ *  IMPORTANT - To enable the resolution of groupNames (i.e. room names), you must manually insert the group IDs
+ *   into the getGroupName() command code at the end of this file.
+ *
+ *  License:
+ *   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: "InfluxDB Logger",
+    namespace: "codersaur",
+    author: "David Lomas (codersaur)",
+    description: "Log SmartThings device states to InfluxDB",
+    category: "My Apps",
+    iconUrl: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience.png",
+    iconX2Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png",
+    iconX3Url: "https://s3.amazonaws.com/smartapp-icons/Convenience/Cat-Convenience@2x.png")
+
+preferences {
+
+    section("General:") {
+        //input "prefDebugMode", "bool", title: "Enable debug logging?", defaultValue: true, displayDuringSetup: true
+        input (
+        	name: "configLoggingLevelIDE",
+        	title: "IDE Live Logging Level:\nMessages with this level and higher will be logged to the IDE.",
+        	type: "enum",
+        	options: [
+        	    "0" : "None",
+        	    "1" : "Error",
+        	    "2" : "Warning",
+        	    "3" : "Info",
+        	    "4" : "Debug",
+        	    "5" : "Trace"
+        	],
+        	defaultValue: "3",
+            displayDuringSetup: true,
+        	required: false
+        )
+    }
+
+    section ("InfluxDB Database:") {
+        input "prefDatabaseHost", "text", title: "Host", defaultValue: "10.10.10.10", required: true
+        input "prefDatabasePort", "text", title: "Port", defaultValue: "8086", required: true
+        input "prefDatabaseName", "text", title: "Database Name", defaultValue: "", required: true
+        input "prefDatabaseUser", "text", title: "Username", required: false
+        input "prefDatabasePass", "text", title: "Password", required: false
+    }
+    
+    section("Polling:") {
+        input "prefSoftPollingInterval", "number", title:"Soft-Polling interval (minutes)", defaultValue: 10, required: true
+    }
+    
+    section("System Monitoring:") {
+        input "prefLogModeEvents", "bool", title:"Log Mode Events?", defaultValue: true, required: true
+        input "prefLogHubProperties", "bool", title:"Log Hub Properties?", defaultValue: true, required: true
+        input "prefLogLocationProperties", "bool", title:"Log Location Properties?", defaultValue: true, required: true
+    }
+    
+    section("Devices To Monitor:") {
+        input "accelerometers", "capability.accelerationSensor", title: "Accelerometers", multiple: true, required: false
+        input "alarms", "capability.alarm", title: "Alarms", multiple: true, required: false
+        input "batteries", "capability.battery", title: "Batteries", multiple: true, required: false
+        input "beacons", "capability.beacon", title: "Beacons", multiple: true, required: false
+        input "buttons", "capability.button", title: "Buttons", multiple: true, required: false
+        input "cos", "capability.carbonMonoxideDetector", title: "Carbon Monoxide Detectors", multiple: true, required: false
+        input "co2s", "capability.carbonDioxideMeasurement", title: "Carbon Dioxide Detectors", multiple: true, required: false
+        input "colors", "capability.colorControl", title: "Color Controllers", multiple: true, required: false
+        input "consumables", "capability.consumable", title: "Consumables", multiple: true, required: false
+        input "contacts", "capability.contactSensor", title: "Contact Sensors", multiple: true, required: false
+        input "doorsControllers", "capability.doorControl", title: "Door Controllers", multiple: true, required: false
+        input "energyMeters", "capability.energyMeter", title: "Energy Meters", multiple: true, required: false
+        input "humidities", "capability.relativeHumidityMeasurement", title: "Humidity Meters", multiple: true, required: false
+        input "illuminances", "capability.illuminanceMeasurement", title: "Illuminance Meters", multiple: true, required: false
+        input "locks", "capability.lock", title: "Locks", multiple: true, required: false
+        input "motions", "capability.motionSensor", title: "Motion Sensors", multiple: true, required: false
+        input "musicPlayers", "capability.musicPlayer", title: "Music Players", multiple: true, required: false
+        input "peds", "capability.stepSensor", title: "Pedometers", multiple: true, required: false
+        input "phMeters", "capability.pHMeasurement", title: "pH Meters", multiple: true, required: false
+        input "powerMeters", "capability.powerMeter", title: "Power Meters", multiple: true, required: false
+        input "presences", "capability.presenceSensor", title: "Presence Sensors", multiple: true, required: false
+        input "pressures", "capability.sensor", title: "Pressure Sensors", multiple: true, required: false
+        input "shockSensors", "capability.shockSensor", title: "Shock Sensors", multiple: true, required: false
+        input "signalStrengthMeters", "capability.signalStrength", title: "Signal Strength Meters", multiple: true, required: false
+        input "sleepSensors", "capability.sleepSensor", title: "Sleep Sensors", multiple: true, required: false
+        input "smokeDetectors", "capability.smokeDetector", title: "Smoke Detectors", multiple: true, required: false
+        input "soundSensors", "capability.soundSensor", title: "Sound Sensors", multiple: true, required: false
+		input "spls", "capability.soundPressureLevel", title: "Sound Pressure Level Sensors", multiple: true, required: false
+		input "switches", "capability.switch", title: "Switches", multiple: true, required: false
+        input "switchLevels", "capability.switchLevel", title: "Switch Levels", multiple: true, required: false
+        input "tamperAlerts", "capability.tamperAlert", title: "Tamper Alerts", multiple: true, required: false
+        input "temperatures", "capability.temperatureMeasurement", title: "Temperature Sensors", multiple: true, required: false
+        input "thermostats", "capability.thermostat", title: "Thermostats", multiple: true, required: false
+        input "threeAxis", "capability.threeAxis", title: "Three-axis (Orientation) Sensors", multiple: true, required: false
+        input "touchs", "capability.touchSensor", title: "Touch Sensors", multiple: true, required: false
+        input "uvs", "capability.ultravioletIndex", title: "UV Sensors", multiple: true, required: false
+        input "valves", "capability.valve", title: "Valves", multiple: true, required: false
+        input "volts", "capability.voltageMeasurement", title: "Voltage Meters", multiple: true, required: false
+        input "waterSensors", "capability.waterSensor", title: "Water Sensors", multiple: true, required: false
+        input "windowShades", "capability.windowShade", title: "Window Shades", multiple: true, required: false
+    }
+
+}
+
+
+/*****************************************************************************************************************
+ *  SmartThings System Commands:
+ *****************************************************************************************************************/
+
+/**
+ *  installed()
+ *
+ *  Runs when the app is first installed.
+ **/
+def installed() {
+    state.installedAt = now()
+    state.loggingLevelIDE = 5
+    log.debug "${app.label}: Installed with settings: ${settings}" 
+}
+
+/**
+ *  uninstalled()
+ *
+ *  Runs when the app is uninstalled.
+ **/
+def uninstalled() {
+    logger("uninstalled()","trace")
+}
+
+/**
+ *  updated()
+ * 
+ *  Runs when app settings are changed.
+ * 
+ *  Updates device.state with input values and other hard-coded values.
+ *  Builds state.deviceAttributes which describes the attributes that will be monitored for each device collection 
+ *  (used by manageSubscriptions() and softPoll()).
+ *  Refreshes scheduling and subscriptions.
+ **/
+def updated() {
+    logger("updated()","trace")
+
+    // Update internal state:
+    state.loggingLevelIDE = (settings.configLoggingLevelIDE) ? settings.configLoggingLevelIDE.toInteger() : 3
+    
+    // Database config:
+    state.databaseHost = settings.prefDatabaseHost
+    state.databasePort = settings.prefDatabasePort
+    state.databaseName = settings.prefDatabaseName
+    state.databaseUser = settings.prefDatabaseUser
+    state.databasePass = settings.prefDatabasePass 
+    
+    state.path = "/write?db=${state.databaseName}"
+    state.headers = [:] 
+    state.headers.put("HOST", "${state.databaseHost}:${state.databasePort}")
+    state.headers.put("Content-Type", "application/x-www-form-urlencoded")
+    if (state.databaseUser && state.databasePass) {
+        state.headers.put("Authorization", encodeCredentialsBasic(state.databaseUser, state.databasePass))
+    }
+
+    // Build array of device collections and the attributes we want to report on for that collection:
+    //  Note, the collection names are stored as strings. Adding references to the actual collection 
+    //  objects causes major issues (possibly memory issues?).
+    state.deviceAttributes = []
+    state.deviceAttributes << [ devices: 'accelerometers', attributes: ['acceleration']]
+    state.deviceAttributes << [ devices: 'alarms', attributes: ['alarm']]
+    state.deviceAttributes << [ devices: 'batteries', attributes: ['battery']]
+    state.deviceAttributes << [ devices: 'beacons', attributes: ['presence']]
+    state.deviceAttributes << [ devices: 'buttons', attributes: ['button']]
+    state.deviceAttributes << [ devices: 'cos', attributes: ['carbonMonoxide']]
+    state.deviceAttributes << [ devices: 'co2s', attributes: ['carbonDioxide']]
+    state.deviceAttributes << [ devices: 'colors', attributes: ['hue','saturation','color']]
+    state.deviceAttributes << [ devices: 'consumables', attributes: ['consumableStatus']]
+    state.deviceAttributes << [ devices: 'contacts', attributes: ['contact']]
+    state.deviceAttributes << [ devices: 'doorsControllers', attributes: ['door']]
+    state.deviceAttributes << [ devices: 'energyMeters', attributes: ['energy']]
+    state.deviceAttributes << [ devices: 'humidities', attributes: ['humidity']]
+    state.deviceAttributes << [ devices: 'illuminances', attributes: ['illuminance']]
+    state.deviceAttributes << [ devices: 'locks', attributes: ['lock']]
+    state.deviceAttributes << [ devices: 'motions', attributes: ['motion']]
+    state.deviceAttributes << [ devices: 'musicPlayers', attributes: ['status','level','trackDescription','trackData','mute']]
+    state.deviceAttributes << [ devices: 'peds', attributes: ['steps','goal']]
+    state.deviceAttributes << [ devices: 'phMeters', attributes: ['pH']]
+    state.deviceAttributes << [ devices: 'powerMeters', attributes: ['power','voltage','current','powerFactor']]
+    state.deviceAttributes << [ devices: 'presences', attributes: ['presence']]
+    state.deviceAttributes << [ devices: 'pressures', attributes: ['pressure']]
+    state.deviceAttributes << [ devices: 'shockSensors', attributes: ['shock']]
+    state.deviceAttributes << [ devices: 'signalStrengthMeters', attributes: ['lqi','rssi']]
+    state.deviceAttributes << [ devices: 'sleepSensors', attributes: ['sleeping']]
+    state.deviceAttributes << [ devices: 'smokeDetectors', attributes: ['smoke']]
+    state.deviceAttributes << [ devices: 'soundSensors', attributes: ['sound']]
+	state.deviceAttributes << [ devices: 'spls', attributes: ['soundPressureLevel']]
+	state.deviceAttributes << [ devices: 'switches', attributes: ['switch']]
+    state.deviceAttributes << [ devices: 'switchLevels', attributes: ['level']]
+    state.deviceAttributes << [ devices: 'tamperAlerts', attributes: ['tamper']]
+    state.deviceAttributes << [ devices: 'temperatures', attributes: ['temperature']]
+    state.deviceAttributes << [ devices: 'thermostats', attributes: ['temperature','heatingSetpoint','coolingSetpoint','thermostatSetpoint','thermostatMode','thermostatFanMode','thermostatOperatingState','thermostatSetpointMode','scheduledSetpoint','optimisation','windowFunction']]
+    state.deviceAttributes << [ devices: 'threeAxis', attributes: ['threeAxis']]
+    state.deviceAttributes << [ devices: 'touchs', attributes: ['touch']]
+    state.deviceAttributes << [ devices: 'uvs', attributes: ['ultravioletIndex']]
+    state.deviceAttributes << [ devices: 'valves', attributes: ['contact']]
+    state.deviceAttributes << [ devices: 'volts', attributes: ['voltage']]
+    state.deviceAttributes << [ devices: 'waterSensors', attributes: ['water']]
+    state.deviceAttributes << [ devices: 'windowShades', attributes: ['windowShade']]
+
+    // Configure Scheduling:
+    state.softPollingInterval = settings.prefSoftPollingInterval.toInteger()
+    manageSchedules()
+    
+    // Configure Subscriptions:
+    manageSubscriptions()
+}
+
+/*****************************************************************************************************************
+ *  Event Handlers:
+ *****************************************************************************************************************/
+
+/**
+ *  handleAppTouch(evt)
+ * 
+ *  Used for testing.
+ **/
+def handleAppTouch(evt) {
+    logger("handleAppTouch()","trace")
+    
+    softPoll()
+}
+
+/**
+ *  handleModeEvent(evt)
+ * 
+ *  Log Mode changes.
+ **/
+def handleModeEvent(evt) {
+    logger("handleModeEvent(): Mode changed to: ${evt.value}","info")
+
+    def locationId = escapeStringForInfluxDB(location.id)
+    def locationName = escapeStringForInfluxDB(location.name)
+    def mode = '"' + escapeStringForInfluxDB(evt.value) + '"'
+	def data = "_stMode,locationId=${locationId},locationName=${locationName} mode=${mode}"
+    postToInfluxDB(data)
+}
+
+/**
+ *  handleEvent(evt)
+ *
+ *  Builds data to send to InfluxDB.
+ *   - Escapes and quotes string values.
+ *   - Calculates logical binary values where string values can be 
+ *     represented as binary values (e.g. contact: closed = 1, open = 0)
+ * 
+ *  Useful references: 
+ *   - http://docs.smartthings.com/en/latest/capabilities-reference.html
+ *   - https://docs.influxdata.com/influxdb/v0.10/guides/writing_data/
+ **/
+def handleEvent(evt) {
+    logger("handleEvent(): $evt.displayName($evt.name:$evt.unit) $evt.value","info")
+    
+    // Build data string to send to InfluxDB:
+    //  Format: <measurement>[,<tag_name>=<tag_value>] field=<field_value>
+    //    If value is an integer, it must have a trailing "i"
+    //    If value is a string, it must be enclosed in double quotes.
+    def measurement = evt.name
+    // tags:
+    def deviceId = escapeStringForInfluxDB(evt.deviceId)
+    def deviceName = escapeStringForInfluxDB(evt.displayName)
+    def groupId = escapeStringForInfluxDB(evt?.device.device.groupId)
+    def groupName = escapeStringForInfluxDB(getGroupName(evt?.device.device.groupId))
+    def hubId = escapeStringForInfluxDB(evt?.device.device.hubId)
+    def hubName = escapeStringForInfluxDB(evt?.device.device.hub.toString())
+    // Don't pull these from the evt.device as the app itself will be associated with one location.
+    def locationId = escapeStringForInfluxDB(location.id)
+    def locationName = escapeStringForInfluxDB(location.name)
+
+    def unit = escapeStringForInfluxDB(evt.unit)
+    def value = escapeStringForInfluxDB(evt.value)
+    def valueBinary = ''
+    
+    def data = "${measurement},deviceId=${deviceId},deviceName=${deviceName},groupId=${groupId},groupName=${groupName},hubId=${hubId},hubName=${hubName},locationId=${locationId},locationName=${locationName}"
+    
+    // Unit tag and fields depend on the event type:
+    //  Most string-valued attributes can be translated to a binary value too.
+    if ('acceleration' == evt.name) { // acceleration: Calculate a binary value (active = 1, inactive = 0)
+        unit = 'acceleration'
+        value = '"' + value + '"'
+        valueBinary = ('active' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('alarm' == evt.name) { // alarm: Calculate a binary value (strobe/siren/both = 1, off = 0)
+        unit = 'alarm'
+        value = '"' + value + '"'
+        valueBinary = ('off' == evt.value) ? '0i' : '1i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('button' == evt.name) { // button: Calculate a binary value (held = 1, pushed = 0)
+        unit = 'button'
+        value = '"' + value + '"'
+        valueBinary = ('pushed' == evt.value) ? '0i' : '1i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('carbonMonoxide' == evt.name) { // carbonMonoxide: Calculate a binary value (detected = 1, clear/tested = 0)
+        unit = 'carbonMonoxide'
+        value = '"' + value + '"'
+        valueBinary = ('detected' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('consumableStatus' == evt.name) { // consumableStatus: Calculate a binary value ("good" = 1, "missing"/"replace"/"maintenance_required"/"order" = 0)
+        unit = 'consumableStatus'
+        value = '"' + value + '"'
+        valueBinary = ('good' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('contact' == evt.name) { // contact: Calculate a binary value (closed = 1, open = 0)
+        unit = 'contact'
+        value = '"' + value + '"'
+        valueBinary = ('closed' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('door' == evt.name) { // door: Calculate a binary value (closed = 1, open/opening/closing/unknown = 0)
+        unit = 'door'
+        value = '"' + value + '"'
+        valueBinary = ('closed' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('lock' == evt.name) { // door: Calculate a binary value (locked = 1, unlocked = 0)
+        unit = 'lock'
+        value = '"' + value + '"'
+        valueBinary = ('locked' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('motion' == evt.name) { // Motion: Calculate a binary value (active = 1, inactive = 0)
+        unit = 'motion'
+        value = '"' + value + '"'
+        valueBinary = ('active' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('mute' == evt.name) { // mute: Calculate a binary value (muted = 1, unmuted = 0)
+        unit = 'mute'
+        value = '"' + value + '"'
+        valueBinary = ('muted' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('presence' == evt.name) { // presence: Calculate a binary value (present = 1, not present = 0)
+        unit = 'presence'
+        value = '"' + value + '"'
+        valueBinary = ('present' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('shock' == evt.name) { // shock: Calculate a binary value (detected = 1, clear = 0)
+        unit = 'shock'
+        value = '"' + value + '"'
+        valueBinary = ('detected' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('sleeping' == evt.name) { // sleeping: Calculate a binary value (sleeping = 1, not sleeping = 0)
+        unit = 'sleeping'
+        value = '"' + value + '"'
+        valueBinary = ('sleeping' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('smoke' == evt.name) { // smoke: Calculate a binary value (detected = 1, clear/tested = 0)
+        unit = 'smoke'
+        value = '"' + value + '"'
+        valueBinary = ('detected' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('sound' == evt.name) { // sound: Calculate a binary value (detected = 1, not detected = 0)
+        unit = 'sound'
+        value = '"' + value + '"'
+        valueBinary = ('detected' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('switch' == evt.name) { // switch: Calculate a binary value (on = 1, off = 0)
+        unit = 'switch'
+        value = '"' + value + '"'
+        valueBinary = ('on' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('tamper' == evt.name) { // tamper: Calculate a binary value (detected = 1, clear = 0)
+        unit = 'tamper'
+        value = '"' + value + '"'
+        valueBinary = ('detected' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('thermostatMode' == evt.name) { // thermostatMode: Calculate a binary value (<any other value> = 1, off = 0)
+        unit = 'thermostatMode'
+        value = '"' + value + '"'
+        valueBinary = ('off' == evt.value) ? '0i' : '1i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('thermostatFanMode' == evt.name) { // thermostatFanMode: Calculate a binary value (<any other value> = 1, off = 0)
+        unit = 'thermostatFanMode'
+        value = '"' + value + '"'
+        valueBinary = ('off' == evt.value) ? '0i' : '1i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('thermostatOperatingState' == evt.name) { // thermostatOperatingState: Calculate a binary value (heating = 1, <any other value> = 0)
+        unit = 'thermostatOperatingState'
+        value = '"' + value + '"'
+        valueBinary = ('heating' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('thermostatSetpointMode' == evt.name) { // thermostatSetpointMode: Calculate a binary value (followSchedule = 0, <any other value> = 1)
+        unit = 'thermostatSetpointMode'
+        value = '"' + value + '"'
+        valueBinary = ('followSchedule' == evt.value) ? '0i' : '1i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('threeAxis' == evt.name) { // threeAxis: Format to x,y,z values.
+        unit = 'threeAxis'
+        def valueXYZ = evt.value.split(",")
+        def valueX = valueXYZ[0]
+        def valueY = valueXYZ[1]
+        def valueZ = valueXYZ[2]
+        data += ",unit=${unit} valueX=${valueX}i,valueY=${valueY}i,valueZ=${valueZ}i" // values are integers.
+    }
+    else if ('touch' == evt.name) { // touch: Calculate a binary value (touched = 1, "" = 0)
+        unit = 'touch'
+        value = '"' + value + '"'
+        valueBinary = ('touched' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('optimisation' == evt.name) { // optimisation: Calculate a binary value (active = 1, inactive = 0)
+        unit = 'optimisation'
+        value = '"' + value + '"'
+        valueBinary = ('active' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('windowFunction' == evt.name) { // windowFunction: Calculate a binary value (active = 1, inactive = 0)
+        unit = 'windowFunction'
+        value = '"' + value + '"'
+        valueBinary = ('active' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('touch' == evt.name) { // touch: Calculate a binary value (touched = 1, <any other value> = 0)
+        unit = 'touch'
+        value = '"' + value + '"'
+        valueBinary = ('touched' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('water' == evt.name) { // water: Calculate a binary value (wet = 1, dry = 0)
+        unit = 'water'
+        value = '"' + value + '"'
+        valueBinary = ('wet' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    else if ('windowShade' == evt.name) { // windowShade: Calculate a binary value (closed = 1, <any other value> = 0)
+        unit = 'windowShade'
+        value = '"' + value + '"'
+        valueBinary = ('closed' == evt.value) ? '1i' : '0i'
+        data += ",unit=${unit} value=${value},valueBinary=${valueBinary}"
+    }
+    // Catch any other event with a string value that hasn't been handled:
+    else if (evt.value ==~ /.*[^0-9\.,-].*/) { // match if any characters are not digits, period, comma, or hyphen.
+		logger("handleEvent(): Found a string value that's not explicitly handled: Device Name: ${deviceName}, Event Name: ${evt.name}, Value: ${evt.value}","warn")
+        value = '"' + value + '"'
+        data += ",unit=${unit} value=${value}"
+    }
+    // Catch any other general numerical event (carbonDioxide, power, energy, humidity, level, temperature, ultravioletIndex, voltage, etc).
+    else {
+        data += ",unit=${unit} value=${value}"
+    }
+    
+    // Post data to InfluxDB:
+    postToInfluxDB(data)
+
+}
+
+
+/*****************************************************************************************************************
+ *  Main Commands:
+ *****************************************************************************************************************/
+
+/**
+ *  softPoll()
+ *
+ *  Executed by schedule.
+ * 
+ *  Forces data to be posted to InfluxDB (even if an event has not been triggered).
+ *  Doesn't poll devices, just builds a fake event to pass to handleEvent().
+ *
+ *  Also calls LogSystemProperties().
+ **/
+def softPoll() {
+    logger("softPoll()","trace")
+    
+    logSystemProperties()
+    
+    // Iterate over each attribute for each device, in each device collection in deviceAttributes:
+    def devs // temp variable to hold device collection.
+    state.deviceAttributes.each { da ->
+        devs = settings."${da.devices}"
+        if (devs && (da.attributes)) {
+            devs.each { d ->
+                da.attributes.each { attr ->
+                    if (d.hasAttribute(attr) && d.latestState(attr)?.value != null) {
+                        logger("softPoll(): Softpolling device ${d} for attribute: ${attr}","info")
+                        // Send fake event to handleEvent():
+                        handleEvent([
+                            name: attr, 
+                            value: d.latestState(attr)?.value,
+                            unit: d.latestState(attr)?.unit,
+                            device: d,
+                            deviceId: d.id,
+                            displayName: d.displayName
+                        ])
+                    }
+                }
+            }
+        }
+    }
+
+}
+
+/**
+ *  logSystemProperties()
+ *
+ *  Generates measurements for SmartThings system (hubs and locations) properties.
+ **/
+def logSystemProperties() {
+    logger("logSystemProperties()","trace")
+
+    def locationId = '"' + escapeStringForInfluxDB(location.id) + '"'
+    def locationName = '"' + escapeStringForInfluxDB(location.name) + '"'
+
+	// Location Properties:
+    if (prefLogLocationProperties) {
+        try {
+            def tz = '"' + escapeStringForInfluxDB(location.timeZone.ID) + '"'
+            def mode = '"' + escapeStringForInfluxDB(location.mode) + '"'
+            def hubCount = location.hubs.size()
+            def times = getSunriseAndSunset()
+            def srt = '"' + times.sunrise.format("HH:mm", location.timeZone) + '"'
+            def sst = '"' + times.sunset.format("HH:mm", location.timeZone) + '"'
+
+            def data = "_stLocation,locationId=${locationId},locationName=${locationName},latitude=${location.latitude},longitude=${location.longitude},timeZone=${tz} mode=${mode},hubCount=${hubCount}i,sunriseTime=${srt},sunsetTime=${sst}"
+            postToInfluxDB(data)
+        } catch (e) {
+		    logger("logSystemProperties(): Unable to log Location properties: ${e}","error")
+        }
+	}
+
+	// Hub Properties:
+    if (prefLogHubProperties) {
+       	location.hubs.each { h ->
+        	try {
+                def hubId = '"' + escapeStringForInfluxDB(h.id) + '"'
+                def hubName = '"' + escapeStringForInfluxDB(h.name) + '"'
+                def hubIP = '"' + escapeStringForInfluxDB(h.localIP) + '"'
+                def hubStatus = '"' + escapeStringForInfluxDB(h.status) + '"'
+                def batteryInUse = ("false" == h.hub.getDataValue("batteryInUse")) ? "0i" : "1i"
+                def hubUptime = h.hub.getDataValue("uptime") + 'i'
+                def zigbeePowerLevel = h.hub.getDataValue("zigbeePowerLevel") + 'i'
+                def zwavePowerLevel =  '"' + escapeStringForInfluxDB(h.hub.getDataValue("zwavePowerLevel")) + '"'
+                def firmwareVersion =  '"' + escapeStringForInfluxDB(h.firmwareVersionString) + '"'
+
+                def data = "_stHub,locationId=${locationId},locationName=${locationName},hubId=${hubId},hubName=${hubName},hubIP=${hubIP} "
+                data += "status=${hubStatus},batteryInUse=${batteryInUse},uptime=${hubUptime},zigbeePowerLevel=${zigbeePowerLevel},zwavePowerLevel=${zwavePowerLevel},firmwareVersion=${firmwareVersion}"
+                postToInfluxDB(data)
+            } catch (e) {
+				logger("logSystemProperties(): Unable to log Hub properties: ${e}","error")
+        	}
+       	}
+
+	}
+
+}
+
+/**
+ *  postToInfluxDB()
+ *
+ *  Posts data to InfluxDB.
+ *
+ *  Uses hubAction instead of httpPost() in case InfluxDB server is on the same LAN as the Smartthings Hub.
+ **/
+def postToInfluxDB(data) {
+    logger("postToInfluxDB(): Posting data to InfluxDB: Host: ${state.databaseHost}, Port: ${state.databasePort}, Database: ${state.databaseName}, Data: [${data}]","debug")
+    
+    try {
+        def hubAction = new physicalgraph.device.HubAction(
+        	[
+                method: "POST",
+                path: state.path,
+                body: data,
+                headers: state.headers
+            ],
+            null,
+            [ callback: handleInfluxResponse ]
+        )
+		
+        sendHubCommand(hubAction)
+    }
+    catch (Exception e) {
+		logger("postToInfluxDB(): Exception ${e} on ${hubAction}","error")
+    }
+
+    // For reference, code that could be used for WAN hosts:
+    // def url = "http://${state.databaseHost}:${state.databasePort}/write?db=${state.databaseName}" 
+    //    try {
+    //      httpPost(url, data) { response ->
+    //          if (response.status != 999 ) {
+    //              log.debug "Response Status: ${response.status}"
+    //              log.debug "Response data: ${response.data}"
+    //              log.debug "Response contentType: ${response.contentType}"
+    //            }
+    //      }
+    //  } catch (e) {	
+    //      logger("postToInfluxDB(): Something went wrong when posting: ${e}","error")
+    //  }
+}
+
+/**
+ *  handleInfluxResponse()
+ *
+ *  Handles response from post made in postToInfluxDB().
+ **/
+def handleInfluxResponse(physicalgraph.device.HubResponse hubResponse) {
+    if(hubResponse.status >= 400) {
+		logger("postToInfluxDB(): Something went wrong! Response from InfluxDB: Headers: ${hubResponse.headers}, Body: ${hubResponse.body}","error")
+    }
+}
+
+
+/*****************************************************************************************************************
+ *  Private Helper Functions:
+ *****************************************************************************************************************/
+
+/**
+ *  manageSchedules()
+ * 
+ *  Configures/restarts scheduled tasks: 
+ *   softPoll() - Run every {state.softPollingInterval} minutes.
+ **/
+private manageSchedules() {
+	logger("manageSchedules()","trace")
+
+    // Generate a random offset (1-60):
+    Random rand = new Random(now())
+    def randomOffset = 0
+    
+    // softPoll:
+    try {
+        unschedule(softPoll)
+    }
+    catch(e) {
+        // logger("manageSchedules(): Unschedule failed!","error")
+    }
+
+    if (state.softPollingInterval > 0) {
+        randomOffset = rand.nextInt(60)
+        logger("manageSchedules(): Scheduling softpoll to run every ${state.softPollingInterval} minutes (offset of ${randomOffset} seconds).","trace")
+        schedule("${randomOffset} 0/${state.softPollingInterval} * * * ?", "softPoll")
+    }
+    
+}
+
+/**
+ *  manageSubscriptions()
+ * 
+ *  Configures subscriptions.
+ **/
+private manageSubscriptions() {
+	logger("manageSubscriptions()","trace")
+
+    // Unsubscribe:
+    unsubscribe()
+    
+    // Subscribe to App Touch events:
+    subscribe(app,handleAppTouch)
+    
+    // Subscribe to mode events:
+    if (prefLogModeEvents) subscribe(location, "mode", handleModeEvent)
+    
+    // Subscribe to device attributes (iterate over each attribute for each device collection in state.deviceAttributes):
+    def devs // dynamic variable holding device collection.
+    state.deviceAttributes.each { da ->
+        devs = settings."${da.devices}"
+        if (devs && (da.attributes)) {
+            da.attributes.each { attr ->
+                logger("manageSubscriptions(): Subscribing to attribute: ${attr}, for devices: ${da.devices}","info")
+                // There is no need to check if all devices in the collection have the attribute.
+                subscribe(devs, attr, handleEvent)
+            }
+        }
+    }
+}
+
+/**
+ *  logger()
+ *
+ *  Wrapper function for all logging.
+ **/
+private logger(msg, level = "debug") {
+
+    switch(level) {
+        case "error":
+            if (state.loggingLevelIDE >= 1) log.error msg
+            break
+
+        case "warn":
+            if (state.loggingLevelIDE >= 2) log.warn msg
+            break
+
+        case "info":
+            if (state.loggingLevelIDE >= 3) log.info msg
+            break
+
+        case "debug":
+            if (state.loggingLevelIDE >= 4) log.debug msg
+            break
+
+        case "trace":
+            if (state.loggingLevelIDE >= 5) log.trace msg
+            break
+
+        default:
+            log.debug msg
+            break
+    }
+}
+
+/**
+ *  encodeCredentialsBasic()
+ *
+ *  Encode credentials for HTTP Basic authentication.
+ **/
+private encodeCredentialsBasic(username, password) {
+    return "Basic " + "${username}:${password}".encodeAsBase64().toString()
+}
+
+/**
+ *  escapeStringForInfluxDB()
+ *
+ *  Escape values to InfluxDB.
+ *  
+ *  If a tag key, tag value, or field key contains a space, comma, or an equals sign = it must 
+ *  be escaped using the backslash character \. Backslash characters do not need to be escaped. 
+ *  Commas and spaces will also need to be escaped for measurements, though equals signs = do not.
+ *
+ *  Further info: https://docs.influxdata.com/influxdb/v0.10/write_protocols/write_syntax/
+ **/
+private escapeStringForInfluxDB(str) {
+    if (str) {
+        str = str.replaceAll(" ", "\\\\ ") // Escape spaces.
+        str = str.replaceAll(",", "\\\\,") // Escape commas.
+        str = str.replaceAll("=", "\\\\=") // Escape equal signs.
+        str = str.replaceAll("\"", "\\\\\"") // Escape double quotes.
+        //str = str.replaceAll("'", "_")  // Replace apostrophes with underscores.
+    }
+    else {
+        str = 'null'
+    }
+    return str
+}
+
+/**
+ *  getGroupName()
+ *
+ *  Get the name of a 'Group' (i.e. Room) from its ID.
+ *  
+ *  This is done manually as there does not appear to be a way to enumerate
+ *  groups from a SmartApp currently.
+ * 
+ *  GroupIds can be obtained from the SmartThings IDE under 'My Locations'.
+ *
+ *  See: https://community.smartthings.com/t/accessing-group-within-a-smartapp/6830
+ **/
+private getGroupName(id) {
+
+    if (id == null) {return 'Home'}
+    else if (id == 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') {return 'Kitchen'}
+    else if (id == 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') {return 'Lounge'}
+    else if (id == 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') {return 'Office'}
+    else {return 'Unknown'}    
+}

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

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

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

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

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

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