Jinx! LED Pixel control from openhab

Hello,

As a result of seeing other people’s questions about controlling LED pixels or multiple DMX effects for architectural lighting or Christmas / Diwali events , I’ve discovered that it’s seriously easy to use the DMX binding to control Jinx!

http://www.live-leds.de/

Jinx! 2.4 Manual PDF

There are some AMAZING effects scripts for Jinx! here

Firstly I should say that I have a totally separate / physical LAN for Art-Net or sACN data, with the machine running Jinx! only having 1 lan port, connected via a dumb LAN hub.

I’ve got a major version of this running for a client with >7100 pixels around his house, using 3 instances of JINX! on one machine, all controlled from openHAB2.
So that he can start and stop chases at will using any of the hardware interfaces in his home.
Alexa, Google Assistant and (obviously for me) any of his Velbus buttons

So my openHAB2 controller has 2 LAN ports, one for the home network and the other (purely) to send Art-Net / sACN data to Jinx!.

I activated the Jinx! remote control and assigned the Art-Net or sACN universe to listen to, and turned on the AUTO option in the scenes window (to automatically crossfade to the newly selected scene)

Then added a handful of Things and Items in to openHAB2 to send out a Master Dimmer control and a single DMX channel to select the chase.

In theory it is completely possible to replicate the Jinx! scene control UI in openHAB, if you switch off the AUTO mode in the scene window in Jinx! and use the appropriate DMX channels to select LEFT and RIGHT scene and cross-fade.

For reference, here are the files.

I chose to get my head around the text file configuration in openHAB2 as I wanted to be able to copy and paste chases

The only things you should need to change in order for this to work for you are the IP address of the machine running Jinx! and the universe number.

Things :

Bridge dmx:artnet-bridge:JinxBridge "JinxArtNet" [ mode="unicast", address="192.168.178.69", universe=0 ] {
  dimmer JinxMaster  "Jinx Master Dimmer" [dmxid="7", fadetime=1000, dimtime=1000 ]
  dimmer JinxChaseChannel  "Jinx Chase Channel" [dmxid="1" ]
  chaser chase01 "Jinx Chase 01" [dmxid="1", steps="0:1:0" ] 
  chaser chase02 "Jinx Chase 02" [dmxid="1", steps="0:2:0" ] 
  chaser chase03 "Jinx Chase 03" [dmxid="1", steps="0:3:0" ] 
  chaser chase04 "Jinx Chase 04" [dmxid="1", steps="0:4:0" ] 
  chaser chase05 "Jinx Chase 05" [dmxid="1", steps="0:5:0" ] 
  chaser chase06 "Jinx Chase 06" [dmxid="1", steps="0:6:0" ]
  chaser chase07 "Jinx Chase 07" [dmxid="1", steps="0:7:0" ] 
  chaser chase08 "Jinx Chase 08" [dmxid="1", steps="0:8:0" ] 
  chaser chase09 "Jinx Chase 09" [dmxid="1", steps="0:9:0" ] 
  chaser chase10 "Jinx Chase 10" [dmxid="1", steps="0:10:0" ] 
  chaser chase11 "Jinx Chase 11" [dmxid="1", steps="0:11:0" ] 
  chaser chase12 "Jinx Chase 12" [dmxid="1", steps="0:12:0" ] 
  chaser chase13 "Jinx Chase 13" [dmxid="1", steps="0:13:0" ]
  chaser chase14 "Jinx Chase 14" [dmxid="1", steps="0:14:0" ] 
  chaser chase15 "Jinx Chase 15" [dmxid="1", steps="0:15:0" ] 
  chaser chase16 "Jinx Chase 16" [dmxid="1", steps="0:16:0" ] 
  chaser chase17 "Jinx Chase 17" [dmxid="1", steps="0:17:0" ] 
  chaser chase18 "Jinx Chase 18" [dmxid="1", steps="0:18:0" ] 
  chaser chase19 "Jinx Chase 19" [dmxid="1", steps="0:19:0" ] 
  chaser chase20 "Jinx Chase 20" [dmxid="1", steps="0:20:0" ]
  }

