So, what do you think about those RGB panels which are obviously cheaper and

gplus
(Marc MERLIN) #1

So, what do you think about those RGB panels which are obviously cheaper and with smaller pitch than neopixels (as small as 3mm pitch).
Big-ish 64x32: https://www.adafruit.com/product/2276
3mmn pitch 64x32: https://www.adafruit.com/product/2279
bendable 64x32: https://www.adafruit.com/product/3803 (didn’t know they had bendable)
64x64, but requiring a special driver plus rPi: https://www.adafruit.com/product/3649

From what I can tell, they are all stupid row and scan displays, where basically you load up one or more shift registers for all the bits of one line, and once you’re done, you display that line.
Then, you quickly move on to the next line, and the next, down to 32 (or apparently 64 with a special extra signal line, probably to segment the panel into multiple parts that get scanned at the same time because doing a full linear 64 line scan would be too slow).
I actually have more experience with this than I wish since I wrote a bare bones driver to do this on dumb matrices:
http://marc.merlins.org/perso/arduino/post_2015-01-06_Driver-for-direct-driving-single-to-3-color-LED-Matrices-with-software-PWM.html
Ah yes, I forgot the best part: colors are done with PWM color flashing and mixing, so you have to drive it even faster and flash the colors yourself at the right rate.

I realize those panel matrices are a bit smarter (and they have to be for that many pixels), but not that much smarter.
Up to now, I thought they were all thick and non bendable, but that’s been fixed.
The next problem is the row scanning that gives non nice looking artifacts if you move the panel, your eyes, or take a picture with a camera that will not open the shutter long enough to get a full frame (I’ve had this problem before).

Still, 64x64 for less than $100 pre-made is just hard to argue with. It just sucks that driving those things is so complicated compared to neopixels, and effectively requires something even faster and more real time than arduinos at some point.

Anyone still liking these? (@Jason_Coon with smartmatrix I guess)
I personally wish for higher frame neopixels that come in premade panels of 32x32, or even 64x64 with multiple data line entries in the middle for parallel driving.
What do you think?

(Louis Beaudoin) #2

FYI the only thing special about the 64x64 panels is a 5th address line. SmartMatrix supports these panels with the latest code on GitHub, using SmartMatrix shield V4.

(Marc MERLIN) #3

@Louis_Beaudoin So, how many lines are refreshed in parallel 2 for a 32 line matrix and 4 for a 64 line matrix?
I’m somehow thinking that you can’t/shouldn’t be scanning more than 16 lines independently or it’s going to be way too much work to avoid flickering, especially if you do PWM on top.
That said, I guess smartmatrix just does all that work for you so that the microcontroller doesn’t have to.
I read http://docs.pixelmatix.com/SmartMatrix/shield-v4.html and didn’t find tech details like:

  1. what’s the refresh rate?
  2. how many bits per color given that it’s PWM mixed with row scanning?
  3. It talks about supporting APA102. What’s the reason to use this board for APA102 instead of FastLED directly from the MCU?
  4. I’m assuming you push pixels to smartmatrix and smartmatrix does its own (hard) work of row scanning + PWM. How much RAM does it have to hold all this? What’s the maximum resolution it can support?

Thanks :slight_smile:

(Yves BAZIN) #4

@Marc_MERLIN you are indeed deporting the work done by the embedded ws2812 chip to the cpu. I have tried some of those which and arduino uno ending up writing the program in assembly to have fast enough refresh rate and it’s really nice as a learning phase but to reduce the workload of the cpu you could join an fpga.

(Marc MERLIN) #5

@Yves_BAZIN I understand the idea of offloading, I’m just not sure I’d get a smartmatrix just to drive an APA102 string, however I would get a smartmatrix to drive those RGB panels that are a real pain to drive from the CPU.
However, FPGA, I actually took a one day tutorial on how to program FPGAs, and OMG was it slow and painful, and requiring some 50GB of Xilinx stuff, or some totally ridiculous amount including a security check that kept failing and kept refusing to let me download the necessary code to talk to the chip, because I might be a terrorist, or something.
You won’t catch me doing FPGA programming if I have another option or can get another sucker to do it for me :slight_smile:

(Yves BAZIN) #6

@Marc_MERLIN ahaha indeed fpga programming is a nightmare especially that even if the simulation works you’re not sure it will work in real life.
After what is important is what you want to do with your panel.

(Marc MERLIN) #7

@Yves_BAZIN wait, did you just say that I have to know what I’m going to do with a 64x64 panel before I’m able to get/build one? You’re no fun at all :wink:

(Marc MERLIN) #8

But more seriously eventually I’m going to upgrade my 24x32 shirt, that resolution is just too poor and I only settled with it because it was the best I could get when I needed to build it.
I really wanted at least 32x48, if not more, but was limited by about 24 cm wide and matrices that had 1cm pitch.

(Yves BAZIN) #9

@Marc_MERLIN I meant what do you expect. I guess if yo my run animations or movie you do not have the same requirements for FPS or color depth. If you were do drive matrix like these driving 6,12 or 24 bits color depth make a huge difference in hardware.
Otherwise of course not !! When I built my panel I just wanted the panel lol

