Configuring parameters for a Fibaro Motion Sensor (FGMS-001)

Hi Community,

I've done a fair amount of reading and testing to try and figure out how to push parameter settings to my Fibaro FGMS-001 Motion Sensors. When adding them to HE they automatically were allocated to the built in driver: Fibaro Motion Sensor ZW5

I've previously used them on my Smartthings setup and having migrated across to HE, I noticed they had reset and are super bright during the night. Serious concerns on their effect on WAF but she loves our light automations so I've got a bit of tolerance to work through. I've tweaked their parameters before on Smartthings but can't seen to get them to update on HE. Really customisable if you can get them to update :smile:

I have read these forums to get some notes and have tried the 3x button push followed by pressing the configure button on the device driver. But despite trying this numerous times near to the hub - nothing changes. I've also confirmed the process in the Fibaro manual: https://manuals.fibaro.com/content/manuals/en/FGMS-001/FGMS-001-EN-T-v2.1.pdf

Has anyone had any luck updating the parameters on these motion sensors?

Thanks in advance.

What you can do is use this driver.
Amend the parameters to what you want them to be in lines 532 onwards.
Allocated the driver to your devices, press the 'b' button 3 times then the config button on the device UI.
It should load the parameters to what you have just set.
If you want you can then revert to the inbuilt driver.

