Pixelmatix and Jason Coon you've talked about pixelmatix in the past.

(Marc MERLIN) #1

@Pixelmatix and @Jason_Coon you’ve talked about pixelmatix in the past.
While I prefer fastled addressing and not having the artifacts from row scanning that those displays use, I’d like to try the 32x64 flexible ones with a 4mm pitch:

I’m just not even clear that they work with pixematix which seems to only support up to 32x32. Can you confirm? (question #1)

Also, I assume that there is no way to use pixelmatix with a chip other than teensy, correct? (question #2)
How does the IO works if I want 64x64 by using 2 64x32 panels and 2 pixelmatix? (question #3)

Then, I assume there is no support at all for this?

can they be driven at all with an arduino like chip? (question #4)

I’m not even sure how adafruit expects the 32x64 ones to be driven with their ATmega library which last I checked does not work on any faster 32 chip. Does anyone know (question #5)

Of course, I would consider fastled if I could just buy matrices of at least 32x32 pre-made with a pitch of 5mm or better. Doe those exist yet (question #6)

(Jason Coon) #2

@Louis_Beaudoin1 can confirm, but I think that panel should work. It says it’s 16 scan, which I assume means 1/16 scan, which should work. SmartMatrix definitely supports higher than 32x32, especially if you use a Teensy 3.6.

2: pretty sure SmartMatrix only supports Teensy.

3: you chain the panels, running the output of one to the input of the next with ribbon cables.

4: see #1

5: I doubt any 8-bit AVR can drive 64x64. They can be driven with Teensy and Raspberry Pi: https://www.adafruit.com/product/3211

6: There are 3535 and 2020 addressable rgb leds, but I haven’t found any matrices with them yet. Anyone else?

(Marc MERLIN) #3

@Jason_Coon thanks. I agree that no 8 bit AVR will run 64x64, adafruit’s code doesn’t work on 32bit chips last I found, and the teensy hat only works up to 32x64 I think, so probably no way to do 64x64 without rPi.

(Louis Beaudoin) #4

Hi Marc,

My docs for SmartMatrix are out of date, chaining and larger panels have been supported for a while. Check out the README for some details:

With a Teensy 3.6 a SmartMatrix Library user has even driven up to 128x128 with 4x chained 64x64 panels, but with a slower refresh rate than I’d prefer for my own use:

For 64x64 pixels driven with a Teensy 3.6, I believe you can get around 120 FPS, depending on what you’re doing, at 36-bit color, and you can drop it down to 24-bit color refresh (matching the color depth on your current addressable LED projects) and get better performance. I think it’s pretty smooth and I consider myself sensitive to LED flicker, but it’s a subjective thing.

I haven’t tried the flexible matrices yet, but I see no reason why they wouldn’t be supported by the SmartMatrix Library. Thanks for the link to that cheap one, I’ll probably pick one up. If you happen to see a cheap one with 5mm pitch, please let me know as that’s a lot more useful for my projects.

One caution on the flexibility of these, they’re not going to be nearly as flexible as what you’re used to with addressable LEDs. They’re made on a thin fiberglass PCB and not whatever material the addressable strips/matrices are made out of. The pictures I see on Aliexpress show pretty aggressive flexing, and I would imagine you’d get failures after doing that a couple times. Watch the Adafruit video that demos one:

I’m not even sure how adafruit expects the 32x64 ones to be driven with their ATmega library which last I checked does not work on any faster 32 chip. Does anyone know (question #5)

That video also talks about compatibility of 64x32 panels. They talk about their newer 32-bit micros.

SmartMatrix Library can use FastLED Functions, but can’t be driven by FastLED directly. There are some examples included with the library:

This one drives the panel using SmartMatrix Library, and in parallel drives an APA102 strip using FastLED:

Also see a document that talks about migrating a sketch that uses a FastLED controller to using the SmartMatrix Library while still using FastLED functions:

I encourage you to use the SmartLED Shield V4 which you can get from Adafruit or SparkFun because it makes wiring easier, but it’s all Open Hardware, and you can get the schematic/bom/gerbers from GitHub and wire it up yourself too.

(Louis Beaudoin) #5

Also, if there was a way you could turn one of these 16x32, 32x32, 64x32, or 64x64 panels into an APA102-compatible panel, would you be interested?

Trying to compare apples to apples:

You can get a 16x16 APA102 matrix for roughly $50 shipped from Aliexpress (rounding down), two for $100:

You can get a P10 16x32 HUB75 panel from Aliexpress for $15 shipped (rounding down).

The APA102-HUB75 adapter would cost around $25-$30 I think. Worst case the total HUB75 panel plus adapter cost for 512 pixels is $45, and you’d have an equivalent display to the $100 APA102 panels.

Granted, it may be a bit dimmer, as these LEDs are 1/8 scan, so each LED is only lit 1/8 of the time. I’m not sure if that brightness is needed for all projects. You can get a brighter panel, 1/4 scan, $20, so total cost is $50:

The adapter should be able to drive a larger panel, or more than one panel chained together. I believe it can do 64x128 easily. So total cost for an extreme example of a 64x128 P10 display plus adapter (16x 16x32 panels = 16x$20) $320 + $30 = $350. With APA102 panels, $1,600.

Now let’s move away from comparing apples to apples:

With HUB75 panels you can get pixel pitch as small as 2mm, which you can’t get close to with addressable LEDs:

Any interest in this? It’s still in the idea stage, but with some encouragement I might start working on it a bit more.

(Marc MERLIN) #6

@Louis_Beaudoin thanks for all the details. I’m also excited to read that there is FastLED compatibility. I’ll probably able to modify FastLED::NeoMatrix to work with SmartMatrix too.
Great to hear that 64x64 panels with an extra address line, work too with smartmatrix, I wasn’t sure about that (and yes I already ordered 2 smartled shield v4 from adafruit)
I’ll go buy one of these https://www.adafruit.com/product/3649 or https://www.sparkfun.com/products/14824
let me answer the rest of your posts in a different answer.

(Marc MERLIN) #7

@Louis_Beaudoin turning those panels into APA102 compatible would be quite nice. 1/8th scan is actually more a problem when you take pictures of them, which I have done at EDM festivals. The picture only shows a portion of the frame refreshed :frowning: but I could probably live with it anyway.
For my application (on my shirt) I do no need some flexibility but not repeated bending.
64x64 would be plenty for me I think, or 64x128 at most.
I don’t need P2 though, but P5 (compared to the P10 I currently have on my neomatrix panels) would be great, and getting 4096 LEDs with less wiring and cheaper than $500 or so ($30 per 16x16 panel x 16), would be nice too.

(Louis Beaudoin) #8


1/8th scan is actually more a problem when you take pictures of them, which I have done at EDM festivals. The picture only shows a portion of the frame refreshed :frowning: but I could probably live with it anyway.

Do you mean more of a problem than 1/16 or 1/32 scan? Is having more of a partial image displayed worse than having just a couple lines of a partial image displayed?

I’ve been porting SmartMatrix Library to the ESP32 platform, which has a very different DMA engine and way of driving GPIO, and more RAM than even the Teensy 3.6. You can do some interesting things like refresh an entire frame for one bit of color depth at once, instead of doing all color depth bits for a row at a time. I wonder if that would make the panels more burning-man-photography friendly. I made a note to try it sometime when I pick up the project again.

$30 per 16x16 panel

What chipset is that? Mind sharing your source?

For my application (on my shirt) I do no need some flexibility but not repeated bending.

I don’t think you’re going to get much flex out of the “flexible” HUB75 panels unless you built some kind of frame with a contour on it and screw the panel into the frame. It takes a good amount of effort to bend these, at least the type that I have (not exactly the same as what Adafruit has, but I imagine similar)

(Marc MERLIN) #9

@Louis_Beaudoin thanks for the heads up on flex, I’ll see how it goes. Thumbs up on ESP32, it’s a much better chip than teensy (and cheaper). Also, I very much like the stack traces when things go bad where teensy is kept in the dark ages by disabling the debug capability with the closed source bootloader :frowning:
I can’t tell you what scan rate was on the panels I tried to take pictures of, just that my camera could not picture a whole frame and it looked bad.
For 16x16 WS2812B, I’ve been using these: http://amazon.com/dp/B01DC0IOCK
They went up in price slightly, but still cheap enough.

(Marc MERLIN) #10

So, just to close this thread since it’s not FastLED related anymore, I got both 2x P4 32x64 panels that I chained together and a P3 64x64 panel and they work without issues with SmartMatrix. Now, I however have to deal with terrible flickering that you get on those panels, visible with the naked eye and even more so with a camera. That’s why I so much prefer Neopixels which don’t have this problem (ok, maybe teensy 3.6 will make this better compared to teensy 3.1).
Too bad neopixes don’t come in P3 or P4 matrices quite yet.
More photos:

missing/deleted image from Google+