Expanding custom 16x32 to 32x32

I have a custom 16x32 matrix (2ft high, 5 feet wide) using high power pixels. Works fine with (custom) electronics based on the SmartMatrix LED shield.

The matrix, like the Adafruit panel I use for programming, has a 1:8 scan rate so the top 8 rows are parallel connected to the bottom 8 rows, eliminating need for extra address line. Row0 scans with Row9, Row1 scans with Row10, etc.

NOW, I’m thinking of expanding to 32x32 matrix, adding on to what I’ve got, if possible. Should I be scanning 1:16? HUB75 has that one extra address line. I’m not sure how I should hook this up.

Any ideas? How does a commercial (eg Adafruit) 32x32 panel work?

Thinking WAY ahead, I might expand to 32 x 64 and buy shares in the power company.

The simplest way would be to keep the 1:8 scan rate, and extend the length of each row to make a 64x16 matrix. Put the extra pixels below the existing 32x16, and tell SmartMatrix Library you have 32x32 instead of 64x32 and it handles the rest.

You could do something with the extra address line but it’s more complicated. If you want to use the same amount of power for double pixels, cut the brightness in half.

Thanks Louis. Yeah I saw the Sparkfun article. Read it about 5 times over the last year. Still confused… I like your solution because it means I can keep my logic board (the one with the Teensy).

You will notice something about the design of most panels. They follow a pattern. The smallest they would want to build is at least 2x16 for HUB75. 1 direct rows on two RGB chains, where the columns are 16 bits. This would be a 1:1 scan matrix. 16 bit shift registers are cheaper. They tend to make the columns a multiple of 16 and a power of two.

The reason for the power of two likely has to do with the cost of the transistors (high multiplex) to the cost of led drivers/shift registers (higher LED brightness). Each roughly doubles and it is cheaper to go one way or another. If you start with 1:8 panels or 16x32 you will move to 32x32 (1:16). Then 32x64(1:16) , 64x64 (1:32), 64x128 (1:32). I used to build custom panels and I found that the cost of increasing the pixels worked this way.

They also build lower multiplex panels like 1:1, 1:2 and 1:4. They usually stop around 1:32, technically they could go higher but you have issues with this. As you increase the multiplexing to save money, you lower quality/color depth.

Note 1:16, 1:32 and high density panels may be implemented with PWM or memory drivers to compensate for this.
Note this is only really needed above 4096 pixels per HUB75. LEDs are only capable of 11 bits color depth, assuming 1:1 multiplex.

You will notice they buy and build almost all of their panels off 16 bits. They buy large amounts of components. Most of the pin outs on the drivers are interchangable. So they only have to build a select few circuit boards. The rest is population.

The lower multiplex panels are likely divergent from the higher multiplex panels due to the LED driver. The lower multiplex panels will likely use a cheaper non PWM drivers due to density costs. Since these panels are brighter and usually high pitch they can only be so long per chain. As they are brighter they will have low density per chip and need/can use higher color depth. Therefore they do not follow the pattern. Strange ones also exist, which do not follow the pattern, again they tend to be chasing lower multiplex against higher density.

So moving to 1:16 is possible. Technically 1:32 is possible with HUB75E. You need a 4 bit decoder, something like 74HC154. However you may be able to use two 74HC138.

It is simpler to use 4 bit decoder. Ground the enable pins and feed A, B, C, D to A0, A1, A2, A3. Then connect Y0-Y15 to the PMOS gates. This should play nice with SmartMatrix. Almost all are common anode due to cost.

There is a lot of ways to do the multiplexing. Direct, decoder, shifter, counter, etc. You generally see decoder, but shift pops up on the higher multiplex. Generally lower multiplex is direct or decoder. I do not know about counter, not likely very economical.

I spent a lot of time on this. Too much to be honest. Beating the premade panels is nearly impossible. Only strange applications have a chance. Their level of modularity enables high levels of scaling. Very composible design, high quality design approach. They reduce cost in a few places which make people unhappy. However that would bankrupt pretty much any consumer for something that can be worked around cheaply.

