Some basic DMX questions

@MDAR thanks for the detailed response!

I played around on QLC+ last night and successfully connected openHAB using sACN. Unless I’m missing something, it seems to now support numerous universes. I was able to control virtual dimmers and start scenes and chasers using openHAB items.

I’ll need to play around with it more once I’ve actually acquired some DMX gear, but it appears to be a great multi platform option. It has a built in RGB matrix tool, and I successfully created a test device of 1x200 pixels that would fit my use case for neopixel lights. It includes a number of chaser options.

I just so happen to have a spare lying around! Does this require a second router, or can you get away with just using static IPs and connecting the devices directly?

That’s excellent news.

I will revisit that and see what’s going on with it.

Thanks for the update :slight_smile:

Oh I say, that is a massive improvement :slight_smile:

That’s exactly the way to do it.

Keep it as simple as possible, with as few active switches as possible.

Just use the dumbest hub you can find.

This article supports this approach.

I look forward to hearing how you get on.

If you’re looking for good Art-NET / sACN to SPi kit, you can do a lot worse that use the Smart-Show stuff.

It’s rock solid and works like a charm.

The Net_WS340 is a good starting point.

@MDAR @andy31 (because you had DMX questions on another thread)

Here’s where I’m at:

I have been continuing to explore QLC+ and it seems like a great multi-platform option.

The developer offers a Raspberry Pi version that is the only paid version (€15), but it seems to install on any Debian installation. Importantly, it runs as a service and offers a web interface that allows access to control it from any browser. These are critical for using it in a home automation environment, as it would be far too fiddly to just leave an instance of the GUI app open. I paid for it and am very intrigued by the possibilities. Currently I have it installed on a RPi 4 that I have as a supplemental desktop computer, but

I’ve ordered a few pieces of DMX hardware, so I’ll have a better sense of how well it works with real world devices once they arrive. That said, it seems to have a loyal following with lighting professionals, so that seems to imply that it’s good software.

I’m prototyping the binding and QLC+ using HABPanel. On the top, 12 sliders control the 12 sliders in the QLC+ virtual desk. The Color item controls the RGB sliders, and the widget next to it activates a chaser. The bottom half is a frame widget pointed at the QLC+ web interface.

1 Like

Could you give some more information about how you’ve created a fader / slider / dimmer in openHAB2 to control a Handle / Fader in QLC+ please.


Is it fairly straightforward, like setting QLC+ to listen to an Art-NET / sACN universe from openHAB2 and map a DMX channel to a fader?

Or is it more complex than that?

I just got some hardware so give me a few days to play around with it and I’ll give you a solid answer based on real world hardware!

My test setup anyways was very easy to map. Basically I just watched the QLC+ tutorials and read the openHAB dmx binding page and I was able to bring them together with minimal effort.

1 Like

Okay, sorry for the delay. I haven’t had lots of tinkering time and have been split between DMX and the new LCARS interface on the other thread.

The short answer is that it’s pretty easy. I run openHAB (and a bunch of other stuff) on an Ubuntu box inside Docker. For my desktop setup, I have a two-monitor MacBook Pro set up, with a RPi4 connected to monitors on either side. The Pi monitors are for light web browsing, logs, and a HABpanel to stay up whenever I’m at the desk.

For the moment, I have QLC+ installed on the RPi4. Like I said elsewhere, I am using the paid version of QLC+ (€15 for lifetime updates). The author makes a pre-built image available, but I installed the .deb package since I’m using the Pi for other things as well.

The package includes the typical QLC+ program (the same as available on Mac) as well as a systemd service version that exposes control via a webpage on the local network. The service version is limited to basic control and doesn’t offer you the ability to create much of anything, so it’s usefulness is limited to running projects that you create using the full version.

At the moment, I’ve found it easier to just run the full desktop version while I build up my DMX system. Once it’s mature, it will be easier to run it on the systemd version.

Yes, it’s straightforward. I have openHAB communicating with QLC+ on Universe 7, and it’s open as an input only universe in QLC+. There’s two options, as far as I’ve discovered, for passing openHAB instructions onto devices with QLC+ in the middle.

  1. Configure a universe (ArtNet or SACN E1.31) as an input from openHAB and as an output to wherever your lights are. When set up this way, openHAB continually overrides any local setting on QLC+, so openHAB has the last say as to how the light is displaying.
  2. Set up a dedicated input universe to communicate between openHAB and QLC+. Then, add items to the virtual desk and configure them to react to input from the openHAB input universe and then output to either a scene, a chaser, or to a level on a channel.

