Let’s Listen To A Tape — Paper Tape

These days, data is as likely as not to be “in the cloud.” Otherwise, it’s probably on a USB flash drive or SD card. But in the old days, paper tape was a widespread way to store and retrieve data. A common way to start the day at the office was to toggle in a few dozen bytes of bootloader code, thread a bigger bootloader tape into your TeleType paper tape reader, and then get your coffee while the more capable bootloader clunked its way into memory. Then you could finish your brew while loading the tape with your compiler or whatever you wanted. [Scott Baker] has a Heathkit H8 and decided using a paper tape machine with it and some of his other gear would be fun.

Instead of a TeleType, [Scott] picked up a used paper tape machine from FANUC intended for the CNC industry. They are widely available on the surplus market, although a working machine might run you $500. [Scott] paid $200, so he had some work to do to make the unit operational.

Paper tape had a few varieties. For computer work, you usually had a tape that could hold eight holes across, one for each bit in a byte. However, there are also 6-bit and 5-bit tapes for special purposes or different encodings (old TeleTypes used 5-bit characters in Baudot). The paper choice varied too. You could get plain paper, oiled paper, which maybe didn’t jam as often, and Mylar, which is less likely to shred up when it does jam.

To make things even more difficult, the machines all worked a little differently as well. Sure, punches almost all use solenoids. But the tape transport was sometimes a pinch roller and sometimes a sprocket-style drive. Reading the holes could be done with mechanical contacts or optically. Some punches left little “hanging chads” on the tape, so you didn’t have to empty a confetti box to throw away the chad.

The repair job was interesting. Inside the machine is an 8051 microcontroller. There was no clock, and the circuit used two custom modules. One was simply a crystal, and the other was an oscillator. Removing both allowed a modern can oscillator to replace both modules. The next problem was a fried serial output driver. Replacing that got things working except for random resets due to a faulty brown-out reset circuit. That was easy to fix, too.

Of course, if you are really cheap, it is easy to make a paper tape reader from 8 phototransistors, and pulling tape through by hand isn’t unheard of. It can even talk USB. We’ve even seen a conference badge that can read tapes.

Continue reading “Let’s Listen To A Tape — Paper Tape” →

TinyBasicLike: A Target-Independent BASIC Interpreter

In the long and winding history of BASIC, it’s sometimes hard to keep track of all the different variants and dialects. Some may still remember TinyBASIC, which was published in 1976 as Palo Alto Tiny BASIC by [Gordon Brandly]. Later, TinyBASIC was modified by a number of people including [Scott Lawrence] who created TinyBASIC Plus (TBP). Inspired by this, [Karl] figured he could improve on TBP by making the original C-based project even easier to port by removing whatever platform dependencies he could find, creating what he calls TinyBasicLike.

The main change is that TinyBasicLike consists out of two C files, with one containing the core code, and the second the platform-specific details that can be used by the core. Although [Karl] started off with the Palo Alto Tiny BASIC-like code by [Scott Lawrence], he decided to make it into his own by making a few alterations, such as adding left and right shift operators, adding an ADDR() function, expanding the features of INPUT and adding multiple logical operators.

In the example STM32F4 project linked on the project page it is demonstrated how to target a new platform with TinyBasicLike. Performance on the STM32F4 Discovery board with a simple counting loop yielded about 6 lines of TBL program code per millisecond. For a 168 MHz STM32 MCU that’s definitely not astounding, but considering how straightforward Tiny BASIC (and TBL as a consequence) is, it’s definitely no slouch.

This is probably a good time to remind that BASIC was the original champion of cross-platform programming and the source of countless fond (and frustrating) memories.

A ZX Spectrum with a Microdrive emulator plugged into its expansion port

A Modern Replacement For The ZX Spectrum’s Odd Tape Storage System

