Tiny TV Celebrates The Forgotten Tech Of CRTs

February 11, 2022 by Dan Maloney 35 Comments

For those of us who grew up before the Internet, the center of pretty much every house was the TV. It was the shrine before which we all worshipped, gathering together at the appointed times to receive the shared wisdom of mass entertainment. In retrospect, it really wasn’t that much. But it’s what we had.

Content aside, one thing all these glowing boxes had in common was that which did the glowing — the cathode ray tube (CRT). Celebrating the marvel of engineering that the CRT represents is the idea behind [Matt Evan]’s tiny desktop TV. The design centers around a 1.5″ CRT that once served as a viewfinder on a 1980s-vintage Sony camcorder. [Matt] salvaged the tube and the two PCB assemblies that drive it, mounting everything in a custom-built acrylic case, the better to show off the bulky but beautiful tube.

The viewfinder originally used a mirror to make the optical path more compact; this forced [Matt] to adapt the circuit to un-reverse the image for direct viewing. Rather than receiving analog signals off the air as we did in the old days — and we liked it that way! — the mini monitor gets its video from a Raspberry Pi, which is set to play clips of TV shows from [Matt]’s youth. Rendered in glorious black and white and nearly needing a magnifying glass to see, it almost recaptures the very earliest days of television broadcasting, when TVs all had screens that looked more like oscilloscope CRTs.

This project is a nice homage to a dying technology, and [Matt] says it has spurred more than one conversation from people you grew up knowing only LCD displays. That’s not to say CRTs are totally dead — if you want to build your own old-school TV, there’s a kit for that.

IBM PalmTop Running Modern (Modified) Linux

February 6, 2022 by Bryan Cockfield 19 Comments

The handheld computing market might seem dominated by smartphones today, but before their mass adoption there were other offerings for those who needed some computing power on-the-go. If a 90s laptop was too bulky, there was always the IBM PalmTop which packed punch for its size-to-weight ratio, and for the era it was created in. [Mingcong Bai] still has one of these antiques and decided to see if it was still usable by loading a customized Linux distribution on it.

The PalmTop sported modest hardware even for its time with an Intel 486SL running at 33 MHz with 20 MiB of RAM. This one also makes use of a 1 GB CompactFlash card for storage and while [Mingcong Bai] notes that it is possible to run Windows 95 on it, it’s not a particularly great user experience. A Linux distribution customized for antique hardware, AOSC/Retro, helps solve some of these usability issues. With this it’s possible to boot into a command line and even do some limited text-based web browsing as long as the Ethernet adapter is included.

While the computer is running at its maximum capacity just to boot and perform basic system functions, it’s admirable that an antique computer such as this still works, especially given its small size and limited hardware functionality. If you’re curious about more PalmTop-style computers, take a look at the first one ever produced: the HP-200LX.

Continue reading “IBM PalmTop Running Modern (Modified) Linux” →

Custom Macintosh With A Real 486

February 1, 2022 by Bryan Cockfield 12 Comments

Older Apple computers can often be something of a collector’s item, with the oldest fetching an enormously high price in auctions. The ones from the late ’80s and early ’90s don’t sell for quite as much yet, but it’s possible that museums and collectors of the future will one day be clamoring for those as well. For that reason, it’s generally frowned upon to hack or modify original hardware. Luckily, this replica of an Apple Macintosh didn’t harm any original hardware yet still manages to run software on bare metal.

The computer is built around a single-board computer, but this SBC isn’t like the modern ARM machines that have become so ubiquitous. It’s a 133MHz AMD 486 which means that it can run FreeDOS and all of the classic DOS PC games of that era without emulation. In order to run Apple’s legacy operating system, however, it does require the use of the vMac emulator, but the 486 is quite capable of handling the extra layer of abstraction. The computer also sports a real SoundBlaster ISA sound card, uses a microSD card for its hard drive, and uses an 800×600 LCD screen.

As a replica, this computer is remarkably faithful to the original and even though it doesn’t ship with a Motorola 68000 it’s still fun to find retro PC gamers that are able to run their games on original hardware rather than emulation. It reminds us of another retro 486 that is capable of running old games on new hardware without an emulator as well.

Reverse Engineering The SEGA Mega Drive

January 19, 2022 by Bryan Cockfield 16 Comments

With the widespread adoption of emulators, almost anyone can start playing video games from bygone eras. Some systems are even capable of supporting homebrew games, with several having active communities that are still creating new games even decades later. This ease of programming for non-PC platforms wasn’t always so easy, though. If you wanted to develop games on a now-antique console when it was still relatively new, you had to jump through a lot of hoops. [Tore] shows us how it would have been done with his Sega Mega Drive development kit that he built from scratch.