/**
 *  Device Type Definition File
 *
 *  Device Type:			RRG Enhanced - Fibaro Motion Sensor
 *  File Name:				FGMS-001.groovy
 *  Initial Release:			2014-12-10
 *  Ported by:				Ronald Gouldner
 *
 ***************************************************************************************
 *
 * Change Log:
 *
 */

 preferences {
 
    input ("Help", "text", title: "Instructions", description: "When changing these values make sure you triple click the sensor b-button (inside) to wake the device (blue light displays) and then select the \"configure\" tile after clicking done on this page.   Note: Param Settings indicated in parentheses (p-80 p1)=Parameter 80 part 1, this helps you lookup possible values in manual.", 
	      displayDuringSetup: false, type: "paragraph", element: "paragraph")	
	input("sensitivity", "number", title: "Sensitivity (p-1) 8-255, 10=(default)", defaultValue:10)
	input("blindTime", "number", title: "Blind Time (p-2) 0-15, 15=(default)", defaultValue:15)	
	input("pirOperatingMode", "enum", title: "PIR Operating Mode (p-8)?", default: "Both", options: ["Both","Day","Night"])
	input("nightDayThreshold", "number", title: "Night/Day Threshold (p-9) 1-65535 (default=200)", defaultValue:200)
	input("illumReportThresh", "number", title: "Illum Report Threshold in Lux (p-40) 0-65535 0=no reports sent, 200=(default)",
		description: "Illumination reports when lux changes by this amount", defaultValue:200)
	input("illumReportInt", "number",
		title: "Illum Report Interval in Seconds (p-42) 0-65535 0=none (default), <5 may block temp readings, too low will waste battery",
		description: "Time interval in seconds to report illum regardless of change", defaultValue:0)     	
	input("ledOnOff", "enum", title: "LED On/Off (p-80 p1)?", default:"On", options: ["On","Off"])
	input("ledModeFrequency", "enum", title: "LED Frequency (p-80 p2)?", default: "Once", options: ["Once","Long-Short","Long-Two Short"])
	input("ledModeColor", "enum", title: "LED Color ? (p-80 p3)", default:"Temp", options: ["Temp","Flashlight","White","Red","Green","Blue","Yellow","Cyan","Magenta"])
	input("ledBrightness", "number",
		title: "LED Brightness 1-100% 0=ambient ? (p-81)",
		description: "LED Brightness Level Percent (1-100) 0=ambient based", defaultValue:50)
	input("tamperLedOnOff", "enum", title: "Tamper LED ? (p-89)", default:"On", options: ["On","Off"])
	
		 
 }
 
 /**
 * Sets up metadata, simulator info and tile definition.
 *
 * @param none
 *
 * @return none
 */
 metadata {
	definition (name: "Fibaro Motion Sensor", namespace: "gouldner", author: "Ronald Gouldner") {
		capability 	"Motion Sensor"
		capability 	"Temperature Measurement"
		capability 	"Acceleration Sensor"
		capability 	"Configuration"
		capability 	"Illuminance Measurement"
		capability 	"Sensor"
		capability 	"Battery"
        
		command		"resetParams2StDefaults"
		command		"listCurrentParams"
		command		"updateZwaveParam"
		command		"test"
		command		"configure"

		fingerprint deviceId: "0x2001", inClusters: "0x30,0x84,0x85,0x80,0x8F,0x56,0x72,0x86,0x70,0x8E,0x31,0x9C,0xEF,0x30,0x31,0x9C"
	}

	tiles {
		standardTile("motion", "device.motion", width: 2, height: 2) {
			state "active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0"
			state "inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff"
		}
		valueTile("temperature", "device.temperature", inactiveLabel: false) {
			state "temperature", label:'${currentValue}#',
			backgroundColors:[
				[value: 31, color: "#153591"],
				[value: 44, color: "#1e9cbb"],
				[value: 59, color: "#90d2a7"],
				[value: 74, color: "#44b621"],
				[value: 84, color: "#f1d801"],
				[value: 95, color: "#d04e00"],
				[value: 96, color: "#bc2323"]
			]
		}
		valueTile("illuminance", "device.illuminance", inactiveLabel: false) {
			state "luminosity", label:'${currentValue} ${unit}', unit:"lux"
		}
		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat") {
			state "battery", label:'${currentValue}% battery', unit:""
		}
		standardTile("configure", "device.configure", inactiveLabel: false, decoration: "flat") {
			state "configure", label:'', action:"configuration.configure", icon:"st.secondary.configure"
		}
        standardTile("listCurrentParams", "listCurrentParams", inactiveLabel: false, decoration: "flat") {
			state "listCurrentParams", label:'', action:"listCurrentParams", icon:"st.quirky.egg-minder.quirky-egg-report"
		}
        standardTile("acceleration", "device.acceleration") {
			state("active", label:'vibration', icon:"st.motion.acceleration.active", backgroundColor:"#53a7c0")
			state("inactive", label:'still', icon:"st.motion.acceleration.inactive", backgroundColor:"#ffffff")
		}
        

		main(["temperature", "motion", "acceleration", "illuminance"])
		details(["motion", "temperature", "acceleration", "battery", "illuminance", "configure","listCurrentParams"])
	}
}
 
 


 /**
 * Configures the device to settings needed by SmarthThings at device discovery time.
 *
 * @param none
 *
 * @return none
 */
