Marc's Public Blog - Arduino Hacking

RGBPanels do use less power even when corrected for amount of brightness generated (my estimate is at least 3 times less), they can be a lot more dense, they're cheaper, but they're a pain in the ass to drive since they require constant refreshes at high speed. That being said, as long as you don't exceed 128x64, which is more or less the practical limit on teensy 3.6 and ESP32 due to memory limits due to how SmartMatrix works (a different implementation could push things to at least 128x128 by sacrificing quality for memory use).

The demos I used for the pictures below are

Here are some shots of Aurora in 32x32 and 32x24 with FastLED::NeoMatrix vs 64x96 with SmartMatrix:

Video:

And then shots of Table from Mark Estes in 32x32 and 32x24 with FastLED::NeoMatrix vs 64x96 with SmartMatrix:

Video:

Show me the code:

Related pages:

Details: After version 3 of my shirt with a neopixel matrix, I had good fun, but was hoping to do more. Its resolution was only 24 x 32 pixels, enough to display fun patterns, but it's really not a lot of pixels.

After months and months of work, here is version 4:

Video demo:

Sadly, going up in resolution with addressable pixels, is not that easy. While in theory you should be able to fit at least 2 addressable pixels per centimeter (aka P5). Currently my premade panels are P10, which is the only thing I could buy pre-made.

What allowed me to switch were those flexible P4 RGB Panels from Azerone: https://amazon.com/gp/product/B07F87CM6Y

With their P4 resolution, I'm able to fit 96x64 on my body using 3 panels of 64x32 chained together. The 3rd panel is then chained to the 2nd set of 3 panels in my back:

On the old shirt, I put the rear panel inside the shirt, using the shirt as a diffuser, but with the RBGPanels, they were too thick for this to be practical, so I had to put them on top of the shirt. As a result, I ended up uing a black shirt which matches the color of the panels. I had to attach velcro to the new shirt, and confirmed that supergluing them was so much faster than sawing, and worked just as well:

I unsoldered the power connectors that were too thick, and used small metal wire to connect the panels together (see top middle of the picture). Turned out those metal wires were a mistake as they can cause shorts on the LEDs on the other side of the board:

Another thing I learned was that the holes I was using to put a metal wire to carry the panels over my shoulders, can't actually take the load, and the wire can cause damage to the copper trace that is just next to the hole. As a result, I replaced the metal wires with fishing wire and didn't use the bigger holes for load bearing:

Speaking of removing thickness from the board, I removed the top of the ribbon connectors to make them a bit thinner. Sadly, RGBPanels still require 15 wires to send the video signal:

I then took one panel and covered it with defusing foam (the rear panel, so that it's not too sharp and blinding to people behind me), while the front panel only has the plastic cover to protect the panels and offer a bit of extra diffusion:

you can see the difference between the diffusion levels

I then protected the rear of the panels given how much electronics were exposed:

Small details had to be solved, like making sure I had enough amps going through the wires (use thicker wires). Without that, my brightest pattern that uses 8 amps, didn't quite make it:

For fun, I made a pattern that scrolls my C++ scrolling code on the screens:

As for the CPU that runs it, I picked the ESP32 since it's dual core and can do refreshes on one core while running code on the other core. My SmartMatrix::GFX page has more details on using ESP32 with SmartMatrix

I went from a breadboard prototype to Jason Coon's ESP32 level shifter board, much more tidy

This video shows how things are wired from the ESP32 to the panels:

Here is what the whole power system looks like:

Walk through video:

I have around 60 demos running on the panels, including some Animated Gifs on ESP32 FFat with the library I was able to improve:

Here is an example of 3 levels of diffusers, including a raw set of panels with no diffusers:

After going to Luminosity Beach Festival, a underpaid and undertrained security guard at the entrance freaked out at the wires, so I made boxes to hide the wires and hopefully remove the "OMG, it's a bomb" reflex that some people might have:

2 batteries, fuse, meters and output

adapter box that takes 16V down to 5V and measures current used while distributing power

both boxes together are bigger than my previous setup, but looks a bit better

You can see a demo of the outfit being worn:

The flexible panels sadly kept breaking, Azerone was super nice in offering to fix them, see the thin patched wires they added, expert work I'm not capable of:

I first tried strenghtening them with light wood, but it still wasn't solid enough, and a waste of time, they still ended up breaking:

I ended up switching to hard panels, I should have used them for the start, They've been a lot more solid:

after vs before

After switching to the hard panels, which are indeed a bit thicker but not unbearably so, everything has been rock solid.

If you don't have time for all this, and are ok with 64x64, you can try this backpack from gearbest with everything built in and a very thin board. Just not fun for me because I can't run my own code on it:

Less blah-blah, more code

What is it?

Give me Examples

This page that shows how I built my EDM Festival and Burning Man LED Pants and Shirt v4 on ESP32 with RGBPanels and SmartMatrix::GFX using this library.

More blah-blah & rationale for SmartMatrix::GFX

This allowed me to do my Party shirt v3 based on a NeoPixel Matrix

However, the main problem I had was the limited pixel density of those neopixels and the price per pixel given that each pixel has a very small computer chip attached. My shirt was only 768 pixels per side (32x8x3) which cost $80 per side. While my shirt looked cool (i.e. better than nothing), 32x24 resolution isn't that much to display cool stuff. I made the best of it, but I knew that I wanted more pixels.
While it's technically possible to get 0.5cm pitch (i.e. P5) with nepixels, there is no such panel I could buy today and I wasn't really interested in fabbing my own, so I switched to RGBPanels.

What allowed me to switch were those flexible P4 RGB Panels from Azerone: https://amazon.com/gp/product/B07F87CM6Y

RGBPanels are a totally different technology based on row scan technology, pretty much like the 8x8 matrices I wrote a scanning driver for but with a built in shift register to load up all the column for each color, multiplied by 2 as for historical reasons you can update 2 halves of the panel separately.
With 32x64 panels, or even 64x64 panels, that's a lot of pixels to push serially via shift registers and address lines to select the line you've currently pushed all those columns for. The LEDs need to be refreshed very quickly to avoid visible flickering.
This limits the list of reasonble CPUs for higher resolutions to teensy 3.6 and ESP32, which also removes the multiple slower and/of inefficient drivers out there. Options I looked at and weren't suitable:

This leaves us with the most complete driver of them all, Smartmatrix. The main pluses are:

So, SmartMatrix is great, but I have all this code that relies on one or more of those APIs:

I have a reasonble collection of demos I've gathered (a few I wrote myself), here: https://github.com/marcmerlin/FastLED_NeoMatrix_SmartMatrix_LEDMatrix_GFX_Demos and they use a combination of those 3 APIs.
The goal was for me to be able to re-use that code and make it work on both FastLED backends and SmartMatrix backends, which why I wrote SmartMatrix::GFX
https://github.com/marcmerlin/SmartMatrix_GFX offers a GFX compat layer that is virtually identical to my FastLED::NeoMatrix library and allows you to run the same code onto of either FastLED or SmartMatrix supported panels.

Hardware, Teensy 3.6 and SmartMatrix Shield v4

Here is what the SmartMatrix shield looks like with a small patch I made to take USB power and send it to the panel (my laptop can output 2A over USB). Note that this is not safe with teensy v3.1/3.2 as it's not meant to pass that much current from its USB connection, but teensy 3.6 can do it fine as its fuse is located after the V+ connection on the chip:

Originally I used the APA connector to send power to the panel

2x 32x64 chained P4 panels with a sad cable extension I had to make, vs pre-made 64x64 P3 panel

SmartMatrix basic demo

The main problem with RGBPanels is that if the refresh rate isn't fast enough, they look bad on pictures. This is the main reason I switched to ESP32 which is dual core and can push a higher refresh rate via DMA than teensy can:

Chained panels giving mirrored output on a total display of 128x96:

Teensy v4 is still work in progress, read here: https://forum.pjrc.com/threads/60337-LED-Matrix-driver-for-T4-0-using-FlexIO-parallel-out-FlexPWM-DMA-amp-SmartLED-shield

Hardware: ESP32

Here are shots of what it looks like with Jason's shield:

it's reasonably compact, 15 IO's for SmartMatrix (14 are really required), IR connected to port 34, and IO 16 connected to a NeoPixel strip

This shows my flexible P4 96x64 panels I bought on amazon from Azerone, 3 tied together, one shown upside down for scale, a blank shield from Jason Coon, how I cut a 16 pin IDC ribbon cable and made it an in line row of pins I can connect into Jason's shield after having added a riser, and a patched board with IR connector on the back, and a yellow wire to redirect the pin Jason's board connected to RX which I use for debugging, to unused pin 27 instead:

While Jason's board is not perfect for this use, it's much better than my self made protoboard full of wires to connect the 74hc245 level shifters:

Here's a quick video summary that shoes the wiring and layout:

Tips for ESP32 and memory:

ESP32 has SPIFFS to use its flash to store data like Animated GIFs. You will find it unacceptably slow if you store 1MB or more and seek across a bunch of files, Instead, use FatFS as explained here:

SmartMatrix Support:
Louis Beaudoin added ESP32 support in this branch https://github.com/pixelmatix/SmartMatrix/tree/teensylc .
You'll want to look at this file for how to wire your ESP32: https://github.com/pixelmatix/SmartMatrix/blob/teensylc/src/MatrixHardware_ESP32_V0.h#L62
While you can apparently get away with no using a level shifter (at least with some panels), I chose to use one. First, I did it the hard way with a protoboard and level shifter chips, and then I switched to Jason Coon's 16 output ESP32 shield.
I then used a HUB75 ribbon, cut the end, and made a straight connector that went directly into the IO pins coming fromthat shield

Here are pictures of what it looks like:

Hopefully in the near future, one will be able to buy a pre-made ESP32 SmartMatrix shield.

End result

As a side note, RGBPanels look better when you have a diffuser sheet in front, so here is a page on that.

Transition to Hard Panels

I first tried strenghtening them, but it still wasn't solid enough, and a waste of time:

I ended up switching to hard panels, I should have used them for the start, They've been a lot more solid:

after vs before