MSA-1646: Gate/Garage opener

devicetypes/smartthings/zwave-dimmer-switch-generic.src/zwave-dimmer-switch-generic.groovy

@@ -24,10 +24,6 @@ metadata {
 		fingerprint inClusters: "0x26", deviceJoinName: "Z-Wave Dimmer"
 		fingerprint mfr:"001D", prod:"1902", deviceJoinName: "Z-Wave Dimmer"
 		fingerprint mfr:"001D", prod:"1B03", model:"0334", deviceJoinName: "Leviton Universal Dimmer"
-		fingerprint mfr:"011A", prod:"0102", model:"0201", deviceJoinName: "Enerwave In-Wall Dimmer"
-		fingerprint mfr:"001D", prod:"1001", model:"0334", deviceJoinName: "Leviton 3-Speed Fan Controller"
-		fingerprint mfr:"001D", prod:"0602", model:"0334", deviceJoinName: "Leviton Magnetic Low Voltage Dimmer"
-		fingerprint mfr:"001D", prod:"0401", model:"0334", deviceJoinName: "Leviton 600W Incandescent Dimmer"
 	}
 
 	simulator {

smartapps/bravenel/rule-machine.src/rule-machine.groovy

@@ -1,623 +0,0 @@
-/**
- *  Rule Machine
- *
- *  Copyright 2015 Bruce Ravenel and Mike Maxwell
- *
- *  Version 1.6.5   1 Jan 2016
- *
- *	Version History
- *
- *	1.6.5	1 Jan 2016		Added version numbers to main page
- *	1.6.4	30 Dec 2015		Multi-commands
- *	1.6.3	26 Dec 2015		UI improvements and icon per Michael Struck
- *	1.6.2	25 Dec 2015		null parameter value patch in expert, maxwell
- *	1.6.1	24 Dec 2015		UI improvement
- *	1.6	23 Dec 2015		Added expert commands per Mike Maxwell
- *
- *  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: "Rule Machine",
-	singleInstance: true,
-	namespace: "bravenel",
-	author: "Bruce Ravenel and Mike Maxwell",
-	description: "Rule Machine",
-	category: "My Apps",
-	iconUrl: "https://raw.githubusercontent.com/bravenel/Rule-Trigger/master/smartapps/bravenel/RuleMachine.png",
-	iconX2Url: "https://raw.githubusercontent.com/bravenel/Rule-Trigger/master/smartapps/bravenel/RuleMachine%402x.png",
-	iconX3Url: "https://raw.githubusercontent.com/bravenel/Rule-Trigger/master/smartapps/bravenel/RuleMachine%402x.png"
-)
-
-preferences {
-	page(name: "mainPage")
-	page(name: "removePage")
-	//expert pages
-	page(name: "expert")
-	page(name: "generalApprovalPAGE")
-	page(name: "customCommandsPAGE")
-	page(name: "addCustomCommandPAGE")
-	page(name: "customParamsPAGE")
-}
-
-def mainPage() {
-    dynamicPage(name: "mainPage", title: "Installed Rules", install: true, uninstall: false, submitOnChange: true) {
-    	if(!state.setup) initialize(true)
-        section {
-            app(name: "childRules", appName: "Rule", namespace: "bravenel", title: "Create New Rule...", multiple: true)
-        }
-	section ("Expert Features") {
-		href( "expert", title: "", description: "Tap to create custom commands", state: "")
-        }
-        section ("Remove Rule Machine"){
-        	href "removePage", description: "Tap to remove Rule Machine ", title: ""
-        }
-        if(state.ver) section ("Version 1.6.5/" + state.ver) { }
-    }
-}
-
-def removePage() {
-	dynamicPage(name: "removePage", title: "Remove Rule Machine And All Rules", install: false, uninstall: true) {
-    	section ("WARNING!\n\nRemoving Rule Machine also removes all Rules\n") {
-        }
-    }
-}
-
-def installed() {
-    if(!state.setup) initialize(true) else initialize(false)
-}
-
-def updated() {
-    initialize(false)
-}
-
-def initialize(first) {
-	if(first) {
-		state.ruleState = [:]
-    		state.ruleSubscribers = [:]
-	}
-	childApps.each {child ->
-		if(child.name == "Rule") {
-			log.info "Installed Rules and Triggers: ${child.label}"
-			if(first) {
-				state.ruleState[child.label] = null
-				state.ruleSubscribers[child.label] = [:]
-			}
-		} 
-	}
-	state.setup = true
-}
-
-def ruleList(appLabel) {
-	def result = []
-	childApps.each { child ->
-		if(child.name == "Rule" && child.label != appLabel && state.ruleState[child.label] != null) result << child.label
-	}
-	return result
-}
-
-def subscribeRule(appLabel, ruleName, ruleTruth, childMethod) {
-//	log.debug "subscribe: $appLabel, $ruleName, $ruleTruth, $childMethod"
-	ruleName.each {name ->
-    	state.ruleSubscribers[name].each {if(it == appLabel) return}
-        if(state.ruleSubscribers[name] == null) state.ruleSubscribers[name] = ["$appLabel":ruleTruth]
-    	else state.ruleSubscribers[name] << ["$appLabel":ruleTruth]
-    }
-}
-
-def setRuleTruth(appLabel, ruleTruth) {
-//	log.debug "setRuleTruth1: $appLabel, $ruleTruth"
-	state.ruleState[appLabel] = ruleTruth
-	def thisList = state.ruleSubscribers[appLabel]
-	thisList.each {
-		if(it.value == null || "$it.value" == "$ruleTruth") {
-			childApps.each { child ->
-				if(child.label == it.key) child.ruleHandler(appLabel, ruleTruth)
-			}
-		}
-	}
-}
-
-def currentRule(appLabel) {
-//	log.debug "currentRule: $appLabel, ${state.ruleState[appLabel]}"
-	def result = state.ruleState[appLabel]
-}
-
-def childUninstalled() {
-//	log.debug "childUninstalled called"
-}
-
-def removeChild(appLabel) {
-//	log.debug "removeChild: $appLabel"
-	unSubscribeRule(appLabel)
-	if(state.ruleState[appLabel] != null) state.ruleState.remove(appLabel)
-	if(state.ruleSubscribers[appLabel] != null) state.ruleSubscribers.remove(appLabel)
-}
-
-def unSubscribeRule(appLabel) {
-//	log.debug "unSubscribeRule: $appLabel"
-	state.ruleSubscribers.each { rule ->
-        def newList = [:]
-        rule.value.each {list ->
-        	if(list.key != appLabel) newList << list
-        }
-        rule.value = newList
-    }
-}
-
-def runRule(rule, appLabel) {
-//	log.debug "runRule: $rule, $appLabel"
-	childApps.each { child ->
-		rule.each {
-			if(child.label == it) child.ruleEvaluator(appLabel)
-		}
-	}
-}
-
-/*****custom command specific pages	*****/
-def expert(){
-	dynamicPage(name: "expert", title: "Expert Features", uninstall: false, install: false) {
-		section(){
-			paragraph "${expertText()}"
-			//expert hrefs...
-			href( "customCommandsPAGE"
-				,title		: "Configure Custom Commands..."
-				,description: ""
-				,state		: anyCustom()
-			)
-		}
-	}
-}
-
-def generalApprovalPAGE(params){
-	def title = params.title
-	def method = params.method
-	def result
-	dynamicPage(name: "generalApprovalPAGE", title: title ){
-		section() {
-			if (method) {
-				result = app."${method}"()
-				paragraph "${result}"
-			}
-		}
-	}
-}
-
-def customCommandsPAGE() {
-	if (!state.lastCmdIDX) state.lastCmdIDX = 0
-	def savedCommands = getCommands()
-	dynamicPage(name: "customCommandsPAGE", title: "Custom Commands", uninstall: false, install: false) {
-		section(){
-			input(
-				name			: "devices"
-				,title			: "Test device"
-				,multiple		: false
-				,required		: false
-				,type			: "capability.actuator"
-				,submitOnChange	: true
-			)
-			if (settings.devices && savedCommands.size() != 0){
-				input(
-					name			: "testCmd"
-					,title			: "Select saved command to test"
-					,multiple		: false
-					,required		: false
-					,type			: "enum"
-					,options		: savedCommands
-					,submitOnChange	: true
-				)
-			}
-		}
-		def result = execCommand(settings.testCmd)
-		if (result) {
-			section("${result}"){
-			}
-		}
-		section(){
-		if (devices){
-				href( "addCustomCommandPAGE"
-					,title		: "New custom command..."
-					,description: ""
-					,state		: null
-				)
-			}
-        }
-		if (getCommands()){
-			section(){
-				input(
-					name			: "deleteCmds"
-					,title			: "Delete custom commands..."
-					,multiple		: true
-					,required		: false
-                    ,description	: ""
-					,type			: "enum"
-					,options		: getCommands()
-					,submitOnChange	: true
-				)
-				if (isValidCommand(deleteCmds)){
-					href( "generalApprovalPAGE"
-						,title			: "Delete command(s) now"
-						,description	: ""
-						,state			: null
-						,params			: [method:"deleteCommands",title:"Delete Command"]
-						,submitOnChange	: true
-					)
-				}
-			}
-		}
-	}
-}
-
-def addCustomCommandPAGE(){
-	def cmdLabel = getCmdLabel()
-	def complete = "" 
-	def test = false
-	def pageTitle = "Create new custom command for:\n${devices}" 
-	if (cmdLabel){
-		complete = "complete"
-		test = true
-	}
-	dynamicPage(name: "addCustomCommandPAGE", title: pageTitle, uninstall: false, install: false) {
-		section(){
-			input(
-		   		name			: "cCmd"
-				,title			: "Available device commands"
-				,multiple		: false
-				,required		: false
-				,type			: "enum"
-				,options		: getDeviceCommands()
-				,submitOnChange	: true
-			)
-			href( "customParamsPAGE"
-				,title: "Parameters"
-				,description: parameterLabel()
-				,state: null
-			)
-		}
-		if (test){
-			def result = execTestCommand()
-			section("Configured command: ${cmdLabel}\n${result}"){
-				if (result == "succeeded"){
-					if (!commandExists(cmdLabel)){
-						href( "generalApprovalPAGE"
-							,title		: "Save command now"
-							,description: ""
-							,state		: null
-							,params		: [method:"addCommand",title:"Add Command"]
-						)
-					}
-				} 
-			}
-		}
-	}
-}
-
-def customParamsPAGE(p){
-	def ct = settings.findAll{it.key.startsWith("cpType_")}
-	state.howManyP = ct.size() + 1
-	def howMany = state.howManyP
-	dynamicPage(name: "customParamsPAGE", title: "Select parameters", uninstall: false) {
-		if(howMany) {
-			for (int i = 1; i <= howMany; i++) {
-				def thisParam = "cpType_" + i
-				def myParam = ct.find {it.key == thisParam}
-				section("Parameter #${i}") {
-					getParamType(thisParam, i != howMany)
-					if(myParam) {
-						def pType = myParam.value
-						getPvalue(pType, i)
-					}
-				}
-			}
-		}
-	}
-}
-
-/***** child specific methods *****/
-
-def getCommandMap(cmdID){
-	return state.customCommands["${cmdID}"]
-}
-
-
-/***** local custom command specific methods *****/
-def anyCustom(){
-	def result = null
-	if (getCommands()) result = "complete"
-	return result
-}
-
-def getParamType(myParam,isLast){  
-	def myOptions = ["string", "number", "decimal"]
-	def result = input (
-					name			: myParam
-					,type			: "enum"
-					,title			: "parameter type"
-					,required		: isLast
-					,options		: myOptions
-					,submitOnChange	: true
-				)
-	return result
-}
-
-def getPvalue(myPtype, n){
-	def myVal = "cpVal_" + n
-	def result = null
-	if (myPtype == "string"){
-		result = input(
-					name		: myVal
-					,title		: "string value"
-					,type		: "text"
-					,required	: false
-				)
-	} else if (myPtype == "number"){
-		result = input(
-					name		: myVal
-					,title		: "integer value"
-					,type		: "number"
-					,required	: false
-				)
-	} else if (myPtype == "decimal"){
-		result = input(
-					name		: myVal
-					,title		: "decimal value"
-					,type		: "decimal"
-					,required	: false
-				)
-	}
-	return result
-}
-
-def getCmdLabel(){
-	def cmd
-	if (settings.cCmd) cmd = settings.cCmd.value
-	def cpTypes = settings.findAll{it.key.startsWith("cpType_")}.sort()
-	def result = null
-	if (cmd) {
-		result = "${cmd}("
-		if (cpTypes.size() == 0){
-			result = result + ")"
-		} else {
-        	def r = getParams(cpTypes)
-            if (r == "") result = r
-            else result = "${result}${r})"
-		}
-	}
-	return result
-}
-
-def getParams(cpTypes){
-	def result = ""
-	def cpValue
-	def badParam = false
-	cpTypes.each{ cpType ->
-		def i = cpType.key.replaceAll("cpType_","")
-		def cpVal = settings.find{it.key == "cpVal_${i}"}
-		if (cpVal){
-			cpValue = cpVal.value
-			if (cpType.value == "string"){
-				result = result + "'${cpValue}'," 
-			} else {
-				if (cpValue.isNumber()){
-					result = result + "${cpValue}," 
-				} else {
-					result = result + "[${cpValue}]: is not a number,"
-				}
-			}
-		} else {
-			badParam = true
-		}
-	}
-	if (badParam) result = ""
-	else result = result[0..-2]   
-	return result
-}
-
-def parameterLabel(){
-	def howMany = (state.howManyP ?: 1) - 1
-	def result = ""
-	if (howMany) {
-		for (int i = 1; i <= howMany; i++) {
-			result = result + parameterLabelN(i) + "\n"
-		}
-		result = result[0..-2]
-	}
-	return result
-}
-
-def parameterLabelN(i){
-	def result = ""
-	def cpType = settings.find{it.key == "cpType_${i}"}
-	def cpVal = settings.find{it.key == "cpVal_${i}"}
-	def cpValue
-	if (cpVal) cpValue = cpVal.value
-	else cpValue = "missing value"
-	if (cpType){
-		result = "p${i} - type:${cpType.value}, value:${cpValue}"
-	} 
-	return result
-}
-
-def getParamsAsList(cpTypes){
-	def result = []
-	cpTypes.each{ cpType ->
-		def i = cpType.key.replaceAll("cpType_","")
-		def cpVal = settings.find{it.key == "cpVal_${i}"}
-		if (cpVal){
-			if (cpType.value == "string"){
-				result << "${cpVal.value}" 
-			} else if (cpType.value == "decimal"){
-				result << cpVal.value.toBigDecimal()
-			} else {
-				result << cpVal.value.toInteger() 
-			}
-		} else {
-        	result << "missing value"
-        }
-	}
-	return result
-}
-
-def getCommands(){
-	def result = [] 
-	def cmdMaps = state.customCommands ?: []
-	cmdMaps.each{ cmd ->
-		def option = [(cmd.key):(cmd.value.text)]
-		result.push(option)
-	}
-	return result
-}
-
-def isValidCommand(cmdIDS){
-	def result = false
-	cmdIDS.each{ cmdID ->
-		def cmd = state.customCommands["${cmdID}"]
-		if (cmd) result = true
-	}
-	return result
-}
-
-def deleteCommands(){
-	def result
-	def cmdMaps = state.customCommands
-	if (deleteCmds.size == 1) result = "Command removed"
-	else result = "Commands removed"
-	deleteCmds.each{ it -> 
-		cmdMaps.remove(it)
-	}
-	return result
-}
-def commandExists(cmd){
-	def result = false
-	if (state.customCommands){
-		result = state.customCommands.find{ it.value.text == "${cmd}" }
-	}
-	return result
-}
-def addCommand(){
-	def result
-	def newCmd = getCmdLabel()
-	def found = commandExists(newCmd)
-	def cmdMaps = state.customCommands
-	//only update if not found...
-	if (!found) {
-		state.lastCmdIDX = state.lastCmdIDX + 1
-		def nextIDX = state.lastCmdIDX
-		def cmd = [text:"${newCmd}",cmd:"${cCmd}"]
-		def params = [:]
-		def cpTypes = settings.findAll{it.key.startsWith("cpType_")}.sort()
-		cpTypes.each{ cpType ->
-			def i = cpType.key.replaceAll("cpType_","")
-			def cpVal = settings.find{it.key == "cpVal_${i}"}
-			def param = ["type":"${cpType.value}","value":"${cpVal.value}"]
-			params.put(i, param)
-		}	
-		cmd.put("params",params)
-		if (cmdMaps) cmdMaps.put((nextIDX),cmd)
-		else state.customCommands = [(nextIDX):cmd]
-		result = "command: ${newCmd} was added"
-	} else {
-		result = "command: ${newCmd} was not added, it already exists."
-	}
-	return result
-}
-
-def execTestCommand(){
-	def result
-	def cTypes = settings.findAll{it.key.startsWith("cpType_")}
-	def p = getParamsAsList(cTypes.sort()) as Object[]
-	devices.each { device ->
-		try {
-			device."${cCmd}"(p)
-			result = "succeeded"
-		}
-		catch (IllegalArgumentException e){
-			def em = e as String
-			def ems = em.split(":")
-			ems = ems[2].replace(" [","").replace("]","")
-			ems = ems.replaceAll(", ","\n")
-			result = "failed, valid commands:\n${ems}"
-		}
-		catch (e){
-			result = "failed with:\n${e}"
-		}
-	}
-	return result
-}
-
-def execCommand(cmdID){
-	def result = ""
-	def pList = []
-	if (cmdID){
-		def cmdMap = state.customCommands["${cmdID}"] 
-		if (testCmd && cmdMap) {
-        	def params = cmdMap.params.sort()
-			params.each{ p ->
-				if (p.value.type == "string"){
-					pList << "${p.value.value}"
-       			} else if (p.value.type == "decimal"){
-		   			pList << p.value.value.toBigDecimal()
-				} else {
-					pList << p.value.value.toInteger()
-				}
-			}
-			def p = pList as Object[]
-			devices.each { device ->
-				try {
-					device."${cmdMap.cmd}"(p)
-					result = "Command succeeded"
-				}
-				catch (IllegalArgumentException e){
-					def em = e as String
-					def ems = em.split(":")
-					ems = ems[2].replace(" [","").replace("]","")
-					ems = ems.replaceAll(", ","\n")
-					result = "Command failed, valid commands:\n${ems}"
-				}
-				catch (e){
-					result = "failed with:\n${e}"
-				}
-			}
-			return result
-		}
-	}
-}
-
-def getDeviceCommands(){
-	def result = ""
-	devices.each { device ->
-		try {
-			device."xxx"()
-			result = "Command succeeded"
-		}
-		catch (IllegalArgumentException e){
-			def em = e as String
-			def ems = em.split(":")
-			ems = ems[2].replace(" [","").replace("]","")
-			result = ems.split(", ").collect{it as String}
-		}
-	}
-	return result
-}
-
-def isExpert(ver){
-	state.ver = ver
-	return getCommands().size() > 0
-}
-
-def expertText() {
-	def text = 
-		"Custom commands allows Rule Machine to control devices with custom capabilities. " +
-		"This includes dual dimmers and switches, ThingShields, FGBW controllers or any device you might build a " +
-		"custom SmartApp to utilize.\n\nCustom commands that are created and saved here will become available for use " +
-		"in any new or existing rules.\n\nAfter saving at least one command, look for 'Run custom device command' in your " + 
-		"'Select Actions' sections."
-}

smartapps/brbeaird/myq-lite.src/myq-lite.groovy

@@ -0,0 +1,536 @@
+/**
+ *  MyQ Lite
+ *
+ *  Copyright 2015 Jason Mok/Brian Beaird/Barry Burke
+ *
+ *  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.
+ *
+ *  Last Updated : 06/14/2016
+ *
+ */
+definition(
+	name: "MyQ Lite",
+	namespace: "brbeaird",
+	author: "Jason Mok/Brian Beaird/Barry Burke",
+	description: "Integrate MyQ with Smartthings",
+	category: "SmartThings Labs",
+	iconUrl:   "http://smartthings.copyninja.net/icons/MyQ@1x.png",
+	iconX2Url: "http://smartthings.copyninja.net/icons/MyQ@2x.png",
+	iconX3Url: "http://smartthings.copyninja.net/icons/MyQ@3x.png"
+)
+
+preferences {
+	page(name: "prefLogIn", title: "MyQ")    
+	page(name: "prefListDevices", title: "MyQ")
+    page(name: "prefSensor1", title: "MyQ")
+    page(name: "prefSensor2", title: "MyQ")
+    page(name: "prefSensor3", title: "MyQ")
+    page(name: "prefSensor4", title: "MyQ")
+}
+
+/* Preferences */
+def prefLogIn() {
+	def showUninstall = username != null && password != null 
+	return dynamicPage(name: "prefLogIn", title: "Connect to MyQ", nextPage:"prefListDevices", uninstall:showUninstall, install: false) {
+		section("Login Credentials"){
+			input("username", "email", title: "Username", description: "MyQ Username (email address)")
+			input("password", "password", title: "Password", description: "MyQ password")
+		}
+		section("Gateway Brand"){
+			input(name: "brand", title: "Gateway Brand", type: "enum",  metadata:[values:["Liftmaster","Chamberlain","Craftsman"]] )
+		}
+	}
+}
+
+def prefListDevices() {
+	if (forceLogin()) {
+		def doorList = getDoorList()		
+		if ((doorList)) {
+			return dynamicPage(name: "prefListDevices",  title: "Devices", nextPage:"prefSensor1", install:false, uninstall:true) {
+				if (doorList) {
+					section("Select which garage door/gate to use"){
+						input(name: "doors", type: "enum", required:false, multiple:true, metadata:[values:doorList])
+					}
+				} 
+			}
+		} else {
+			def devList = getDeviceList()
+			return dynamicPage(name: "prefListDevices",  title: "Error!", install:false, uninstall:true) {
+				section(""){
+					paragraph "Could not find any supported device(s). Please report to author about these devices: " +  devList
+				}
+			}
+		}  
+	} else {
+		return dynamicPage(name: "prefListDevices",  title: "Error!", install:false, uninstall:true) {
+			section(""){
+				paragraph "The username or password you entered is incorrect. Try again. " 
+			}
+		}  
+	}
+}
+
+
+def prefSensor1() {
+	log.debug "Doors chosen: " + doors
+    
+    //Set defaults
+    def nextPage = ""
+    def showInstall = true
+    def titleText = ""
+    
+    //Determine if we have multiple doors and need to send to another page
+    if (doors instanceof String){ //simulator seems to just make a single door a string. For that reason we have this weird check.
+    	log.debug "Single door detected (string)."
+        titleText = "Select Sensors for Door 1 (" + state.data[doors].name + ")"
+    }
+    else if (doors.size() == 1){
+    	log.debug "Single door detected (array)."
+        titleText = "Select Sensors for Door 1 (" + state.data[doors[0]].name + ")"
+    }
+    else{
+    	log.debug "Multiple doors detected."
+        nextPage = "prefSensor2"
+        titleText = "Select Sensors for Door 1 (" + state.data[doors[0]].name + ")"
+        showInstall = false;
+    }    
+    
+    return dynamicPage(name: "prefSensor1",  title: "Sensors", nextPage:nextPage, install:showInstall, uninstall:true) {        
+        section(titleText){			
+			input(name: "door1Sensor", title: "Contact Sensor", type: "capability.contactSensor", required: true, multiple: false)
+			input(name: "door1Acceleration", title: "Acceleration Sensor", type: "capability.accelerationSensor", required: false, multiple: false)
+		}
+    }
+}
+
+def prefSensor2() {	   
+    def nextPage = ""
+    def showInstall = true
+    def titleText = "Sensors for Door 2 (" + state.data[doors[1]].name + ")"
+     
+    if (doors.size() > 2){
+    	nextPage = "prefSensor3"
+        showInstall = false;
+    }
+    
+    return dynamicPage(name: "prefSensor2",  title: "Sensors", nextPage:nextPage, install:showInstall, uninstall:true) {
+        section(titleText){			
+			input(name: "door2Sensor", title: "Contact Sensor", type: "capability.contactSensor", required: true, multiple: false)
+			input(name: "door2Acceleration", title: "Acceleration Sensor", type: "capability.accelerationSensor", required: false, multiple: false)
+		}
+    }
+}
+
+def prefSensor3() {	   
+    def nextPage = ""
+    def showInstall = true
+    def titleText = "Sensors for Door 3 (" + state.data[doors[2]].name + ")"
+     
+    if (doors.size() > 3){
+    	nextPage = "prefSensor4"
+        showInstall = false;
+    }
+    
+    return dynamicPage(name: "prefSensor3",  title: "Sensors", nextPage:nextPage, install:showInstall, uninstall:true) {
+        section(titleText){			
+			input(name: "door3Sensor", title: "Contact Sensor", type: "capability.contactSensor", required: true, multiple: false)
+			input(name: "door3Acceleration", title: "Acceleration Sensor", type: "capability.accelerationSensor", required: false, multiple: false)
+		}
+    }
+}
+
+def prefSensor4() {	   
+	def titleText = "Contact Sensor for Door 4 (" + state.data[doors[3]].name + ")"
+    return dynamicPage(name: "prefSensor4",  title: "Sensors", install:true, uninstall:true) {
+        section(titleText){			
+			input(name: "door4Sensor", title: "Contact Sensor", type: "capability.contactSensor", required: "true", multiple: "false")
+			input(name: "door4Acceleration", title: "Acceleration Sensor", type: "capability.accelerationSensor", required: false, multiple: false)
+		}
+    }
+}
+
+/* Initialization */
+def installed() { initialize() }
+
+def updated() { 
+	unsubscribe()
+	initialize()
+}
+
+def uninstalled() {}	
+
+def initialize() {    
+	login()
+    state.sensorMap = [:]
+    
+    // Get initial device status in state.data
+	state.polling = [ last: 0, rescheduler: now() ]
+	state.data = [:]
+    
+	// Create selected devices
+	def doorsList = getDoorList()
+	//def lightsList = getLightList()
+	def selectedDevices = [] + getSelectedDevices("doors")
+  
+	selectedDevices.each { 
+    	log.debug "Creating child device: " + it
+		if (!getChildDevice(it)) {
+			if (it.contains("GarageDoorOpener")) { addChildDevice("brbeaird", "MyQ Garage Door Opener", it, null, ["name": "MyQLite: " + doorsList[it]]) }			
+		} 
+	}
+
+	// Remove unselected devices
+	def deleteDevices = (selectedDevices) ? (getChildDevices().findAll { !selectedDevices.contains(it.deviceNetworkId) }) : getAllChildDevices()
+	deleteDevices.each { deleteChildDevice(it.deviceNetworkId) }    
+    
+    //Create subscriptions
+    if (door1Sensor)
+        subscribe(door1Sensor, "contact", sensorHandler)    
+    if (door2Sensor)    	
+        subscribe(door2Sensor, "contact", sensorHandler)
+    if (door3Sensor)        
+        subscribe(door3Sensor, "contact", sensorHandler)        
+    if (door4Sensor)    	
+        subscribe(door4Sensor, "contact", sensorHandler)
+        
+    if (door1Acceleration)
+        subscribe(door1Acceleration, "acceleration", sensorHandler)    
+    if (door2Acceleration)    	
+        subscribe(door2Acceleration, "acceleration", sensorHandler)
+    if (door3Acceleration)        
+        subscribe(door3Acceleration, "acceleration", sensorHandler)        
+    if (door4Acceleration)    	
+        subscribe(door4Acceleration, "acceleration", sensorHandler)
+        
+    //Set initial values
+    syncDoorsWithSensors()   
+}
+
+def syncDoorsWithSensors(child){	
+    def firstDoor = doors[0]
+        
+    //Handle single door (sometimes it's just a dumb string thanks to the simulator)
+    if (doors instanceof String)
+    firstDoor = doors
+    
+    def doorDNI = null
+    if (child) {								// refresh only the requesting door (makes things a bit more efficient if you have more than 1 door
+    	doorDNI = child.device.deviceNetworkId
+        switch (doorDNI) {
+        	case firstDoor:
+            	updateDoorStatus(firstDoor, door1Sensor, door1Acceleration, door1ThreeAxis, child)
+                break
+            case doors[1]:
+            	updateDoorStatus(doors[1], door2Sensor, door2Acceleration, door2ThreeAxis, child)
+                break
+            case doors[2]:
+            	updateDoorStatus(doors[2], door3Sensor, door3Acceleration, door3ThreeAxis, child)
+                break
+            case doors[3]:
+            	updateDoorStatus(doors[3], door4Sensor, door4Acceleration, door4ThreeAxis, child)
+     	}
+    } else {           					// refresh ALL the doors
+		if (firstDoor) updateDoorStatus(firstDoor, door1Sensor, door1Acceleration, door1ThreeAxis, null)
+		if (doors[1]) updateDoorStatus(doors[1], door2Sensor, door2Acceleration, door2ThreeAxis, null)
+		if (doors[2]) updateDoorStatus(doors[2], door3Sensor, door3Acceleration, door3ThreeAxis, null)
+		if (doors[3]) updateDoorStatus(doors[3], door4Sensor, door4Acceleration, door4ThreeAxis, null)
+    }
+}
+
+def updateDoorStatus(doorDNI, sensor, acceleration, threeAxis, child){
+	
+    //Get door to update and set the new value
+    def doorToUpdate = getChildDevice(doorDNI)
+    def doorName = state.data[doorDNI].name
+    
+    def value = "unknown"
+    def moving = "unknown"
+    def door = doorToUpdate.latestValue("door")
+    
+    if (acceleration) moving = acceleration.latestValue("acceleration")
+    if (sensor) value = sensor.latestValue("contact")
+
+    if (moving == "active") {
+    	if (value == "open") {			
+        	if (door != "opening") value = "closing" else value = "opening"  // if door is "open" or "waiting" change to "closing", else it must be "opening"
+    	} else if (value == "closed") { 
+        	if (door != "closing") 	value = "opening" else value = "closed"
+    	}
+    } else if (moving == "inactive") {
+    	if (door == "closing") {
+    		if (value == "open") { 	// just stopped but door is still open
+    			value = "stopped"
+        	}
+        }
+    }
+    	
+    doorToUpdate.updateDeviceStatus(value)
+    doorToUpdate.updateDeviceSensor("${sensor} is ${sensor.currentContact}")
+    
+    log.debug "Door: " + doorName + ": Updating with status - " + value + " -  from sensor " + sensor
+    
+    //Write to child log if this was initiated from one of the doors    
+    if (child)
+    	child.log("Door: " + doorName + ": Updating with status - " + value + " -  from sensor " + sensor)
+ 
+     if (acceleration) {
+     	doorToUpdate.updateDeviceMoving("${acceleration} is ${moving}")
+        log.debug "Door: " + doorName + ": Updating with status - " + moving + " - from sensor " + acceleration
+        if (child)
+        	child.log("Door: " + doorName + ": Updating with status - " + moving + " - from sensor " + acceleration)
+     }
+    
+    //Get latest activity timestamp for the sensor (data saved for up to a week)
+    def eventsSinceYesterday = sensor.eventsSince(new Date() - 7)    
+    def latestEvent = eventsSinceYesterday[0]?.date
+    def timeStampLogText = "Door: " + doorName + ": Updating timestamp to: " + latestEvent + " -  from sensor " + sensor
+    
+    if (!latestEvent)	//If the door has been inactive for more than a week, timestamp data will be null. Keep current value in that case.
+    	timeStampLogText = "Door: " + doorName + ": Null timestamp detected "  + " -  from sensor " + sensor + " . Keeping current value."
+    else
+    	doorToUpdate.updateDeviceLastActivity(latestEvent)    	
+    	
+    log.debug timeStampLogText    
+    
+    //Write to child log if this was initiated from one of the doors
+    if (child)
+    	child.log(timeStampLogText)
+}
+
+def refresh(child){	
+    def door = child.device.deviceNetworkId
+    def doorName = state.data[door].name
+    child.log("refresh called from " + doorName + ' (' + door + ')')
+    syncDoorsWithSensors(child)
+}
+
+def sensorHandler(evt) {    
+    log.debug "Sensor change detected: Event name  " + evt.name + " value: " + evt.value   + " deviceID: " + evt.deviceId    
+    
+    switch (evt.deviceId) {
+    	case door1Sensor.id:
+        case door1Acceleration?.id:
+            def firstDoor = doors[0]
+			if (doors instanceof String) firstDoor = doors
+        	updateDoorStatus(firstDoor, door1Sensor, door1Acceleration, door1ThreeAxis, null)
+            break
+    	case door2Sensor?.id:
+        case door2Acceleration?.id:
+        	updateDoorStatus(doors[1], door2Sensor, door2Acceleration, door2ThreeAxis, null)
+            break    	
+        case door3Sensor?.id:
+        case door3Acceleration?.id:
+        	updateDoorStatus(doors[2], door3Sensor, door3Acceleration, door3ThreeAxis, null)
+            break        
+    	case door4Sensor?.id:
+        case door4Acceleration?.id:
+        	updateDoorStatus(doors[3], door4Sensor, door4Acceleration, door4ThreeAxis, null)
+            break
+        default:
+			syncDoorsWithSensors()
+    }
+}
+
+def getSelectedDevices( settingsName ) { 
+	def selectedDevices = [] 
+	(!settings.get(settingsName))?:((settings.get(settingsName)?.getAt(0)?.size() > 1)  ? settings.get(settingsName)?.each { selectedDevices.add(it) } : selectedDevices.add(settings.get(settingsName))) 
+	return selectedDevices 
+} 
+
+/* Access Management */
+private forceLogin() {
+	//Reset token and expiry
+	state.session = [ brandID: 0, brandName: settings.brand, securityToken: null, expiration: 0 ]
+	state.polling = [ last: 0, rescheduler: now() ]
+	state.data = [:]
+	return doLogin()
+}
+
+private login() { return (!(state.session.expiration > now())) ? doLogin() : true }
+
+private doLogin() { 
+	apiGet("/api/user/validate", [username: settings.username, password: settings.password] ) { response ->
+		log.debug "got login response: " + response
+        if (response.status == 200) {
+			if (response.data.SecurityToken != null) {
+				state.session.brandID = response.data.BrandId
+				state.session.brandName = response.data.BrandName
+				state.session.securityToken = response.data.SecurityToken
+				state.session.expiration = now() + 150000
+				return true
+			} else {
+				return false
+			}
+		} else {
+			return false
+		}
+	} 	
+}
+
+// Listing all the garage doors you have in MyQ
+private getDoorList() { 	    
+	def deviceList = [:]
+	apiGet("/api/v4/userdevicedetails/get", []) { response ->
+		if (response.status == 200) {
+        //log.debug "response data: " + response.data.Devices
+        //sendAlert("response data: " + response.data.Devices)
+			response.data.Devices.each { device ->
+				// 2 = garage door, 5 = gate, 7 = MyQGarage(no gateway), 17 = Garage Door Opener WGDO
+				if (device.MyQDeviceTypeId == 2||device.MyQDeviceTypeId == 5||device.MyQDeviceTypeId == 7||device.MyQDeviceTypeId == 17) {
+					log.debug "Found door: " + device.MyQDeviceId
+                    def dni = [ app.id, "GarageDoorOpener", device.MyQDeviceId ].join('|')
+					def description = ''
+                    def doorState = ''
+                    def updatedTime = ''
+                    device.Attributes.each { 
+						
+                        if (it.AttributeDisplayName=="desc")	//deviceList[dni] = it.Value                        	
+                        {
+                        	description = it.Value
+                        }
+                        	
+						if (it.AttributeDisplayName=="doorstate") { 
+                        	doorState = it.Value
+                            updatedTime = it.UpdatedTime							
+						}
+					}
+                    
+                    //Ignore any doors with blank descriptions
+                    if (description != ''){
+                        log.debug "adding door: " + description + "type: " + device.MyQDeviceTypeId + " status: " + doorState
+                        deviceList[dni] = description
+                        state.data[dni] = [ status: doorState, lastAction: updatedTime, name: description ]
+                    }
+				}
+			}
+		}
+	}    
+	return deviceList
+}
+
+private getDeviceList() { 	    
+	def deviceList = []
+	apiGet("/api/v4/userdevicedetails/get", []) { response ->
+		if (response.status == 200) {
+			response.data.Devices.each { device ->
+				log.debug "MyQDeviceTypeId : " + device.MyQDeviceTypeId.toString()
+				if (!(device.MyQDeviceTypeId == 1||device.MyQDeviceTypeId == 2||device.MyQDeviceTypeId == 3||device.MyQDeviceTypeId == 5||device.MyQDeviceTypeId == 7)) {					
+                    device.Attributes.each { 
+						def description = ''
+                        def doorState = ''
+                        def updatedTime = ''
+                        if (it.AttributeDisplayName=="desc")	//deviceList[dni] = it.Value
+                        	description = it.Value
+						
+                        //Ignore any doors with blank descriptions
+                        if (description != ''){
+                        	log.debug "found device: " + description
+                        	deviceList.add( device.MyQDeviceTypeId.toString() + "|" + device.TypeID )
+                        }
+					}
+				}
+			}
+		}
+	}    
+	return deviceList
+}
+
+/* api connection */
+// get URL 
+private getApiURL() {
+	if (settings.brand == "Craftsman") {
+		return "https://craftexternal.myqdevice.com"
+	} else {
+		return "https://myqexternal.myqdevice.com"
+	}
+}
+
+private getApiAppID() {
+	if (settings.brand == "Craftsman") {
+		return "QH5AzY8MurrilYsbcG1f6eMTffMCm3cIEyZaSdK/TD/8SvlKAWUAmodIqa5VqVAs"
+	} else {
+		return "JVM/G9Nwih5BwKgNCjLxiFUQxQijAebyyg8QUHr7JOrP+tuPb8iHfRHKwTmDzHOu"
+	}
+}
+	
+// HTTP GET call
+private apiGet(apiPath, apiQuery = [], callback = {}) {	
+	// set up query
+	apiQuery = [ appId: getApiAppID() ] + apiQuery
+	if (state.session.securityToken) { apiQuery = apiQuery + [SecurityToken: state.session.securityToken ] }
+       
+	try {
+		httpGet([ uri: getApiURL(), path: apiPath, query: apiQuery ]) { response -> callback(response) }
+	}	catch (SocketException e)	{
+		//sendAlert("API Error: $e")
+        log.debug "API Error: $e"
+	}
+}
+
+// HTTP PUT call
+private apiPut(apiPath, apiBody = [], callback = {}) {    
+	// set up body
+	apiBody = [ ApplicationId: getApiAppID() ] + apiBody
+	if (state.session.securityToken) { apiBody = apiBody + [SecurityToken: state.session.securityToken ] }
+    
+	// set up query
+	def apiQuery = [ appId: getApiAppID() ]
+	if (state.session.securityToken) { apiQuery = apiQuery + [SecurityToken: state.session.securityToken ] }
+    
+	try {
+		httpPut([ uri: getApiURL(), path: apiPath, contentType: "application/json; charset=utf-8", body: apiBody, query: apiQuery ]) { response -> callback(response) }
+	} catch (SocketException e)	{
+		log.debug "API Error: $e"
+	}
+}
+
+// Get Device ID
+def getChildDeviceID(child) {
+	return child.device.deviceNetworkId.split("\\|")[2]
+}
+
+// Get single device status
+def getDeviceStatus(child) {
+	return state.data[child.device.deviceNetworkId].status
+}
+
+// Get single device last activity
+def getDeviceLastActivity(child) {
+	return state.data[child.device.deviceNetworkId].lastAction.toLong()
+}
+
+// Send command to start or stop
+def sendCommand(child, attributeName, attributeValue) {
+	if (login()) {	    	
+		//Send command
+		apiPut("/api/v4/deviceattribute/putdeviceattribute", [ MyQDeviceId: getChildDeviceID(child), AttributeName: attributeName, AttributeValue: attributeValue ]) 
+        
+        if ((attributeName == "desireddoorstate") && (attributeValue == 0)) {		// if we are closing, check if we have an Acceleration sensor, if so, "waiting" until it moves
+            def firstDoor = doors[0]
+    		if (doors instanceof String) firstDoor = doors
+        	def doorDNI = child.device.deviceNetworkId
+        	switch (doorDNI) {
+        		case firstDoor:
+                	if (door1Acceleration) child.updateDeviceStatus("waiting") else child.updateDeviceStatus("opening")
+                	break
+            	case doors[1]:
+            		if (door2Acceleration) child.updateDeviceStatus("waiting") else child.updateDeviceStatus("opening")
+                	break
+            	case doors[2]:
+            		if (door3Acceleration) child.updateDeviceStatus("waiting") else child.updateDeviceStatus("opening")
+                	break
+            	case doors[3]:
+            		if (door4Acceleration) child.updateDeviceStatus("waiting") else child.updateDeviceStatus("opening")
+        			break
+            }
+        }      
+		return true
+	} 
+}