def configure() {
	log.debug "Configuring Device For SmartThings Use"
	def cmds = []
    
	// send associate to group 3 to get sensor data reported only to hub
	cmds << zwave.associationV2.associationSet(groupingIdentifier:3, nodeId:[zwaveHubNodeId]).format()
	
	//  Set Sensitivity (1) Values 8-255 default 10
	log.debug "Setting sensitivity $sensitivity"
	def senseValue = sensitivity as int
	if (senseValue < 8 || senseValue > 255) {
		log.warn "Unknown sensitivity-Setting to default of 10"
		senseValue = 10
	}
	log.debug "Setting Param 1 to $senseValue"
	cmds << zwave.configurationV1.configurationSet(configurationValue: [senseValue], parameterNumber: 1, size: 1).format()
        
	//  Set Blind Time (3) Value 0-15 default 15
	log.debug "Setting blind time $blindTime"
	def blindValue = blindTime as int
	if (blindValue < 0 || blindValue > 15) {
		log.warn "Blind time outside allowed values-Setting to default of 15"
		blindValue = 15
	}
	log.debug "Setting Param 2 to $blindValue"
	cmds << zwave.configurationV1.configurationSet(configurationValue: [blindValue], parameterNumber: 2, size: 1).format()
    
	log.debug "Setting pir operating mode $pirOperatingMode"
	def pirOperatingModeParamValue=0 // Both (default)
	if (pirOperatingMode == "Day") {
		pirOperatingModeParamValue=1
	} else if (pirOperatingMode == "Night") {
	    pirOperatingModeParamValue=2
	}
	log.debug "Setting Param 8 to $pirOperatingModeParamValue"
	cmds << zwave.configurationV1.configurationSet(configurationValue: [pirOperatingModeParamValue], parameterNumber: 8, size: 1).format()
	
	log.debug "Setting Night/Day threshold $nightDayThreshold"
	def nightDayThresholdAsInt = nightDayThreshold.toInteger()
	if (nightDayThresholdAsInt >= 1 && nightDayThresholdAsInt <= 65535 ) {
		def short nightDayThresholdLow = nightDayThresholdAsInt & 0xFF
		def short nightDayThresholdHigh = (nightDayThresholdAsInt >> 8) & 0xFF
		def nightDayThresholdBytes = [nightDayThresholdHigh, nightDayThresholdLow]
		log.debug "Setting Param 9 to $nightDayThresholdBytes"
		cmds << zwave.configurationV1.configurationSet(configurationValue: nightDayThresholdBytes, parameterNumber: 9, size: 2).format()
	} else {
		log.warn "Setting Param 9 out of rang changing to default of 200"
	    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,200], parameterNumber: 9, size: 2).format()
	}
	
	
	// turn on tamper sensor with active/inactive reports (use it as an acceleration sensor) default is 0, or off
	log.debug "Setting Param 24 to value of 4 - HARD CODED"
	cmds << zwave.configurationV1.configurationSet(configurationValue: [4], parameterNumber: 24, size: 1).format()
	
	log.debug "Illum Report Threshole Preference illumReportThresh=$illumReportThresh"
	def illumReportThreshAsInt = illumReportThresh.toInteger()
	if (illumReportThreshAsInt >= 0 && illumReportThreshAsInt <= 65535 ) {
		def short illumReportThreshLow = illumReportThreshAsInt & 0xFF
		def short illumReportThreshHigh = (illumReportThreshAsInt >> 8) & 0xFF
		def illumReportThreshBytes = [illumReportThreshHigh, illumReportThreshLow]
		log.debug "Setting Param 40 to $illumReportThreshBytes"
		cmds << zwave.configurationV1.configurationSet(configurationValue: illumReportThreshBytes, parameterNumber: 40, size: 2).format()
	}
	
	log.debug "Illum Interval Preference illumReportInt=$illumReportInt"
	def illumReportIntAsInt = illumReportInt.toInteger()
	if (illumReportIntAsInt >= 0 && illumReportIntAsInt <= 65535 ) {
		def short illumReportIntLow = illumReportIntAsInt & 0xFF
		def short illumReportIntHigh = (illumReportIntAsInt >> 8) & 0xFF
		def illumReportBytes = [illumReportIntHigh, illumReportIntLow]
		log.debug "Setting Param 42 to $illumReportBytes"
		cmds << zwave.configurationV1.configurationSet(configurationValue: illumReportBytes, parameterNumber: 42, size: 2).format()
	}
	
	// temperature change report threshold (0-255 = 0.1 to 25.5C) default is 1.0 Celcius, setting to .5 Celcius
	log.debug "Setting Param 60 to value of 5 - HARD CODED"
	cmds << zwave.configurationV1.configurationSet(configurationValue: [5], parameterNumber: 60, size: 1).format()
	  
	if (ledOnOff == "Off") {
		log.debug "Setting LED off"
		// 0 = LED Off signal mode
		log.debug "Setting Param 80 to 0"
	    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 80, size: 1).format()
	} else {
	    log.debug "Setting LED on"
 	    // ToDo Add preference for other available Led Signal Modes
		def ledModeConfigValue=0
		log.debug "ledModeFrequency=$ledModeFrequency"
		log.debug "ledModeColor=$ledModeColor"
		if (ledModeFrequency == "Once") {
			if (ledModeColor == "Temp") {
					ledModeConfigValue=1
			} else if (ledModeColor == "Flashlight") {
					ledModeConfigValue=2
			} else if (ledModeColor == "White") {
					ledModeConfigValue=3
			}else if (ledModeColor == "Red") {
					ledModeConfigValue=4
			}else if (ledModeColor == "Green") {
					ledModeConfigValue=5
			}else if (ledModeColor == "Blue") {
					ledModeConfigValue=6
			}else if (ledModeColor == "Yellow") {
					ledModeConfigValue=7
			}else if (ledModeColor == "Cyan") {
					ledModeConfigValue=8
			}else if (ledModeColor == "Magenta") {
					ledModeConfigValue=9
			} else {
				log.warn "Unknown LED Color-Setting LED Mode to default of 10"
					ledModeConfigValue=10
			}
		} else if (ledModeFrequency == "Long-Short") {
			if (ledModeColor == "Temp") {
				ledModeConfigValue=10
		    } else if (ledModeColor == "Flashlight") {
				ledModeConfigValue=11
		    } else if (ledModeColor == "White") {
				ledModeConfigValue=12
		    } else if (ledModeColor == "Red") {
				ledModeConfigValue=13
		    } else if (ledModeColor == "Green") {
				ledModeConfigValue=14
		    } else if (ledModeColor == "Blue") {
				ledModeConfigValue=15
		    } else if (ledModeColor == "Yellow") {
				ledModeConfigValue=16
		    } else if (ledModeColor == "Cyan") {
				ledModeConfigValue=17
		    } else if (ledModeColor == "Magenta") {
				ledModeConfigValue=18
		    } else {
				log.warn "Unknown LED Color-Setting LED Mode to default of 10"
				ledModeConfigValue=10
			}
		} else if (ledModeFrequency =="Long-Two Short") {
			if (ledModeColor == "Temp") {
				ledModeConfigValue=19
			} else if (ledModeColor == "Flashlight") {
				log.info "Flashlight Mode selected with Frequency Long-Two Short setting ledMode to 11-flashlight mode"
				ledModeConfigValue=11
			} else if (ledModeColor == "White") {
				ledModeConfigValue=20
			} else if (ledModeColor == "Red") {
				ledModeConfigValue=21
			} else if (ledModeColor == "Green") {
				ledModeConfigValue=22
			} else if (ledModeColor == "Blue") {
				ledModeConfigValue=23
			} else if (ledModeColor == "Yellow") {
				ledModeConfigValue=24
			} else if (ledModeColor == "Cyan") {
				ledModeConfigValue=25
			} else if (ledModeColor == "Magenta") {
				ledModeConfigValue=26
			} else {
				log.warn "Unknown LED Color-Setting LED Mode to default of 10"
				ledModeConfigValue=10
			}
		} else {
			log.warn "Unknown LED Frequencey-Setting LED Mode to default of 10"
			ledModeConfigValue=10
		}
		log.debug "Setting Param 80 to $ledModeConfigValue"
		cmds << zwave.configurationV1.configurationSet(configurationValue: [ledModeConfigValue], parameterNumber: 80, size: 1).format()
	}
	
	//  Set Brightness Parameter (81) Percentage 0-100
	log.debug "LED Brightness $ledBrightness"
	def brightness = ledBrightness as int
	if (brightness<0) {
		log.warn "LED Brightness less than 0, setting to 1"
		brightness=1
	}
	if (brightness>100) {
		log.warn "LED Brightness greater than 100, setting to 100"
		brightness=100
	}
	log.debug "Setting Param 81 to $brightness"
	cmds << zwave.configurationV1.configurationSet(configurationValue: [brightness], parameterNumber: 81, size: 1).format()
	
	if (tamperLedOnOff == "Off") {
		log.debug "Setting Tamper LED off"
		log.debug "Setting Param 89 to 0"
		cmds << zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 89, size: 1).format()
	} else {
		log.debug "Setting Tamper LED on"
		log.debug "Setting Param 89 to 1"
		cmds << zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 89, size: 1).format()
	}

	delayBetween(cmds, 500)
}

