I am thinking of trying to build a large led matrix in a way that is both modular and scalable (maybe up to around 100x100, or 500x16).

My thought is to make a single 8x8 module that I can make a few at a time as budget allows. Each module will simply pass its rows and columns through to the adjacent modules. I will use shift registers (595 or similar) on the end modules only to drive the columns and the common cathodes on the rows.

Is there a limit to how many shift registers I can chain in a row, or will they pretty much extend indefinitely? Are there any limits other than the time required to shift out an increasing number of bytes? As the number of columns increases the time to shift out that many bytes increases, so I could imagine needing a heavier microcontroller to shift out larger displays at higher refresh rates. I am not too worried about that. My initial design will use an arduino, but I can move to a heavier 32 bit mcu as I need it.

My main concern is current. If I only am driving one row at a time, does it matter how many rows I have connected to each column? Do I need to adjust my resistor values as the matrix scales up, or add more resistors per column? Does my power supply need to get bigger the more leds I add?

  • \$\begingroup\$ Also is there a threshold where I cannot use a shifter for the cathode sinks? Should I start out adding a transistor circuit into each row between the shifter and the cathodes? \$\endgroup\$
    – captncraig
    Commented Oct 31, 2011 at 21:06

1 Answer 1


As the number of shift registers grows, it will become necessary to shift data through them faster in order to achieve a particular frame rate. This will in turn increase the amount of current required by each shift register.

It would probably be a good idea to use a partially-parallel arrangement. If the CPU can clock out eight or sixteen bits in parallel, that will reduce by a factor of eight or sixteen the number of bits that have to go through each shifter. It may also be useful to design a circuit which will take every eight or sixteen bits shifted in and send one to each of eight or sixteen shifters. Applying such circuits even one or two deep will greatly minimize the number of rapidly-switching signals required.

My inclination would probably be to use boards of e.g. 64x8 LEDs, multiplexed 64x8. Boards could be chained to a certain depth, but I probably wouldn't recommend chaining all 64 boards together. If the goal is a 128x64 grid, it might be reasonable to have eight pairs of 64x8 boards chained together, and output one bit to each pair simultaneously (so 128x8 bits for each 1/8 frame). I would suggest that the mutliplex timing be controlled by a master device, but each 8x64 panel should include its own row drivers along with some circuitry to limit each row's duty cycle to a maximum of 16% or so (when all is working properly, the duty cycle should be 1/8).

  • \$\begingroup\$ I like the idea, but it does decrease the modularity of the design. Are you saying that I should limit any given shift chain to something like 32 or 64 bits and start over after that with a new output and a new chain? I can definitely see how that could speed it up, assuming I have the outputs for it. \$\endgroup\$
    – captncraig
    Commented Oct 31, 2011 at 21:10
  • \$\begingroup\$ @CMP: One could chain a few modules together in each string; the current savings one gets going from one big string to two smaller strings is greater than the current savings one would get going from two smaller strings to sixteen. The savings going from four to eight, and even from eight to sixteen, might still be worthwhile, but as the amount of extra circuitry goes up, the savings become less and less significant. \$\endgroup\$
    – supercat
    Commented Oct 31, 2011 at 22:28

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.