Hacker News Reader

Comment by michaelbuckbee | Hacker News Reader

Towards the end of the article the author mentions not wanting to pursue this as a business as there are so many cheap programmable signs out there already.

As someone who would love to buy one of these and customize it for myself does anyone have experience or recommendations with any of these?

View on HN

Some experience. The cheapest and easiest route is to buy a pre-made sign from AliExpress and just use the serial/usb interface to send data to the sign. That's somewhat limited, as you can't really control each pixel in a real time way, and you're limited to sending a series of "screens" as either text (in their limited choices of fonts) or images, defining some linger time, transitions, etc. With some visual disruption as you send new data to redefine what to display. But it's easy. There's also variations on this theme. Some signs, for example, have had people who reverse engineered the protocol so that you can send stuff from your own scripts instead of the supplied (usually crappy) software.

The other path is to buy plain led matrix modules and use some SBC to directly control what's displayed. More fun, but more work. This particular sign uses qty 2, 4mm pitch, 32x64 pixel panels, side by side. Like this one: https://www.aliexpress.us/item/2251832064290423.html?spm=a2g... Lots of choices in pitch, single/three/full color, indoor or outdoor brightness, etc. Though you need to ensure your choice of driver (see paragraph below) supports it. They have different refresh rates, data sequence, and timing requirements.

Then, you pick what to drive it with. Lots of choices there. There are libraries and hardware level-shifter adapters for a variety of things like a Parallax Propeller, Raspberry Pi, BeagleBone Black, etc. With various advantages and disadvantages. Fwiw, the Rpi is usually trickier as you're bitbanging from a non-real-time OS. The Parallax and BeagleBone have better ways to be quasi real time.

Thank you for the very detailed answer. Though I think you may have just convinced me to stay with my current solution of Raspberry Pi's + 4k TVs for custom display signage in my office (but it's not nearly as cool).

You can use a colorlight card to control the panels, they can be had for $15 and connect to the nerwork using gigabit ethernet ( must be gigabit ). You then send then data using the windows software or you can use a Pi/computer running FPP software to send whatever you want.

This would reduce cost to:

2x panels

1x colorlight card

1x power supply

Misc cables / case

Edit: The card can handle an 8x8 matrix of panels ( IIRC ) and the cards can be chained together to make larger displays. I dont recall the max size. The biggest I’ve made is 5x5 for a xmas display.

Interesting. Can you interact in a sort of live/api way, or is it limited to writing configuration and "launching" it?

Edit: Ahh, that's a great option...assuming that reverse engineered way to send frames is stable, etc.

So the configuration is a one time thing to set the card parameters, you shouldn’t need to touch it once its setup for your panels and layout. As far as I know it can only be done using their widows app.

The display is done by sending the card network frames ( someone did a reverse engineering of the protocol, i dont know the details ). You can send the display anything you want.

I just got home and was able to look at some of the RE efforts, here is one that looked interesting:

https://hkubota.wordpress.com/2022/01/31/winter-project-colo...

Did you intentionally leave out Arduino from the "what to drive with" options?

Assuming largish, multi-color matrixes, and/or chained ones, yes. A ~10Mhz+ pixel clock, double-buffering, or just the size of the pixel map would strain most of those. This sign is 32x128 pixels, with each pixel taking data for RGB (on/off), with the PWM rate controlling brightness for each of the three colors. Though there are examples of using something beefier/faster like an ESP32. There's also in this case, the assumed requirement of fetching train data and transforming text into pixels.

The panels themselves don't take data and hold it. You have to refresh the display constantly, typically on a 1/8 or 1/4 duty cycle.

You can drive smallish, single color matrix displays with a cheap MCU. Or there's also the approach of using addressable LEDs instead of these more "dumb" matrix modules, like arranging the smart strips into a matrix. Moves the refresh logic down into each LED.

The ESP32 can handle a 64x64 HUB75 display pretty handily. Several of them, even. There’s a solid library out there [0] that just pumps pixels right from memory via the ESP32’s built-in DMA engine. Adafruit_GFX is the supported library for drawing primitives/text/bitmaps/etc., so you can re-use a lot of code that’s out there.

But let’s start with a simple, quick hit of dopamine: There’s a web-based installer [1] (it uses web serial, so Chrome is required) for a couple varieties of clock designed for a 64x64 HUB75 panel and an ESP32. $20 in parts from AliExpress if you already have a suitable 5V power supply.

To use that site, all you need is that aforementioned 5V power supply—4A or more recommended, 10A if you’re planning to drive a full panel of pixels on an outdoor panel at full brightness—a 64x64 HUB75 matrix panel, and an ESP32. Everything except power is run directly to the ESP32. Many panels even come with a 16-pin female IDC connector for the panel, with individual DuPont-style female connectors at the other end that you can just slip over the pins on the ESP32.

The source code for each clock (repo is linked from the web page) is a great starting point for making your own versions.

The panels, as others have mentioned, are shockingly cheap from the usual sources like eBay [2] or AliExpress (search for “HUB75 panel” or “p3 64x64”), but even those in a hurry can get a 64x64 panel for under $40 from Amazon [3].

[0]: https://github.com/mrfaptastic/ESP32-HUB75-MatrixPanel-DMA [1]: https://clockwise.page [2]: https://www.ebay.com/sch/i.html?_nkw=HUB75%20Panel [3]: https://www.amazon.com/dp/B0B3F7WKJ1/

That is impressive, though it's using a few tricks to keep up, like relatively low-duty cycle panels, and BCM in place of PWM.

Yeah. I tried a project driving 32x16 pixels with a Arduino (an Uno, ATMega328) and it was just barely on the edge of usable for mild animation. Furthermore, I could really only use it at full brightness. These panels are extremely bright, and my project was meant to be desktop display. For the next version, I moved to an ESP8266 which provides plenty of compute speed to drive these panels at a brightness that’s comfortable.

I see now.

There are a lot of different sorts of programmable signs out there: https://tidbyt.com/ https://www.vestaboard.com/

Thank you! The Tidbyt looks like the more approachable of the two. Less than $200 vs $3k for the Vestaboard and a it has a purposefully simplified Python like dev lang to pull data and shove it into widgets.

I'm a happy Tidbyt user. The device is really well made, it has a bunch of widgets that you can load from their app, and you can create your own and push to it (although I haven't spent much time trying it).

adafruit sells most of the parts you need if you go the DIY route https://www.adafruit.com/product/5362

great tutorials too https://learn.adafruit.com/rgb-led-matrix-cube-for-pi

Second this. The 32x64 version is what I used to make this digital tide clock as a project with my nephew https://www.filepicker.io/api/file/UzFNawTTWq4h5h6YF9Im. It fetches tide data from NOAA to tell you next high and low tides.

We also made an arcade game with the LED screen.

Not the cheapest route but it’s relatively easy and fun to get it working

If you're willing to go for a programmable wrist-sized sign (aka a programmable smartwatch) I'd go with Bangle.js.

Reply on news.ycombinator.com