Reviving Soviet-Era Plasma Displays with Custom Hardware and Firmware

As an electronics engineer, I’ve worked on many different types of devices throughout my career. However, my true passion has always been vintage display technologies, including Nixie tubes, VFDs, CRTs, and other retro indication systems.

Recently, a friend from Ukraine called me and said, “Hey Acho, I know you’re into old display technologies like Nixies and VFDs, but look at what I’ve got.” A few moments later, he sent me photos of two Soviet-era plasma display panels: the IGPP2-32×32 and the IGG5-64×64M2. At that moment, I knew I had discovered something special.

These panels are extremely rare, have been obsolete for at least 30 years, and are extremely rare to find. After discussing logistics and shipping details, the panels began their journey to me.

After about a month, they arrived, and my attention immediately shifted to a new challenge: figuring out how to drive them.

Old Schematics and Circuitry

My first discovery was encouraging. These are DC plasma panels, with the anode and cathode clearly marked on the rear PCB. That gave me a starting point. The next step would be to dive into the datasheet, which was conveniently included in the box. Some of the panels were even brand new, still sealed in their original factory packaging.

The datasheet quickly revealed why these displays had remained untouched for so long. The operating voltage is 400v, a surprisingly high value for a display panel. Fortunately, the documentation also included an example anode-driver schematic, offering the first clues to how these fascinating devices were meant to be controlled.

Rather than working from a fragile paper datasheet, I recreated the original circuit in schematic form. This made it much easier to analyze and ultimately understand how the panel is meant to be driven.

Before we dive into the details, ignore the transistor types and component values shown below. The schematic presented here is an updated version of my design. The original schematic was first reproduced directly from the datasheet, and then refined as I learned more about the panel’s operation.

How the Anode Driver Works

Let’s take a closer look at the circuit. In its idle state, a high level is applied to R29. This forces the Q13 to open and connect the left side of capacitor C1 to ground through diode D5. Meanwhile, the right side of C1 is connected to the +200v line through R17-D1, charging the capacitor to 200v. Q9 tightens its base to GND, the driver is fully charged and ready to shoot a 400v pulse.

The momentary 400v potential is applied to the pixel through current-limiting resistor R25, initiating the plasma discharge and causing the pixel to illuminate.

When the signal at R29 transitions low, Q13 closes and disconnects C1 from ground. At the same time, Q9 turns on through resistor R2, connecting the left side of C13 to the 200v line.

After a fraction of time, C1 fully discharges and that forces D1 to open, current flows through R17-D1. That only describes the firing phase of the cycle. To prepare for the next pulse, R29 must return high, turning Q13 back on and allowing C1 to recharge to 200v. The driver is then ready for another ignition event.

An Important Observation

While analyzing the circuit, I noticed something interesting: the anode driver cannot actively turn a pixel off. Its sole purpose is to generate the ignition pulse that turns a pixel on.

That means pixel blanking is handled elsewhere in the system. The only remaining possibility is the cathode driver, which suggests that turning a pixel off happens on the cathode side of the panel.

With the anode driver finally understood, it was time to move on to the cathode driver and discover how the display actually clears pixels.

1. Initial state
2. Cathode driver: LOW
3. Anode driver control (R29): HIGH
4. Set R2 HIGH. This turns on the cathode driver and pulls the cathode to ground. The voltage difference between the anode and cathode is now only 200 V, which is not enough to ignite the plasma discharge.
5. Set R29 LOW. The anode driver generates a 400 V ignition pulse, which is sufficient to start the discharge. Once capacitor C1 discharges, the driver continues supplying 200 V to sustain the glow. Congratulations, the pixel is now lit.
6. Set R29 HIGH again. This recharges capacitor C1 and prepares the anode driver for the next ignition pulse.
7. Set R2 LOW. Q1 turns off, causing the cathode to rise to the 200 V level. With no voltage difference across the pixel, the discharge extinguishes, and the pixel turns off.

When viewed this way, the operation is actually quite elegant. The anode driver is responsible for igniting pixels, while the cathode driver is responsible for extinguishing them.