Consider the HUB75 for example. It is horrible. Data pairs with no series termination, single ended, no shielding, no clock correction, few grounds, etc. Yet they work most of the time just fine. If you follow their solutions they will work almost everytime with minimal tweeking.

People using them on Pi or SmartMatrix tend to use them incorrectly in certain cases. I have a rough clue about some of this due to several reasons. There are equations which are fairly straight forward which can keep you out of trouble, if used correctly. The design probably works against these limits more or less.

Adafruit does not build RGB panels except for the NeoPixels. (They got really high margins on them too.) Sparkfun used to build smaller ones, but those are gone. Now most people just sell the premade ones from China. They are a little annoying for hobby project but are really cheap.

Note RPI and SmartMatrix have scaling issues. This does not apply too you. The panels do enforce limits. The controller create limits. One of the big ones is the cost memory and type of memory. This one gave me hell. There is more to it, but that was another core problem I found.

Most hobby controllers are designed for smaller hobby like projects. They can scale up under specific cases. Most of the libraries allow more color depth than you can actually have too. Most of them are not economical as controllers. The commerical solutions have also optimized the controller in the receiver cards about as much as you can too. (However there are probably a few areas you could tweek.)

Those are another interesting area of study. Commerical controllers are actually better. Higher quality and refresh, cheaper, etc. However the integration cost for something like Pi or SmartMatrix likely makes it pointless below a certain number of pixels. The main way they achieve this is with multiple IO connectors, decent levels of SRAM, mass production and usage of FPGA.

Hobby controllers are economical for project integration only. Most work for small displays. Some can scale up against quality. At a certain point stability or color depth collapses the scaling. Assuming the HUB75/Panel, memory, cost, processing power, etc. limits do not get you first.

Note none of these limits should apply to you. Even at 32x64. It should still work up to 64x64 (I think that is the biggest Adafruit sells.), beyond that and you start to lose color depth. (For certain resolutions this may not be bad either.) There are other drivers (PWM and memory drivers) that work differently but they are a royal pain. I doubt they will ever be supported by this.

I hate the communities with Merlin in it. Creates a degree of confusion all by himself. So I will not likely be posting here too much. I just wanted to answer this since I was not sure if anyone here will.

Note most LED power can have the brightness reduced. This will reduce color depth. You can do this in software or at the LED driver via current resistor. Some drivers have software gain but you will need to use TI chip (High margins there too.) or specific ones with a full datasheet to use it.

LED panels are used in message and far distance applications. The high power makes them bright. For their brightness they are fairly effiecent. TVs and projectors sometimes have scaling issues. For the size in hobby projects they are fairly cheap. The resolution is low, but that does not matter for message applications.

I guess that will cover it.

Thanks for your long reply. Always good to have all the facts. Some comments:

  • I say “Adafruit”, but I really mean “cheap-similar-panels-from-China.” I did buy one 16x32 panel from Adafruit though. Blew it up with 12 volts…
  • My logic card (“controller”) with the Teensy on it uses all thru-hole DIPs, same with MOSFETs. My plan is to redesign for SMD. My 3-watt pixels are all SMD: cooked them in the kitchen oven, saving me from soldering ~2048 joints
  • I don’t use PWM and stick with very basic colors. I don’t display “pictures”, only images I draw with SmartMatrix. (What can you do with only 16x32?)
  • I’m trying to display across a 700 foot cove, hence the high power requirement (I run the 3W pixels at about 1 watt, limited by resistor on each channel.

The panels use single rail power. The drivers usually support dual rail. The drivers support multiple applications.

Not sure I would have done it in the kitchen oven. Lot of flux. In a junk or small one it should work. Some you can do with a hair dryer if you use the right solder. This is what I usually do, but it may not work here. Tends to be an issue for high temperature components.

There is a lot of stuff you can do with a 16x32.

I could write a book on this stuff lol. Not likely to though. Could you imagine a troll getting it…

Sorry Bob, LEDsBright is @dthacher (I merged his two accounts) who has been trolling our and other message boards with long mostly useless messages. Best to ignore what he’s posting and not try to extract anything useful from it