Reverse Engineering a Commercial Dryer 9‑Digit LED Dot Matrix Display

Commercial dryer machines often use custom LED dot‑matrix displays instead of simple 7‑segment LEDs. These displays show time, error codes, status messages, and animations — all driven by minimal hardware and very clever multiplexing.

In this project, I reverse-engineered the dot‑matrix display system from a commercial dryer, focusing on:

1. How 9 dot‑matrix digits are driven
2. How rows and columns are multiplexed
3. How shift registers reduce MCU pin usage
4. How fonts are encoded and scanned
5. Why changing scan direction dramatically improves performance

This is pure reverse engineering — no schematics, no datasheets from the manufacturer.

Programming the ATmega128

For programming the ATmega128, I used an Arduino Mega as an ISP (In-System Programmer).

This approach is simple, reliable, and does not require a dedicated AVR programmer.

The Arduino Mega was configured using the ArduinoISP sketch, and the ATmega128 was programmed directly through its SPI pins (MOSI, MISO, SCK, and RESET). This method made it easy to upload and update firmware while reverse engineering and testing the dot-matrix display logic.

1. Using the Arduino Mega as a programmer allowed fast iteration during development and helped validate the reverse-engineered display timing, font scanning, and multiplexing behavior.

ToolPurpose

Multimeter Continuity & power tracing

Oscilloscope Timing & multiplexing analysis

Camera / phone PCB documentation

ATmega128 (for reproduction) Display controller

Logic analyzer (optional) Verifying scan patterns

The dryer front panel contains:

1. 9 individual LED dot‑matrix digits
2. Each digit arranged as 5×7 LEDs
3. Digits placed side‑by‑side

Important observation:

There is no driver IC per digit. All digits are passive.

This immediately tells us:

1. The display is fully multiplexed
2. Brightness and stability depend entirely on scan timing

By tracing the connector from the display board:

1. Rows are shared across all digits
2. Columns are digit‑specific

This reveals a classic multiplexed dot‑matrix layout:

Rows: R0 R1 R2 R3 R4 R5 R6 (shared)

Columns: C0–C4 per digit × 9 digits

Total control lines are drastically reduced.

Tracing the PCB reveals five ABT574 octal latches.

Why ABT574?

1. Fast output switching
2. Strong LED drive capability
3. Latched outputs = stable columns during row scan

Functional roles:

1. ABT574 #2 → Column data
2. ABT574 #3 → Digit / row selection

This means:

The MCU shifts data once, latches it, then rapidly scans rows.

By probing with an oscilloscope:

1. One group of signals pulses rapidly (scan lines)
2. Another group changes more slowly (data lines)

This confirms:

1. Rows are scanned
2. Columns hold font data

Original implementation (observed):

1. 7 scan cycles per character
2. Font stored column‑based
3. Each scan activates one row

This works — but it’s inefficient.

By freezing the display and capturing column states:

Each character is stored as 5 bytes, each byte representing one column:

Column font example ('H'):

0xFE

0x10

0x10

0x10

0xFE

bit 7 → top LED

bit 1 → bottom LED

This confirms:

1. Column-wise font encoding
2. 7 vertical scan steps

After fully understanding the original system, I redesigned the font logic:

Original:

1. 7 scan cycles per digit
2. Column font
3. Higher CPU load

New approach:

1. Row-based font encoding
2. Only 5 scan cycles
3. Each scan outputs one full row across all digits

Why this matters:

1. ~30% faster refresh
2. Higher brightness
3. More CPU time for scrolling & animations
4. Cleaner multiplexing timing

This is a huge architectural improvement over the original design.

Digit selection works like this:

1. Disable all columns
2. Clear row latches
3. Load font data into column latch
4. Enable exactly one digit
5. Advance to next digit

This happens hundreds of times per second, creating a stable image.

Manufacturers optimize for:

1. Minimal parts
2. Low cost
3. Reliable brightness
4. Simple firmware

Using:

1. Passive LED matrices
2. Shift registers
3. Aggressive multiplexing

This design hits all those goals — even if it’s not the most CPU‑efficient.

To validate the reverse engineering:

1. Rebuilt the display logic using ATmega128
2. Reimplemented both column‑scan and row‑scan fonts
3. Achieved identical visual output
4. Improved refresh quality using row-based scan

If you can recreate it from scratch — you truly understand it.

Reverse engineering this dot‑matrix display revealed that:

1. Display performance is mostly about scan strategy
2. Font encoding direction matters a lot
3. Commercial designs prioritize cost over elegance
4. Small architectural changes make massive improvements

This project turned a black‑box appliance display into a fully understood, reproducible system.

All the code is in this link

https://github.com/banoubbanoub/5x7-LED-Dot_Matrix-display