Items

Switch JinxMasterMute "Jinx Master Mute" { channel="dmx:artnet-bridge:JinxBridge:mute" }

Number JinxChaseChannel "Jinx Chase Channel" { channel="dmx:dimmer:JinxBridge:JinxChaseChannel:brightness" }
Number JinxChaseChannel256 "Jinx Chase Channel as 256"
Dimmer JinxMaster "Jinx Master" { channel="dmx:dimmer:JinxBridge:JinxMaster:brightness" }
Switch JinxChase01 "Jinx Chase 01" { channel="dmx:chaser:JinxBridge:chase01:switch" }
Switch JinxChase02 "Jinx Chase 02" { channel="dmx:chaser:JinxBridge:chase02:switch" }
Switch JinxChase03 "Jinx Chase 03" { channel="dmx:chaser:JinxBridge:chase03:switch" }
Switch JinxChase04 "Jinx Chase 04" { channel="dmx:chaser:JinxBridge:chase04:switch" }
Switch JinxChase05 "Jinx Chase 05" { channel="dmx:chaser:JinxBridge:chase05:switch" }
Switch JinxChase06 "Jinx Chase 06" { channel="dmx:chaser:JinxBridge:chase06:switch" }
Switch JinxChase07 "Jinx Chase 07" { channel="dmx:chaser:JinxBridge:chase07:switch" }
Switch JinxChase08 "Jinx Chase 08" { channel="dmx:chaser:JinxBridge:chase08:switch" }
Switch JinxChase09 "Jinx Chase 09" { channel="dmx:chaser:JinxBridge:chase09:switch" }
Switch JinxChase10 "Jinx Chase 10" { channel="dmx:chaser:JinxBridge:chase10:switch" }
Switch JinxChase11 "Jinx Chase 11" { channel="dmx:chaser:JinxBridge:chase11:switch" }
Switch JinxChase12 "Jinx Chase 12" { channel="dmx:chaser:JinxBridge:chase12:switch" }
Switch JinxChase13 "Jinx Chase 13" { channel="dmx:chaser:JinxBridge:chase13:switch" }
Switch JinxChase14 "Jinx Chase 14" { channel="dmx:chaser:JinxBridge:chase14:switch" }
Switch JinxChase15 "Jinx Chase 15" { channel="dmx:chaser:JinxBridge:chase15:switch" }
Switch JinxChase16 "Jinx Chase 16" { channel="dmx:chaser:JinxBridge:chase16:switch" }
Switch JinxChase17 "Jinx Chase 17" { channel="dmx:chaser:JinxBridge:chase17:switch" }
Switch JinxChase18 "Jinx Chase 18" { channel="dmx:chaser:JinxBridge:chase18:switch" }
Switch JinxChase19 "Jinx Chase 19" { channel="dmx:chaser:JinxBridge:chase19:switch" }
Switch JinxChase20 "Jinx Chase 20" { channel="dmx:chaser:JinxBridge:chase20:switch" }

I have added a rule that reads back the chase channel % value and converts it back to a 256 value to confirm that the right channel is in use.

To take it a step further, I created a rule that steps through the chases when a power socket is ON in my house. (The socket powers other lights)

var int XmasInterval = 10
var int XmasSteps = 0
var Timer XmasTimer = null
var double Val256 = 0
var double chaseval = 0


	rule "Convert percent to 256"
	when
		Item JinxChaseChannel changed
	then

		JinxChaseChannel256.postUpdate(256 * JinxChaseChannel.state as Number)
	end


rule "Step sequence"

when
     Item LoungeGreenSocket changed from OFF to ON