I’m using the second approach. It’s more work to setup but respects the chasers rather than overriding the levels with an openHAB color item.

Does that answer your questions? I found the QLC+ video tutorials helpful in figuring this all out.

1 Like

I’ve run into a bit of a snag. I’m trying to control QLC from openHAB. I am using Universe 7 to control QLC.

Things file:

 dimmer dmxch101 [dmxid="101"]

Items file:

Dimmer A_SYSP_DMX_U07_Ch101 "DMX U07 CH 101" { channel="dmx:dimmer:dmx-u07:dmxch101:brightness" }

What I’d like to do is use a dimmer item in openHAB to send numerical values to QLC. For example, I have an Ambient scene I want to trigger when the dimmer is set to 12. Unfortunately, the value of the number immediately changes from a round number to a rather long decimal.

2020-03-11 23:51:33.245 [nt.ItemStatePredictedEvent] - A_SYSP_DMX_U07_Ch012 predicted to become 55

2020-03-11 23:51:33.247 [vent.ItemStateChangedEvent] - A_SYSP_DMX_U07_Ch012 changed from 74.901960784313729391215019859373569488525390625 to 55

2020-03-11 23:51:33.268 [vent.ItemStateChangedEvent] - A_SYSP_DMX_U07_Ch012 changed from 55 to 54.90196078431372228578766225837171077728271484375

I’m guessing the issue is that the binding is converting a round percentile number into a percentage of 255. Unfortunately it’s wreaking havoc with QLC - the first proper number is received, but the second number with many decimal places is sent a few milliseconds later, causing the scene I want to select to only flash briefly.

I tried substituting the dimmer with number, and while it did stop the numbers from getting messed up, the binding stopped sending values to QLC+.

Any suggstions? I strongly prefer to use a single DMX item if possible to avoid cluttering up my paperUI. It also would fit far better into my existing scene scheme.

Before anyone spends too much trying to help here, I think this might not work on the QLC side either. I probably will need to use a button for each scene I want to control, and will need to build logic so each button press will be simulated by a change of value on each corresponding channel.

1 Like

I’m wondering if there is a way to leverage the web interface of QLC+ and send your Number to the asset / handle / slider / text field via a HTTP call?

Sounds like it, yep.
This binding offers no transform at channel level, so we can’t tackle it there.
A transform profile works at channel->Item level, that would be good … but sadly not currently usable with Number or Dimmer types.
Any corrective action will have to be either binding enhancement or external e.g. dummy Items and rules.

Tell us more about why this gives you a problem. What is this scene that flashes, how is it related to or derived from the Item state. Perhaps we can fix that end and make it less data-format-dependent

Who cares, that’s an adminstrators toolkit. I strongly recommend using one of the proper user-facing UIs.

I’m not sure what can be done with the API for QLC+…

but have you seen this demo?

Can you make use of the Cue list control ?

This API demonstrates how to control a Virtual Console Cue List widget. The parameters to be used are:
Cue List ID : The Cue List widget ID as retrieved with the ‘getWidgetsList’ API
Operation : The Cue List operation to perform. Possible values are ‘PLAY’, ‘NEXT’, ‘PREV’ and ‘STEP’. Only the ‘STEP’ operation requires a third parameter. The ‘PLAY’ operation will stop the Cue List if called twice.
Step : The Cue List step index to play. Index starts from 0.

Or the Basic Widget Value Set ?

This API is the direct way to set a Virtual Console widget value. It can be used for Buttons, Sliders and Audio Triggers. The value to set depends on the widget type itself. Buttons and Audio triggers will only support values 0 (= off) and 255 (= on) while Sliders will accept all the values in the 0-255 range.

@MDAR and @rossko57 thanks for the help!

I won’t bore you with what I thought, because later last night I discovered I was wrong! Even if I had been getting nice round integers over to QLC+, I wouldn’t have been successful in triggering functions as I didn’t understand how to set everything up in QLC+ and what the limitations are.

That is indeed how I use it; I do find myself in my Things list fairly often making changes.

I had no idea - that’s exactly what I’m looking for! I already use nodeRED for a majority of my scene based automation, so it was really easy to set up web sockets next to the existing automation logic. I’m using the “Basic widget value set” to trigger the various functions, and use a trigger node to send a “0” command afterward to ensure it’s ready for a future activation (per QLC+ documentation, it prefers a “255” followed by a “0” to activate a button.)

