Reviving a Vintage LED Sign with Arduino and PS/2 Control -- Episode 708

An ageing LED sign picked up from an auction turns into a practical exercise in reverse engineering, electrical safety, and creative interfacing. After uncovering unsafe internal wiring, Clem rebuilds the power system, then works around the original control limitations by using an Arduino Uno R4 WiFi to emulate a PS/2 keyboard, unlocking a simple but effective way to update messages. Along the way, he explores the quirks of legacy hardware, from timing-sensitive inputs to unreliable networking attempts, ultimately giving the display a functional second life.

Watch the Build

Edit media

Dimensions x Small Medium Large Custom

Subject (required) Brief Description Tags (separated by comma) Video visibility in search results Visible Hidden

Parent content

Reviving a Vintage LED Sign with Arduino and PS/2 Control -- Episode 708

Poster

Upload Preview

Ok

Cancel

Reviving a Vintage LED Sign - With a Few Lessons Along the Way

Clem has a habit of picking up hardware that most people would walk past. So when an ageing LED sign surfaced at an event company auction, it didn’t take much convincing before it ended up on his bench. At first glance, it’s exactly what you’d expect from a previous generation of display tech: rows of discrete red LEDs arranged into a scrolling matrix. No modular panels, no driver ICs doing the heavy lifting, just a dense grid of components and straightforward multiplexing.

Against better judgement, Clem powers it up before opening it.

It works.

Even more interestingly, it’s still displaying its last programmed message, preserved from its previous life. A small detail, but one that immediately confirms the hardware is at least functional, and worth digging into further.

A Shocking Discovery

That initial optimism fades quickly once the enclosure comes off.

Inside, this isn’t a neatly engineered commercial product. It’s been modified, heavily. The most concerning detail is the power input: mains AC wires are soldered directly onto an AC/DC converter module, with no strain relief, no insulation, and no grounding.

Clem doesn’t overstate it, he calls out just how precarious this setup is, noting that “this is the sort of thing that only works until it really doesn’t”. The entire system depends on external protection breakers, RCDs, rather than anything inside the unit itself. It’s a hazard.

Before anything else, that has to be addressed.

Making It Safe (First, Always)

There’s no attempt to salvage the original power arrangement.

The internal supply is removed entirely and replaced with a simple, external 5 V input via a barrel jack. The sign itself has modest power requirements, so a regulated supply,like a Raspberry Pi adapter, is more than sufficient.

It’s not an interesting modification, but it’s the most critical one. As Clem puts it, “there’s no point reverse engineering something you can’t safely touch.”

Only once the risk is eliminated does the project move forward.

Inside the Sign

With the electrical hazards out of the way, attention turns to the electronics.

The controller board is built around an 8051-family microcontroller, unsurprising for hardware of this era. There’s no clear branding or standardisation; everything about the board suggests it’s been adapted rather than designed as a standalone product.

The LED matrix reinforces that impression. Tracks have been cut and rerouted, and sections appear to have been physically reshaped to fit the enclosure. Clem notes that “it looks like the display and the case weren’t originally meant for each other.”

This isn’t just old hardware, it’s repurposed hardware that’s already had one life before this.

UART… or Not?

The next step is straightforward in theory: find a way to change the message.

A connector on the board looks promising—something resembling a UART or RS-232 interface. Clem brings in an Arduino Uno R4 WiFi, specifically chosen because it operates at 5 V logic levels, avoiding the need for level shifting.

He wires directly into the pins and starts probing.

Nothing.

No valid serial output. No obvious baud rate. No response when transmitting. Clem remarks that “it behaves like it should be serial, but it just… isn’t.”

The working theory shifts: this connector may not be for programming at all. Instead, it likely served as a link between multiple signs—daisy-chaining displays rather than configuring them. It’s a dead end. The breakthrough comes from something far less technical.

Among the accessories that came with the sign is a sheet of command instructions, and a PS/2 keyboard.

Plugging it in works immediately.

The sign accepts specific key sequences and stores messages internally. No protocol decoding, no reverse engineering required, just a human interface that had been there all along. Clem highlights the simplicity of it: “sometimes the interface is exactly what it looks like, it’s just a keyboard.”

That discovery re-frames the problem entirely. Instead of trying to talk to the sign electrically, the goal becomes emulating a keyboard.

Teaching an Arduino to Type (Very Slowly)

Using the Arduino Uno R4 and a PS/2 device library, Clem sets out to replicate keystrokes programmatically. This turns out to be less straightforward than expected.

Timing is critical. The sign is extremely sensitive to how quickly input arrives. If characters are sent too fast, they’re dropped or misinterpreted. Clem notes that “it only really behaves if you type like a person—and not a particularly fast one.”

The solution is deliberately slow input, with significant delays between each keypress. The implementation in code reflects this. A simplified version of the approach:

void sendMessage(const char* msg) {
    sendControlSequenceStart();

    for (int i = 0; msg[i] != '\0'; i++) {
        ps2Keyboard.write(msg[i]);
        delay(150); // deliberately slow to match human typing
    }

    sendControlSequenceEnd();
}

The full implementation in Clem’s code expands on this with control characters, message framing, and serial input handling, allowing text to be sent over USB and translated into PS/2 keystrokes.  Clem points out that AI-assisted coding helped bridge some of the gaps here, particularly in structuring the PS/2 communication: “it got me 80% of the way there, and then I had to make it actually work.”

There is one limitation: after updating the message, the sign requires a power cycle before it begins scrolling the new text. It’s not ideal, but it’s consistent, and workable.

Putting It on the Network

With reliable message input achieved, Clem pushes further. The Uno R4’s built-in Wi-Fi opens the door to remote control. A lightweight web server is implemented, exposing a simple interface where messages can be submitted via HTTP requests.

On paper, it’s a clean solution. In practice, it’s inconsistent.

Clem observes that “sometimes it works perfectly, and sometimes it just drops off the network entirely.” The metal enclosure likely contributes to signal attenuation, but even with the board exposed, reliability isn’t guaranteed.

This leaves the networking aspect in an unfinished state, a proof of concept rather than a dependable feature. Despite the false starts and limitations, the outcome is clear. The sign is now safe to use, fully programmable, and capable of being driven by modern hardware. It retains its original character, hundreds of red LEDs scrolling text in a way that feels distinctly of its era, but with a new interface layered on top.

Clem sums it up simply: “it’s not perfect, but it works, and that’s kind of the point.”

What started as a questionable auction find is now a functioning piece of workshop hardware, ready for a second life, this time without the risk of electric shock, and with just enough modern control to make it genuinely useful.

Supporting Files and Links

- Github Repository (Code Snapshot)

Bill of Materials