I have recently purchased a Yale Assure Lock 2 (YRD450-F-ZW3-619). It has a Z-Wave module in it and I have also purchased the Wi-Fi bridge that works with it. I have used the Generic Z-Wave Lock driver and it does not include anything for DoorSense. The source code for that driver is not available so I did a search and found https://raw.githubusercontent.com/hansandersson/hubitat/master/yale-assure-z-wave-lock.groovy source code. This driver worked OK except for lock codes which does not concern me at this time. I have never written a driver so I thought modifying this one would be fun to try. I have added code to the driver and it functions in my custom app when I subscribe to my new attribute DoorSense. Now my question is that if you look at the inline code I added to the routine "zwaveEvent(hubitat.zwave.Command cmd)" at line 962 to provide DoorSense I am VERY sure that this code should be in a separate new zwaveEvent() routine. I could not figure out how to do that and would love for someone to tell me the proper way I should include this functionality. I really appreciate the help.
My modified driver follows:
My Driver
/**
- Z-Wave Lock
- Copyright 2015 SmartThings
- Derivative Work Copyright 2019 Hans Andersson
- Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- in compliance with the License. You may obtain a copy of the License at:
http://www.apache.org/licenses/LICENSE-2.0- Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- for the specific language governing permissions and limitations under the License.
*/
metadata {
definition (name: "Yale Assure Z-Wave Lock", namespace: "handersson86", author: "Hans Andersson") {
capability "Actuator"
capability "Lock"
capability "Polling"
capability "Refresh"
capability "Sensor"
capability "Lock Codes"
capability "Battery"
capability "Health Check"
capability "Configuration"fingerprint mfr:"0129", prod:"8002", model:"0600", deviceJoinName: "Yale Assure Lock" //YRD416, YRD426, YRD446 fingerprint mfr:"0129", prod:"8004", model:"0600", deviceJoinName: "Yale Assure Lock Push Button Deadbolt" //YRD216 fingerprint mfr:"0129", prod:"800B", model:"0F00", deviceJoinName: "Yale Assure Keypad Lever Door Lock" // YRL216-ZW2 fingerprint mfr:"0129", prod:"800C", model:"0F00", deviceJoinName: "Yale Assure Touchscreen Lever Door Lock" // YRL226-ZW2 fingerprint mfr:"0129", prod:"8002", model:"1000", deviceJoinName: "Yale Assure Lock" //YRD-ZWM-1}
}import hubitat.zwave.commands.doorlockv1.*
import hubitat.zwave.commands.usercodev1.*/**
- Called on app installed
*/
def installed() {
// Device-Watch pings if no device events received for 1 hour (checkInterval)
sendEvent(name: "checkInterval", value: 1 * 60 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID, offlinePingable: "1"])
scheduleInstalledCheck()
}/**
- Verify that we have actually received the lock's initial states.
- If not, verify that we have at least requested them or request them,
- and check again.
*/
def scheduleInstalledCheck() {
runIn(120, installedCheck)
}def installedCheck() {
if (device.currentState("lock") && device.currentState("battery")) {
unschedule("installedCheck")
} else {
// We might have called updated() or configure() at some point but not have received a reply, so don't flood the network
if (!state.lastLockDetailsQuery || secondsPast(state.lastLockDetailsQuery, 2 * 60)) {
def actions = updated()if (actions) { sendHubCommand(actions.toHubAction()) } } scheduleInstalledCheck()}
}/**
- Called on app uninstalled
*/
def uninstalled() {
def deviceName = device.displayName
log.trace "[DTH] Executing 'uninstalled()' for device $deviceName"
sendEvent(name: "lockRemoved", value: device.id, isStateChange: true, displayed: false)
}/**
- Executed when the user taps on the 'Done' button on the device settings screen. Sends the values to lock.
- @return hubAction: The commands to be executed
*/
def updated() {
// Device-Watch pings if no device events received for 1 hour (checkInterval)
sendEvent(name: "checkInterval", value: 1 * 60 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID, offlinePingable: "1"])def hubAction = null
try {
def cmds =
if (!device.currentState("lock") || !device.currentState("battery") || !state.configured) {
log.debug "Returning commands for lock operation get and battery get"
if (!state.configured) {
cmds << doConfigure()
}
cmds << refresh()
cmds << reloadAllCodes()
if (!state.MSR) {
cmds << zwave.manufacturerSpecificV1.manufacturerSpecificGet().format()
}
if (!state.fw) {
cmds << zwave.versionV1.versionGet().format()
}
hubAction = response(delayBetween(cmds, 30*1000))
}
} catch (e) {
log.warn "updated() threw $e"
}
hubAction
}/**
- Configures the device to settings needed by SmarthThings at device discovery time
*/
def configure() {
log.trace "[DTH] Executing 'configure()' for device ${device.displayName}"
def cmds = doConfigure()
log.debug "Configure returning with commands := $cmds"
cmds
}/**
- Returns the list of commands to be executed when the device is being configured/paired
/
def doConfigure() {
log.trace "[DTH] Executing 'doConfigure()' for device ${device.displayName}"
state.configured = true
def cmds = []
cmds << secure(zwave.doorLockV1.doorLockOperationGet())
cmds << secure(zwave.batteryV1.batteryGet())
cmds = delayBetween(cmds, 301000)state.lastLockDetailsQuery = now()
log.debug "Do configure returning with commands := $cmds"
cmds
}/**
- Responsible for parsing incoming device messages to generate events
- @param description: The incoming description from the device
- @return result: The list of events to be sent out
*/
def parse(String description) {
log.trace "[DTH] Executing 'parse(String description)' for device ${device.displayName} with description = $description"def result = null
if (description.startsWith("Err")) {
if (state.sec) {
result = createEvent(descriptionText:description, isStateChange:true, displayed:false)
} else {
result = createEvent(
descriptionText: "This lock failed to complete the network security key exchange. If you are unable to control it via SmartThings, you must remove it from your network and add it again.",
eventType: "ALERT",
name: "secureInclusion",
value: "failed",
displayed: true,
)
}
} else {
def cmd = zwave.parse(description, [ 0x98: 1, 0x62: 1, 0x63: 1, 0x71: 2, 0x72: 2, 0x80: 1, 0x85: 2, 0x86: 1 ])
if (cmd) {
result = zwaveEvent(cmd)
}
}
log.info "[DTH] parse() - returning result=$result"
result
}/**
- Responsible for parsing ConfigurationReport command
- @param cmd: The ConfigurationReport command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.configurationv2.ConfigurationReport cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.configurationv2.ConfigurationReport cmd)' with cmd = $cmd"
return null
}/**
- Responsible for parsing SecurityMessageEncapsulation command
- @param cmd: The SecurityMessageEncapsulation command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.securityv1.SecurityMessageEncapsulation)' with cmd = $cmd"
def encapsulatedCommand = cmd.encapsulatedCommand([0x62: 1, 0x71: 2, 0x80: 1, 0x85: 2, 0x63: 1, 0x98: 1, 0x86: 1])
if (encapsulatedCommand) {
zwaveEvent(encapsulatedCommand)
}
}/**
- Responsible for parsing NetworkKeyVerify command
- @param cmd: The NetworkKeyVerify command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.securityv1.NetworkKeyVerify cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.securityv1.NetworkKeyVerify)' with cmd = $cmd"
createEvent(name:"secureInclusion", value:"success", descriptionText:"Secure inclusion was successful", isStateChange: true)
}/**
- Responsible for parsing SecurityCommandsSupportedReport command
- @param cmd: The SecurityCommandsSupportedReport command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.securityv1.SecurityCommandsSupportedReport cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.securityv1.SecurityCommandsSupportedReport)' with cmd = $cmd"
state.sec = cmd.commandClassSupport.collect { String.format("%02X ", it) }.join()
if (cmd.commandClassControl) {
state.secCon = cmd.commandClassControl.collect { String.format("%02X ", it) }.join()
}
createEvent(name:"secureInclusion", value:"success", descriptionText:"Lock is securely included", isStateChange: true)
}/**
- Responsible for parsing DoorLockOperationReport command
- @param cmd: The DoorLockOperationReport command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(DoorLockOperationReport cmd) {
log.trace "[DTH] Executing 'zwaveEvent(DoorLockOperationReport)' with cmd = $cmd"
def result =unschedule("followupStateCheck")
unschedule("stateCheck")// DoorLockOperationReport is called when trying to read the lock state or when the lock is locked/unlocked from the DTH or the smart app
def map = [ name: "lock" ]
map.data = [ lockName: device.displayName ]
if (cmd.doorLockMode == 0xFF) {
map.value = "locked"
map.descriptionText = "Locked"
} else if (cmd.doorLockMode >= 0x40) {
map.value = "unknown"
map.descriptionText = "Unknown state"
} else if (cmd.doorLockMode == 0x01) {
map.value = "unlocked with timeout"
map.descriptionText = "Unlocked with timeout"
} else {
map.value = "unlocked"
map.descriptionText = "Unlocked"
if (state.assoc != zwaveHubNodeId) {
result << response(secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId)))
result << response(zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId))
result << response(secure(zwave.associationV1.associationGet(groupingIdentifier:1)))
}
}
return result ? [createEvent(map), *result] : createEvent(map)
}def delayLockEvent(data) {
log.debug "Sending cached lock operation: $data.map"
sendEvent(data.map)
}/**
- Responsible for parsing AlarmReport command
- @param cmd: The AlarmReport command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.alarmv2.AlarmReport cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.alarmv2.AlarmReport)' with cmd = $cmd"
def result =if (cmd.zwaveAlarmType == 6) {
result = handleAccessAlarmReport(cmd)
} else if (cmd.zwaveAlarmType == 7) {
result = handleBurglarAlarmReport(cmd)
} else if(cmd.zwaveAlarmType == 8) {
result = handleBatteryAlarmReport(cmd)
} else {
result = handleAlarmReportUsingAlarmType(cmd)
}result = result ?: null
log.debug "[DTH] zwaveEvent(hubitat.zwave.commands.alarmv2.AlarmReport) returning with result = $result"
result
}/**
- Responsible for handling Access AlarmReport command
- @param cmd: The AlarmReport command to be parsed
- @return The event(s) to be sent out
*/
private def handleAccessAlarmReport(cmd) {
log.trace "[DTH] Executing 'handleAccessAlarmReport' with cmd = $cmd"
def result =
def map = null
def codeID, changeType, lockCodes, codeName
def deviceName = device.displayName
lockCodes = loadLockCodes()
if (1 <= cmd.zwaveAlarmEvent && cmd.zwaveAlarmEvent < 10) {
map = [ name: "lock", value: (cmd.zwaveAlarmEvent & 1) ? "locked" : "unlocked" ]
}
switch(cmd.zwaveAlarmEvent) {
case 1: // Manually locked
map.descriptionText = "Locked manually"
map.data = [ method: (cmd.alarmLevel == 2) ? "keypad" : "manual" ]
break
case 2: // Manually unlocked
map.descriptionText = "Unlocked manually"
map.data = [ method: "manual" ]
break
case 3: // Locked by command
map.descriptionText = "Locked"
map.data = [ method: "command" ]
break
case 4: // Unlocked by command
map.descriptionText = "Unlocked"
map.data = [ method: "command" ]
break
case 5: // Locked with keypad
if (cmd.eventParameter || cmd.alarmLevel) {
codeID = readCodeSlotId(cmd)
codeName = getCodeName(lockCodes, codeID)
map.descriptionText = "Locked by "$codeName""
map.data = [ codeId: codeID as String, usedCode: codeID, codeName: codeName, method: "keypad" ]
} else {
map.descriptionText = "Locked manually"
map.data = [ method: "keypad" ]
}
break
case 6: // Unlocked with keypad
if (cmd.eventParameter || cmd.alarmLevel) {
codeID = readCodeSlotId(cmd)
codeName = getCodeName(lockCodes, codeID)
map.descriptionText = "Unlocked by "$codeName""
map.data = [ codeId: codeID as String, usedCode: codeID, codeName: codeName, method: "keypad" ]
}
break
case 7:
map = [ name: "lock", value: "unknown", descriptionText: "Unknown state" ]
map.data = [ method: "manual" ]
break
case 8:
map = [ name: "lock", value: "unknown", descriptionText: "Unknown state" ]
map.data = [ method: "command" ]
break
case 9: // Auto locked
map = [ name: "lock", value: "locked", data: [ method: "auto" ] ]
map.descriptionText = "Auto locked"
break
case 0xA:
map = [ name: "lock", value: "unknown", descriptionText: "Unknown state" ]
map.data = [ method: "auto" ]
break
case 0xB:
map = [ name: "lock", value: "unknown", descriptionText: "Unknown state" ]
break
case 0xC: // All user codes deleted
result = allCodesDeletedEvent()
map = [ name: "codeChanged", value: "all deleted", descriptionText: "Deleted all user codes", isStateChange: true ]
map.data = [notify: true, notificationText: "Deleted all user codes in $deviceName at ${location.name}"]
result << createEvent(name: "lockCodes", value: (new groovy.json.JsonOutput()).toJson([:]), displayed: false, descriptionText: "'lockCodes' attribute updated")
break
case 0xD: // User code deleted
if (cmd.eventParameter || cmd.alarmLevel) {
codeID = readCodeSlotId(cmd)
if (lockCodes[codeID.toString()]) {
codeName = getCodeName(lockCodes, codeID)
map = [ name: "codeChanged", value: "$codeID deleted", isStateChange: true ]
map.descriptionText = "Deleted "$codeName""
map.data = [ codeName: codeName, notify: true, notificationText: "Deleted "$codeName" in $deviceName at ${location.name}" ]
result << codeDeletedEvent(lockCodes, codeID)
}
}
break
case 0xE: // Master or user code changed/set
if (cmd.eventParameter || cmd.alarmLevel) {
codeID = readCodeSlotId(cmd)
codeName = getCodeNameFromState(lockCodes, codeID)
changeType = getChangeType(lockCodes, codeID)
map = [ name: "codeChanged", value: "$codeID $changeType", descriptionText: "${getStatusForDescription(changeType)} "$codeName"", isStateChange: true ]
map.data = [ codeName: codeName, notify: true, notificationText: "${getStatusForDescription(changeType)} "$codeName" in $deviceName at ${location.name}" ]
if(!isMasterCode(codeID)) {
result << codeSetEvent(lockCodes, codeID, codeName)
} else {
map.descriptionText = "${getStatusForDescription('set')} "$codeName""
map.data.notificationText = "${getStatusForDescription('set')} "$codeName" in $deviceName at ${location.name}"
}
}
break
case 0xF: // Duplicate Pin-code error
if (cmd.eventParameter || cmd.alarmLevel) {
codeID = readCodeSlotId(cmd)
clearStateForSlot(codeID)
map = [ name: "codeChanged", value: "$codeID failed", descriptionText: "User code is duplicate and not added",
isStateChange: true, data: [isCodeDuplicate: true] ]
}
break
case 0x10: // Tamper Alarm
case 0x13:
map = [ name: "tamper", value: "detected", descriptionText: "Keypad attempts exceed code entry limit", isStateChange: true, displayed: true ]
break
case 0x11: // Keypad busy
map = [ descriptionText: "Keypad is busy" ]
break
case 0x12: // Master code changed
codeName = getCodeNameFromState(lockCodes, 0)
map = [ name: "codeChanged", value: "0 set", descriptionText: "${getStatusForDescription('set')} "$codeName"", isStateChange: true ]
map.data = [ codeName: codeName, notify: true, notificationText: "${getStatusForDescription('set')} "$codeName" in $deviceName at ${location.name}" ]
break
case 0xFE:
// delegating it to handleAlarmReportUsingAlarmType
return handleAlarmReportUsingAlarmType(cmd)
default:
// delegating it to handleAlarmReportUsingAlarmType
return handleAlarmReportUsingAlarmType(cmd)
}if (map) {
if (map.data) {
map.data.lockName = deviceName
} else {
map.data = [ lockName: deviceName ]
}
result << createEvent(map)
}
result = result.flatten()
result
}/**
- Responsible for handling Burglar AlarmReport command
- @param cmd: The AlarmReport command to be parsed
- @return The event(s) to be sent out
*/
private def handleBurglarAlarmReport(cmd) {
log.trace "[DTH] Executing 'handleBurglarAlarmReport' with cmd = $cmd"
def result =
def deviceName = device.displayNamedef map = [ name: "tamper", value: "detected" ]
map.data = [ lockName: deviceName ]
switch (cmd.zwaveAlarmEvent) {
case 0:
map.value = "clear"
map.descriptionText = "Tamper alert cleared"
break
case 1:
case 2:
map.descriptionText = "Intrusion attempt detected"
break
case 3:
map.descriptionText = "Covering removed"
break
case 4:
map.descriptionText = "Invalid code"
break
default:
// delegating it to handleAlarmReportUsingAlarmType
return handleAlarmReportUsingAlarmType(cmd)
}result << createEvent(map)
result
}/**
- Responsible for handling Battery AlarmReport command
- @param cmd: The AlarmReport command to be parsed
- @return The event(s) to be sent out
*/
private def handleBatteryAlarmReport(cmd) {
log.trace "[DTH] Executing 'handleBatteryAlarmReport' with cmd = $cmd"
def result =
def deviceName = device.displayName
def map = null
switch(cmd.zwaveAlarmEvent) {
case 0x01: //power has been applied, check if the battery level updated
result << response(secure(zwave.batteryV1.batteryGet()))
break;
case 0x0A:
map = [ name: "battery", value: 1, descriptionText: "Battery level critical", displayed: true, data: [ lockName: deviceName ] ]
break
case 0x0B:
map = [ name: "battery", value: 0, descriptionText: "Battery too low to operate lock", isStateChange: true, displayed: true, data: [ lockName: deviceName ] ]
break
default:
// delegating it to handleAlarmReportUsingAlarmType
return handleAlarmReportUsingAlarmType(cmd)
}
result << createEvent(map)
result
}/**
- Responsible for handling AlarmReport commands which are ignored by Access & Burglar handlers
- @param cmd: The AlarmReport command to be parsed
- @return The event(s) to be sent out
/
private def handleAlarmReportUsingAlarmType(cmd) {
log.trace "[DTH] Executing 'handleAlarmReportUsingAlarmType' with cmd = $cmd"
def result = []
def map = null
def codeID, lockCodes, codeName
def deviceName = device.displayName
lockCodes = loadLockCodes()
switch(cmd.alarmType) {
case 9:
case 17:
map = [ name: "lock", value: "unknown", descriptionText: "Unknown state" ]
break
case 16: // Note: for levers this means it's unlocked, for non-motorized deadbolt, it's just unsecured and might not get unlocked
case 19: // Unlocked with keypad
map = [ name: "lock", value: "unlocked" ]
if (cmd.alarmLevel != null) {
codeID = readCodeSlotId(cmd)
codeName = getCodeName(lockCodes, codeID)
map.isStateChange = true // Non motorized locks, mark state changed since it can be unlocked multiple times
map.descriptionText = "Unlocked by "$codeName""
map.data = [ codeId: codeID as String, usedCode: codeID, codeName: codeName, method: "keypad" ]
}
break
case 18: // Locked with keypad
codeID = readCodeSlotId(cmd)
map = [ name: "lock", value: "locked" ]
codeName = getCodeName(lockCodes, codeID)
map.descriptionText = "Locked by "$codeName""
map.data = [ codeId: codeID as String, usedCode: codeID, codeName: codeName, method: "keypad" ]
break
case 21: // Manually locked
map = [ name: "lock", value: "locked", data: [ method: (cmd.alarmLevel == 2) ? "keypad" : "manual" ] ]
map.descriptionText = "Locked manually"
break
case 22: // Manually unlocked
map = [ name: "lock", value: "unlocked", data: [ method: "manual" ] ]
map.descriptionText = "Unlocked manually"
break
case 23:
map = [ name: "lock", value: "unknown", descriptionText: "Unknown state" ]
map.data = [ method: "command" ]
break
case 24: // Locked by command
map = [ name: "lock", value: "locked", data: [ method: "command" ] ]
map.descriptionText = "Locked"
break
case 25: // Unlocked by command
map = [ name: "lock", value: "unlocked", data: [ method: "command" ] ]
map.descriptionText = "Unlocked"
break
case 26:
map = [ name: "lock", value: "unknown", descriptionText: "Unknown state" ]
map.data = [ method: "auto" ]
break
case 27: // Auto locked
map = [ name: "lock", value: "locked", data: [ method: "auto" ] ]
map.descriptionText = "Auto locked"
break
case 32: // All user codes deleted
result = allCodesDeletedEvent()
map = [ name: "codeChanged", value: "all deleted", descriptionText: "Deleted all user codes", isStateChange: true ]
map.data = [notify: true, notificationText: "Deleted all user codes in $deviceName at ${location.name}"]
result << createEvent(name: "lockCodes", value: (new groovy.json.JsonOutput()).toJson([:]), displayed: false, descriptionText: "'lockCodes' attribute updated")
break
case 33: // User code deleted
codeID = readCodeSlotId(cmd)
if (lockCodes[codeID.toString()]) {
codeName = getCodeName(lockCodes, codeID)
map = [ name: "codeChanged", value: "$codeID deleted", isStateChange: true ]
map.descriptionText = "Deleted "$codeName""
map.data = [ codeName: codeName, notify: true, notificationText: "Deleted "$codeName" in $deviceName at ${location.name}" ]
result << codeDeletedEvent(lockCodes, codeID)
}
break
case 38: // Non Access
map = [ descriptionText: "A Non Access Code was entered at the lock", isStateChange: true ]
break
case 13:
case 112: // Master or user code changed/set
codeID = readCodeSlotId(cmd)
codeName = getCodeNameFromState(lockCodes, codeID)
def changeType = getChangeType(lockCodes, codeID)
map = [ name: "codeChanged", value: "$codeID $changeType", descriptionText:
"${getStatusForDescription(changeType)} "$codeName"", isStateChange: true ]
map.data = [ codeName: codeName, notify: true, notificationText: "${getStatusForDescription(changeType)} "$codeName" in $deviceName at ${location.name}" ]
if(!isMasterCode(codeID)) {
result << codeSetEvent(lockCodes, codeID, codeName)
} else {
map.descriptionText = "${getStatusForDescription('set')} "$codeName""
map.data.notificationText = "${getStatusForDescription('set')} "$codeName" in $deviceName at ${location.name}"
}
break
case 34:
case 113: // Duplicate Pin-code error
codeID = readCodeSlotId(cmd)
clearStateForSlot(codeID)
map = [ name: "codeChanged", value: "$codeID failed", descriptionText: "User code is duplicate and not added",
isStateChange: true, data: [isCodeDuplicate: true] ]
break
case 130: // Batteries replaced
map = [ descriptionText: "Batteries replaced", isStateChange: true ]
break
case 131: // Disabled user entered at keypad
map = [ descriptionText: "Code ${cmd.alarmLevel} is disabled", isStateChange: false ]
break
case 161: // Tamper Alarm
if (cmd.alarmLevel == 2) {
map = [ name: "tamper", value: "detected", descriptionText: "Front escutcheon removed", isStateChange: true ]
} else {
map = [ name: "tamper", value: "detected", descriptionText: "Keypad attempts exceed code entry limit", isStateChange: true, displayed: true ]
}
break
case 167: // Low Battery Alarm
if (!state.lastbatt || now() - state.lastbatt > 1260601000) {
map = [ descriptionText: "Battery low", isStateChange: true ]
result << response(secure(zwave.batteryV1.batteryGet()))
} else {
map = [ name: "battery", value: device.currentValue("battery"), descriptionText: "Battery low", isStateChange: true ]
}
break
case 168: // Critical Battery Alarms
map = [ name: "battery", value: 1, descriptionText: "Battery level critical", displayed: true ]
break
case 169: // Battery too low to operate
map = [ name: "battery", value: 0, descriptionText: "Battery too low to operate lock", isStateChange: true, displayed: true ]
break
default:
map = [ displayed: false, descriptionText: "Alarm event ${cmd.alarmType} level ${cmd.alarmLevel}" ]
break
}if (map) {
if (map.data) {
map.data.lockName = deviceName
} else {
map.data = [ lockName: deviceName ]
}
result << createEvent(map)
}
result = result.flatten()
result
}/**
- Responsible for parsing UserCodeReport command
- @param cmd: The UserCodeReport command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(UserCodeReport cmd) {
log.trace "[DTH] Executing 'zwaveEvent(UserCodeReport)' with userIdentifier: ${cmd.userIdentifier} and status: ${cmd.userIdStatus}"
def result =
// cmd.userIdentifier seems to be an int primitive type
def codeID = cmd.userIdentifier.toString()
def lockCodes = loadLockCodes()
def map = [ name: "codeChanged", isStateChange: true ]
def deviceName = device.displayName
def userIdStatus = cmd.userIdStatusif (userIdStatus == UserCodeReport.USER_ID_STATUS_OCCUPIED ||
(userIdStatus == UserCodeReport.USER_ID_STATUS_STATUS_NOT_AVAILABLE && cmd.user)) {def codeName = getCodeName(lockCodes, codeID) def changeType = getChangeType(lockCodes, codeID) if (!lockCodes[codeID]) { result << codeSetEvent(lockCodes, codeID, codeName) } else { map.displayed = false } map.value = "$codeID $changeType" map.descriptionText = "${getStatusForDescription(changeType)} \"$codeName\"" map.data = [ codeName: codeName, lockName: deviceName ]} else {
// We are using userIdStatus here because codeID = 0 is reported when user tries to set programming code as the user code
// code is not set
if (lockCodes[codeID]) {
def codeName = getCodeName(lockCodes, codeID)
map.value = "$codeID deleted"
map.descriptionText = "Deleted "$codeName""
map.data = [ codeName: codeName, lockName: deviceName, notify: true, notificationText: "Deleted "$codeName" in $deviceName at ${location.name}" ]
result << codeDeletedEvent(lockCodes, codeID)
} else {
map.value = "$codeID unset"
map.displayed = false
map.data = [ lockName: deviceName ]
}
}clearStateForSlot(codeID)
result << createEvent(map)if (codeID.toInteger() == state.checkCode) { // reloadAllCodes() was called, keep requesting the codes in order
if (state.checkCode + 1 > state.codes || state.checkCode >= 8) {
state.remove("checkCode") // done
state["checkCode"] = null
sendEvent(name: "scanCodes", value: "Complete", descriptionText: "Code scan completed", displayed: false)
} else {
state.checkCode = state.checkCode + 1 // get next
result << response(requestCode(state.checkCode))
}
}
if (codeID.toInteger() == state.pollCode) {
if (state.pollCode + 1 > state.codes || state.pollCode >= 15) {
state.remove("pollCode") // done
state["pollCode"] = null
} else {
state.pollCode = state.pollCode + 1
}
}result = result.flatten()
result
}/**
- Responsible for parsing UsersNumberReport command
- @param cmd: The UsersNumberReport command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(UsersNumberReport cmd) {
log.trace "[DTH] Executing 'zwaveEvent(UsersNumberReport)' with cmd = $cmd"
def result = [createEvent(name: "maxCodes", value: cmd.supportedUsers, displayed: false)]
state.codes = cmd.supportedUsers
if (state.checkCode) {
if (state.checkCode <= cmd.supportedUsers) {
result << response(requestCode(state.checkCode))
} else {
state.remove("checkCode")
state["checkCode"] = null
}
}
result
}/**
- Responsible for parsing AssociationReport command
- @param cmd: The AssociationReport command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.associationv2.AssociationReport cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.associationv2.AssociationReport)' with cmd = $cmd"
def result =
if (cmd.nodeId.any { it == zwaveHubNodeId }) {
state.remove("associationQuery")
state["associationQuery"] = null
result << createEvent(descriptionText: "Is associated")
state.assoc = zwaveHubNodeId
if (cmd.groupingIdentifier == 2) {
result << response(zwave.associationV1.associationRemove(groupingIdentifier:1, nodeId:zwaveHubNodeId))
}
} else if (cmd.groupingIdentifier == 1) {
result << response(secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId)))
} else if (cmd.groupingIdentifier == 2) {
result << response(zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId))
}
result
}/**
- Responsible for parsing TimeGet command
- @param cmd: The TimeGet command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.timev1.TimeGet cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.timev1.TimeGet)' with cmd = $cmd"
def result =
def now = new Date().toCalendar()
if(location.timeZone) now.timeZone = location.timeZone
result << createEvent(descriptionText: "Requested time update", displayed: false)
result << response(secure(zwave.timeV1.timeReport(
hourLocalTime: now.get(Calendar.HOUR_OF_DAY),
minuteLocalTime: now.get(Calendar.MINUTE),
secondLocalTime: now.get(Calendar.SECOND)))
)
result
}/**
- Responsible for parsing BasicSet command
- @param cmd: The BasicSet command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.basicv1.BasicSet cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.basicv1.BasicSet)' with cmd = $cmd"
// DEPRECATED: The old Schlage locks use group 1 for basic control - we don't want that, so unsubscribe from group 1
def result = [ createEvent(name: "lock", value: cmd.value ? "unlocked" : "locked") ]
def cmds = [
zwave.associationV1.associationRemove(groupingIdentifier:1, nodeId:zwaveHubNodeId).format(),
"delay 1200",
zwave.associationV1.associationGet(groupingIdentifier:2).format()
]
[result, response(cmds)]
}/**
- Responsible for parsing BatteryReport command
- @param cmd: The BatteryReport command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.batteryv1.BatteryReport cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.batteryv1.BatteryReport)' with cmd = $cmd"
def map = [ name: "battery", unit: "%" ]
if (cmd.batteryLevel == 0xFF) {
map.value = 1
map.descriptionText = "Has a low battery"
} else {
map.value = cmd.batteryLevel
map.descriptionText = "Battery is at ${cmd.batteryLevel}%"
}
state.lastbatt = now()
createEvent(map)
}/**
- Responsible for parsing ManufacturerSpecificReport command
- @param cmd: The ManufacturerSpecificReport command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport)' with cmd = $cmd"
def result =
def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
updateDataValue("MSR", msr)
result << createEvent(descriptionText: "MSR: $msr", isStateChange: false)
result
}/**
- Responsible for parsing VersionReport command
- @param cmd: The VersionReport command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.versionv1.VersionReport cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.versionv1.VersionReport)' with cmd = $cmd"
def fw = "${cmd.applicationVersion}.${cmd.applicationSubVersion}"
updateDataValue("fw", fw)
if (getDataValue("MSR") == "003B-6341-5044") {
updateDataValue("ver", "${cmd.applicationVersion >> 4}.${cmd.applicationVersion & 0xF}")
}
def text = "${device.displayName}: firmware version: $fw, Z-Wave version: ${cmd.zWaveProtocolVersion}.${cmd.zWaveProtocolSubVersion}"
createEvent(descriptionText: text, isStateChange: false)
}/**
- Responsible for parsing ApplicationBusy command
- @param cmd: The ApplicationBusy command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.applicationstatusv1.ApplicationBusy cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.applicationstatusv1.ApplicationBusy)' with cmd = $cmd"
def msg = cmd.status == 0 ? "try again later" :
cmd.status == 1 ? "try again in ${cmd.waitTime} seconds" :
cmd.status == 2 ? "request queued" : "sorry"
createEvent(displayed: true, descriptionText: "Is busy, $msg")
}/**
- Responsible for parsing ApplicationRejectedRequest command
- @param cmd: The ApplicationRejectedRequest command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.commands.applicationstatusv1.ApplicationRejectedRequest cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.commands.applicationstatusv1.ApplicationRejectedRequest)' with cmd = $cmd"
createEvent(displayed: true, descriptionText: "Rejected the last request")
}def GetMap(String str) {
// Finding string length int n = str.length(); // Last character of a string char last = str.charAt(n - 1); //The last character is sometimes missing?! if (last != ')') { str = str + ')' } def ReturnedString = str.replaceFirst("\\(", "\\[") ReturnedString = ReturnedString.replaceFirst("\\)", "\\]") def index = ReturnedString.indexOf("[") ReturnedString = ReturnedString.substring(index) ReturnedMap = evaluate(ReturnedString) return(ReturnedMap)}
/**
- Responsible for parsing zwave command
- @param cmd: The zwave command to be parsed
- @return The event(s) to be sent out
*/
def zwaveEvent(hubitat.zwave.Command cmd) {
log.trace "[DTH] Executing 'zwaveEvent(hubitat.zwave.Command)' with cmd = $cmd"def cmdMap = GetMap(cmd.toString())// log.debug "*** cmdMap *** = " + cmdMap
def encapsulatedCmd = cmd.encapsulatedCommand(commandClassVersions)// log.debug "*** encapsulatedCmd *** = " + encapsulatedCmd
def Map = GetMap(encapsulatedCmd.toString())// log.debug "*** encapsulatedMap *** = " + Map
// is this a NotificationReport if (encapsulatedCmd.toString().indexOf("NotificationReport") == 0) { log.trace "got NotificationReport" // is this v1AlarmType = 0x2b (DoorState/DoorSense) if (Map.v1AlarmType == 43) { // what is the state of DoorSense log.trace "got v1AlarmType = 43" switch (Map.v1AlarmLevel) { case 0: // Door is open log.trace "got v1AlarmLevel = 0 (Door Open)" sendEvent(name: "DoorSense", value: "open", isStateChange: true) break; case 1: // Door is closed log.trace "got v1AlarmLevel = 1 (Door Closed)" sendEvent(name: "DoorSense", value: "closed", isStateChange: true) break; case 2: // Door Propped (door open for longer than configurable door propped open) log.trace "got v1AlarmLevel = 2 (Door Propped)" sendEvent(name: "DoorSense", value: "Propped", isStateChange: true) break; default: log.trace "NotificationReport Error (Received non supported v1AlarmLevel from lock)" break; } } } createEvent(displayed: false, descriptionText: "$cmd")}
/**
- Executes lock and then check command with a delay on a lock
*/
def lockAndCheck(doorLockMode) {
secureSequence([
zwave.doorLockV1.doorLockOperationSet(doorLockMode: doorLockMode),
zwave.doorLockV1.doorLockOperationGet()
], 4200)
}/**
- Executes lock command on a lock
*/
def lock() {
log.trace "[DTH] Executing lock() for device ${device.displayName}"
lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_SECURED)
}/**
- Executes unlock command on a lock
*/
def unlock() {
log.trace "[DTH] Executing unlock() for device ${device.displayName}"
lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_UNSECURED)
}/**
- Executes unlock with timeout command on a lock
*/
def unlockWithTimeout() {
log.trace "[DTH] Executing unlockWithTimeout() for device ${device.displayName}"
lockAndCheck(DoorLockOperationSet.DOOR_LOCK_MODE_DOOR_UNSECURED_WITH_TIMEOUT)
}/**
- PING is used by Device-Watch in attempt to reach the Device
*/
def ping() {
log.trace "[DTH] Executing ping() for device ${device.displayName}"
runIn(30, followupStateCheck)
secure(zwave.doorLockV1.doorLockOperationGet())
}/**
- Checks the door lock state. Also, schedules checking of door lock state every one hour.
*/
def followupStateCheck() {
runEvery1Hour(stateCheck)
stateCheck()
}/**
- Checks the door lock state
*/
def stateCheck() {
sendHubCommand(new hubitat.device.HubAction(secure(zwave.doorLockV1.doorLockOperationGet())))
}/**
- Called when the user taps on the refresh button
*/
def refresh() {
log.trace "[DTH] Executing refresh() for device ${device.displayName}"def cmds = secureSequence([zwave.doorLockV1.doorLockOperationGet(), zwave.batteryV1.batteryGet()])
if (!state.associationQuery) {
cmds << "delay 4200"
cmds << zwave.associationV1.associationGet(groupingIdentifier:2).format() // old Schlage locks use group 2 and don't secure the Association CC
cmds << secure(zwave.associationV1.associationGet(groupingIdentifier:1))
state.associationQuery = now()
} else if (now() - state.associationQuery.toLong() > 9000) {
cmds << "delay 6000"
cmds << zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId).format()
cmds << secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId))
cmds << zwave.associationV1.associationGet(groupingIdentifier:2).format()
cmds << secure(zwave.associationV1.associationGet(groupingIdentifier:1))
state.associationQuery = now()
}
state.lastLockDetailsQuery = now()cmds
}/**
- Called by the Smart Things platform in case Polling capability is added to the device type
/
def poll() {
log.trace "[DTH] Executing poll() for device ${device.displayName}"
def cmds = []
// Only check lock state if it changed recently or we haven't had an update in an hour
def latest = device.currentState("lock")?.date?.time
if (!latest || !secondsPast(latest, 6 * 60) || secondsPast(state.lastPoll, 55 * 60)) {
cmds << secure(zwave.doorLockV1.doorLockOperationGet())
state.lastPoll = now()
} else if (!state.lastbatt || now() - state.lastbatt > 5360601000) {
cmds << secure(zwave.batteryV1.batteryGet())
state.lastbatt = now() //inside-214
}
if (state.assoc != zwaveHubNodeId && secondsPast(state.associationQuery, 19 * 60)) {
cmds << zwave.associationV1.associationSet(groupingIdentifier:2, nodeId:zwaveHubNodeId).format()
cmds << secure(zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:zwaveHubNodeId))
cmds << zwave.associationV1.associationGet(groupingIdentifier:2).format()
cmds << "delay 6000"
cmds << secure(zwave.associationV1.associationGet(groupingIdentifier:1))
cmds << "delay 6000"
state.associationQuery = now()
} else {
// Only check lock state once per hour
if (secondsPast(state.lastPoll, 55 * 60)) {
cmds << secure(zwave.doorLockV1.doorLockOperationGet())
state.lastPoll = now()
} else if (!state.MSR) {
cmds << zwave.manufacturerSpecificV1.manufacturerSpecificGet().format()
} else if (!state.fw) {
cmds << zwave.versionV1.versionGet().format()
} else if (!device.currentValue("maxCodes")) {
state.pollCode = 1
cmds << secure(zwave.userCodeV1.usersNumberGet())
} else if (state.pollCode && state.pollCode <= state.codes) {
cmds << requestCode(state.pollCode)
} else if (!state.lastbatt || now() - state.lastbatt > 536060*1000) {
cmds << secure(zwave.batteryV1.batteryGet())
}
}if (cmds) {
log.debug "poll is sending ${cmds.inspect()}"
cmds
} else {
// workaround to keep polling from stopping due to lack of activity
sendEvent(descriptionText: "skipping poll", isStateChange: true, displayed: false)
null
}
}/**
- Returns the command for user code get
- @param codeID: The code slot number
- @return The command for user code get
*/
def requestCode(codeID) {
secure(zwave.userCodeV1.userCodeGet(userIdentifier: codeID))
}/**
- API endpoint for server smart app to populate the attributes. Called only when the attributes are not populated.
- @return The command(s) fired for reading attributes
*/
def reloadAllCodes() {
log.trace "[DTH] Executing 'reloadAllCodes()' by ${device.displayName}"
sendEvent(name: "scanCodes", value: "Scanning", descriptionText: "Code scan in progress", displayed: false)
def lockCodes = loadLockCodes()
sendEvent(lockCodesEvent(lockCodes))
state.checkCode = state.checkCode ?: 1def cmds =
// Not calling validateAttributes() here because userNumberGet command will be added twice
if (!state.codes) {
// BUG: There might be a bug where Schlage does not return the below number of codes
cmds << secure(zwave.userCodeV1.usersNumberGet())
} else {
sendEvent(name: "maxCodes", value: state.codes, displayed: false)
cmds << requestCode(state.checkCode)
}
if(cmds.size() > 1) {
cmds = delayBetween(cmds, 4200)
}
cmds
}def getCodes() {
return reloadAllCodes()
}/**
- API endpoint for setting the user code length on a lock. This is specific to Schlage locks.
- @param length: The user code length
- @returns The command fired for writing the code length attribute
*/
def setCodeLength(length) {
return null
}/**
- API endpoint for setting a user code on a lock
- @param codeID: The code slot number
- @param code: The code PIN
- @param codeName: The name of the code
- @returns cmds: The commands fired for creation and checking of a lock code
*/
def setCode(codeID, code, codeName = null) {
if (!code) {
log.trace "[DTH] Executing 'nameSlot()' by ${this.device.displayName}"
nameSlot(codeID, codeName)
return
}log.trace "[DTH] Executing 'setCode()' by ${this.device.displayName}"
def strcode = code
if (code instanceof String) {
code = code.toList().findResults { if(it > ' ' && it != ',' && it != '-') it.toCharacter() as Short }
} else {
strcode = code.collect{ it as Character }.join()
}def strname = (codeName ?: "Code $codeID")
state["setname$codeID"] = strnamedef cmds = validateAttributes()
cmds << secure(zwave.userCodeV1.userCodeSet(userIdentifier:codeID, userIdStatus:1, userCode:code))
if(cmds.size() > 1) {
cmds = delayBetween(cmds, 4200)
}
cmds
}/**
- Validates attributes and if attributes are not populated, adds the command maps to list of commands
- @return List of commands or empty list
*/
def validateAttributes() {
def cmds =
if(!device.currentValue("maxCodes")) {
cmds << secure(zwave.userCodeV1.usersNumberGet())
}
log.trace "validateAttributes returning commands list: " + cmds
cmds
}/**
- API endpoint for setting/deleting multiple user codes on a lock
- @param codeSettings: The map with code slot numbers and code pins (in case of update)
- @returns The commands fired for creation and deletion of lock codes
*/
def updateCodes(codeSettings) {
log.trace "[DTH] Executing updateCodes() for device ${device.displayName}"
if(codeSettings instanceof String) codeSettings = (new groovy.json.JsonOutput()).parseJson(codeSettings)
def set_cmds =
codeSettings.each { name, updated ->
if (name.startsWith("code")) {
def n = name[4..-1].toInteger()
if (updated && updated.size() >= 4 && updated.size() <= 8) {
log.debug "Setting code number $n"
set_cmds << secure(zwave.userCodeV1.userCodeSet(userIdentifier:n, userIdStatus:1, user:updated))
} else if (updated == null || updated == "" || updated == "0") {
log.debug "Deleting code number $n"
set_cmds << deleteCode(n)
}
} else log.warn("unexpected entry $name: $updated")
}
if (set_cmds) {
return response(delayBetween(set_cmds, 2200))
}
return null
}/**
- Renames an existing lock slot
- @param codeSlot: The code slot number
- @param codeName The new name of the code
*/
void nameSlot(codeSlot, codeName) {
codeSlot = codeSlot.toString()
if (!isCodeSet(codeSlot)) {
return
}
def deviceName = device.displayName
log.trace "[DTH] - Executing nameSlot() for device $deviceName"
def lockCodes = loadLockCodes()
def oldCodeName = getCodeName(lockCodes, codeSlot)
def newCodeName = codeName ?: "Code $codeSlot"
lockCodes[codeSlot] = newCodeName
sendEvent(lockCodesEvent(lockCodes))
sendEvent(name: "codeChanged", value: "$codeSlot renamed", data: [ lockName: deviceName, notify: false, notificationText: "Renamed "$oldCodeName" to "$newCodeName" in $deviceName at ${location.name}" ],
descriptionText: "Renamed "$oldCodeName" to "$newCodeName"", displayed: true, isStateChange: true)
}/**
- API endpoint for deleting a user code on a lock
- @param codeID: The code slot number
- @returns cmds: The command fired for deletion of a lock code
*/
def deleteCode(codeID) {
log.trace "[DTH] Executing 'deleteCode()' by ${this.device.displayName}"
// AlarmReport when a code is deleted manually on the lock
secureSequence([
zwave.userCodeV1.userCodeSet(userIdentifier:codeID, userIdStatus:0),
zwave.userCodeV1.userCodeGet(userIdentifier:codeID)
], 4200)
}/**
- Encapsulates a command
- @param cmd: The command to be encapsulated
- @returns ret: The encapsulated command
*/
private secure(hubitat.zwave.Command cmd) {
zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
}/**
- Encapsulates list of command and adds a delay
- @param commands: The list of command to be encapsulated
- @param delay: The delay between commands
- @returns The encapsulated commands
*/
private secureSequence(commands, delay=4200) {
delayBetween(commands.collect{ secure(it) }, delay)
}/**
- Checks if the time elapsed from the provided timestamp is greater than the number of senconds provided
- @param timestamp: The timestamp
- @param seconds: The number of seconds
- @returns true if elapsed time is greater than number of seconds provided, else false
*/
private Boolean secondsPast(timestamp, seconds) {
if (!(timestamp instanceof Number)) {
if (timestamp instanceof Date) {
timestamp = timestamp.time
} else if ((timestamp instanceof String) && timestamp.isNumber()) {
timestamp = timestamp.toLong()
} else {
return true
}
}
return (now() - timestamp) > (seconds * 1000)
}/**
- Reads the code name from the 'lockCodes' map
- @param lockCodes: map with lock code names
- @param codeID: The code slot number
- @returns The code name
*/
private String getCodeName(lockCodes, codeID) {
if (isMasterCode(codeID)) {
return "Master Code"
}
lockCodes[codeID.toString()] ?: "Code $codeID"
}/**
- Reads the code name from the device state
- @param lockCodes: map with lock code names
- @param codeID: The code slot number
- @returns The code name
*/
private String getCodeNameFromState(lockCodes, codeID) {
if (isMasterCode(codeID)) {
return "Master Code"
}
def nameFromLockCodes = lockCodes[codeID.toString()]
def nameFromState = state["setname$codeID"]
if(nameFromLockCodes) {
if(nameFromState) {
//Updated from smart app
return nameFromState
} else {
//Updated from lock
return nameFromLockCodes
}
} else if(nameFromState) {
//Set from smart app
return nameFromState
}
//Set from lock
return "Code $codeID"
}/**
- Check if a user code is present in the 'lockCodes' map
- @param codeID: The code slot number
- @returns true if code is present, else false
*/
private Boolean isCodeSet(codeID) {
// BUG: Needed to add loadLockCodes to resolve null pointer when using schlage?
def lockCodes = loadLockCodes()
lockCodes[codeID.toString()] ? true : false
}/**
- Reads the 'lockCodes' attribute and parses the same
- @returns Map: The lockCodes map
*/
private Map loadLockCodes() {
def stuff = device.currentValue("lockCodes")
log.debug(stuff)
// parseJson(device.currentValue("lockCodes") ?: "{}") ?: [:]
parseJson(stuff ?: "{}") ?: [:]
}/**
- Populates the 'lockCodes' attribute by calling create event
- @param lockCodes The user codes in a lock
*/
private Map lockCodesEvent(lockCodes) {
createEvent(name: "lockCodes", value: (new groovy.json.JsonOutput()).toJson(lockCodes), displayed: false,
descriptionText: "'lockCodes' attribute updated")
}/**
- Utility function to figure out if code id pertains to master code or not
- @param codeID - The slot number in which code is set
- @return - true if slot is for master code, false otherwise
*/
private boolean isMasterCode(codeID) {
if(codeID instanceof String) {
codeID = codeID.toInteger()
}
(codeID == 0) ? true : false
}/**
- Creates the event map for user code creation
- @param lockCodes: The user codes in a lock
- @param codeID: The code slot number
- @param codeName: The name of the user code
- @return The list of events to be sent out
*/
private def codeSetEvent(lockCodes, codeID, codeName) {
clearStateForSlot(codeID)
// codeID seems to be an int primitive type
lockCodes[codeID.toString()] = (codeName ?: "Code $codeID")
def result =
result << lockCodesEvent(lockCodes)
def codeReportMap = [ name: "codeReport", value: codeID, data: [ code: "" ], isStateChange: true, displayed: false ]
codeReportMap.descriptionText = "${device.displayName} code $codeID is set"
result << createEvent(codeReportMap)
result
}/**
- Creates the event map for user code deletion
- @param lockCodes: The user codes in a lock
- @param codeID: The code slot number
- @return The list of events to be sent out
*/
private def codeDeletedEvent(lockCodes, codeID) {
lockCodes.remove("$codeID".toString())
// not sure if the trigger has done this or not
clearStateForSlot(codeID)
def result =
result << lockCodesEvent(lockCodes)
def codeReportMap = [ name: "codeReport", value: codeID, data: [ code: "" ], isStateChange: true, displayed: false ]
codeReportMap.descriptionText = "${device.displayName} code $codeID was deleted"
result << createEvent(codeReportMap)
result
}/**
Creates the event map for all user code deletion
@return The List of events to be sent out
*/
private def allCodesDeletedEvent() {
def result =
def lockCodes = loadLockCodes()
def deviceName = device.displayName
lockCodes.each { id, code ->
result << createEvent(name: "codeReport", value: id, data: [ code: "" ], descriptionText: "code $id was deleted",
displayed: false, isStateChange: true)def codeName = code
result << createEvent(name: "codeChanged", value: "$id deleted", data: [ codeName: codeName, lockName: deviceName,
notify: true, notificationText: "Deleted "$codeName" in $deviceName at ${location.name}" ],
descriptionText: "Deleted "$codeName"",
displayed: true, isStateChange: true)
clearStateForSlot(id)
}
result
}/**
- Checks if a change type is set or update
- @param lockCodes: The user codes in a lock
- @param codeID The code slot number
- @return "set" or "update" basis the presence of the code id in the lockCodes map
*/
private def getChangeType(lockCodes, codeID) {
def changeType = "set"
if (lockCodes[codeID.toString()]) {
changeType = "changed"
}
changeType
}/**
- Method to obtain status for descriptuion based on change type
- @param changeType: Either "set" or "changed"
- @return "Added" for "set", "Updated" for "changed", "" otherwise
*/
private def getStatusForDescription(changeType) {
if("set" == changeType) {
return "Added"
} else if("changed" == changeType) {
return "Updated"
}
//Don't return null as it cause trouble
return ""
}/**
- Clears the code name and pin from the state basis the code slot number
- @param codeID: The code slot number
*/
def clearStateForSlot(codeID) {
state.remove("setname$codeID")
state["setname$codeID"] = null
}/**
- Generic function for reading code Slot ID from AlarmReport command
- @param cmd: The AlarmReport command
- @return user code slot id
*/
def readCodeSlotId(hubitat.zwave.commands.alarmv2.AlarmReport cmd) {
if(cmd.numberOfEventParameters == 1) {
return cmd.eventParameter[0]
} else if(cmd.numberOfEventParameters >= 3) {
return cmd.eventParameter[2]
}
return cmd.alarmLevel
}def logsOff(){
log.warn "debug logging disabled..."
}
Update 6 hours later:
When I open and close the door I do see in the device page under Current States the "DoorSense" properly showing open and closed. I also see when I manually or with the app lock and unlock the status is reported on the device page correctly. But, when I select lock and unlock from the device page is does not work. When I select lock on the device page I do see in the log "[DTH] Executing lock() for device Yale Assure 2 - Front Door" (from line 1025) but the lock does not respond and no error reported.
