Panel chaining vs the 64x64 5th address line, and general limits?

From reading https://learn.sparkfun.com/tutorials/getting-started-with-the-smartled-shield-for-teensy I think I understand how addressing works up to 32x32.

Question #1
I’m just not too sure how it works when you chain panels after that. There are no address lines to say “this is for panel #0, #1, or #3”.
Thinking about it, I’m guessing the way is to keep pushing more data into the shift registers and it gets pushed onto the other panels? Then, when you select a line, it lights up the line on all the panels based on the data for columns sent through the shift registers to all of them, correct?

Question #2
The “5th address line” for 64x64 isn’t shown in the pinouts I’ve found. Does it take a redundant ground line and turn it into the extra address line? (maybe pin #4 or #8?)
Either way I understand how you can get 2x as many pixels with an extra address line, but I’m a bit more surprised that 64x64 seemed slower in my tests than 64x32x2 chained (49fps vs 53fps).
If they added a 5th address line, shouldn’t it be twice as fast as 64x32x2 chained?

Question #3
Is there a limit to how many panels you can chain in theory?
(yes, there is a limit on the microcontroller side on how quickly it can push data and memory required of course). Basically the more panels you have, the longer it takes to load the shift register and push data onto all the other panels. You still get the same /16 refreshes, but you have to start pushing into the shift register faster and faster to keep the same FPS and eventually you hit the wire limit of the shift register assuming your hardware can push data that fast.
No idea what number of panels that translates into though. I’m thinking about big video displays with plenty of panels working together

Question #4
Has anyone used multiple teensies to drive each panel at higher speed and somehow made a bigger display without chaining but by merging multiple displays each controlled by their own teensy?

Thanks, Marc

Question #1
I’m just not too sure how it works when you chain panels after that

The panels are basically shift registers and multiplexers. The address lines for the multiplexers are shared with all panels. When you add another panel to the chain, the chain of shift registers gets longer.

https://learn.adafruit.com/32x16-32x32-rgb-led-matrix/how-the-matrix-works

Question #2
The “5th address line” for 64x64 isn’t shown in the pinouts I’ve found. Does it take a redundant ground line

When I started the SmartMatrix Library and made pinout diagrams and photos, there were only /16 panels available (at least where I looked). Yes, one of the redundant ground pins is used for the “E” line.

You can address twice as many rows by adding a 5th address line. You have to scan through 32 rows instead of 16, so that’s twice as much shifting (and waiting) that needs to be done, it’s not faster. I guess there’s a tradeoff between the time it takes to shift out a longer chain of data and the time it takes to shift a shorter chain of data out to more rows, but in general I think it’s slower and results in dimmer LEDs to have more address lines.

Question #3
Is there a limit to how many panels you can chain in theory?

Look at this project for an example of what you can do with a lot more memory: https://github.com/hzeller/rpi-rgb-led-matrix

I don’t think that library has as good color depth as SmartMatrix Library, but I’m not following it closely and haven’t tried it myself, I could be wrong.

Question #4
Has anyone used multiple teensies to drive each panel at higher speed and somehow made a bigger display

I’m not aware of anyone syncing Teensys to each other to make a larger panel. I (partially) ported Fadecandy over to the SmartMatrix Library, and you could use several of those to make a large panel with content sent by an external computer to several Teensys. Others have ported other streaming protocols which I believe could be used in parallel to drive multiple Teensy/panel combinations:

Thanks for the replies.

  1. how it works, yeah, I didn’t really find anything that explained how the chaining worked, but good to know my guess was correct.
  2. 5th address line: good to know that my test which showed it was slower, was not a fluke. Interesting that they came up with a new scheme, that it was slower, and that they shipped it anyway
  3. limit, this looks really cool. I absolutely must not do this :slight_smile: https://github.com/hzeller/rpi-rgb-led-matrix/raw/master/img/user-action-shot.jpg
  4. nice to see the streaming options, thanks.