Some basic DMX questions

I was hoping to get some info from the community regarding DMX. It looks to be a really good option for controlling LEDs. Some of my questions might be answered by tinkering, but I wanted to get some information before I commit to buying hardware, especially since my HA budget is very small at the moment.

I’ve done a considerable amount of research and understand the basics of DMX universes, channels, types of cable for connection, etc. My questions mostly revolve about how the system interacts with openHAB, since that will be my main use and most of the information online is more relevant to lighting professionals.

Here is the basics of my planned setup:

ArtNET / sACN controller:

NeoPixel (SK6812/WS2811) controller(s): I will initially use two of these to drive a total of 200 pixels (600 channels) of the string lights below

String of WS2811 lights: Driven by the controller above

High power PWM decoder: I’ll use this for driving several circuits of 12v landscape lighting. I’m also considering using it for some solenoids for a custom yard irrigation system (see questions below)

30 Channel PWM decoder: I’ll use this for driving RGB and tunable white LED strips.

Down the road, I thought it would be fun to buy some inexpensive DMX stage lighting to create a fun space for my family. I originally was going to use Hue lights but DMX appears to be very powerful and cost effective.

Here are my main questions:

  • In researching how openHAB handles chasers, I did some quick math and realized that doing a chaser on the 200 pixel string would be too big for a single universe and would be split between two. Even more cumbersome, if I split it equally between two items, each stage of the chaser would require 300 entries!!! Is there an easy way to generate these? I’d be open to using outside software and moving the steps to a text file, but typing out 300 channels sounds impossible.

  • I saw that some users have used Jinx in conjunction with openHAB. I don’t use Windows and don’t want to start just for this. Is there a good alternative? I have a Mac but would prefer Linux.

  • Will my proposed DMX setup use an extraordinary amount of system or network resources? I have a one year old Ubuntu PC with an AMD Ryzen 5 2600 and 32GB ram. I have a gigabit switch as well as cat6 cable runs. openHAB runs in a Docker container. The computer is a dedicated server.

  • Would it be a bad idea to use the above referenced decoder board to drive solenoids for irrigation use? I would ensure current ratings are respected, install a reverse diode, and configure them to operate as on/off only.

Thanks in advance!

I know little about resources needed for DMX but will point out that openHAB is not a real time system. If you rely upon it to directly control e.g. chase effects, you are likely be to be disappointed.
As an overseer, instructing some specialist box to “do sequence B at speed X”, it should be fine.

1 Like

Thanks for the response.

Makes sense. Would it handle a few RGB led strips with fade effect, or would even that be pretty jerky?

By this, do you mean a computer with dedicated DMX control software?

I’m investigating some Jinx alternatives that run on multiple platforms. QLC looks promising.

It would likely be jerky. I would put the effects into the hardware / firmware of the leds and turn them on/off with openHAB



I’ve got a fair bit of experience with DMX \ Art-NET \ sACN, both commercially and with openHAB2.

For my money, openHAB2 when used in a fairly quiet local network will drive a reasonable amount of pixels / fixtures without too many dropped frames.

However, if you want complex chases then you are definitely better off running a dedicated lighting solution on a physically isolated LAN.


And here’s the big part, controlling it with openHAB2 is the sticking point.

I choose Jinx! because it’s capable of being controlled simply via sACN / Art-NET on the ‘Home’ LAN and output sACN and / or Art-NET on a separate LAN. (Which most of the time is a simple 10mb usb dongle)

I’ve tried all kinds of different software with varying degrees of success, but the biggest obstacle is always finding a way of remotely controlling it.

FreestylerDMX is nice, but lacks a remotely controllable effects generator. (Chases can be stored and remotely triggered, but the LED effects generator can’t)

It’s also limited to 2 universes of DMX

There is a HTTP / UDP remote for this, I might get on better with it, now that I understand more about openHAB2 / NodeRed

MagicQ is amazing, but has time / usage restrictions & remote control restrictions unless you (quite rightly) invest in at least one of their own devices.

QLC+ is a fork of the QLC project, but limited to 1 universe.

But it does show Art-NET as an input option.

If you find something comparable to Jinx! for functionality and flexibility, that runs on a Linux machine, I’d be very interested to know more about it.

1 Like

@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