Specialty chips like the MAX7219 can make visually-striking devices easier to work with. The ‘7219 is designed to drive an 8×8 matrix of LEDs, from a single SPI input. Additional modules can be easily added to the chain, allowing the creation of larger displays. A few helper C functions fold the pixels into the usual rectangular shape even if they’re not wired that way. With the SPI interface, updates are fast — at least several dozen Hz for four modules (32×8).
Four blue 8×8 LED modules. (They’re blue, not pale-blue or white — but even the lowest brightness overpowers the camera.)Each module sends excess data on to the next one. The only limit (other than supply current, which could be supplied) is update time.
Weirdly, even though the modules are sold as (and work as) MAX7219 chips, the ICs themselves seem to have had any identifying markings removed. (The original seller photos show both Maxim-branded (now part of Analog Devices) as well as the anonymous chips.)
The product listing says it’s a MAX7219. It works like one. Why the obfuscation?
A basic Arduino sketch (tested on ESP32) is up on GitHub. I’ll probably add digits next, if there isn’t a library already out there, suitable for these. They’d make a good compass display for the Santana.
Just don’t try to take a picture of them without strong lighting…
This isn’t how it looks IRL either, but it gives you an idea of the level of blue. At low brightness.
I recently came across an “ESP32 SEPTA Bus Monitor” project that would query a SEPTA Transit API and update a large scoreboard-like display with information about the predicted arrival time of the next SEPTA bus. Since project author [grandpasquarepants] lives right next to a bus stop, this format is perfect to be able to not only see when the next bus will arrive, but share this information with other riders.
I live half a block from my bus stop. It’s too far to be in easy sight from the bus stop, but a similar clock would be a useful addition to my entryway, helping me decide whether to walk or to wait for the bus when I head out. (If it’s more than a ten-minute wait, I’ll get to work faster by walking.)
So I asked GPT5.1 to take a look at the original ESP32 SEPTA Bus Monitor site and modify the code to simply print out the information to the serial port, as a test. After adding in my WiFi credentials to the sketch, this worked quite well, and a few prompts later, I had the world’s weirdest wall clock…
The Bus Prognosticator. (Now if only there were a bus inbound…)Eventually, a bus is inbound!
When one or more buses are inbound to the stop, the estimated time to the first bus to arrive is displayed. Sometimes there’s an incoming bus and therefore a time displayed, sometimes not. When there is, it usually counts down (bus making forward progress) but sometimes stands still (bus stuck in traffic) or even counts up (I don’t want to know.) The script can be modified to show buses in both directions; as it is, it only shows inbound buses (towards city center), since that’s all I use the bus line for.
Here’s the Github, including source code and .stl files for the wall-mount case, as shown. It seems pretty reliable, if you leave a minute or so slack. Enjoy!
A twin pack of eight-shot FlipFlash arrays. (You got four flashes per side, then flipped it over to use the other four.)
Taking pictures used to cost actual money.
Even today, you do still need a camera — but we all have smartphones with us anyway. Back in the day, you not only needed the camera, but needed to buy film and then either have it processed (for more money) or process it yourself in a home darkroom (which cost a lot of money to set up and then more for the materials.) Most people paid to have the pictures developed — FotoMat huts were a common sight in shopping center parking lots. Polaroid pictures were self-developing, but also more expensive and couldn’t be used for slides.
Even the lighting was often consumable. You could usually take daylight pictures outdoors using ambient light, but taking pictures indoors usually needed extra light. Professional photographers would lug around large umbrella lights with xenon strobe bulbs and exotic chargers that whined after every flash.
The consumer option was a lot more convenient — but a lot more expensive per shot, over time. A multiple-shot flash cartridge was designed, where a stored electrical charge from the camera would trigger a controlled explosive reaction between fine zirconium wire and a pure oxygen environment, resulting in a brief, bright flash of light.
The reaction consumed the filament and oxygen, ruining the bulb, but the genius idea was to harness the heat from this reaction to sever the connection to the currently-firing bulb, and also to enable the connection to the next bulb in the chain, so it would fire with the next picture taken. Although each individual bulb was single-use, you could take four (or five) pictures in a row, and then flip the flash cartridge over (thus the name) to use the others. Most FlipFlash cartridges came with colored dots on the back to indicate how many flashes remained.
Photo shops (and most drug stores and many grocery stores) sold these consumable flash cartridges — either the older Flash Cube style or Kodak’s Flip Flash, used on the 126 Instamatic and other cameras. For a few bucks, you could get a two-pack of flash cartridges, good for a total of sixteen flashes (not counting the occasional fairly rare misfire). That’s twenty cents per shot, in 1980s-era money, just to light up the shot. ($3.33 would buy lunch, back then.)
When I got my first digital camera in 1997, I calculated that it was roughly 600 times less expensive to take digital pictures and then burn them to a CD-R for storage, back then. The resolution back then didn’t compete with film — but it does, now.
Removing all effective cost per picture taken (as well the new ones being in digital form from the start) has not only allowed the explosion of multimedia social sites like Instagram and Facebook — it is a profound new tool to understand, record, and document our world. When students want a record of lab activities to include in the report, they simply take a picture and think nothing of it. 1980 would be amazed at how easy and inexpensive modern photography is.
xkcd is a gold mine of insightful thoughts and cool ideas. Even posts that introduce original ideas like “Nerd Sniping” usually have thought-provoking STEM content as a bonus.
As an EE-adjacent nerd, I sometimes think about the original Nerd Sniping problem itself: What is the resistance between two nodes a knight’s move apart on an infinite resistor grid?
While I still don’t know how I’d go about getting a closed-form Solution to it (maybe you could set up a recurrence relation between rectangular rings of nodes?), it recently occurred to me that it wouldn’t take much math at all (just a moderately large amount of compute) to simulate such a setup at finite-but-large sizes. Create an (N+3) by (N+2) grid of nodes, where N is nonnegative. Each node is connected to its four Manhattan neighbors via an ideal resistance R (1 ohm in the original problem; I simulated it at 1k). Connect each node to Ground via a 1nF capacitor, with no initial charge. (The two source nodes have no ground capacitor.)
Place two source nodes a knight’s move apart (dx=2; dy=1) centered in this grid, with one held at +1V and the other held at -1V. (Using symmetrical voltages makes for a nice color map.) Once per small timestep, note the voltage differences between neighboring nodes, flow Q=(dV/R)*dt coulombs of charge between the two, and update the capacitor voltages accordingly. Top the source nodes back off so they remain at 1V and -1V, noting how much charge (and therefore current) it takes to do this.
Eventually, everything will more or less stabilize. At that point, measure how much current (charge per timestep, divided by timestep) is flowing in to the positive node. This should exactly match the current flowing out of the negative node. (If not, something is wrong.) Since 2V is applied between the nodes, the equivalent resistance is 2.0 divided by the current in amps. Simulate for a millisecond or so if using 1k resistors, and even large networks stabilize.
I’ve increasingly found LLMs to be amazing coding assistants, even in languages I speak fluently. I know how to make a simulation like this, but it would probably take several hours and would be a more-or-less naïve discrete-timestep model. Collaborating with GPT-5-Thinking to create a simulation of this in FreeBasic (I still understand the syntax nuances of FreeBasic better at least for now, but GPT-5 is far faster at coding), we came up with a discrete-time numerical simulation using Gauss-Seidel convergence and a visual heat map after two or three bugfix iterations. The code GPT-5 came up with even uses some FreeBasic graphics libraries I wasn’t aware of.
A heatmap of node voltages. Bright blue = +1.0V source; bright red = -1.0V source. (The steady-state current is slightly lower here than for a larger — or infinite — grid.)
The steady-state current flowing into the network does increase as additional rectangular rings of nodes are added outside the original 3×2, but this quickly approaches a limit of about 2.587mA for a 4000×4000 grid, and only a slight bit more for larger grids (a 400×400 grid has the same current, to within about microamp).
Given the 2.0V voltage difference applied, this means that R is about 0.773 ohms in the original xkcd problem, or about 773 ohms if using 1k resistors.
