Odd parseXml error from ST device handler

🛎️ Get Help
1

Try to use the ST DH for Zooz Mini Sensor and I get the following when saving the driver.

No signature of method: Script1.parseXml() is applicable for argument types: (java.lang.String) values: [ Motion detection sensitivity Range: 8~255 Default: 12 Number of seconds the associated device to stay ON for after being triggered by the sensor before it automatically turns OFF Range: 5~600 Default: 30 Associated device will turn ON when triggered by the sensor (255) or Brightness level (percentage) the associated device will turn ON to when triggered by the sensor (1-99). Range: 1~99,255 Default: 255 Enable or disable motion detection. Default: Enabled Light level change (in LUX) to set off light trigger Range: 0~1000 Default: 100 Number of seconds for motion trigger interval Range: 1~8 Default: 8 Light polling interval in seconds Range: 60~360000 Default: 180 Enable or disable the light trigger Default: Disabled Light level change (in LUX) to be reported by the sensor to the controller Range: 0~255 Default: 20 Enable or disable LED notifications Default: Enabled Range: None Default: 0 Note: The calibration value = standard value - measure value. E.g. If measure value = 80% Lux and the standard value = 75% Lux, so the calibration value = 75 – 80 = -5. If the measure value = 85% Lux and the standard value = 90% Lux, so the calibration value = 90 – 85 = 5. Set the wake interval for the device in seconds. Decreasing this value will reduce battery life. Range: 240~65536 Default: 43200 (12 Hours) ] Possible solutions: parse(java.lang.String)

The error is referring to the "Help" section for each configuration parameter as follows:

<Value type="byte" index="1" label="Motion Sensitivity" min="8" max="255" value="12" byteSize="1" setting_type="zwave">

<Help>

Motion detection sensitivity

Range: 8~255

Default: 12

</Help>

</Value>

The function looks fine. But I'm not a groovy expert.

def configuration = parseXml(configuration_model)

Odd this works with ST. I guessing it could be a simple statement replace. I'll have to toy around with this one a bit.

2

It looks like it already parsed the XML response. Try removing the call to parseXML() and see if you can move it on in the code.

3

You might also want to try using this:
def configuration = groovy.util.XmlSlurper.parse(configuration_model)

we do not provide a parseXML() method for apps, but it sounds like it should be added to the feature request list.

