Long distance LED chaser design

Question

I need to design a LED chaser that expands as you add modules, modules are daisy chained to each other over long distance.

I was thinking of using a master and N number of slaves, my first though is to use UART as I can transmit commands from one module to the other. But how do I transmit the number of connected modules in the system to the master. The master will be a MCU that will control the pattern of activation and timings. The slaves can also either be small cheap MCUs or some LED drivers or something else.

Here is an illustration.

Answer 1

You can implement a GetSlaveCountCommand. You send the command to OUT channel. That slave on OUT channel will answer with its "child" count. When being asked, you answer "child" count of your slave +1. You only need to implement a RX on master.

If you change your chaining to create a ring, you can also implement a chirp command where Master sends 0 to slave 1. Slave 1 sends 1 to slave 2 and so on. The last slave loops back to master. You will get your count. This technique is interesting because you can add another byte to indicate whether the chirp first started from master. If not, you actual counter value indicates which slave is orphaned.

By example, if you have 5 slave and, master would expect to receive 5. If connection between slave 3 and 4 is broken, slave 4 will send 1 (with flag indicating not from master), 5 will send (2 with not from master flag) and master will know that 2nd slave in a 0-indexed mode from end is disconnected from the chain. When all slaves are connected correctly, master receives 5 and not from master flag won't be set, so it is actual count.

If you use only a single UART port for this slave 1 tx to slave 2 rx; slave 2 tx to slave 3 rx and so on, it will take exactly the same amount of wiring and you will get your feedback back to master with device failure detection.

Answer 2

As @Mishyoshi suggests you need to have a way to get the length of the string as you dynamically extend it.
You can do this by sending a command that gets the last module to respond, however that implies that each module knows when there is a downstream partner connected.

In conventional RS232 land you'd do this with CTS/RTS so you know there is a client connected to the output port. Since this involves extra wires I'm sure you'd want to avoid it as a solution.

As a simple protocol without any inter module connection test you could send a command to which each module responds with its ID number, so for one out command character you'd get say a one character reply from each module ...so for 4 modules south of the master you'd get four characters in sequence back to the master. Send the command on a regular basis and you'd have a viable schema. Here you have each module separately identified (if you have unique module ID numbers, which is a good idea IMO) with the character order telling you it's position in the string.
The downside here is that when the out command reaches the end of the module string you have to use a timeout value to know the end of the string was reached.

If you want to reduce the number of character replies involved or don't have ID numbers for modules, one thought is to use a current detector on the Vin power line. Draw say a fixed number of mA (your downstream MCU may be enough) and assume that if current is drawn there is a southside client connected. The last module now knows if there is another module connected, and if there is not, it sends a reply character. So the command out gets a single character reply from the query command.
To get a string count the modules would have to increment the count for the return character as it passes through each module on the way back to the master. Each module records the count value as it's own position number in the string. So modules have a count value from the south end starting at 1.

While on the subject of Vin, I'd suggest it would be better to use a much higher supply voltage (say 48 V DC) to reduce the current flowing down the wires. You will have voltage drop to contend with in both Vin and Gnd so increasing the voltage reduces this problem.

If you are using RS232 Tx/RX then your baud rate needs to reflect the distance between modules, with 10m I'd suggest no more that 9600 baud ...this gives you a character space of about 1 ms and you'd need to decide if this is fast enough fro your application.

Answer 3

If your micro of choice has a single micro you can chain them like this.

In that scheme messages are normally send as a packet of data that includes an address byte or bytes. If the first slave received the packet and sees it is not address to it, it simply sends on the data to the next one.

If the packet IS for that slave, the slave does what it is ordered and sends a response packet, this is again simply forwarded by the following slaves.

A special "WhoIsThere" command can also be sent and received by each slave which causes them to send on the command after first altering the command to increase a count, or, if the slaves have different functions, add a byte on the end of the packet to identify what that particular slave does. In the process of doing that, each slave then knows it's address in the line from the data already added to the received command.

Because the last slave has its TX and RX tied together, everything should end up back at the master to deal with appropriately.

Note the slaves should also buffer the return line so the line length is controlled to the hops between slaves.

You can also add logic to the boards to allow the micro to bypass the pass-the-parcel chain once the addresses are configured. This significantly improves performance, especially on long chains.

^{simulate this circuit – Schematic created using CircuitLab}

Answer 4

Yiou may want to consider yusing a Texas Instruments TLC5973 3-Channel, 12-Bit, PWM Constant-Current LED Driver with Single-Wire Interface.

Rather than use the outputs to drive an RGB LED, use one output with a resistor as your PWM Gate driver.