// Parse incoming device messages to generate events
def parse(String description)
{
	def result = []
	def cmd = zwave.parse(description, [0x72: 2, 0x31: 2, 0x30: 1, 0x84: 1, 0x9C: 1, 0x70: 2, 0x80: 1, 0x86: 1, 0x7A: 1, 0x56: 1])
    
    log.debug "parse cmd=$cmd description=$description"
    if (description == "updated") {
        result << response(zwave.wakeUpV1.wakeUpIntervalSet(seconds: 7200, nodeid:zwaveHubNodeId))
		result << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet())            
	}
    
	if (cmd) {
		if( cmd.CMD == "8407" ) { 
            result << response(zwave.batteryV1.batteryGet().format())
        	result << new hubitat.device.HubAction(zwave.wakeUpV1.wakeUpNoMoreInformation().format()) 
        }
		result << createEvent(zwaveEvent(cmd))
	}
    
    if ( result[0] != null ) {
		log.debug "Parse returned ${result}"
		result
    }
}

def zwaveEvent(hubitat.zwave.commands.crc16encapv1.Crc16Encap cmd)
{
	def versions = [0x31: 2, 0x30: 1, 0x84: 1, 0x9C: 1, 0x70: 2]
	// def encapsulatedCommand = cmd.encapsulatedCommand(versions)
	def version = versions[cmd.commandClass as Integer]
	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
	if (!encapsulatedCommand) {
		log.debug "Could not extract command from $cmd"
	} else {
		zwaveEvent(encapsulatedCommand)
	}
}