1 Like
4 
/**
 *  HUBITAT: Dome Motion Sensor v1.0
 *  (Model: DMMS1)
 *
 *  Author: 
 *    Kevin LaFramboise (krlaframboise)
 *
 *  Changelog:
 *
 *    1.0 (02/10/2018)
 *      - Initial Release
 *
 *
 *  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: "Dome Motion Sensor", 
		namespace: "krlaframboise", 
		author: "Kevin LaFramboise"
	) {
		capability "Sensor"
		capability "Motion Sensor"
		capability "Illuminance Measurement"
		capability "Battery"
		capability "Configuration"
		capability "Refresh"
		capability "Health Check"
		
		attribute "lastCheckin", "string"
		
		fingerprint deviceId: "0x0701", inClusters: "0x30, 0x31, 0x59, 0x5A, 0x5E, 0x70, 0x71, 0x72, 0x73, 0x80, 0x84, 0x85, 0x86"
		
		fingerprint mfr:"021F", prod:"0003", model:"0083"
	}
	
	simulator { }
	
	preferences {
		input "ledEnabled", "enum",
			title: "Enable/Disable LED:",
			defaultValue: ledEnabledSetting,
			required: false,
			displayDuringSetup: true,
			options: ledEnabledOptions.collect { it.name }
		input "motionClearedDelay", "enum",
			title: "Motion Cleared Delay:",
			defaultValue: motionClearedDelaySetting,
			required: false,
			displayDuringSetup: true,
			options: motionClearedDelayOptions.collect { it.name }
		input "motionRetrigger", "enum",
			title: "Motion Retrigger Interval:",
			defaultValue: motionRetriggerSetting,
			required: false,
			displayDuringSetup: true,
			options: motionRetriggerOptions.collect { it.name }
		input "motionSensitivity", "enum",
			title: "Motion Detection Sensitivity:",
			defaultValue: motionSensitivitySetting,
			required: false,
			displayDuringSetup: true,
			options: motionSensitivityOptions.collect { it.name }
		input "lightReporting", "enum",
			title: "Light Reporting Interval:",
			defaultValue: lightReportingSetting,
			required: false,
			displayDuringSetup: true,
			options: lightReportingOptions.collect { it.name }
		input "lightSensitivity", "enum",
			title: "Light Reporting Sensitivity:",
			defaultValue: lightSensitivitySetting,
			required: false,
			displayDuringSetup: true,
			options: lightSensitivityOptions.collect { it.name }
		input "wakeUpInterval", "enum",
			title: "Checkin Interval:",
			defaultValue: checkinIntervalSetting,
			required: false,
			displayDuringSetup: true,
			options: checkinIntervalOptions.collect { it.name }
		input "batteryReportingInterval", "enum",
			title: "Battery Reporting Interval:",
			defaultValue: batteryReportingIntervalSetting,
			required: false,
			displayDuringSetup: true,
			options: checkinIntervalOptions.collect { it.name }
		input "debugOutput", "bool", 
			title: "Enable debug logging?", 
			defaultValue: true, 
			required: false
	}

	tiles(scale: 2) {
		multiAttributeTile(name:"motion", type: "generic", width: 6, height: 4, canChangeIcon: false){
			tileAttribute ("device.motion", key: "PRIMARY_CONTROL") {
				attributeState "inactive", 
					label:'No Motion', 
					icon:"st.motion.motion.inactive", 
					backgroundColor:"#cccccc"
				attributeState "active", 
					label:'Motion', 
					icon:"st.motion.motion.active", 
					backgroundColor:"#00a0dc"
			}			
			tileAttribute ("device.illuminance", key: "SECONDARY_CONTROL") {
				attributeState "illuminance", 
					label:'Light is ${currentValue} lux', 
					backgroundColor:"#ffffff"
			}
		}	
		
		valueTile("illuminance", "device.illuminance", decoration: "flat", width: 2, height: 2){
			state "illuminance", label:'Light\n${currentValue} lx', unit: ""
		}	
		
		standardTile("refresh", "device.refresh", width: 2, height: 2) {
			state "refresh", label:'Refresh', action: "refresh", icon:"st.secondary.refresh-icon"
		}
		
		valueTile("battery", "device.battery", decoration: "flat", width: 2, height: 2){
			state "battery", label:'${currentValue}% battery', unit:""
		}
					
		main "motion"
		details(["motion", "illuminance", "refresh", "battery"])
	}
}

// Sets flag so that configuration is updated the next time it wakes up.
def updated() {	
	// This method always gets called twice when preferences are saved.
	if (!isDuplicateCommand(state.lastUpdated, 3000)) {		
		state.lastUpdated = new Date().time
		logTrace("updated()")

		logForceWakeupMessage "The configuration will be updated the next time the device wakes up."
	}		
}

// Initializes the device state when paired and updates the device's configuration.
def configure() {
	logTrace("configure()")
	def cmds = []
	def refreshAll = (!state.isConfigured || !settings?.ledEnabled)
	
	if (!state.isConfigured) {
		logTrace("Waiting 1 second because this is the first time being configured")
		sendEvent(getEventMap("motion", "inactive", false))
		sendEvent(getEventMap("illuminance", 0, false, null, "lx"))
		cmds << "delay 1000"
	}
	
	configData.sort { it.paramNum }.each { 
		cmds += updateConfigVal(it.paramNum, it.size, it.value, refreshAll)	
	}
		
	if (refreshAll || (checkinIntervalSettingMinutes * 60) != state.checkinInterval) {
		cmds << wakeUpIntervalSetCmd(checkinIntervalSettingMinutes)
		cmds << wakeUpIntervalGetCmd()
	}
	
	if (cmds) {
		logDebug("Sending configuration to device.")
	}
		
	if (state.pendingRefresh || canReportBattery()) {
		cmds << batteryGetCmd()
	}
	
	return cmds ? delayBetween(cmds, 1000) : []
}

private updateConfigVal(paramNum, paramSize, val, refreshAll) {
	def result = []
	def configVal = state["configVal${paramNum}"]
	
	if (refreshAll || (configVal != val)) {
		logDebug "#${paramNum}: changing ${configVal} to ${val}"
		result << configSetCmd(paramNum, paramSize, val)
		result << configGetCmd(paramNum)
	}	
	return result
}

private initializeCheckin() {
	// Set the Health Check interval so that it can be skipped once plus 2 minutes.
	def checkInterval = ((checkinIntervalSettingMinutes * 2 * 60) + (2 * 60))
	
	sendEvent(name: "checkInterval", value: checkInterval, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
}

// Required for HealthCheck Capability, but doesn't actually do anything because this device sleeps.
def ping() {
	logDebug("ping()")
}

// Forces the configuration to be resent to the device the next time it wakes up.
def refresh() {	
	if (state.pendingRefresh) {
		logForceWakeupMessage "All settings will be sent to the device the next time it wakes up."
		configData.each {
			state."configVal${it.paramNum}" = null
		}
	}
	else {
		logForceWakeupMessage "The sensor data will be refreshed the next time the device wakes up."
		state.pendingRefresh = true
	}
}

private logForceWakeupMessage(msg) {
	logDebug("${msg}  You can force the device to wake up immediately by pressing the connect button once.")
}

// Processes messages received from device.
def parse(String description) {
	def result = []
	
	sendEvent(name: "lastCheckin", value: convertToLocalTimeString(new Date()), displayed: false, isStateChange: true)	
	
	def cmd = zwave.parse(description, commandClassVersions)
	if (cmd) {
		result += zwaveEvent(cmd)
	}
	else {
		logDebug("Unable to parse description: $description")
	}
	return result
}

// Updates devices configuration, requests battery report, and/or creates last checkin event.
def zwaveEvent(hubitat.zwave.commands.wakeupv2.WakeUpNotification cmd)
{
	logTrace("WakeUpNotification: $cmd")
	def result = []
	
	result += configure()
		
	if (result) {
		result << "delay 2000"
	}
	
	result << wakeUpNoMoreInfoCmd()	
	return response(result)
}

def zwaveEvent(hubitat.zwave.commands.wakeupv2.WakeUpIntervalReport cmd) {
	logTrace("WakeUpIntervalReport: $cmd")
	state.checkinInterval = cmd.seconds
	initializeCheckin()
	return [ ]
}

// Creates the event for the battery level.
def zwaveEvent(hubitat.zwave.commands.batteryv1.BatteryReport cmd) {
	logTrace("BatteryReport: $cmd")
	state.pendingRefresh = false
	
	def val = (cmd.batteryLevel == 0xFF ? 1 : cmd.batteryLevel)
	if (val > 100) {
		val = 100
	}
	state.lastBatteryReport = new Date().time	
	logDebug("Battery ${val}%")
	[
		createEvent(getEventMap("battery", val, null, null, "%"))
	]
}	

// Stores the configuration values so that it only updates them when they've changed or a refresh was requested.
def zwaveEvent(hubitat.zwave.commands.configurationv2.ConfigurationReport cmd) {	
	// logTrace("ConfigurationReport $cmd")	
	def name = configData.find { it.paramNum == cmd.parameterNumber }?.name
	if (name) {	
		def val = convertToScaledValue(cmd.configurationValue, cmd.size)
		logDebug("${name}(#${cmd.parameterNumber}) = ${val}")
	
		state."configVal${cmd.parameterNumber}" = val
	}
	else {
		logDebug("Parameter ${cmd.parameterNumber}: ${cmd.configurationValue}")
	}
	state.isConfigured = true
	state.pendingRefresh = false	
	return []
}

// Creates motion events.
def zwaveEvent(hubitat.zwave.commands.notificationv3.NotificationReport cmd) {
	def result = []	
	// logTrace("NotificationReport: $cmd")
	
	if (cmd.notificationType == 0x07) {
		switch (cmd.event) {
			case 0x00:
				logDebug("Motion Inactive")
				result << createEvent(getEventMap("motion", "inactive"))
				break
			case 0x08:
				logDebug("Motion Active")
				result << createEvent(getEventMap("motion", "active"))
				break
			default:
				logDebug("Unknown Notification Event: ${cmd}")
		}
	}
	return result
}

// Creates illuminance events.
def zwaveEvent(hubitat.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd) {
	state.pendingRefresh = false
	
	def result = []	
	logTrace("SensorMultilevelReport $cmd")
	if (cmd.sensorType == 3) {
		result << createEvent(getEventMap("illuminance", cmd.scaledSensorValue, null, null, "lx"))
	}
	
	state.lastRefreshed = new Date().time
	state.pendingRefresh = false
	return result
}

// Ignoring event because motion events are being handled by notification report.
def zwaveEvent(hubitat.zwave.commands.sensorbinaryv2.SensorBinaryReport cmd) {
	// logTrace("SensorBinaryReport: $cmd")
	return []
}

// Logs unexpected events from the device.
def zwaveEvent(hubitat.zwave.Command cmd) {
	logDebug("Unhandled Command: $cmd")
	return []
}

private getEventMap(name, value, displayed=null, desc=null, unit=null) {	
	def isStateChange = (device.currentValue(name) != value)
	displayed = (displayed == null ? isStateChange : displayed)
	def eventMap = [
		name: name,
		value: value,
		displayed: displayed,
		isStateChange: isStateChange
	]
	if (desc) {
		eventMap.descriptionText = desc
	}
	if (unit) {
		eventMap.unit = unit
	}	
	// logTrace("Creating Event: ${eventMap}")
	return eventMap
}

private wakeUpIntervalGetCmd() {
	return zwave.wakeUpV2.wakeUpIntervalGet().format()
}

private wakeUpIntervalSetCmd(minutesVal) {		
	return zwave.wakeUpV2.wakeUpIntervalSet(seconds:(minutesVal * 60), nodeid:zwaveHubNodeId).format()
}

private wakeUpNoMoreInfoCmd() {
	return zwave.wakeUpV2.wakeUpNoMoreInformation().format()
}

private batteryGetCmd() {
	return zwave.batteryV1.batteryGet().format()
}

private configGetCmd(paramNum) {
	return zwave.configurationV2.configurationGet(parameterNumber: paramNum).format()
}

private configSetCmd(paramNum, size, val) {
	return zwave.configurationV2.configurationSet(parameterNumber: paramNum, size: size, configurationValue: convertFromScaledValue(val, size)).format()
}


private getCommandClassVersions() {
	[
		0x30: 2,	// Sensor Binary
		0x31: 5,	// Sensor Multilevel
		0x59: 1,  // AssociationGrpInfo
		0x5A: 1,  // DeviceResetLocally
		0x5E: 2,  // ZwaveplusInfo
		0x70: 2,  // Configuration
		0x71: 3,  // Notification v4
		0x72: 2,  // ManufacturerSpecific
		0x73: 1,  // Powerlevel
		0x80: 1,  // Battery
		0x84: 2,  // WakeUp
		0x85: 2,  // Association
		0x86: 1		// Version (2)
	]
}

private canReportBattery() {
	def reportEveryMS = (batteryReportingIntervalSettingMinutes * 60 * 1000)
		
	return (!state.lastBatteryReport || ((new Date().time) - state.lastBatteryReport > reportEveryMS)) 
}


// Settings
private getLedEnabledSetting() {
	return settings?.ledEnabled ?: findDefaultOptionName(ledEnabledOptions)
}

private getMotionSensitivitySetting() {
	return settings?.motionSensitivity	?: findDefaultOptionName(motionSensitivityOptions)
}

private getLightSensitivitySetting() {
	return settings?.lightSensitivity ?: findDefaultOptionName(lightSensitivityOptions)
}

private getMotionClearedDelaySetting() {
	return settings?.motionClearedDelay ?: findDefaultOptionName(motionClearedDelayOptions)
}

private getMotionRetriggerSetting() {
	return settings?.motionRetrigger ?: findDefaultOptionName(motionRetriggerOptions)
}

private getLightReportingSetting() {
	return settings?.lightReporting ?: findDefaultOptionName(lightReportingOptions)
}

private getCheckinIntervalSettingMinutes() {
	return convertOptionSettingToInt(checkinIntervalOptions, checkinIntervalSetting) ?: 720
}

private getCheckinIntervalSetting() {
	return settings?.wakeUpInterval ?: findDefaultOptionName(checkinIntervalOptions)
}

private getBatteryReportingIntervalSettingMinutes() {
	return convertOptionSettingToInt(checkinIntervalOptions, batteryReportingIntervalSetting) ?: checkinIntervalSettingMinutes
}

private getBatteryReportingIntervalSetting() {
	return settings?.batteryReportingInterval ?: findDefaultOptionName(checkinIntervalOptions)
}


// Configuration Parameters
private getConfigData() {
	return [
		[paramNum: 1, name: "Motion Sensitivity", value: convertOptionSettingToInt(motionSensitivityOptions, motionSensitivitySetting), size: 1],
		[paramNum: 2, name: "Motion Cleared Delay", value: convertOptionSettingToInt(motionClearedDelayOptions, motionClearedDelaySetting), size: 2],
		[paramNum: 6, name: "Motion Retrigger Interval", value: convertOptionSettingToInt(motionRetriggerOptions, motionRetriggerSetting), size: 1],
		[paramNum: 7, name: "Light Reporting Interval", value: convertOptionSettingToInt(lightReportingOptions, lightReportingSetting), size: 2],
		[paramNum: 9, name: "Light Sensitivity", value: convertOptionSettingToInt(lightSensitivityOptions, lightSensitivitySetting), size: 1],
		[paramNum: 10, name: "LED Enabled", value: convertOptionSettingToInt(ledEnabledOptions, ledEnabledSetting), size: 1],
	]	
}

private getMotionSensitivityOptions() {
	return getSensitivityOptions(28, 8, 255, 10)
}

private getLightSensitivityOptions() {
	// Dome: max value documented as 255, but is really 100.
	return getSensitivityOptions(49, 1, 100, 4)	
}

private getSensitivityOptions(defaultVal, minVal, maxVal, interval) {	
	def options = []

	options << [name: "1 (Most Sensitive)", value: minVal]

	(2..24).each {
		minVal += interval
		options << [name: "${it}", value: minVal]
	}

	options << [name: "25 (Least Sensitive)", value: maxVal]
	
	options.each {
		if (it.value == defaultVal) {
			it.name = formatDefaultOptionName("${it.name}")
		}
	}
	return options
}

private getLightReportingOptions() {
	[
		[name: "1 Minute", value: 60],
		[name: "2 Minutes", value: 120],
		[name: formatDefaultOptionName("3 Minutes"), value: 180],
		[name: "4 Minutes", value: 240],
		[name: "5 Minutes", value: 300],
		[name: "10 Minutes", value: 600],
		[name: "30 Minutes", value: 1800],
		[name: "1 Hour", value: 3600],
		[name: "2 Hours", value: 7200],
		[name: "4 Hours", value: 1440],
		[name: "8 Hours", value: 28800]
	]
}

private getMotionClearedDelayOptions() {
	[
		[name: "10 Seconds", value: 10],		
		[name: "15 Seconds", value: 15],
		[name: formatDefaultOptionName("30 Seconds"), value: 30],
		[name: "45 Seconds", value: 45],
		[name: "1 Minute", value: 60],
		[name: "2 Minutes", value: 120],
		[name: "3 Minutes", value: 180],
		[name: "4 Minutes", value: 240],
		[name: "5 Minutes", value: 300],
		[name: "7 Minutes", value: 420],
		[name: "10 Minutes", value: 600]
	]
}

private getMotionRetriggerOptions() {
	def result = []

	result << [name: "1 Second", value: 1]
	
	(2..7).each {
		result << [name: "${it} Seconds", value: it]
	}
	
	result << [name: formatDefaultOptionName("8 Seconds"), value: 8]
	return result
}

private getLedEnabledOptions() {
	[
		[name: "Disabled", value: 0],
		[name: formatDefaultOptionName("Enabled"), value: 1]
	]
}

private getCheckinIntervalOptions() {
	[
		[name: "10 Minutes", value: 10],
		[name: "15 Minutes", value: 15],
		[name: "30 Minutes", value: 30],
		[name: "1 Hour", value: 60],
		[name: "2 Hours", value: 120],
		[name: "3 Hours", value: 180],
		[name: "6 Hours", value: 360],
		[name: "9 Hours", value: 540],
		[name: formatDefaultOptionName("12 Hours"), value: 720],
		[name: "18 Hours", value: 1080],
		[name: "24 Hours", value: 1440]
	]
}

private convertOptionSettingToInt(options, settingVal) {
	return safeToInt(options?.find { "${settingVal}" == it.name }?.value, 0)
}

private formatDefaultOptionName(val) {
	return "${val}${defaultOptionSuffix}"
}

private findDefaultOptionName(options) {
	def option = options?.find { it.name?.contains("${defaultOptionSuffix}") }
	return option?.name ?: ""
}

private getDefaultOptionSuffix() {
	return "   (Default)"
}

private safeToInt(val, defaultVal=-1) {
	return "${val}"?.isInteger() ? "${val}".toInteger() : defaultVal
}

private safeToDec(val, defaultVal=-1) {
	return "${val}"?.isBigDecimal() ? "${val}".toBigDecimal() : defaultVal
}

private convertToScaledValue(val, size) {
	if (size == 2) {
		return val[1] + (val[0] * 0x100)
	}
	else {
		return val[0]
	}
}

private convertFromScaledValue(val, size) {
	if (size == 2) {
		return [(byte) ((val >> 8) & 0xff),(byte) (val & 0xff)]
	}
	else {
		return [val]
	}
}

private canCheckin() {
	// Only allow the event to be created once per minute.
	def lastCheckin = device.currentValue("lastCheckin")
	return (!lastCheckin || lastCheckin < (new Date().time - 60000))
}

private convertToLocalTimeString(dt) {
	def timeZoneId = location?.timeZone?.ID
	if (timeZoneId) {
		return dt.format("MM/dd/yyyy hh:mm:ss a", TimeZone.getTimeZone(timeZoneId))
	}
	else {
		return "$dt"
	}	
}

private isDuplicateCommand(lastExecuted, allowedMil) {
	!lastExecuted ? false : (lastExecuted + allowedMil > new Date().time) 
}

private logDebug(msg) {
	if (settings?.debugOutput || settings?.debugOutput == null) {
		log.debug "$msg"
	}
}

private logTrace(msg) {
	// log.trace "$msg"
}
3 Likes
5

And there’ s Kevin to the rescue!!!

damn @krlaframboise is good!

3 Likes
6

I just saw your post on the ST forum stating that this device doesn't work with Hubitat.

What problems are you still having with it?

7

No the ZSE09 worked with your driver. It is the ZSE02 that still won’t work with Hubitat. Under SmartThings it didn’t have a special DH for it, just the Generic Z-Wave Motion Sensor. That worked well. Under Hubitat the Generic driver did nothing. I tried all of the built in drivers and nothing worked.

8

I have that device, but I haven't moved it over yet. I'll try to look at it tonight.

9

Any progress with a device handler for the Dome Motion sensor. I tried the one in the 4th post, and all I get is “lastCheckin” when it senses motion

10

I've been using that driver for a while and haven't had any problems with it. In the right column you should see motion and either active or inactive next to it.

Try saving the settings screen and then holding the action button on the device for 1 second to wake it up. That will ensure that all the default configuration settings get sent to the device.

11

It looks like it is seeing motion in the right hand column, but it is not triggering the action in a hubitat simple light app. I tried saving the screen settings and pressing the action button for 1 sec, no luck

12

I excluded the sensor, and re-included it, and it seems to be working now

1 Like
13

Just for the record, the conversion that works:

def configuration = parseXml(configuration_model)

to

def configuration = new XmlSlurper().parseText(configuration_model)

I have converted my device handlers to Hubitat. I haven't tested them all. The ones that rely on child devices will not work yet, but most of the others should work.

2 Likes
14

@ericm I took your "Aeon RGBW Bulb (Advanced)" and tried it... there are several problems and I although I "fixed" a few, there's a couple more that would need your advice.

Debug wasn't working so I replaced it with the more common form:

 input "debugOutput", "bool", 
 	    title: "Enable debug logging?", 
 	    defaultValue: true, 
 	    required: false

That cascades to several other changes, of course. :slight_smile:

The big one is Hail pops an error.

def zwaveEvent(hubitat.zwave.commands.hailv1.Hail cmd) {
// response(command(zwave.switchMultilevelV1.switchMultilevelGet()))
}

I chose to comment it out vs ignore the error. Same result I think.

error No signature of method: hubitat.device.HubAction.getRequest() is applicable for argument types: () values: on line null

Finally, RM has Capture and Restore State that seems to be failing and I'm hoping it's a driver error.

I just want to start a conversation not dump a laundry list here. :slight_smile:

15

Great, thanks for testing. I think the hail issue has been fixed with the latest firmware because I'm not getting the error. I'll fix the debug issue so users can view the logs if they want.

As for the rule machine capture / restore, I don't see it trying to restore the color, only on/off state. That seemed to be working for me.

16

Agree. v'108" fixed the problem with Hail.

I guess I'll have to wait for RM to recognize Color in Capture/Restore state.

And Thanks !

17

This topic was automatically closed 365 days after the last reply. New replies are no longer allowed.