I'd like to experiment with creating some sequences using scripting languages (like Python), running on a Windows PC. Particularly pixels, but not exclusively. Mainly I'm thinking of targeting DMX or E1.31.
What would be the easiest and/or best way to do that?
1) Open a IP port and send multicast UDP packets following some spec? How to handle timing?
2) It would be cool if there was an API to which pass an array of for example 512 x 80,000 bytes (one universe wide by 200 sec at 25ms slices) and let it feed the data to the controller at the right timing. Is there such a thing, either standalone or as an API to a sequencer?
3) (not immediate but ok for testing) Create sequences as disk files in some format and let a sequencer play them out? What would be the best format for that?
4) Other options?
#3 could be OK for experimenting with canned effects (say some variant on a chase), but something which worked in near real time would be especially great, to allow for things like responding to sensors.
I don't think there are any open source sequencers, are there?
I mentioned Python because I think it would be fun to use for this, but i would consider Visual Basic or C/C++ or some other language if that opened the doors more easily or powerfully. I'm interested in both answers about "easy to get started" options as well as "more learning curve but better results down the road" ones.
I don't have controller hardware yet - and this could influence where I begin.
Thanks!
As the author of an open source sequencing package written in Python, this interests me a bit 🙂
I don't currently have support for DMX or pixels, but that should be a simple matter of writing the appropriate plug-in drivers to send the right bits out to the serial port going to those controllers.
Using UDP is interesting but feels a bit like overkill to me, although as far as I know pixels typically are driven by DMX controllers anyway, right? So why not use a serial interface for that instead of going into the IP stack? If you're interested in Python-based light control, feel free to check out my project. If writing an output driver for it to talk to the pixels you have will work, that would be easy.
As it stands now, the project is still a work in progress. There's no sequence editor yet (that's the next thing planned), but you can create sequences in something else (Vixen 2.x is easy to use and export sequences into Lumos, for example, or you could even write a Python script to create sequences for you, or whatever) for now.
The code is at http://lumos.sourceforge.net
Glad to meetcha, Steve. Your project looks interesting.
I have a few thoughts after browsing your manual (which was quite readable by the way). Forgive me if you already knew all this.
The Renard and DMX controllers are often daisy chained, so the same serial port is used for multiple controllers, strung together in sequence. They do it differently - DMX has a standard packet with up to 512 one-byte dimming values and each controller knows which piece of the packet to pay attention to (starting offset and length). Renards have a variable packet length and the first controller eats as many values from the start as it has channels (always from offset 0), then starts forwarding the rest to the next controller down the line. (with many Renards, this same approach is also used internally between each 8 bit group of channels). That will likely be a bit of extension to your configuration concepts (a series of controllers on one serial port, not just one). (There is also DMX on Renard, a hybrid which handles DMX protocol via Renard hardware with special firmware).
For DMX you typically need to encapsulate the DMX packet inside a siimple envelope used by the "dongle" which translates to DMX protocol. The protocol is async serial but at the non-standard rate of 250000 bps, and with some special breaks around packets - the dongle typically buffers up a packet and sends it out in the correct way.
If you get Renard and DMX, Lumos will be compatible with a lot of people's gear - they seem much more common now than the older parallel port and serial controllers, at least in my browsing.
Pixels are partly another matter. They use their own synchronous serial protocols - and there are a number of them. So one usually has a protocol converter which goes from something like DMX to some selected pixel protocols. If it's DMX, you can control it like regular dimming channels. However, since pixels can so easily grow to huge numbers of channels, people are often tempted to either create their own computer-to-protocol-converter protocol (using higher speeds, multiple RS-485 pairs, and/or longer packets), or to use ethernet with sACN or ArtNet protocols.
I would suggest getting Renard and then DMX well handled before making explicit features for pixels.
One thing that is worth considering however is the problem of editing sequences for pixels. Basically, the traditional editors like Vixen 2 tend to become cumbersome to work with for really large channel counts. We are on the cusp of a new generation of sequence editors which have been rethought to handle large numbers of channels and RGB pixels better. If you intend to expand Lumos to handle large pixel counts when you implement sequence editing, it will likely affect your design in fundamental ways. Vixen 3 seems to be a nearly complete redesign over Vixen 2, largely tho not only for those reasons. If it's more than you have time for, there's nothing wrong with targeting more modest channel counts; better to have fund with something which handles one niche well, than to never get something fancier working (or at least that's my judgement call).
Anyway, these are my friendly tips, based on what I've learned here - you are welcome to ignore. I'm currently too busy with a few other aspects of life to spend much time on this, but when my attention returns I will be very interested in exploring Lumos further. Good luck!
Thanks!
Yes, I assume serial controllers may be daisy chained. The support for multiple ports ("networks") is in case you have a mixture of devices which don't understand each other's protocol or have so many controllers you need to distribute them out into multiple data channels. I do have a Renard driver in there (based on public documentation at this point, since I don't have an actual controller to play with), but from what I've read DMX may not be too difficult to support.
I agree that pixels are another matter entirely, enough so that I'm planning to finish what I have here first before looking at them.
I want to make some kind of more complex multi-channel object for sequencing, e.g., RGB strings (not pixels), so you can select colors via the usual color picker dialogs (RGB, HSV, etc) and do color change effects and so forth without having to work in red/green/blue channels independently. As to large numbers of channels, I'm not sure yet, but the design I'm using, where channels are more abstract objects, should lend itself to making more complex hierarchies of channels to break up the work enough to be sane.
If you want to take a file and send it out ---
Look into HLS and use the PixelPlane capability.
HLS reads PixelPlane data from a text file and outputs it.
Right now - the design limit is 75 Universes or 30,000 channels.
Use Python to build your data and HLS to export it.
Joe
