I’m looking to strip out a couple of misbehaving Fibaros and put these in as they seem a bit more bulletproof from what I’ve read. I’ll be putting them in the ceiling rose, so I’ll have neutral, which is a requirement.
I wondered if anyone was using them, or knew of an existing Device Type?
I have 5 Qubino units. The dimmer works great. But the Flush 2 Relays only control of 1 relay works.
The Dimmer is really nice and it works on most lightning. Recommended compared to the Fibaro
Do you have the device type code for the dimmer?
My reason for looking at these is that they’ve been recommended to me by the retailer for my setup (wiring into the ceiling rose) and as such in hoping to get their support if these don’t work out. I asked them about the Aeon boxes, which they sell and had nothing negative to say about them, but suggested the Qubino ones have so far proven to work in all setups.
My current problem is that when I switch on via z-wave, they come on for a fraction of a second and then turn off. It’s really frustrating, and happens most of the time but not 100% of the time. I’ve not had a chance to run the live log yet, but I don’t see how an off could be getting sent to the unit, assuming of course that is what is happening.
Have a couple Qubino flush dimmers. These are connected to a pair of ordinary light bulbs with low watt and works superbly. Could wish me they dimmed up and down a little slower. Wonder if it is easy to adjust the dimming time ?
The device type I have is ZMNHDD1 H1S1P1 (EU, z-wave plus)
Fingerprint is 0 0 0x1101 0 0 0 13 0x5E 0x86 0x72 0x5A 0x73 0x20 0x27 0x25 0x26 0x30 0x71 0x32 0x60 0x85 0x8E 0x59 0x70 0xEF 0x20
There are three values affecting dimming time- but I think we’d need need a custom device handler so set them (it sounds like parameter 66 is the one Geir wants):-
Parameter no. 65 – Dimming time (soft on/off)
Set value means time of moving the Dimmer between min. and max. dimming values by short press of push button I1 or controlled through UI (BasicSet). Available configuration parameters (data type is 2 Byte DEC):
default value 100 = 1s
50 - 255 = 500 mseconds - 2550 mseconds (2,55s), step is 10 mseconds
Parameter no. 66 – Dimming time when key pressed
Time of moving the Dimmer between min. and max dimming values by continues hold of push button I1 or associated device. Available configuration parameters (data type is 2 Byte DEC):
default value 3 = 3s
1- 255 = 1 second – 255 seconds
Parameter no. 68 – Dimming duration
This parameter is used with association group 3.
The Duration field MUST specify the time that the transition should take from the current value to the new target value. A supporting device SHOULD respect the specified Duration value. Available configuration parameters (data type is 1 Byte DEC):
default value 0 (dimming duration according to parameter 66)
1 - 127 (from 1 to 127 seconds)
What device type are others using? Mine was detected as z-wave multi-channel device but I’ve changed this to z-wave metering dimmer. I really want a custom handler so I can use the second and third input to control other devices…
The only issue I’ve had with them is the manual switch now only turns mine off- not on. I think I need to set a parameter…
The manual switch issue was cleared with Qubino support and found a good point…
The Z-wave plus Qubino use switched live for control as opposed to switched neutral on the non Zwave plus Qubino devices.
I have a custom handler now, recognised by fingerprint but have some issues with java exceptions- think I’ve tried to be a bit too clever with my first handler…
Hi Chris,
Would you mind sharing the device handler code please?
Thanks, Paul.
PS, no problem if it’s buggy. I’m new to writing handlers too.
Hi Paul,
sorry, been away and just seen your message.
See below the handler. The fingerprint is right, but I bit off a bit too much trying to get the custom attributes working from a handler I copied- errors there. That said, spent a lot of time getting the right text for custom attributes in so it might help you get where you want.
Let me know if you get anywhere- I’m up to my ears in work just now and solving more pressing Smartthings issues in the litle time I have- so will be at least 2 - 3 months before I can look at this again!
/**
*
http://www.apache.org/licenses/LICENSE-2.0
*/
metadata {
definition (name: “Qubino Flush Plus Dimmer”, namespace: “chrisgla”, author: “Chris McGookin”) {
attribute "needUpdate", "string"
capability "Switch"
capability "Polling"
capability "Power Meter"
capability "Energy Meter"
capability "Refresh"
capability "Switch Level"
capability "Sensor"
capability "Actuator"
capability "Configuration"
capability "Zw Multichannel"
command "reset"
command "resetParams2StDefaults"
command "listCurrentParams"
command "updateZwaveParam"
command "test"
command "configure"
fingerprint deviceId: "0x1101", inClusters: "0x5E,0x86,0x72,0x5A,0x73,0x20,0x27,0x25,0x26,0x30,0x71,0x32,0x60,0x85,0x8E,0x59,0x70,0xEF,0x20"
}
simulator {
status "on": "command: 2603, payload: FF"
status "off": "command: 2603, payload: 00"
status "09%": "command: 2603, payload: 09"
status "10%": "command: 2603, payload: 0A"
status "33%": "command: 2603, payload: 21"
status "66%": "command: 2603, payload: 42"
status "99%": "command: 2603, payload: 63"
for (int i = 0; i <= 10000; i += 1000) {
status "power ${i} W": new physicalgraph.zwave.Zwave().meterV3.meterReport(
scaledMeterValue: i, precision: 3, meterType: 4, scale: 2, size: 4).incomingMessage()
}
for (int i = 0; i <= 100; i += 10) {
status "energy ${i} kWh": new physicalgraph.zwave.Zwave().meterV3.meterReport(
scaledMeterValue: i, precision: 3, meterType: 0, scale: 0, size: 4).incomingMessage()
}
["FF", "00", "09", "0A", "21", "42", "63"].each { val ->
reply "2001$val,delay 100,2602": "command: 2603, payload: $val"
}
}
tiles {
standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
state "turningOn", label:'${name}', icon:"st.switches.switch.on", backgroundColor:"#79b821"
state "turningOff", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ffffff"
}
valueTile("power", "device.power") {
state "default", label:'${currentValue} W'
}
valueTile("energy", "device.energy") {
state "default", label:'${currentValue} kWh'
}
standardTile("reset", "device.energy", inactiveLabel: false, decoration: "flat") {
state "default", label:'reset kWh', action:"reset"
}
controlTile("levelSliderControl", "device.level", "slider", height: 1, width: 3, inactiveLabel: false) {
state "level", action:"switch level.setLevel"
}
standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
}
}
main(["switch","power","energy"])
details(["switch", "power", "energy", "levelSliderControl", "refresh", "reset"])
}
/**
/**
def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
dimmerEvents(cmd)
}
def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
dimmerEvents(cmd)
}
def zwaveEvent(physicalgraph.zwave.commands.switchmultilevelv3.SwitchMultilevelReport cmd) {
dimmerEvents(cmd)
}
def dimmerEvents(physicalgraph.zwave.Command cmd) {
def result = []
def value = (cmd.value ? “on” : “off”)
def switchEvent = createEvent(name: “switch”, value: value, descriptionText: “$device.displayName was turned $value”)
result << switchEvent
if (cmd.value) {
result << createEvent(name: “level”, value: cmd.value, unit: “%”)
}
if (switchEvent.isStateChange) {
result << response([“delay 3000”, zwave.meterV3.meterGet(scale: 2).format()])
}
return result
}
def zwaveEvent(physicalgraph.zwave.commands.meterv3.MeterReport cmd) {
if (cmd.meterType == 1) {
if (cmd.scale == 0) {
return createEvent(name: “energy”, value: cmd.scaledMeterValue, unit: “kWh”)
} else if (cmd.scale == 1) {
return createEvent(name: “energy”, value: cmd.scaledMeterValue, unit: “kVAh”)
} else if (cmd.scale == 2) {
return createEvent(name: “power”, value: Math.round(cmd.scaledMeterValue), unit: “W”)
} else {
return createEvent(name: “electric”, value: cmd.scaledMeterValue, unit: [“pulses”, “V”, “A”, “R/Z”, “”][cmd.scale - 3])
}
}
}
def on() {
delayBetween([
zwave.basicV1.basicSet(value: 0xFF).format(),
zwave.switchMultilevelV3.switchMultilevelGet().format(),
], 5000)
}
def off() {
delayBetween([
zwave.basicV1.basicSet(value: 0x00).format(),
zwave.switchMultilevelV3.switchMultilevelGet().format(),
], 5000)
}
def poll() {
delayBetween([
zwave.meterV3.meterGet(scale: 0).format(),
zwave.meterV3.meterGet(scale: 2).format(),
], 1000)
}
def refresh() {
delayBetween([
zwave.switchMultilevelV3.switchMultilevelGet().format(),
zwave.meterV3.meterGet(scale: 0).format(),
zwave.meterV3.meterGet(scale: 2).format(),
], 1000)
}
def setLevel(level) {
if(level > 99) level = 99
delayBetween([
zwave.basicV1.basicSet(value: level).format(),
zwave.switchMultilevelV3.switchMultilevelGet().format()
], 5000)
}
preferences {
input description: "Once you change values on this page, the `Synced` Status will become `pending` status.",
displayDuringSetup: false, type: "paragraph", element: "paragraph"
generate_preferences(configuration_model())
}
/**
/**
/**
Update current cache properties
*/
def update_current_properties(cmd)
{
def currentProperties = state.currentProperties ?: [:]
currentProperties."${cmd.parameterNumber}" = cmd.configurationValue
if (settings."${cmd.parameterNumber}" != null)
{
if (settings."${cmd.parameterNumber}".toInteger() == cmd2Integer(cmd.configurationValue))
{
sendEvent(name:“needUpdate”, value:“NO”, displayed:false, isStateChange: true)
}
else
{
sendEvent(name:“needUpdate”, value:“YES”, displayed:false, isStateChange: true)
}
}
state.currentProperties = currentProperties
}
/**
Update needed settings
*/
def update_needed_settings()
{
def cmds = []
def currentProperties = state.currentProperties ?: [:]
def configuration = parseXml(configuration_model())
def isUpdateNeeded = “NO"
configuration.Value.each
{
if (currentProperties.”${it.@index}" == null)
{
log.debug “Current value of parameter ${it.@index} is unknown"
isUpdateNeeded = “YES”
}
else if (settings.”${it.@index}" != null && cmd2Integer(currentProperties."${it.@index}") != settings."${it.@index}".toInteger())
{
log.debug “Parameter ${it.@index} will be updated to " + settings.”${it.@index}“
isUpdateNeeded = “YES"
switch(it.@type)
{
case [“byte”, “list”]:
cmds << zwave.configurationV2.configurationSet(configurationValue: [(settings.”${it.@index}”).toInteger()], parameterNumber: it.@index.toInteger(), size: 1).format()
breakconfigurationV2.configurationGet
case “short”:
def short valueLow = settings."${it.@index}" & 0xFF
def short valueHigh = (settings."${it.@index}" >> 8) & 0xFF
def value = [valueHigh, valueLow]
cmds << zwave.configurationV2.configurationSet(configurationValue: value, parameterNumber: it.@index.toInteger(), size: 2).format()
break
}
cmds << zwave.configurationV2.configurationGet(parameterNumber: it.@index.toInteger()).format()
}
}
sendEvent(name:“needUpdate”, value: isUpdateNeeded, displayed:false, isStateChange: true)
return cmds
}
/**
Try to sync properties with the device
*/
def sync_properties()
{
def currentProperties = state.currentProperties ?: [:]
def configuration = parseXml(configuration_model())
def cmds = []
configuration.Value.each
{
if (! currentProperties."${it.@index}" || currentProperties."${it.@index}" == null)
{
log.debug "Looking for current value of parameter ${it.@index}"
cmds << zwave.configurationV2.configurationGet(parameterNumber: it.@index.toInteger()).format()
}
}
if (device.currentValue(“needUpdate”) == “YES”) { cmds += update_needed_settings() }
return cmds
}
/**
*/
def configure() {
log.debug "Configuring Device For SmartThings Use"
def cmds = []
// Associate Group 3 Device Status (Group 1 is for Basic direct action -switches-, Group 2 for Tamper Alerts System -alarm-)
// Hub need to be Associate to group 3
cmds << zwave.associationV2.associationSet(groupingIdentifier:1, nodeId:[zwaveHubNodeId]).format()
cmds << zwave.associationV2.associationSet(groupingIdentifier:2, nodeId:[zwaveHubNodeId]).format()
cmds << zwave.associationV2.associationSet(groupingIdentifier:3, nodeId:[zwaveHubNodeId]).format()
cmds << zwave.associationV2.associationSet(groupingIdentifier:4, nodeId:[zwaveHubNodeId]).format()
cmds << zwave.associationV2.associationSet(groupingIdentifier:5, nodeId:[zwaveHubNodeId]).format()
cmds << zwave.associationV2.associationSet(groupingIdentifier:6, nodeId:[zwaveHubNodeId]).format()
cmds << zwave.associationV2.associationSet(groupingIdentifier:7, nodeId:[zwaveHubNodeId]).format()
cmds << zwave.associationV2.associationSet(groupingIdentifier:8, nodeId:[zwaveHubNodeId]).format()
cmds << zwave.associationV2.associationSet(groupingIdentifier:9, nodeId:[zwaveHubNodeId]).format()
cmds << zwave.associationV2.associationSet(groupingIdentifier:10, nodeId:[zwaveHubNodeId]).format()
cmds << zwave.associationV2.associationSet(groupingIdentifier:11, nodeId:[zwaveHubNodeId]).format()
cmds += sync_properties()
delayBetween(cmds , 1500)
}
/**
/**
Define the Qubino Dimmer model used to generate preference pane.
*/
def configuration_model()
{
’’'
0 - mono-stable switch type (push button) – button quick press turns between previous set Dimmer value and zero
1 - bi-stable switch type
Default setting: 0
0 - mono-stable switch type (push button) – button quick press turns between previous set Dimmer value and zero
1 - bi-stable switch type
Default setting: 0
<Value type="byte" index="3" label="Input 2 contact type" min="0" max="1" value="0">
<Help>
0 - NO (normally open) input type
1 - NC (normally close) input type
Default setting: 0
sensor binary (9): GENERIC_TYPE_SENSOR_BINARY, SPECIFIC_TYPE_NOT_USED
9 - Sensor binary
Default setting: 1
NOTE 1: After parameter change, first exclude module (without setting parameters to default value) then wait at least 30s and then re include the module!
NOTE 2: When the parameter is set to value 9 the notifications are send for Home Security
sensor binary (9): GENERIC_TYPE_SENSOR_BINARY, SPECIFIC_TYPE_NOT_USED
9 - Sensor binary
Default setting: 1
NOTE 1: After parameter change, first exclude module (without setting parameters to default value) then wait at least 30s and then re include the module!
NOTE 2: When the parameter is set to value 9 the notifications are send for Home Security
def createEvent(physicalgraph.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(physicalgraph.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(physicalgraph.zwave.commands.firmwareupdatemdv1.FirmwareMdReport cmd, Map item1) {
log.debug "checksum: ${cmd.checksum}"
log.debug "firmwareId: ${cmd.firmwareId}"
log.debug “manufacturerId: ${cmd.manufacturerId}”
// log.debug “Parse received ${description}”
}
Thanks, can you attach it as a txt file or something please?
I’m getting this when paste the above code into the IDE: Java.lang.reflect.UndeclaredThrowableException
If I haven’t fried my 2 flush dimmers I’ll tidy this up. I initially wired them up with switched neutral (Qubino Dimmer style) instead of a switched live (Quibino Flush Dimmer).
They worked for a couple of weeks after I re-wired them correctly but they’re both completely unresponsive at the mo.
Thanks again.
I done the same thing as they changed switching pole between zwave and zwave plus and some of the faq’s are wrong.
They are probably not fried.
For now I’m using zwave metered dimmer, I thought they were unresponsive but found that after applying power each time they do nothing when you switch them on. Try increasing the dim slider to 100% and that may works- mine seem to default to dim level of 0% when powered on at first.
Will try to extract the device handler when I get a chance but Smartthings UK don’t make it easy- why oh why won’t they give us Github integration!!!
Mine came back to life after power cycling the downstairs lighting circuit, I was actually working on some other lights so it was a nice surprise.
Ditto the thoughts on the Github intergration!
Any updates on the more advanced device handler on this one guys?
Trying the code above results in Java.lang.reflect.UndeclaredThrowableException when trying to create a new handler from code.
I’ve just ordered a couple to try out, I have a couple of fibaro dimmer 2’s that work great but I prefer the idea of using these on my circuits that only have a couple of LED bulbs rather than the less elegant idea of using a bypass.
Sorry, been working away and struggle to get my head into handler dev mode! The generic zwave handler is ok- main omission is the second input and tuning parameters.
Could you perhaps have a skim of what I’ve been working on today (maybe someone could give it a shot - I’m waiting for my Qubino dimmers to arrive)?
I’ve adapted a very nice Fibaro Dimmer 2 profile from Rajiv - I have replaced with the fingerprint you posted above, and taken all the parameter tiles from the instruction manual… I’ve also adjusted the Byte size per parameter according to the manual (I think, lol).
Not sure what else might need doing but perhaps it might help get things rolling!
EDIT - ok posting code just really doesn’t work on the forum for me lol.
Just created this github account, hopefully this link works https://github.com/Zeeflyboy/Glowing-Eureka/blob/master/Qubino%20Dimmer%20Plus
Ok so my Qubino’s just arrived and i got them installed.
Great bit of kit, very good dimming control and no flickering, even on the landing circuit where there’s just 2 x 5w led bulbs.
Anyway, as you say it does work with no frills using the z-wave metering dimmer device type.
I tried my code linked to above and with that device type installed, all the configuration options show up under the settings tab, so that’s good. Unfortunately it doesn’t turn on, so that’s bad. Clearly need to spend more time figuring out this programming malarky.
Gentlemen,
I have installed one Qubino dimmer (ZMNHDD1), and the LED bulb turns on, but I cannot turn it off again or dim up and down. I am using the Z-Wave Metering Dimmer device type, which all the rest of you seem to be using with no problems. Is there anything I am missing? (the LED bulb is a dimmable 7.5W megaman bulb). The device also has status “inactive” in the smartthings IDE.
Best regards,
Eivind
Bump. Is anyone else having any issues with this dimmer, or is it working flawlessly for everyone else?
Regards,
Eivind
I’ m having no less issues than with other z-wave things using Z-wave metering dimmer device handler ( I have unresolved failure to actuate with some things)
Only thing that causes me confusion is when power goes off it seems to set level to 0%. Fix this in Smart Lighting app by using “turn on and set level to” rather than just turn on