While [Tore] had an Atari ST, he wanted to do something a little more cutting edge and at the time there was nothing better than the Mega Drive (or the Genesis as it was known in North America). It had a number of features that lent the platform to development, namely the Motorola 68000 chip that was very common for the time and as a result had plenty of documentation available. He still needed to do quite a bit of reverse engineering of the system to get a proper dev board running, though, starting with figuring out how the cartridge system worked. He was able to build a memory bank that functioned as a re-writable game cartridge.

With the hard parts out of the way [Tore] set about building the glue logic, the startup firmware which interfaced with his Atari ST, and then of course wiring it all together. He was eventually able to get far enough along to send programs to the Mega Drive that would allow him to control sprites on a screen with the controller, but unfortunately he was interrupted before he could develop any complete games. The amount of research and work to get this far is incredible, though, and there may be some helpful nuggets for anyone in the homebrew Mega Drive community today. If you don’t want to get this deep into the Mega Drive hardware, though, you can build a cartridge that allows for development on native Sega hardware instead.

A Nixie Clock, The Hard Way

December 15, 2021 by Dan Maloney 16 Comments

Notice: no vintage Hewlett Packard test equipment was harmed in the making of this overly complicated Nixie clock. In fact, if anything, the HP 5245L electronic counter came out better off than it went into the project.

HP 5245 hand-wired backplane — Beautiful hand-wired backplane in the HP 5245 counter.

We mention the fate of this instrument mainly because we’ve seen our fair share of cool-looking-old-thing-gutted-and-filled-with-Arduinos projects before, and while they can be interesting, there’s something deeply disturbing about losing another bit of our shared electronic heritage. To gut this device, which hails from the early 1960s and features some of the most beautiful point-to-point backplane wiring we’ve ever seen, would have been a tragedy, one that [Shahriar] wisely avoided.

After a bit of recapping and some power supply troubleshooting, the video below treats us to a tour of the Nixie-based beauty. It’s a wonderful piece, and still quite accurate after all these decades, although it did need a bit of calibration. Turning it into a clock non-destructively required adding a little bit of gear, though. Internally, [Shahriar] added a divide-by-ten card to allow the counter to use an external 10-MHz reference. Externally, an ERASynth++ programmable signal generator was used to send a signal to the counter from 0 Hz to 23,595.9 kHz, ramping up by 100 Hz every second.

The end result is the world’s most complicated 24-hour clock, which honestly wasn’t even the point of the build at all. It was to show off the glorious insides of the counter, introduce us to some cool new RF tools, and as always with [Shahriar]’s videos, to educate and inform. We’ve always enjoyed his wizardry, from his look into automotive radars to a million-dollar scope teardown, and this was another great project.

Continue reading “A Nixie Clock, The Hard Way” →

Hacking An Obsolete Yet Modern Calculator

November 1, 2021 by Bryan Cockfield 7 Comments

The gold standard for graphing calculators, at least in the US, are the Texas Instruments TI-84 series. Some black sheep may have other types, but largely due to standardized testing these calculators dominate the market. Also because of standardized testing, these calculators have remained essentially unchanged for decades. While this isn’t great for getting value for money, it does mean that generations of students have been able to hack on these calculators to do all kinds of interesting things as [George Hilliard] outlines.

Even before the creation of these graphing calculators, the z80 processor behind them was first produced over four decades ago and was ubiquitous in the computer scene at the time, which also lends to its hackability. There’s plenty to catch up on here, too, from custom TI games that trick the two-tone display into grayscale to Game Boy emulators that can play Zelda since the TI and Game Boy share the same processors. There are also several methods of running native code or otherwise “jailbreaking” these devices to run arbitrary code.

It looks like the world of TI hacking is alive and well now, and with several decades of projects to browse there’s always something new to find. As it stands, there may be more decades of these types of projects to come, since neither TI nor the various testing standardization companies and government agencies show any signs of changing any time soon.

Thanks to [Adrian] for the tip!

POLF: Retro 3D Game Uses Only A Character Display

October 18, 2021 by Donald Papp 11 Comments

Got a retrocomputing itch? So does [David Given], and luckily for us all he indulged it by writing POLF: a first-person 3D game for the Commodore PET that uses only the system’s 40×25 text mode character display for visuals. It’s a fantastic achievement, considering that the 80s-era computer boasts 32 kB of memory and doesn’t even have a graphical display.

Each level in POLF is a small, maze-like room in which one’s goal is to play a sort of cross between billiards and golf, aiming to move the round “ball” object into the square “hole” object. The 3D view is rendered using raycasting, which is a way of efficiently drawing a workable 3D perspective using limited resources. Raycasting can only do so much, but as a method it works fantastically within its limitations, and there are useful tutorials out there that lay the process bare.

The GitHub repository for the project is here, and it should run on any 40-column screen PET with at least 16 kB of RAM. Watch it in action in the video, embedded below. (Hint: the little bar graphs under the compass headings at the bottom of the screen represent the player’s proximity to the ball and hole objects. )

Continue reading “POLF: Retro 3D Game Uses Only A Character Display” →