I found and used a Homeseer forum post to help me get it up and running.

Here’s the nodeRED logic using web socket out nodes:

If anyone else is looking into trying QLC+, I will write up a tutorial once I’ve gotten my setup stable.


That’s excellent :slight_smile:

How are you structuring the payload for the websocket?

Sorry, I’ve been preoccupied lately and forgot to respond to this!

I’ve updated it to remove the change node. I can accomplish everything I want using just the trigger node.
Screen Shot 2020-04-11 at 00.46.25

This is what the trigger node looks like:

This is what the websocket config looks like:

Screen Shot 2020-04-11 at 00.57.55

QLC+ states in its documentation that to actuate a button the software expects a value of 255 followed by 0, hence the trigger node. As for 5, that’s the name of the appropriate widget (in this case, it corresponds to the “stage” scene I created in QLC and added to the virtual console:

Screen Shot 2020-04-11 at 00.52.47

I obtained the widget number using the API you referenced earlier:

Thanks again for pointing that out!

1 Like

Thanks again for your detailed explanation of how you’ve linked openHAB2 to QLCplus, it really inspired me to get my head around it.

Curiously, I’ve managed to do everything I wanted to by just using the DMX binding of openHAB2 and link sACN channels to elements of the Virtual Console in QLCplus.

As I’ve also got my head around the expire binding, I can create the button press that you were looking for purely with DMX too.
But it seems to respond to any value >0 to trigger.
So I just use a button in HabPanel to send anything to the correct DMX Dimmer Item and let it time out back to 0

(Dimmer 9 is what I’ve tested it with in these examples.)

Being able to use a ColourPicker in HabPanel to set the start and end colours of effects is pretty cool too.

These are the sample Things and Item files that got me started.


 Bridge dmx:sacn-bridge:QLCBridge "QLCsACN" @ "QLC"	[ mode="unicast", address="", universe=1 ] {
	dimmer QLC_Master  "QLC Master Dimmer" @ "QLC" [dmxid="1", fadetime=1000, dimtime=1000 ]
	dimmer QLC_all  "QLC All sub Channels" @ "QLC" [dmxid="2/511" ]
	dimmer QLC_Ch02  "QLC Channel 2" @ "QLC" [dmxid="2" ]
	dimmer QLC_Ch03  "QLC Channel 3" @ "QLC" [dmxid="3" ]
	dimmer QLC_Ch04  "QLC Channel 4" @ "QLC" [dmxid="4" ]
	dimmer QLC_Ch05  "QLC Channel 5" @ "QLC" [dmxid="5" ]
	dimmer QLC_Ch06  "QLC Channel 6" @ "QLC" [dmxid="6" ]
	dimmer QLC_Ch07  "QLC Channel 7" @ "QLC" [dmxid="7" ]
	dimmer QLC_Ch08  "QLC Channel 8" @ "QLC" [dmxid="8" ]
	dimmer QLC_Ch09  "QLC Channel 9" @ "QLC" [dmxid="9" ]
	dimmer QLC_Ch10  "QLC Channel 10" @ "QLC" [dmxid="10" ]
	dimmer QLC_Ch11  "QLC Channel 11" @ "QLC" [dmxid="11" ]
	chaser QLC_chase01 "QLC Chase 01" @ "QLC" [dmxid="2/10", steps="2000:255,0,0,0,0,0,0,0,0,0:-1" ] 
	chaser QLC_chase02 "QLC Chase 02" @ "QLC" [dmxid="2/10", steps="2000:0,255,0,0,0,0,0,0,0,0:-1" ] 
	chaser QLC_chase03 "QLC Chase 03" @ "QLC" [dmxid="2/10", steps="2000:0,0,255,0,0,0,0,0,0,0:-1" ] 
	chaser QLC_chase04 "QLC Chase 04" @ "QLC" [dmxid="2/10", steps="2000:0,0,0,255,0,0,0,0,0,0:-1" ] 
	chaser QLC_chase05 "QLC Chase 05" @ "QLC" [dmxid="2/10", steps="2000:0,0,0,0,255,0,0,0,0,0:-1" ] 
	chaser QLC_chase06 "QLC Chase 06" @ "QLC" [dmxid="2/10", steps="2000:0,0,0,0,0,255,0,0,0,0:-1" ]
	chaser QLC_chase07 "QLC Chase 07" @ "QLC" [dmxid="2/10", steps="2000:0,0,0,0,0,0,255,0,0,0:-1" ] 
	chaser QLC_chase08 "QLC Chase 08" @ "QLC" [dmxid="2/10", steps="2000:0,0,0,0,0,0,0,255,0,0:-1" ] 
	chaser QLC_chase09 "QLC Chase 09" @ "QLC" [dmxid="2/10", steps="2000:0,0,0,0,0,0,0,0,255,0:-1" ]
	chaser QLC_chase10 "QLC Chase 10" @ "QLC" [dmxid="2/10", steps="2000:0,0,0,0,0,0,0,0,255,0:-1" ]
	color  QLC_rgb01 "QLC RGB 01" @ "QLC"    [dmxid="50/3", fadetime=1000, dimtime=10000 ]


Group:Dimmer:MAX QLC_SubMaster_1 "QLC SubMaster 1"

Switch QLCMasterMute "QLC Master Mute" { channel="dmx:sacn-bridge:QLCBridge:mute" }

Dimmer QLCMaster "QLC Master"  { channel="dmx:dimmer:QLCBridge:QLC_Master:brightness" }

Dimmer QLC_Ch02_Dim "QLC Channel 02 Dimmer" (QLC_SubMaster_1) { channel="dmx:dimmer:QLCBridge:QLC_Ch02:brightness" }
Dimmer QLC_Ch03_Dim "QLC Channel 03 Dimmer" (QLC_SubMaster_1) { channel="dmx:dimmer:QLCBridge:QLC_Ch03:brightness" }
Dimmer QLC_Ch04_Dim "QLC Channel 04 Dimmer" (QLC_SubMaster_1) { channel="dmx:dimmer:QLCBridge:QLC_Ch04:brightness" }
Dimmer QLC_Ch05_Dim "QLC Channel 05 Dimmer" (QLC_SubMaster_1) { channel="dmx:dimmer:QLCBridge:QLC_Ch05:brightness" }
Dimmer QLC_Ch06_Dim "QLC Channel 06 Dimmer" (QLC_SubMaster_1) { channel="dmx:dimmer:QLCBridge:QLC_Ch06:brightness" }
Dimmer QLC_Ch07_Dim "QLC Channel 07 Dimmer" (QLC_SubMaster_1) { channel="dmx:dimmer:QLCBridge:QLC_Ch07:brightness" }
Dimmer QLC_Ch08_Dim "QLC Channel 08 Dimmer" (QLC_SubMaster_1) { channel="dmx:dimmer:QLCBridge:QLC_Ch08:brightness" }
Dimmer QLC_Ch09_Dim "QLC Channel 09 Dimmer" (QLC_SubMaster_1) { channel="dmx:dimmer:QLCBridge:QLC_Ch09:brightness",expire="1s,command=0" }
Dimmer QLC_Ch10_Dim "QLC Channel 10 Dimmer" (QLC_SubMaster_1) { channel="dmx:dimmer:QLCBridge:QLC_Ch10:brightness" }
Dimmer QLC_Ch11_Dim "QLC Channel 11 Dimmer" (QLC_SubMaster_1) { channel="dmx:dimmer:QLCBridge:QLC_Ch11:brightness" }

Switch QLC_Chase01 "QLC Chase 01" { channel="dmx:chaser:QLCBridge:QLC_chase01:switch" }
Switch QLC_Chase02 "QLC Chase 02" { channel="dmx:chaser:QLCBridge:QLC_chase02:switch" }
Switch QLC_Chase03 "QLC Chase 03" { channel="dmx:chaser:QLCBridge:QLC_chase03:switch" }
Switch QLC_Chase04 "QLC Chase 04" { channel="dmx:chaser:QLCBridge:QLC_chase04:switch" }
Switch QLC_Chase05 "QLC Chase 05" { channel="dmx:chaser:QLCBridge:QLC_chase05:switch" }
Switch QLC_Chase06 "QLC Chase 06" { channel="dmx:chaser:QLCBridge:QLC_chase06:switch" }
Switch QLC_Chase07 "QLC Chase 07" { channel="dmx:chaser:QLCBridge:QLC_chase07:switch" }
Switch QLC_Chase08 "QLC Chase 08" { channel="dmx:chaser:QLCBridge:QLC_chase08:switch" }
Switch QLC_Chase09 "QLC Chase 09" { channel="dmx:chaser:QLCBridge:QLC_chase09:switch" }
Switch QLC_Chase10 "QLC Chase 10" { channel="dmx:chaser:QLCBridge:QLC_chase10:switch" }

Color	QLC_rgb01			"QLC RGB 01"			{ channel="dmx:color:QLCBridge:QLC_rgb01:color" }

// I didn't need these extra controls in the end, I just set the Uni & Channel manually in QLCplus
//    Dimmer	QLC_rgb01_RED 		"QLC RGB 01 RED" 		{ channel="dmx:color:QLCBridge:QLC_rgb01:brightness_r" }
//    Dimmer	QLC_rgb01_GREEN 	"QLC RGB 01 GREEN" 		{ channel="dmx:color:QLCBridge:QLC_rgb01:brightness_g" }
//    Dimmer	QLC_rgb01_BLUE 		"QLC RGB 01 BLUE" 		{ channel="dmx:color:QLCBridge:QLC_rgb01:brightness_b" }

Huge amounts of Kudos to @J-N-K again for giving us the DMX binding in the first place.

1 Like

Thanks so much for all this info. openHAB, QLC and Art-Net/sACN seem like great options to automate my home lighting but I’m new to all of them and this reduces the overwhelm factor a lot.

I’ve been looking for a reliable and relatively simple way to detect when light switches are pressed. I want to keep my standard (old school, AC powered) light switches but change the wiring to CAT6 (I like wires not wireless). I was planning to run a CAT6 cable from each light switch to an Arduino board with ethernet shield, connecting the standard terminals in the light switch to input pins on the Arduino, and use MQTT + NodeRed to manage the logic. But could I use DMX, Art-Net or sACN instead of MQTT and NodeRed?
Let me know if that’s not a relevant question for this discussion and I’ll start a new post.


1 Like

Hey Phil

Welcome to the party.

Maybe a new thread would be better, if you’re planning on a whole house approach.

DMX stuff is certainly more for the architectural lighting or faster changing stuff. (Even movement and positional)

If your looking to pick up the states of your current mechanical switches, then (obviously) I’d suggest popping a Velbus VMB8PBU { Yes, you can use them with 2 state switches, not just momentary, it’s just easier with momentary } behind the switches and hooking it up to Ring / Bus type data cable (rather than bringing each leg back to a central location).

Then just a USB interface into openHAB2 (and / or Node-RED) to pick up all the button state changes.

You could use Velbus hardware to control your standard lighting, if you only want switched or dimmed lighting.

You could fit LED feedback lights into the switches if you want that too.

Or if you want something super fun, I’ve got some 12 channel fully addressable 12V digital downlights that you can use to create infinite amounts of effects and scenes.

The big question is…

  • What is the end game?

AKA what do you have in mind for the amount of control and flexibility?

Thanks Stuart, appreciate the info.
Could you give a link to those 12 channel fully addressable 12V digital downlights?

I re-posted the question to a new topic with a lot more detail:

Is there any such thing as a tutorial for openHAB + QLC?


I haven’t packaged them up or actively promoted them yet, in fact I was only having a conversation with the chap who designed and populates the PCBs last night.

(There is a box of 80 under my desk)

What I can do…

Is give you a link to a YouTube video of them on my desk.

I’ve got some more above my desk, so now that I’ve got QLCplus up and running, I’ll try to do something funky with openHAB2.
Then work out how to demonstrate it, including linking them to Velbus button actions.


I’m happy to loan you one or two to play with to see if they’ll be what you’re looking for. (Along with a simple Art-NET / sACN LAN adapter so you can try them with openHAB2 directly, or with QLCplus, remotely controlled by openHAB2.

Other than what @Dome and I have put on this forum, I’m not aware of anything.

Maybe Dome & I could put something together.

The various Thing & Item files that I uploaded will get you a way to issue remote controls to QLCplus or Jinx!

@Dome What do you think?
Should we work at putting a guide together?

I think I’ve cracked the remote control side, including sending openHAB2 RGB values, so that QLCplus can use them in functions.
(I particularly like how it converts RGB colour picker data onto something that works for RGBW lamps, that’s something that expensive software sometimes struggles with)

1 Like

Those down lights are nice. Is it too much to hope that they fit into a standard down light fitting for an MR16 halogen/led bulb?
What hardware do you use to power them and control them?
Could they be used in outdoor down light fittings under eaves?

I’ve got some of these but they’re just not bright enough:

Do you have pricing for them yet?