/**
- on - Turns on the switch
- Required for the “Switch” capability
*/
def on() {
if (switchDisabled) {
logDebug “switch disabled, doing nothing”
delayBetween([
formatCommand(zwave.switchBinaryV1.switchBinaryGet())
], 200)
} else {
logDebug “switching it on”
delayBetween([
formatCommand(zwave.switchBinaryV1.switchBinarySet(switchValue: 0xFF)),
formatCommand(zwave.switchBinaryV1.switchBinaryGet())
], 200)
}
}
/**
- off - Turns off the switch
- Required for the “Switch” capability
*/
def off() {
if (switchDisabled) {
logDebug “switch disabled, doing nothing”
delayBetween([
formatCommand(zwave.switchBinaryV1.switchBinaryGet())
], 200)
} else {
logDebug “switching it off”
delayBetween([
formatCommand(zwave.switchBinaryV1.switchBinarySet(switchValue: 0x00)),
formatCommand(zwave.switchBinaryV1.switchBinaryGet())
], 200)
}
}
/**
-
poll - Polls the device
-
Required for the “Polling” capability
*/
def poll() {
logTrace “poll()”delayBetween([
formatCommand(zwave.switchBinaryV1.switchBinaryGet()),
formatCommand(zwave.meterV3.meterGet(scale: 0)), // energy kWh
formatCommand(zwave.meterV3.meterGet(scale: 1)), // energy kVAh
formatCommand(zwave.meterV3.meterGet(scale: 2)), // watts
formatCommand(zwave.meterV3.meterGet(scale: 4)), // volts
formatCommand(zwave.meterV3.meterGet(scale: 5)), // amps
], 200)
}
/**
-
refresh - Refreshed values from the device
-
Required for the “Refresh” capability
*/
def refresh() {
logInfo “refresh()”
updateDeviceInfo()sendEvent(name: “power”, value: “0”, displayed: true, unit: “W”)
sendEvent(name: “energy”, value: “0”, displayed: true, unit: “kWh”)
sendEvent(name: “amperage”, value: “0”, displayed: true, unit: “A”)
sendEvent(name: “voltage”, value: “0”, displayed: true, unit: “V”)sendEvent(name: “currentEnergyCostDay”, value: “0”, displayed: true)
sendEvent(name: “currentEnergyCostWeek”, value: “0”, displayed: true)
sendEvent(name: “currentEnergyCostMonth”, value: “0”, displayed: true)
sendEvent(name: “currentEnergyCostYear”, value: “0”, displayed: true)sendEvent(name: “cumulativeEnergyCostDay”, value: “0”, displayed: true)
sendEvent(name: “cumulativeEnergyCostWeek”, value: “0”, displayed: true)
sendEvent(name: “cumulativeEnergyCostMonth”, value: “0”, displayed: true)
sendEvent(name: “cumulativeEnergyCostYear”, value: “0”, displayed: true)delayBetween([
formatCommand(zwave.switchMultilevelV1.switchMultilevelGet()),
formatCommand(zwave.meterV3.meterGet(scale: 0)), // energy kWh
formatCommand(zwave.meterV3.meterGet(scale: 1)), // energy kVAh
formatCommand(zwave.meterV3.meterGet(scale: 2)), // watts
formatCommand(zwave.meterV3.meterGet(scale: 4)), // volts
formatCommand(zwave.meterV3.meterGet(scale: 5)), // amps
formatCommand(zwave.configurationV1.configurationGet(parameterNumber: 0x51)), // device state
formatCommand(zwave.configurationV1.configurationGet(parameterNumber: 0x53)), // night light RGB value
formatCommand(zwave.configurationV1.configurationGet(parameterNumber: 0x54)), // led brightness
], 200)
}
/**
- reset - Resets the devices energy usage meter and attempt to reset device
- Required for the “Switch Level” capability
*/
def setLevel(level) {
setBrightnessLevel(level)
}
/**
-
Sets the color to the passed in maps values
-
Required for the “Color Control” capability
*/
def setColor(colormap) {
logDebug " in setColor"if (colormap.hex == null && colormap.hue) {
def hexColor = colorUtil.hslToHex(colormap.hue, colormap.saturation)
logDebug " in setColor colormap = $hexColor"sendEvent(name: "color", value: hexColor) formatCommand(zwave.configurationV1.configurationSet(parameterNumber: 0x53, size: 3, configurationValue: colorUtil.hexToRgb(hexColor)))} else {
logDebug " in setColor: hex = ${colormap.hex}"
sendEvent(name: “color”, value: colormap.hex)
def hexColorList = colorUtil.hexToRgb(colormap.hex)
formatCommand(zwave.configurationV1.configurationSet(parameterNumber: 0x53, size: 3, configurationValue: [hexColorList[0], hexColorList[1], hexColorList[2]]))
}
}
/*******************************************************************************
- Methods *
******************************************************************************/
/**
-
installed - Called when the device handling is being installed
*/
def installed() {
logInfo “installed() called”if (state.deviceInfo == null) {
state.deviceInfo = [:]
state.deviceInfo[‘secureInclusion’] = false
}// Call a reset upon install to clear all values.
reset();updateDeviceInfo();
}
/**
-
updated - Called when the preferences of the device type are changed
*/
def updated() {
logInfo “updated()”updateStatus()
//updatePowerStatus(0)
response(configure())
}
/**
-
reset - Resets the devices energy usage meter and attempt to reset device
-
Defined by the custom command “reset”
*/
def reset() {
logInfo “reset()”
state.energyMeterRuntimeStart = now()def timeString = new Date().format(“MM-dd-yy h:mm a”, location.timeZone)
sendEvent(name: “resetDate”, value: "Since: "+timeString, unit: “”)delayBetween([
formatCommand(zwave.meterV3.meterReset()),
formatCommand(zwave.meterV3.meterGet(scale: 0)), // energy kWh
formatCommand(zwave.meterV3.meterGet(scale: 1)), // energy kVAh
formatCommand(zwave.meterV3.meterGet(scale: 2)), // watts
formatCommand(zwave.meterV3.meterGet(scale: 4)), // volts
formatCommand(zwave.meterV3.meterGet(scale: 5)), // amps
], 200)
}
def factoryReset() {
logDebug “factoryReset()”
formatCommand(zwave.configurationV1.configurationSet(parameterNumber: 0xFF, size: 4, scaledConfigurationValue: 1))
//factory reset
configure()
}
def getDeviceInfo() {
logDebug “getDeviceInfo()”
delayBetween([
formatCommand(zwave.versionV1.versionGet()),
formatCommand(zwave.firmwareUpdateMdV2.firmwareMdGet()),
//zwave.manufacturerSpecificV2.deviceSpecificGet().format(),
formatCommand(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
], 200)
}
private updateStatus() {
def sinceTime = ‘’
if (state.energyMeterRuntimeStart != null) {
sinceTime = “${getBatteryRuntime()}”
} else {
sinceTime = now()
}
sendEvent(name: "statusText3", value: "Elasped Time since Reset: $sinceTime", displayed: false)
}
private updateDeviceInfo() {
logInfo “updateDeviceInfo()”
if (state.deviceInfo == null) {
state.deviceInfo = [:]
}
def buffer = "Get Device Info";
def newBuffer = null;
def switchStatus = "SWITCH ENABLED\n"
if (switchDisabled) {
switchStatus = "SWITCH DISABLED\n"
}
if (state.deviceInfo['applicationVersion'] == null ||
state.deviceInfo['manufacturerName'] == null) {
getDeviceInfo()
} else {
newBuffer = "${switchStatus}"
}
if (state.deviceInfo['applicationVersion'] != null) {
if (newBuffer == null) {
newBuffer = "${switchStatus}"
}
newBuffer += "app Version: ${state.deviceInfo['applicationVersion']} Sub Version: ${state.deviceInfo['applicationSubVersion']}\n";
newBuffer += "zWaveLibrary Type: ${state.deviceInfo['zWaveLibraryType']}\n";
newBuffer += "zWaveProtocol Version: ${state.deviceInfo['zWaveProtocolVersion']} Sub Version: ${state.deviceInfo['zWaveProtocolSubVersion']}\n";
newBuffer += "secure inclusion: ${state.deviceInfo['secureInclusion'] || secureInclusionOverride}\n";
}
if (state.deviceInfo['manufacturerName'] != null) {
if (newBuffer == null) {
newBuffer = "${switchStatus}"
}
newBuffer += "manufacturer Name: ${state.deviceInfo['manufacturerName']}\n";
newBuffer += "manufacturer Id: ${state.deviceInfo['manufacturerId']}\n";
newBuffer += "product Id: ${state.deviceInfo['productId']} Type Id: ${state.deviceInfo['productTypeId']}\n";
newBuffer += "firmwareId: ${state.deviceInfo['firmwareId']} checksum: ${state.deviceInfo['checksum']}\n";
}
if (newBuffer == null) {
newBuffer = buffer
}
return sendEvent(name: "deviceInfo", value: "$newBuffer", displayed: false)
}
private getBatteryRuntime() {
def currentmillis = now() - state.energyMeterRuntimeStart
def days = 0
def hours = 0
def mins = 0
def secs = 0
secs = (currentmillis / 1000).toInteger()
mins = (secs / 60).toInteger()
hours = (mins / 60).toInteger()
days = (hours / 24).toInteger()
secs = (secs - (mins * 60)).toString().padLeft(2, ‘0’)
mins = (mins - (hours * 60)).toString().padLeft(2, ‘0’)
hours = (hours - (days * 24)).toString().padLeft(2, ‘0’)
if (days > 0) {
return "$days days and $hours:$mins:$secs"
} else {
return "$hours:$mins:$secs"
}
}
private getBatteryRuntimeInHours() {
def currentmillis = now() - state.energyMeterRuntimeStart
def days = 0
def hours = 0
def mins = 0
def secs = 0
secs = (currentmillis / 1000)
mins = (secs / 60)
hours = (mins / 60)
return hours
}
void logInfo(str) {
log.info str
}
void logWarn(str) {
log.warn str
}
void logError(str) {
log.error str
}
void logDebug(str) {
if (isLogLevelDebug) {
log.debug str
}
}
void logTrace(str) {
if (isLogLevelTrace) {
log.trace str
}
}
def nightLight() {
logDebug “in set nightlight mode”
sendEvent(name: “deviceMode”, value: “nightLight”, displayed: true)
setDeviceMode(2)
}
def energy() {
logDebug “in set energy mode”
sendEvent(name: “deviceMode”, value: “energy”, displayed: true)
setDeviceMode(0)
}
def momentary() {
logDebug “in momentary mode”
sendEvent(name: “deviceMode”, value: “momentary”, displayed: true)
setDeviceMode(1)
}
def setDeviceMode(mode) {
logTrace “set current mode to ‘$mode’”
formatCommand(zwave.configurationV1.configurationSet(parameterNumber: 0x51, size: 1, scaledConfigurationValue: mode))
}
def setBrightnessLevel(newLevel) {
logDebug “in set setlevel newlevel = ‘$newLevel’”
sendEvent(name: “brightnessLevel”, value: newLevel.toInteger(), displayed: true)
// There seems to have an error in the documentation where this config should be a size = 1
formatCommand(zwave.configurationV1.configurationSet(parameterNumber: 0x54, size: 3, configurationValue: [newLevel, newLevel, newLevel]))
}
def formatCommand(physicalgraph.zwave.Command cmd) {
if (isSecured()) {
logTrace “Formatting secured command: ${cmd}”
zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
} else {
logTrace “Formatting unsecured command: ${cmd}”
cmd.format()
}
}
def isSecured() {
(state.deviceInfo && state.deviceInfo[‘secureInclusion’]) || secureInclusionOverride
}
def internalCreateEvent(event) {
if (forceStateChangeOnReport) {
event.isStateChange = true
}
return createEvent(event)
}
Here is the Settings Page:
I also want to double check my understanding since the Smart Switch 7 supports this with a hardware flag and the Smart Switch 6 really doesn’t have a flag for this (which your code was super helpful in verifying).
The caveat is that it wouldn’t report the switch status at all, but perhaps that’s acceptable and how the existing DTH works?
It should be easy either way, though the separate driver without the switch capability would be super simple (if it’s something that seems viable).