(Yves BAZIN) #10

@Marc_MERLIN I understand I have seen higher resolution flexible panel
22x22 in a 16cmx16cm form factor.

(Marc MERLIN) #11

@Yves_BAZIN 22x22 in 16x16 is a good start, but that’s still 44cm wide for more than 22 pixels, so not usable for my shirt, sadly.

(Louis Beaudoin) #12

Marc, in general it’s not “SmartMatrix” hardware that’s doing anything, it’s software and DMA inside the Teensy (or the ESP32 in the work-in-progress branch) that’s setting up data in RAM and then moving that data to GPIO to refresh the panel. The hardware is no more complex than some buffers and latches.

So, how many lines are refreshed in parallel 2 for a 32 line matrix and 4 for a 64 line matrix?

Any HUB75 pinout panel refreshes 2 lines in parallel.

  1. what’s the refresh rate?

It depends on a lot of factors. Default is 120Hz, but it can drop if you’re trying to refresh too many pixels or too much color depth.

  1. how many bits per color given that it’s PWM mixed with row scanning?

You select 8, 12, or 16 bits per channel

  1. It talks about supporting APA102. What’s the reason to use this board for APA102 instead of FastLED directly from the MCU?

This post explains why: https://community.particle.io/t/smartmatrix-apa102-library-open-hardware-photon-apa102-shield/21562?u=pixelmatix

Also, there are things SmartMatrix Library can do that FastLED can’t (natively): layers, scrolling text.

  1. I’m assuming you push pixels to smartmatrix and smartmatrix does its own (hard) work of row scanning + PWM. How much RAM does it have to hold all this? What’s the maximum resolution it can support?

It’s all on the processor. With a Teensy 3.6 you can do 128x128 pixels. ESP32 less than that, I think 128x64.

(Louis Beaudoin) #13

Any HUB75 pinout panel refreshes 2 lines in parallel

That’s not actually correct, the panels that SmartMatrix supports currently only have 2 lines in parallel. These are the types of panels that Adafruit sells. There are others available that light up more lines in parallel (still shifting and latching only two lines at once, but the lines wrap around on the panel), and these panels are brighter. SmartMatrix Library may support those in the future.

(Yves BAZIN) #14

@Louis_Beaudoin interesting stuff.
Interesting to see how the teensy line has evolved and its new capabilities.
For the moment I admit I am an esp32 guy because of the wireless capabilities on board, it’s double cores and it large ram (twice that of the 3.6 I think). But I should have a teensy on the side to see what it can do.

(Louis Beaudoin) #15

@Yves_BAZIN here’s the link to the ESP32 Port: https://community.pixelmatix.com/t/smartmatrix-library-esp32-port/272

(Marc MERLIN) #16

@Louis_Beaudoin thanks for answering all the questions. Interesting to see that you can get as much as 16 bits per color, that’s impressive.
But from your reply you said the board does very little and the CPU ends up doing most (if not all) of the work.
In that case, what does the board actually offer that you couldn’t do without it, by wiring the panel directly to the CPU like adafruit does with the old and underpowered arduino mega?

(Marc MERLIN) #17

@Louis_Beaudoin I did see that smartmatrix does layers, which I guess is cool, but I never had the use for it.
As for scrolling text, you can trivially do this with FastLED using either my Fastled::Neomatrix library or the LEDMatrix library which does even more fancy font stuff.
See https://youtu.be/9yGZLtewmfI?t=4m44s on the right side of the screen
LEDMatrix: https://photos.app.goo.gl/c5ae6GnJmTB4Vi8b9
https://youtu.be/9yGZLtewmfI?t=4m45s

(Marc MERLIN) #18

@Louis_Beaudoin I was re-reading this and noticed you mentioned that you think ESP32 can only do 128x64 while Teensy 3.6 can do 128x128.
I happen to have 8x 64x32 panels laying around and was considering building a 128x128 for fun.
Is that still correct AFAYK that I need to go back to teensy for 128x128 because despite its DMA ESP32 wouldn’t be fast enough to push that much data?
I’m looking at basic 24bpp and a single layer (I don’t use the other layers at all).
Thanks.

(Louis Beaudoin) #19

@Marc_MERLIN Yes, as far as I know 128x64 is the largest the current state of the ESP32 SmartMatrix Library can handle. I believe it’s a general RAM limitation (and not a DMA RAM limitation), so if you upgrade your ESP32 module to a WROVER module with an extra external RAM chip, you might be able to handle a larger panel. I only recently found a WROVER module attached to a Dev C form factor board, and bought one but haven’t tried it out yet. It’s possible it works with no code modifications, or it’s possible that the SmartMatrix Library doesn’t work on the WROVER module at all. Sorry I’m not working on this project right now, so I can’t tell you anytime soon.

Here’s a link to the rare ES32-DevKitC board with WROVER module:

(Louis Beaudoin) #20

FYI the normal ESP32 can’t handle refreshing such a large panel because an entire (double-buffered) frame ready to shift out to the panel is stored in RAM vs on the teensy where only minimum 2 (default 4) rows are stored in RAM ready to shift out to the panel.