Flipping Dots Fast.

Some time ago, I repurposed a bus flipdot display. From then I kept an interest on this fascinating mechanical way of displaying information. Some companies such as AlfaZeta or Breakfast continue to produce them. They managed to drive them very fast, making animation possible. Usually, and it was the case for my bus display, all the dots of a matrix are driven sequentially. It is very common that each columns of a dots matrix are flipped one after the other, and for good reasons. Information on these matrices are meant to be rather static, and doing so requires electronics only for each rows and columns, and not every pixel.

If you saw my previous post about the Neon pixels, you probably see some similarly.

Gigantic modern fast flipdot matrices are truly impressive (and very expensive), notably here : https://youtu.be/SJU2-1X8kHQ and here https://youtu.be/VFG1D7lVMiY. There is a nice article on Hackaday. However one can see the driving process.

Some 8×8 squares or larger structures are notably driven separately, giving some artifacts when the animation is fast.

How these matrices are driven ?

There are tiny magnets hidden inside each flat dots. Basically, to flip a dot, you have to flow an electrical current into the coil, generating a magnetic field around it. The direction this current flows will flip the dot from one position to the other. Only a short pulse of current is needed. The electromagnet core stays polarized, keeping the dot on position, even when the power is gone.

Image courtesy eldisrl.com

The common solution to the problem of flowing a current pulse in both directions is using a kind of H-bridge topology. Add two diodes and you can multiplex the dots in a row/column way.

Frederic L made a very extensive explanation of how this works on his hackaday.io project.

And Yann Guidon started as well a Hackday.io project call Dot Flippers, aiming discussions and exchange about using flip dots.

How can we imagine a different way. My aim from here is to drive all the dots of a matrix at once, possibly up to 30 times per second.

Obviously, a driving mechanism should be implemented for each dot. There is some integrated H-bridge chip, but they are quite expensive if you consider one per dot.

After playing a bit with raw flipdots, I observed that a charged capacitor of around 10uF at 16V, discharged directly into the dot’s coil, is enough energy to make the dot flipping correctly. There is something to dig here, so I made a circuit with the coil in series with a capacitor, as shown below. One side is grounded. If you apply a voltage on the other side, the capacitor will charge, with a current flowing through the coil in one direction. If you discharge the capacitor by grounding this same side, the current will flow the other way.

Now how to charge and discharge this circuit? With a CMOS, or complementary Mosfet for example. (Or half H-Bridge…) Lets try to simulate this concept in LTspice:

It seems to work, the green line is the current across the coil. Pulses in both directions are generated, depending on which input is enabled.

A nice feature of this circuit is only the charge will consume energy, the flip back is for free.

We can buy flipdots here on Hannio.org. They come in rows of 7 dots, probably because of 7×5 fonts.

Lets start KiCad and prototype this idea. We need 7 drivers, a microcontroller and a voltage regulator. I Choose a PIC with a handy SPI peripheral, plus two 8bit port. The PIC16F15355.

Using a 4 layer PCB, I manage to fit everything within the flipdot footprint.

I ordered the boards from JLCPCB. As usual, I’m very satisfied. The price for 4 layers boards are very attractive, the quality is very nice, and they are in the mailbox in one week.

Now lets try assemble and make a test program.

The only problem I had is some transient negative pulse appearing when I unplug the main power rail. This kills the cheap 5v regulator I first used. With a free-wheel diode connected on the main 24V power supply (it should be max 20V as pointed in the comment! thanks Ken536) and a more robust voltage regulator (MIC5233-5.0YM5-TR), it seems we can proceed with the assembly!

Meanwhile, few purple boards arrived from OSHpark as well. Quality is top notch as usual, the silkscreen is amazingly precise. However the board sides have to be sanded to remove the supports. Too bad the ‘after dark’ option is not available for 4 layers.

The second Covid-19 lock down, and curfew here in France, gave me some time to solder the 2500 components and program the 48 PIC. I have to admit, having a task where you can focus and with an objective, helped me not going crazy during winter.

Communication is SPI, and all modules are daisy chained exactly as the Neon Pixel modules. However I had to feed the 20V at each ends of the boards stack, apparently the impedance of 48 boards in series is too much and prevent the dots to flip correctly at the end of the stack.

To test this 14×24 matrix, an ESP32 act as a socket server over WiFi and sends the frames on the matrix SPI input. A Java program captures and generate a video flux on a distant computer.

To conclude, I’m quite happy the resulting matrix is so responsive. And I have yet an other adventure planed for this matrix.

All the sources and schematics are on the following github repository : https://github.com/pierre-muth/fast-flipdot .

A small addition to people willing to reproduce this project: calculate the gran total in cost and time. Unless you’d like to experiment this driving strategy, it is probably wise to buy a professional product from AflaZeta.