Unless you were lucky enough to be able to afford a floppy disk drive, you probably used cassette tapes to store programs and data if you used pretty much any home computer in the 1980s. ZX Spectrum users, however, had another option in the form of the Microdrive. This was a rather unusual continuous-loop mini-tape cartridge that could store around 100 kB and load it at lightning speed, all at a much lower price point than a floppy drive. The low price came at the cost of poor durability however, and after four decades it’s becoming harder and harder to find cartridges that work reliably. [Derek Fountain] therefore set out to make a modern Microdrive emulator that stores data on SD cards.

Several projects already exist to replace Microdrives, but they typically also need the ZX Interface 1, a serial/network expansion module that’s becoming equally hard to find. Hence [Derek]’s choice to make his emulator a completely standalone system that directly plugs into the Spectrum’s expansion port.

A 3D-printed box with a PCB inside holding three Raspberry Pi Picos and an SD cardThe system is housed in a 3D-printed enclosure that holds two PCBs. Three Raspberry Pi Picos run the show inside: one to hold the ZX Interface 1’s ROM image and interface with the Spectrum’s bus, another to simulate the Microdrive, and a third to run the user interface and communicate with the SD card. The user can choose between eight tape images stored in .MDR format by using two pushbuttons and a rotary encoder, with a small OLED display showing the machine’s configuration.

While you might think that three dual-core 133 MHz ARM CPUs would run circles around the Spectrum’s Z80, it actually took quite a bit of work to get everyting running properly in real time. The 3.5 MHz bus clock rate gave the second Pico precious little time to fetch the required bytes out of its flash memory. Its RAM was fast enough for that, but too small to hold all eight tape images at the same time. In the end, [Derek] settled on using a separate 8 MB SPI DRAM chip that could easily keep up the data rate, with the Pi just using its GPIO ports to shuttle the data around.

All source code and extensive documentation are available on Derek’s excellent blog post and GitHub page. Be sure to also check out [Jenny]’s detailed review and teardown if you’d like to know more about the weird and wonderful Microdrive system.

Thanks for the tip, [Andrew]! Continue reading “A Modern Replacement For The ZX Spectrum’s Odd Tape Storage System” →

OLED Display Lets Vintage PC Engage Turbo Mode In Style

Back in the 486 days, it was common to see a “Turbo” button on the front panel of many PCs, which was used to toggle between the CPU’s maximum speed and a slower clock rate that was sometimes necessary for compatibility with older software. Usually an LED would light up to show you were running at this higher speed, or if your machine was very fancy, it might even have a numerical display that would show the current CPU frequency.

[Joshua Woehlke] wanted to add a similar display to his 486, but figured that with modern technology, he could do something a bit more interesting. Especially when he realized that the spot on his case where the two-digit LED display would have originally been mounted was the perfect size to hold a common 0.96″ SSD1306 OLED. From there it was just a matter of wiring it up to an Arduino and writing some code to display different graphics depending on the computer’s current CPU speed.

Just like the frequency indicators of yore, the Arduino doesn’t actually measure the CPU’s frequency, it’s simply reading the state of the Turbo LED on the front panel. When the LED is off the Arduino shows an image of a i8088 CPU on the screen to indicate the computer is running in compatibility mode, and when the LED is on, the screen shows the Cyrix Cx486 DX2 logo. When the button hasn’t been pressed in awhile, the display defaults to a star field screensaver.

Regular readers may recall we recently covered a similar project that used an Arduino to add a little flair to an era appropriate seven-segment LED display. We’d say there’s still a good deal of romanticism about computers having a big “TURBO” button you can smash whenever you feel the need for speed.

486 Gets Animated Turbo Button Thanks To Arduino

There was a point in time, excruciatingly brief, in which desktop computers often had a large “TURBO” button on their front panel. Some even featured an LED display that would indicate the current CPU frequency, providing visual conformation that your machine had leaped to a blistering 66 MHz.

