Most cost effective/best way to drive a large array of panels (256x256+)?

[StarLite]

I am planning to build a largish led panel using the well known HUB75 panels from China.
From what I have read, the limit of even an ESP32 or Teensy 4.0 board seems to be around 128x64 - 128x128 at the moment.

I was wondering what the best way would be to drive a larger panel, my target size would be 512x256 or ideally 512x512 pixels.

I have seen a solution using an raspberry PI to drive a 256x256 at 140hz, so I guess 512x512 should be doable at 30-ish FPS?
For the cost of a single raspberry PI , you could get almost 10 ESP32’s tho, has anyone found a way to use a single ESP32 per smaller panel and chain them together somehow to be able to drive a large amount of pixels that way yet?
I know it has been done with multiple teensy’s to drive WS2811 strips : https://www.pjrc.com/teensy/td_libs_OctoWS2811.html#tech , but I have not seen a similar solution for ESP32 and HUB75 panels yet.
Such a solution with separate ESP32’s would seem very scalable, you can even make different aspect ratio’s with multiple smaller panels and easily add/replace 1 of them on the fly.

Would the Raspberry PI way be the best way to go for such a project, or does such a solution exist with ESP32/Teensy’s?

[Louis]

I’m working on a project that allows an ESP32 to receive data from an outside source via SPI (using APA102 LED formatted data) and refresh an up to 128x64 panel. It can receive SPI data at up to 32MHz CLK. Theoretically you could use several of these in parallel to drive several large panels.

Let’s go with your 512x512 pixel example. APA102 formatted data requires 4 bytes per pixel (plus some overhead we can ignore), so 1024kB of data per frame. With 32MHz SPI, you could only update the panels 3.8 frames per second (actually a little bit lower with overhead).

You could separate the data streams, let’s say you divide the SPI data into 8 parallel channels, kinda like OctoWS2811 is doing. You’d be able to get 30FPS updates.

512x512 is a huge size though. Each ESP32 can only refresh a 128x64 panel, so you’d need 32 ESP32s just to refresh panels, plus something else to provide the data. I’m not even sure an ESP32 WROVER module with extra RAM can keep up with generating data that fast. You may need a Raspberry Pi or something similar to generate the data alone.

I’d look at this project which can drive large panel setups, maybe 512x512, I’m not sure: https://github.com/hzeller/rpi-rgb-led-matrix

[marcmerlin]

Funny you’d mention that, I was just making this post:

384x192 RGBPanel Matrix

Having fun with RGBPanels. I temporarily built myself a 384x192 display with 9 scan row RGBPanels linked 3 levels wide and 3 rows run in parallel. All running on an rPi4 with https://github.com/hzeller/rpi-rgb-led-matrix given that ESP32 or teensy can’t really do more than 128x64 on a single chip. My refresh rate is just above 100Hz on an rPi4. Realistically you can’t run many more pixels than 64x384 or maybe 64x512 off a single chip, whatever your chip is, because of the limitations of RGBPan…

512x512 could be done on rpi-rgb-led-matrix but the refresh rate would be unacceptable.
Realistically you can do the 384x192 I just did, or you can step up to 384x384 (half refresh rate), and then 512x384 (refresh rate will really suffer), and this is by having 3 busses running in parallel.