Upgrading the Tandy Model 100: A Retro Computing Journey

The tricky part is its strange display.

In 2021, I purchased a Tandy Model 100 (often referred to as M100) for about $90 at the Vintage Computer Festival in the Eastern United States. This computer was first released in 1983 and is a pioneer of modern laptops, featuring a high-quality keyboard and an LCD display. It runs on 4 AA batteries, providing 20 hours of operation and a month of standby time.

Thanks to the Club 100 user group, I was able to access a variety of software written for the M100. Unfortunately, my device was broken. I identified the faulty components but didn’t attempt to find new replacements. Instead, I bought a cheap, broken M100 sold for parts on eBay. I removed the necessary components from its motherboard and repaired my original M100. Then I looked at the second M100, which was in worse condition but still had a good keyboard and screen, and thought, “I can definitely do something with this.” How hard could it be to replace a 40-year-old 8-bit 8085 CPU and motherboard to turn it into a modern device?

Upgrading the Tandy Model 100: A Retro Computing Journey

Of course, I wasn’t the first to have this idea. Many people have upgraded the M100, but they typically replaced the 240×64 pixel monochrome display with some high-resolution color screens or kept the original LCD just for text display. I wanted to keep the original display because I love its chunky pixel experience and low power consumption; I also wanted it to display images and different fonts like the original M100. If I could achieve this, I could use any replacement CPU with software like CircuitPython’s displayio library. However, I soon discovered that the M100’s display is very strange by today’s standards, presenting me with a challenge.

The M100’s LCD is actually ten independent displays, each controlled by its own HD44102 driver chip. Except for the two chips on the right that control a 40 pixel x 32 pixel display area, each of the other driver chips controls a 50 pixel x 32 pixel display area. Therefore, the total resolution is 240 pixels x 64 pixels. Within each area, pixels are split into 4 rows (or lines), each 8 pixels high. These 8 vertical columns of pixels correspond to 1 byte in the driver’s local memory.

To set a pixel, you need to determine its area on the screen, activate the corresponding driver chip, tell the chip you want to send a command; send a command to select the row and column, and tell the chip you want to send pixel data; then write a byte of data, setting 8 pixels at once, including the pixel you selected and the other 7 accompanying pixels.

This arrangement is beneficial because it greatly speeds up the process when displaying text. By using a 7-pixel high font with 1 pixel of blank space at the bottom, you can directly copy the bitmap of that font from memory byte by byte. The sequence of bytes sent usually doesn’t require additional commands; once the chip receives the data byte, it can automatically advance the column index and change the order of rows for fast scrolling display.

This row/column addressing scheme is still in use today, such as in some modern OLED displays, but their rows span the entire display, meaning each screen has one chip. I have to manage each area and driver chip myself.

Some aspects made it easier. First, the M100’s design is maintenance-friendly. The display driver chips are on a circuit board that connects to the motherboard via a 15×2 pin connector, making it easy to remove. The keyboard uses a simple 10×10 matrix, also connected via an easily detachable connector. There is a good maintenance manual detailing each circuit. With the help of this maintenance manual, the HD44102 datasheet, and useful tips provided by other LCD enthusiasts online, I built an interface to connect this display to an Arduino Mega 2560. The fact that old machines tend to be more tolerant of errors helps, avoiding issues like “it smokes as soon as the voltage exceeds 3.8 volts.” Accidentally connecting wires incorrectly? No problem, just fix it and try again. Inputting unprocessed PWM signals instead of constant analog signals? No problem, it’s acceptable, just a bit flickery.

The interface provides the ±5 volts needed for the LCD display. Additionally, the interface has an RC low-pass filter to smooth the PWM signal, which simulates the 0 to 4 volts output of an adjustable angle potentiometer. Other pins are connected to the Mega’s digital inputs/outputs or power lines.

I wrote some code to store a 240×64 pixel frame buffer and mapped its pixels to the corresponding display areas. The software selects the appropriate chip, row, and column, sends data, and manages various clock and control signals. From the outside, the Mega acts as a driver for a modern monochrome display, accepting bitmap data according to the pixels of the rows (or columns) across the screen, which the displayio library can handle perfectly.

Now, the LCD can be connected in parallel or serially with the microcontroller of my choice through the Mega, which copies the input data to the frame buffer; I plan to use the Teensy 4.1, which allows me to directly communicate with the matrix keyboard and has enough computing power to support some basic text editing firmware. It also provides a VT100 terminal serial interface, and a Raspberry Pi 4 can also be installed in the M100. This enables Wi-Fi, a 64-bit operating system, and up to 8 gigabytes of memory, which is a huge upgrade compared to the 8 to 24 kilobytes originally accommodated by the device!

Author: Stephen Cass

IEEE Spectrum

Official WeChat Public Platform

“Technology Review”

Previous IssuesRecommendations

RISC-V Strives to Capture Raspberry Pi

The Secrets Inside the First ExaFLOP Computer

Hardcore Teardown of a 1968 U.S. Military Computer

Related posts:

Leave a Comment Cancel reply