The 486 that [someyob] is restoring had the Turbo button, but sadly there was just a simple LED to show whether or not it was engaged. But there was a window in the front panel where it seemed like a numerical display was intended to go, so they decided to wire up their own CPU indicator by sensing the state of the Turbo LED with an Arduino Pro Mini.

Now to modern audiences, this might seem like cheating. After all, the Arduino isn’t actually measuring the CPU speed, nor is it directly controlling it (that’s still done by the original Turbo button wiring). But the truth is, even back in the day, the CPU frequency displays faked it — they just toggled between showing two predefined frequencies depending on the state of the button. The arrangement [someyob] has come up with does the same thing, except now there’s some extra processing power in the mix, so the display can show some slick animations as it switches between 33 and 66 Mhz.

In the GitHub repository, [someyob] has provided the Arduino source code and schematics showing how the microcontroller was shoehorned into the existing front panel wiring without compromising its functionality. There’s even a brief video below that shows the display in operation.

Like the idea but don’t have a 486 laying around? Don’t worry. We’ve seen a similar panel built for modern machines that  just doesn’t look the part, it actually manages to be functional.

Continue reading “486 Gets Animated Turbo Button Thanks To Arduino” →

Selectric Typewriter Goes From Trash Can To Linux Terminal

If there’s only lesson to be learned from [alnwlsn]’s conversion of an IBM Selectric typewriter into a serial terminal for Linux, it’s that we’ve been hanging around the wrong garbage cans. Because that’s where he found the donor machine for this project, and it wasn’t even the first one he’s come across in the trash. The best we’ve ever done is a nasty old microwave.

For being a dumpster find, the Selectric II was actually in pretty decent shape. The first couple of minutes of the video after the break show not only the minimal repairs needed to get the typewriter back on its feet, but also a whirlwind tour of the remarkably complex mechanisms that turn keypresses into characters on the page. As it turns out, knowing how the mechanical linkages work is the secret behind converting the Selectric into a teletype, entirely within the original enclosure and with as few modifications to the existing mechanism as possible.

Keypresses are mimicked with a mere thirteen solenoids — six for the “latch interposers” that interface with the famous whiffletree mechanism that converts binary input to a specific character on the typeball, and six more that control thinks like the cycle bail and control keys. The thirteenth solenoid controls an added bell, because every good teletype needs a bell. For sensing the keypresses — this is to be a duplex terminal, after all — [alnwlsn] pulled a page from the Soviet Cold War fieldcraft manual and used opto-interrupters to monitor the positions of the latch interposers as keys are pressed, plus more for the control keys.

The electronics are pretty straightforward — a bunch of MOSFETs to drive the solenoids, plus an AVR microcontroller. The terminal speaks RS-232, as one would expect, and within the limitations of keyboard and character set differences over the 50-odd years since the Selectric was introduced, it works fantastic as a Linux terminal. The back half of the video is loaded with demos, some of which aptly demonstrate why a lot of Unix commands look the way they do, but also some neat hybrid stuff, like a ChatGPT client.

Hats off to [alnwlsn] for tackling a difficult project while maintaining the integrity of the original hardware.

Continue reading “Selectric Typewriter Goes From Trash Can To Linux Terminal” →

Restoring The Cheapest TRS-80 At The Swap Meet

We don’t know if you’ve looked into it recently, but the prices for vintage computers are through the roof right now. These classic machines are going through something of a renaissance at the moment, with even relatively commonplace computers commanding several hundred dollars if they’re in good condition. For those looking to start a collection without breaking the bank, you may need to accept some specimens that have seen better days.

That’s the situation [Vlado Vince] recently found himself in — he wanted to get his hands on a TRS-80 Model I, but wasn’t willing to spend eBay prices. So he waited until the Vintage Computer Federation’s swap meet in June and was able to snag a “fully functional” example for $95. Unfortunately the seller must have been using some form of that phrase which we were previously unaware of, as it took a considerable amount of work to get it back online.

Continue reading “Restoring The Cheapest TRS-80 At The Swap Meet” →