def createEvent(hubitat.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd, Map item1) { 
	log.debug "manufacturerId:   ${cmd.manufacturerId}"
    	log.debug "manufacturerName: ${cmd.manufacturerName}"
    	log.debug "productId:        ${cmd.productId}"
    	log.debug "productTypeId:    ${cmd.productTypeId}"
}

def createEvent(hubitat.zwave.commands.versionv1.VersionReport cmd, Map item1) {	
    updateDataValue("applicationVersion", "${cmd.applicationVersion}")
    log.debug "applicationVersion:      ${cmd.applicationVersion}"
    log.debug "applicationSubVersion:   ${cmd.applicationSubVersion}"
    log.debug "zWaveLibraryType:        ${cmd.zWaveLibraryType}"
    log.debug "zWaveProtocolVersion:    ${cmd.zWaveProtocolVersion}"
    log.debug "zWaveProtocolSubVersion: ${cmd.zWaveProtocolSubVersion}"
}

def createEvent(hubitat.zwave.commands.firmwareupdatemdv1.FirmwareMdReport cmd, Map item1) { 
    log.debug "checksum:       ${cmd.checksum}"
    log.debug "firmwareId:     ${cmd.firmwareId}"
    log.debug "manufacturerId: ${cmd.manufacturerId}"
}

def zwaveEvent(hubitat.zwave.commands.sensoralarmv1.SensorAlarmReport cmd)
{
	def map = [:]
    map.name = "acceleration"

	map.value = cmd.sensorState ? "active" : "inactive"
	if (map.value == "active") {
		map.descriptionText = "$device.displayName detected vibration"
	}
	else {
		map.descriptionText = "$device.displayName vibration has stopped"
	}
    map
}

// Event Generation
def zwaveEvent(hubitat.zwave.commands.wakeupv1.WakeUpNotification cmd)
{
	[descriptionText: "${device.displayName} woke up", isStateChange: false]
}