then
	
	XmasInterval = 400

	JinxMasterMute.sendCommand(OFF)
	Thread::sleep(200)
	JinxMaster.sendCommand("75")
	JinxChase05.sendCommand(ON)

     XmasTimer = createTimer(now.plusSeconds(XmasInterval))
         [|
 			if(XmasSteps == 0){
 				JinxChase01.sendCommand(ON)

 
 				XmasSteps = 1
 			}else if(XmasSteps == 1){
				JinxChase01.sendCommand(ON)

 
 				XmasSteps = 2
 			}else if(XmasSteps == 2){
				JinxChase02.sendCommand(ON)

 
 				XmasSteps = 3
 			}else if(XmasSteps == 3){
				JinxChase03.sendCommand(ON)

 
 				XmasSteps = 4
 			}else if(XmasSteps == 4){
				JinxChase04.sendCommand(ON)

 
 				XmasSteps = 5
 			}else if(XmasSteps == 5){
				JinxChase05.sendCommand(ON)

 
 				XmasSteps = 6
 			}else if(XmasSteps == 6){
				JinxChase06.sendCommand(ON)

 
 				XmasSteps = 7
 			}else if(XmasSteps == 7){
				JinxChase07.sendCommand(ON)
				
 				XmasSteps = 8
 			}else if(XmasSteps == 8){
				JinxChase08.sendCommand(ON)

 
 				XmasSteps = 9
 			}else if(XmasSteps == 9){
				JinxChase09.sendCommand(ON)

 
 				XmasSteps = 10
 			}else {
				JinxChase10.sendCommand(ON)

 
 				XmasSteps = 0
			}
			
 			XmasTimer.reschedule(now.plusSeconds(XmasInterval))
         ]

end




rule "Timer Stop" when
     Item LoungeGreenSocket changed from ON to OFF
then
 	if(XmasTimer !== null){
 		XmasTimer.cancel()
 		XmasTimer = null
 	}
 	

	JinxMaster.sendCommand(OFF)
	Thread::sleep(2000)
	JinxMasterMute.sendCommand(OFF)


end

Update

The above Rule seems to be giving me trouble with the latest version of openHAB2, so I’ve made life a LOT easier by putting the above sequence into a DMX chaser and simply switching the chase on and off (or even mirror link the Item for the socket to the Chase switch)

Chase looks like this

0:1:100000|0:2:100000|0:3:100000|0:4:100000|0:5:100000|0:6:100000|0:7:100000|0:8:100000|0:9:100000|0:10:100000|0:11:100000|0:12:100000|0:13:100000|0:14:100000|0:15:100000|0:16:100000|0:17:100000|0:18:100000

With just the one DMX channel (the one used to select the chase within Jinx!)


Similar Topic :

Here are some simple videos showing the results.

4 Likes

Hi Stuart,

Very impressive, thanks for sharing this with everyone, videos are superb - what an effect :+1:.

I’m looking to get some LED RGB strips and install them around house (bedroom, staircase, kitchen and bathroom) Jinx could be fantastic addition if possible to implement in my current setup. My openhab runs on RPI3 so there is only one LAN port which is already being utilised.
If I read your post correctly second LAN port is required for Jinx ?
Would you be able to recommend some RGB LED strips available on UK market (amazon or eBay). Not really sure which type of LEDs are the best at the moment so let me ask an expert a opinion.

Best Regards,

1 Like

Thanks Andy,

That’s very kind of you to say :smile_cat:

It’s a little fragile, so you might need to schedule a Windows restart once a week, just to keep it alive. (which is what we have had to do on the big project that’s shown in one of those videos)

Another chap is looking into QLC+ which I think is avalible for Linux, you might want to explore that too.

Well… Yes and… no… well…maybe

It’s totally up to you.

Strictly speaking, it is “best practice” to keep any fast frame lighting control on an isolated network.

