512 channel LED strip controller over RJ45 (TCP or UDP based commands)

Question

How would you make the following?

I'm looking for a 512 channel LED strip (varying size) dimmer, controlled over TCP/IP or UDP.

My dream board has:

• 512 individual channels @ 12V
• Each channel capable of sinking up to 0.3A (ideally 0.5A max)
• Overall average current per channel 0.2A (80->100A max total is more than adequate, won't always use the full 512 channels)
• Predetermined fade time between on/off states, around 0.5 seconds
• IDC connectors or screw terminal plugs in groups of ~16
• RJ45 cat5e interface to control over network
• The ability to send simple commands over TCP or UDP in a form like ".c,s;" (where c is channel number and s is state to switch to 1/0, on/off)
• Decent latency times (i.e. unnoticeable delay when lighting all channels at once)
• Industrial format (i.e. DIN rail mountable, insulated)

I've tried building and buying various systems. I developed an mbed/MM5451 board with high channel count (144) but low current rating. Tried working with PCA9685 chips, couldn't wrap my head round the functionality. Tried shift registers and darlington arrays with arduino, though scaling this up was problematic. Seen plenty of 3rd party solutions, non of which adequate. Most successful solution to date was daisy chaining specialist DMX boards, with an arduino intermediate and a Raspberry pi as a command server.

After a year of tinkering, I truly hope someone can point me in the ultimate direction. I usually end up compromising over current vs channel count with inadequate solutions to the same problem. Certainly not an electrical engineer, would appreciate an experienced opinion.

Ideas?

And is DMX suitable considering I have no need to vary brightness (besides the fading between states)?

Answer 1

You need:

1. 512 channels of high-current PWM driver;
2. Some means of configuring any/all of the channels on the fly;
3. Some means of communicating with the configuration device.

If you can find a multi-channel high-current PWM driver with a serial control interface then that would be a good start (because you could eliminate the FPGA's). Failing that, to me, the solution is:

1. 512 channels of open-collector/-drain driver, either as individual drivers or as multi-channel units.
2. An FPGA (or a collection of FPGA's) with at least 512 output pins to provide your PWM, and possibly fade logic.

3. A reasonably powerful MCU with an Ethernet interface and an external memory bus that you can use to map the PWM control registers in the FPGA/s directly into MCU memory for easy access.

   • An ARM Cortex-M3 or M4 with the necessary peripherals would be ideal, e.g. the STM32F407 in a QFP144 package, plus supporting circuitry including an Ethernet PHY and magnetics.
   • A collection of Xilinx XC6SLX4's in QFP144 package for the FPGA's; you'd need at least 8, plus supporting circuitry.
   • Drivers will cost; your current and voltage requirements are non-trivial so you will pay through the nose. Bear in mind how much heat those drivers will generate, too; cooling will not be optional.
   • Last but not least, the power supply. This is what will really hurt: 512 channels at up to 500mA each is 256 amps @ 12V. That's over 3kW of power. If you try to low-side the spec on the power supply (to 512*0.2A i.e. 1.2kW) then sooner or later it will let you down, so don't do it.

In short, this is a sizable design project that, particularly as a one-off, will cost quite a bit of money (at least $750 in parts, excluding the PSU and circuit boards). You would also have to program it to do what you want.