The approaches listed above for 'routing' the control signals makes me a bit uneasy. The chips listed ('HC4514 and that analog part) are not really meant for transmitting signals any distance, and there will probably be problems when you get past the initial debug phase or have other people using your design. I think that you'll either need lots of null pixels or some sort of differential line driver and receiver.
The pixel string would be about 6' from the chip. How are other pixel boards handling this?
74HC540 or 541 tri state buffer on the output would be appropriate. Cheap and easy.
snunn wrote:The pixel string would be about 6' from the chip. How are other pixel boards handling this?
They're probably ignoring any possible issue.
Over 6 feet there might not be too much of an issue, since the propagation time of the signal down the cable is about the same value as the signal rise/fall time, around 6 ns each. And the capacitance of the cable is perhaps 70 pf, so you might not even need a high-power driver for it (although ground-bounce might start to be a problem if there are a lot of simultaneous transitions). Things become much worse over longer distances, though, and even the facile solution (single-ended, high-power driver) might not be adequate as the capacitance rises and the propagation delays over the cable mount up. A lot depends on how sensitive the receivers are to ringing and/or smeared-out transitions on their inputs.
Hi, rfallatt & ThaiWay.
With regard to what we are trying to do:
Use a Raspberry Pi as the basis of a lighting interface. With the idea that it provides; a cheap form of processing power, is well documented, has an Ethernet interface and a memory card.
The projects are just at the start, personally I have (using other peoples software) been able to drive a single short string of WS2801 pixels and am currently reverse engineering the different elements of the software to see how the control worked. I am also playing with the 74HC595 shift register with the view to expanding from 1 to a series of parallel outputs to drive pixels.
snunn is exploring the use of multiplexing ics to do a similar, ronp5683 is working on and output board and MPH is (in a different thread) working on a PIC based output board (but has moved from the PI to the Beagle board).
The interesting part is what could be achieved:
MPH has already used the PI to output video (stored on the PI's SD card) to a projector, and controlled this via DMX (E1.31).
The Ethernet interface will accept wifi dongles so any of the the PI devices could be wireless (cheap ebay wifi dongle).
Inputs and data sources.
Can receive DMX via E1.31 packets.
Can generate it's own sequences from mathematical formula.
Can read data / sequences from its SD card.
Can accept inputs via its GPIO to trigger something.
Outputs.
Can output DMX via E1.31.
Can output to various types of pixels.
Should be able to output DMX.
The fun bit is when you start to combine these with a little processing between them.
An E1.31 pixel driver (but we have them all ready).
Stand a loan controller that will run your garden lights off season that can be adjusted via a URL accessed from your smart phone (can be done – only with one string of pixels at this time). A DMX version would be ideal for those floods.
A mega tree (star or any effect that is pixel heavy), that has short sequences stored on the PIs SD card or networked drive. These can be called up using E1.31 from your show computer (only needs one channel to call up 255 different effects) and the PI outputs this sequence via E1.31 to your existing E681.
As above but where the PI mathematically generates effects (e.g. a chase on your roof line) in real time, where the effect is adjusted by a single channel input (speed based on a beat – colour, direction and pattern based on a 0 to 255 input) and outputted directly from the PI.
Any combination of the above, but with sensors incorporated into your show, where the PI makes changes based on the sensor input (singing faces that only sing if you stand in front of them or clap loudly).
So a really cool outcome would be, to produce some hardware to drive stuff and accept inputs (one or more boards to piggyback onto the PI) and various software applications. Basically whatever you can think of and someone can program.
Then you select the board for your application (if needed). Download the software (and sequences, if needed) to your SD card. Set it up for your application via a web interface. Plug in stuff. Power up. Sit back and enjoy the complements.
There will be lots of limitations – and I know that my programming is not good enough (at the moment) to achieve all that. But who would have though Nutcracker and HLS would have been as they are this time last year.
If anyone wants to offer ideas or help out – speak up.
Anyway I’m off to do the next part of my 2 day online Python tutorial.