In the setups I use, the Lighting control software machines have 2 Wired LAN connections (I tried with a WiFi and a wired LAN, but there was something odd going on with WiFi that meant it missed instructions from openHAB2 on the home network.

Using my mantra “if you want it to work, use a bit of wire”, I just threw a cheap USB to LAN dongle onto the machine that was running Jinx! and used that as the incoming / remote control connection.

It works just as well the other way around.

  • Lighting / Art-Net / sACN on the USB <> LAN dongle
  • Remote control on the built in LAN

openHAB2 doesn’t need the second LAN port, just the machine that is running the lighting control software.
(which I guess might still be the same machine, so you can use the software loopback connection.)

I could…

But there really isn’t a simple answer.

Other than “Buying Cheap = Buying Twice

If you just want RGB (or GRB) strips / pixels, then just search for WS2812 as the chip.

Ali-Express have literally thousands of suppliers, in a similar way that Ebay and Amazon does.

These are super easy to configure in Jinx! as you just need to set the Pixel order and tell it how they are laid out.

If you want RGBW (Red, Green, Blue & White) from your strips, then the SK6812 chip is a good start.
They come in these formats;

  • wWcWA (Warm White, Cool White & Amber)
  • GRBwW (Green, Red, Blue & Warm White)
  • GRBcW (Green, Red, Blue & Cool White)

These aren’t quite to easy to setup in Jinx! becuase it doesn’t have a RGBW pixel order, you’d have to assign the RGB part, then assign a different part of the Matrix for the white element.
rinse and repeat until all pixels are accounted for.

QLC+ does have an RGBW fixture profile, so this will give you a HUGE colour temperature range to choose from and make setup a lot easier.
However setting up a big matrix isn’t the easiest process.

You might also want to check out @CrazyIvan359 Micheals’ MQTTany project.

The only other things to consider are

  • Pixel Density
    Most strips are availble in; 30 Pixels per Mtr, 60 Pixels per Mtr & 144 Pixels per Mtr
  • IP rating
    Don’t use open PCB strips as they are very flimsy and easy to damage. (Unless you intend to use extrusions with well fitting cappings)
    Half moon silicone covered strips seems to be a good option.
    Encapulsated strips are not much more than the open PCB strips inside a rectangular silicone tube. They are waterproof, but a bit of a pain to fit and difficult to repair / shorten / re-waterproof / mount and impossible to attach an effective heat sink to.

The advantage of the half moon strip is that you can still mount them to metal extrusions to make use of the heat sinking properties.

(try not to mount them directly onto wood, as that is an insulator… sounds obvious, but often over looked)

If you want some addressable downlights, we are making these now …


Useful reference

1 Like

My post on another thread regarding QLC+ might be relevant.

1 Like

That could really work, if I can work out how to add multiple universes of Pixels to a matrix.
(I can see how to do one (pixel) at a time, but I need to add about 7000 pixels to a matrix)

Thanks for posting about QLC+, especially the Debian service, that could be really useful.

Yeah, I was wondering the same thing. I’ll let you know if I make any progress.

1 Like

Thanks guys @MDAR & @Dome .
I`m going to get some basic RGBW wirelessly controlled strips for the time being and will look into Jinx integration next month.
I need approximately 12 metres for one bedroom, quick search online shows me that normally strips with WS2812 chip comes in 5metres as max length ? I just need to find some trustworthy supplier on ebay or amazon :wink:

1 Like

Do you mean Art-Net / sACN based controller? or something that uses MQTTany?

Art-Net controller will be overspec for me , would prefer MQTT type for the time being.

They are two VERY different approaches.

If you go down @CrazyIvan359 's MQTTany route, you’ll need to program chases into a standalone device, which takes triggers from MQTT

Whereas Art-Net / sACN controllers take pixel by pixel commands from openHAB2 directly, or a number of software solutions, including Jinzx! and QLC+

It very much comes down to personal preference and abilities.

I’ve traditionally used MQTT to communicate with Arduino (ethernet) and Particle (wi-fi) boards. It’s a solid approach but does require considerable programming to build in lighting effects. It’s particularly fiddly to upload sketches to your Arduino from across the house. For these reasons as well as scalability, I’ve decided to switch to DMX. As @MDAR says though, it’s completely about preference.

1 Like

Just read this page and was thinking about your question about multiple universes and RGB panels on QLC+. Hope this helps.

https://www.qlcplus.org/docs/html_en_EN/addrgbpanel.html

1 Like

Thanks for that.

I’d read somewhere else about creating matrix panels as fixtures, for placement in bigger matrix’s.

When I get time, I’ll give it a try.

Cheers,
Stuart

Hey :smile:

The long awaited answer is…

Yes, it does help and Yes it is possible to create quite large Matrix layouts that span multiple universes.

It takes a bit of getting you head around and you have to have thought carefully about what you’re trying to achieve… oh,. and don’t try to do with with a small screen (I tried and got very frustrated, so jumped on my dual screen machine and it was MUCH easier)

Essentially, you create all the fixtures and position them onto a Matrix.

The difference between Jinx! and QLCplus seems to be that multiple Fixtures can be mapped to multiple Matrix’, with different effects applied to different Matrix layouts in QLCplus.
Whereas Jinx! uses an “on-the-Fly” region system to limit one of the 8 effect players to a section of the master matrix.

So the conclusion is…

Jinx! is great for fast (ish) RGB or MonoChrome setups with a maximum matrix pixel count of 48000, which can be up to 480 pixel wide but proportioned to meet the 48000 limit, with the effects players and region-ing being easy enough.
For “Live” lighting control where things are done on-the-fly in response to a crowd (for example) then Jinx! wins.

QLCPlus… Well, that’s a monster and needs a lot of planning and thought… BUT… WOW… it’ got some serious power.

The biggest matrix I tried to create was 999 x 999 pixels. (more than enough for the 30m run of 30 pixel per metre tape, or the 3m2 section with 144 pixel per metre tape)

and an added bonus. it runs on almost any platform.

There is even a Raspberry Pi image that runs QLCPlus without a full desktop. (it has it’s limitations, but it works well) I’ve just got to see if I can get the special DEB file to run on an Odroid C1 (32 bit ArmHF)

What I really like from an installer’s point of view is this…

I can load QLCplus onto a machine and set it all up, then link elements of the Virtual desk to openHAB2 remote controls.

Even being able to adapt the start ( and end ) colours of effects from openHAB2.

As far as a user sees, it’s just some dimmers in openHAB2 that change the brightness of each pattern and some colour pickers to set the basis of each effect.

Thanks for your encouragement to look into QLCplus.

@Dome goes into lots of detail about how he has got openHAB2 / Node-RED controlling QLCplus via a websocket here.

I’ll post my Items and Things file on that thread to keep the context.


Information on how to run QLCplus in an X session with a VNC server –

1 Like

Hi @MDAR
Thanks a lot for all the information here and congrats about your realizations, very impressive!
If I would have know earlier about the half moon covers I would have bought different ledstrip… Should have read you earlier!
Anyway, now I have 3 SK6812 ledstrips, an AN404 artnet controller and Jinx! to control them all (and in the brightness bind them :mage: :grimacing:) .
Since you mentioned that RGBW can be patched in Jinx! with a separate patching for the white pixels, would it be possible to know a bit more about that procedure? I am struggling to figure out by myself, and patching one by one pixels in Jinx! is very … cucumbersome :cucumber: :confused:

Also I need to find a way to have Jinx! sending 3 different effects to the 3 ledstrips, because I want to use my own scripts, which you cannot assign to the matrix regions. So either I code manually in the script the regions, or I need to have 3 Jinx! instances running in parallel… But that would mean patching the 3 ledstrips each time I start Jinx! I suppose :frowning:
If you have an idea I would be very happy to hear that!

For those who might be interested here is the link to the AN404 controller

Thanks for the compliment.

Are you sure you can’t region you script in each player in Jinx?

Surely it’s no different than running any other effect.

As for patching RGBW fixtures.

I’m sorry, but in Jinx it is a long slow process.

QLCplus allows you to allocate a space between each fixture when patching.

So 40 RGBW fixtures would be

40 X RGB with a 1 channel space

&

40 white with a 3 channel space.

Hello @MDAR,

Thanks a lot for your feedback, much appreciated!
You are right, I was going to modify my post: you can attribute regions to the script as well in Jinx!, although the minimum width remains 4 pixels for some reason, which is a bit annoying.

I need to look into QLC+ I believe, but I find the interface less intuitive than Jinx!.

Thanks again for your help.

1 Like