def zwaveEvent(hubitat.zwave.commands.sensormultilevelv2.SensorMultilevelReport cmd)
{
	def map = [:]
	switch (cmd.sensorType) {
		case 1:
			// temperature
			def cmdScale = cmd.scale == 1 ? "F" : "C"
			map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmdScale, cmd.precision)
			map.unit = getTemperatureScale()
			map.name = "temperature"
			break;
		case 3:
			// luminance
			map.value = cmd.scaledSensorValue.toInteger().toString()
			map.unit = "lux"
			map.name = "illuminance"
			break;
	}
	map
}

def zwaveEvent(hubitat.zwave.commands.batteryv1.BatteryReport cmd) {
log.debug cmd
	def map = [:]
	map.name = "battery"
	map.value = cmd.batteryLevel > 0 ? cmd.batteryLevel.toString() : 1
	map.unit = "%"
	map.displayed = false
	map
}

def zwaveEvent(hubitat.zwave.commands.sensorbinaryv1.SensorBinaryReport cmd) {
	def map = [:]
	map.value = cmd.sensorValue ? "active" : "inactive"
	map.name = "motion"
	if (map.value == "active") {
		map.descriptionText = "$device.displayName detected motion"
	}
	else {
		map.descriptionText = "$device.displayName motion has stopped"
	}
	map
}

def zwaveEvent(hubitat.zwave.commands.basicv1.BasicSet cmd) {
	def map = [:]
	map.value = cmd.value ? "active" : "inactive"
	map.name = "motion"
	if (map.value == "active") {
		map.descriptionText = "$device.displayName detected motion"
	}
	else {
		map.descriptionText = "$device.displayName motion has stopped"
	}
	map
}

def zwaveEvent(hubitat.zwave.Command cmd) {
	log.debug "Catchall reached for cmd: ${cmd.toString()}}"
	[:]
}

def zwaveEvent(hubitat.zwave.commands.configurationv2.ConfigurationReport cmd) {
	log.debug "${device.displayName} parameter '${cmd.parameterNumber}' with a byte size of '${cmd.size}' is set to '${cmd.configurationValue}'"
}

def zwaveEvent(hubitat.zwave.commands.configurationv1.ConfigurationReport cmd) {
	log.debug "V1 ${device.displayName} parameter '${cmd.parameterNumber}' with a byte size of '${cmd.size}' is set to '${cmd.configurationValue}'"
}

def zwaveEvent(hubitat.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) {
	def result = []

	def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
	log.debug "msr: $msr"
    updateDataValue("MSR", msr)
    
    if ( msr == "010F-0800-2001" ) { //this is the msr and device type for the fibaro motion sensor
    	configure()
    }

	result << createEvent(descriptionText: "$device.displayName MSR: $msr", isStateChange: false)
	result
}

//used to add "test" button for simulation of user changes to parameters
def test() {
	def params = [paramNumber:80,value:10,size:1]
	updateZwaveParam(params)
}

 /**
 * This method will allow the user to update device parameters (behavior) from an app.
 * A "Zwave Tweaker" app will be developed as an interface to do this. Or the user can
 * write his/her own app to envoke this method. No type or value checking is done to
 * compare to what device capability or reaction. It is up to user to read OEM
 * documentation prior to envoking this method.
 *
 * <p>THIS IS AN ADVANCED OPERATION. USE AT YOUR OWN RISK! READ OEM DOCUMENTATION!
 *
 * @param List[paramNumber:80,value:10,size:1]
 *
 *
 * @return none
 */