First Prototype

The driving method is relatively simple and straightforward: pixels turn on through anode drivers and off through cathode drivers. Of course, “simple” is a relative term here. It looks a bit more complicated than LED driving, doesn’t it?

Now that we understand all the details and nuances, it’s time to heat up the soldering iron for some prototyping.

Since I wasn’t particularly excited to solder all 32 anode drivers and 32 cathode drivers on the breadboard, I decided to implement eight channels of each. That amount is more than enough to test my hypothesis and see if my understanding of the circuitry is correct.

The first tests showed that I was on the right path:

However, a new problem soon presented itself. The datasheet included the driver schematics with resistor values, but it does not provide information about operating currents or the transistor types used in the original design. As a result, a significant amount of experimentation was required to find suitable component values.

I also searched for similar designs and came across a project on Hackaday involving a similar plasma display panel. Although the author used the original values from the datasheet, which certainly worked, it likely resulted in high power dissipation. In my prototype, the transistors were running at around 60°C. This temperature is perfectly acceptable, but hotter than I would have liked and wasting power.

My assumption was that the original Soviet design had been built around transistors with relatively low current gain. To ensure reliable switching, the designers likely used comparatively high base currents, which explains the low value of resistor R21.

Using modern transistors with higher gain allowed me to increase R21 resistor value and base current, which significantly reduced the heat generated by transistors (you can hold a finger on it without problem). With the first successful prototype complete and the driver circuitry behaving as expected, I moved on to designing universal boards to drive a single panel or up to nine panels using different STM32 MCUs.

PCB Design Challenges

Initially, I designed the PCB specifically for the IGPP-32×32 panels that I had on hand. Since these panels include integrated edge connectors, my plan was simple: I decided to make the same pattern connectors on the PCB to connect it to the panel.

Fortunately, the connector design turned out to be fairly forgiving. Although the original panels use a metric 2.5mm pitch, the connector pins are wide enough that standard 2.54mm pin headers fit just fine. This made sourcing compatible connectors much easier than expected.

Unfortunately, that was where the easy part ended. After working with several panels, I quickly discovered that the spacing between connectors was not consistent between panels, due, in part, to the famous quality of USSR manufacturing. As a result, I had to abandon my plans to standardize the assembly process. Instead, each set of connectors had to be soldered in place while the PCB was mounted directly on the panel.

Firmware Architecture

With the hardware assembled, it was time to write the code.

The anode drivers are controlled through a chain of 74HC595 shift registers, while the cathode drivers are connected through 74HC139 and 74HC238 decoders. Since we can only scan the panel by cathodes (I’ll let you guess why it’s not possible to scan by anodes), we use decoders on the cathode side. This greatly simplifies the hardware and reduces the amount of MCU I/O required.

To make the system more practical, I also added a simple 12v to 200v power supply to the controller board. This allowed the panel to be powered from a standard wall adapter instead of an external high-voltage supply.

According to the datasheet, the recommended scanning frequency is between 200 Hz and 1000 Hz. Going below this range can cause unwanted mechanical resonances inside the panel, while a high frequency may affect anode driver performance.

Yes, it can be quite hard to drive this old stuff; constraints are everywhere. But it’s very satisfying when the circuitry starts to work as intended. After receiving the PCB, soldering, and grinding code, the single panel board started working and even showing time.

Wrapping Up Part One

At this point, the one-of-a-kind Soviet panel had gone from a complete mystery to a fully functional display. What began as a few intriguing photos from a friend had evolved into a working hardware platform. Reverse-engineering was a success; the custom driver approach worked, and the first controller board actually displayed legible content instead of just a green, jumbled mess.

Of course, getting a single panel running is only the beginning.

In the next installment, the project shifts from a simple proof of concept to something more ambitious. The question is no longer “Can I drive one of these panels?” but rather “What happens when you collect a lot more of them and try to build a tiled display?”

As it turns out, the answer calls for more hardware, more firmware, more high voltage, and a few surprises that I definitely wasn’t expecting.

To be continued…