def updateZwaveParam(params) {
	if ( params ) {   
        def pNumber = params.paramNumber
        def pSize	= params.size
        def pValue	= [params.value]
        log.debug "Make sure device is awake and in recieve mode"
        log.debug "Updating ${device.displayName} parameter number '${pNumber}' with value '${pValue}' with size of '${pSize}'"

		def cmds = []
        cmds << zwave.configurationV1.configurationSet(configurationValue: pValue, parameterNumber: pNumber, size: pSize).format()
        cmds << zwave.configurationV1.configurationGet(parameterNumber: pNumber).format()
        delayBetween(cmds, 1000)        
    }
}

 /**
 * Sets all of available Fibaro parameters back to the device defaults except for what
 * SmartThings needs to support the stock functionality as released. This will be
 * called from the "Fibaro Tweaker" or user's app.
 *
 * <p>THIS IS AN ADVANCED OPERATION. USE AT YOUR OWN RISK! READ OEM DOCUMENTATION!
 *
 * @param none
 *
 * @return none
 */
def resetParams2StDefaults() {
	log.debug "Resetting Sensor Parameters to SmartThings Compatible Defaults"
	def cmds = []
	// Sensitivity 8-255 default 10 (lower value more sensitive)
	cmds << zwave.configurationV1.configurationSet(configurationValue: [10], parameterNumber: 1, size: 1).format()
	// Blind Time 0-15 default 15 (8 seconds) seconds = .5 * (setting + 1)
	// Longer Blind = Longer Battery Life
    cmds << zwave.configurationV1.configurationSet(configurationValue: [15], parameterNumber: 2, size: 1).format()
	
    cmds << zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 4, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,30], parameterNumber: 6, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 8, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,200], parameterNumber: 9, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 12, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 16, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [15], parameterNumber: 20, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,30], parameterNumber: 22, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [4], parameterNumber: 24, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 26, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,200], parameterNumber: 40, size: 2).format()
    // Illum Report Interval 0=none, 1-5 may cause temp report fail, low values waste battery
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], parameterNumber: 42, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [5], parameterNumber: 60, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [3,132], parameterNumber: 62, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], parameterNumber: 64, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], parameterNumber: 66, size: 2).format()
    // Led Signal Mode Default Default 10  0=Inactive
    cmds << zwave.configurationV1.configurationSet(configurationValue: [10], parameterNumber: 80, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [50], parameterNumber: 81, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,100], parameterNumber: 82, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [3,232], parameterNumber: 83, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [18], parameterNumber: 86, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [28], parameterNumber: 87, size: 1).format()
    // Tamper LED Flashing (White/REd/Blue) 0=Off 1=On	
    cmds << zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 89, size: 1).format()
    
    delayBetween(cmds, 500)
}

 /**
 * Lists all of available Fibaro parameters and thier current settings out to the 
 * logging window in the IDE This will be called from the "Fibaro Tweaker" or 
 * user's own app.
 *
 * <p>THIS IS AN ADVANCED OPERATION. USE AT YOUR OWN RISK! READ OEM DOCUMENTATION!
 *
 * @param none
 *
 * @return none
 */
def listCurrentParams() {
	log.debug "Listing of current parameter settings of ${device.displayName}"
    def cmds = []

    cmds << zwave.configurationV1.configurationGet(parameterNumber: 1).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 2).format()
/*    
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 3).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 4).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 6).format()
*/
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 8).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 9).format()
/*
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 12).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 14).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 16).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 20).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 22).format()
*/
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 24).format()
/*
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 26).format()
*/
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 40).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 42).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 60).format()
/*
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 62).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 64).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 66).format()
*/
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 80).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 81).format()
/*
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 82).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 83).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 86).format()
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 87).format()
*/
    cmds << zwave.configurationV1.configurationGet(parameterNumber: 89).format()
	cmds << response(zwave.batteryV1.batteryGet())
	// Not sure what these do so commenting out.
	//cmds << response(zwave.versionV1.versionGet().format())
	//cmds << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet().format())
	//cmds << response(zwave.firmwareUpdateMdV2.firmwareMdGet().format())
    
	delayBetween(cmds, 2000)
}
1 Like

Thanks @bobbles, appreciate the quick response! I'll give it a go this evening and feedback.

Also, if you open another window with live logging, you should see the config being passed to the device in the logs.

I've updated the settings as per - added comments where I have amended:

// Sensitivity 8-255 default 10 (lower value more sensitive)
	cmds << zwave.configurationV1.configurationSet(configurationValue: [10], parameterNumber: 1, size: 1).format()
	// Blind Time 0-15 default 15 (8 seconds) seconds = .5 * (setting + 1)
	// Longer Blind = Longer Battery Life
    cmds << zwave.configurationV1.configurationSet(configurationValue: [15], parameterNumber: 2, size: 1).format()
	
    cmds << zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 3, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [2], parameterNumber: 4, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,30], parameterNumber: 6, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 8, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,200], parameterNumber: 9, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 12, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 16, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [15], parameterNumber: 20, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,30], parameterNumber: 22, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [4], parameterNumber: 24, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], parameterNumber: 26, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,200], parameterNumber: 40, size: 2).format()
    // Illum Report Interval 0=none, 1-5 may cause temp report fail, low values waste battery
    //Send illumanance reports every hour
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,3600], parameterNumber: 42, size: 2).format() 
    cmds << zwave.configurationV1.configurationSet(configurationValue: [5], parameterNumber: 60, size: 1).format()
    //Original was 132 but don't need as often
    cmds << zwave.configurationV1.configurationSet(configurationValue: [3,900], parameterNumber: 62, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], parameterNumber: 64, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], parameterNumber: 66, size: 2).format()
    // Led Signal Mode Default Default 10  0=Inactive
    cmds << zwave.configurationV1.configurationSet(configurationValue: [10], parameterNumber: 80, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [50], parameterNumber: 81, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,200], parameterNumber: 82, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [3,232], parameterNumber: 83, size: 2).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [18], parameterNumber: 86, size: 1).format()
    cmds << zwave.configurationV1.configurationSet(configurationValue: [28], parameterNumber: 87, size: 1).format()
    // Tamper LED Flashing (White/REd/Blue) 0=Off 1=On	
    cmds << zwave.configurationV1.configurationSet(configurationValue: [1], parameterNumber: 89, size: 1).format()

When I open live logging I'm seeing some errors before clicking resetParams2StDefaults and during the push:

Maybe change the parameters in the in-built driver and do the same. Press the b button then config button.
Check to see if the config gets passed as you want it.

Thanks for the support. I wasn't sure the parameters were updating as the behaviour wasn't changing the brightness of the LED when it was dark (parameter 82).

I found this tool, Super basic Z-Wave parameter tool which is really easy to query the individual paramters and because I only was tweaking 3 of them I used this instead. When I query the parameter after updating it indicates things have changed but as I said the behaviour still is the same.

I'll have another play around at some stage and if I notice things change, I'll try to remember to update here for completeness.

Thanks again for the help. Appreciate you making the community as supportive as it is!

1 Like

Just to add to the body of knowledge for these devices. I played around with the standard device handler (Fibaro Motion Sensor ZW5) and updated the available parameters in the device UI. I’ve been using the Basic ZWave Tool to validate settings.

So to update from the std. device handler, I triple clicked the B button on the device and the LED goes blue (Wake mode). I then clicked the Configure button in the UI and monitored Live Logging. Once the blue LED goes away, triple click again and now press Refresh in the UI. Click Refresh once again and see the instructions in Live Logging. Finally to update the device parameters in the UI with those on the device, while the device is still in Wake Mode, click the B button once on the device and you’ll see the parameters being requested from the device. These then update on the device UI...

I’m still not seeing the desired behaviour based on certain parameter (specifically 82 to dim the LED in low light) but I’ll leave it overnight to see if it needs cycling or something like that....otherwise the search continues.

Is this for the old z-wave 300 version since it said 2014?
Do you know any functionality difference between the old and the ZW5 version other than ZW vs ZW Plus?
Old version is considerably cheaper for new. It has motion and lux that will fit my purpose and particular interested in the eye LED to double use it on Halloween trick or treat door or table.

Download the Hubitat app