Input devices consisting of optical readers for punched paper tape have been around since the earliest days of computing, so why stop now? [Jürgen]’s Paper Tape Reader project connects to any modern computer over USB, acting like a serial communications device. Thanks to the device’s automatic calibration, it works with a variety of paper materials. As for reading speed, it’s pretty much only limited to how fast one can pull tape through without damaging it.
While [Jürgen]’s device uses LEDs and phototransistors to detect the presence or absence of punched holes, it doesn’t rely on hardware calibration. Instead, the device takes analog readings of each phototransistor, and uses software-adjusted thresholds to differentiate ones from zeros. This allows it to easily deal with a wide variety of tape types and colors, even working with translucent materials. Reading 500 characters per second isn’t a problem if the device has had a chance to calibrate.
There’s nothing quite like going to a museum and being given a tour by a docent who really knows their way around the exhibits. When that docent has first hand experience in the subject matter, the experience is enhanced even further. So you can imagine our excitement when hacker, maker, and former DEC mainframe memory engineer [Ned Utzig] published a tour of what he calls “Memories of Weird Memories of Computers Past.” [Ned] expertly guides us through each technology, adding flavor and nuance to an already fascinating subject.
The tour begins with early storage media such as IBM punch cards, and then walks us through time to the paper tape, vacuum tubes, and even complex vats of mercury — all used for the sake of storing data either permanently or temporarily.
Next in the exhibit is an impressive CRT hack that isn’t unlike modern DRAM. The tour continues on to ferrite core memory such as that used on mainframes, minicomputers, and even the Apollo Guidance Computer. Each type is examined for its strengths and weaknesses and its place in computing history.
We really appreciated the imaginative question posed toward the end of the article. We won’t give it away here- it’s worth it to go give The Mad Ned Memo a read.
We’re not quite sure what drove the development of this project, but [shapoco] has put together an intriguing device that reads I2C signals (Japanese Twitter link) which have been printed as black and white rectangles on paper tape. He wrote a program that prints an I2C byte stream onto strips containing the SCL and SDA signal patterns. Once printed, you cut the strips from the paper and glue them together into one long piece, making a complete message — in this case, commands to a small LCD screen that will display the phrase “Hello, Tape I2C”.
We’re not sure exactly sure what’s inside that rectangular widget epoxied to the bottom of that perf board through which the tape passes. But clearly, it must contain a pair of LEDs to illuminate the tape and a pair of sensors to detect the reflection off the tape (looking at the wiring, it seems unlikely that anything is mounted underneath the tape). According to one machine-translated Twitter message, detection is done using a Schmitt trigger made from an LM393 comparator with hysteresis (see this TI app note for a review of this type of circuit). Here’s a scope capture of the resulting signals. [Shapoco] notes that the circuit can operate much faster — the tape is being pulled slowly in the video to make it easier to see.
This is not [shapoco]’s first experiment in optical I2C communications. Check out the second video down below where he’s reading I2C signals from a computer’s display. One person tweeted about how software source code was sometimes printed optically in old Byte magazines many years ago, a topic we talked about in Hackaday Podcast #049 last year when discussing Cauzin strips.
Besides just being cool, and possibly helpful as an educational device, does this technique have any real-world applications these days? Let us know your thoughts in the comment section below. Thanks to [Manawyrm] for sending us this tip.
Meme investing is all the rage these days, and what better way to get in on the loss fun than with your very own old-timey mechanical stock ticker? Unfortunately, they’re about as expensive and rare as you might expect for a piece of Victorian-era electronics. Lucky for us, [secretbatcave] has shown that you can put together a functional look-alike that costs about as much as a GameStop (GME) share was worth before it started heading to the Moon.
This might seem like an ambitious project, but in actuality the machine only has a few moving parts. There’s a stepper motor to feed the paper, another to spin an inked embossing wheel, and a couple of solenoids attached to a pusher plate. Rather than trying to move the heavy wheel, the pusher plate smashes the paper up into it. The fact that this produces a satisfying “clack” sound as each character is printed is just an added bonus.
To sell the look, [secretbatcave] put the whole mechanism inside a tall glass dome from IKEA. The matching wooden base was extended so the pusher plate solenoids could fit inside, after which it was dunked in ink and sprayed with a gloss sealer to give it that shiny black finish people seemed to love in the 1900s. With the addition of an engraved brass nameplate, it looks like the machine fell out of a time warp.
In terms of electronics, there’s an ESP32, a pair of stepper motor controllers, and a relay for the solenoids. As of right now it all lives in a rather utilitarian box that’s tethered to the ticker, but we’re sure the lot could get tucked under the base with the help of a custom PCB should you be so inclined.
With an ESP32 at the helm, the ticker could easily be configured to print out whatever data it receives over the network or picks up from MQTT. With hardware like this and a pair of Diamond Hands, those tendies are as good as yours.
Computer gaming has come a very long way since the 1960s. While computers of that era may not run Doom or anything even close to it, many of us had our first exposure to computers playing Hunt the Wumpus, Adventure, or Star Trek over a clackety old TeleType machine. If you missed those days, or if you simply miss them, you might enjoy the video from [somecomputerguy] who fires up an old retired gas pipeline computer and loads enough paper tape into it to play Lunar Lander. (Video embedded below.)
We don’t miss the days of toggling in a bootloader so you could load the paper tape for a second bootloader before you could enter the actual program you wanted to run.
The recent Cyphercon badge featured a very clever integrated paper tape reader, and had the hidden feature of a party mode in which all its lights would flash. When [Gigawatts] discovered this after the conference had ended, it was too late to find the tape to activate it. The solution? Build a tape emulator with a microcontroller hooked into the badge’s tape sensors to send the data directly into it.
It was a Tweet from [AND!XOR] that revealed the flashing hidden mode, and in case you missed it you can find all about the amazing badge in our review. The emulator takes a TI Stellaris LaunchPad LM4F120 and a set of jumper wires soldered directly to the jumper wires on the badge’s reverse. Hex values are created from a tape through an in-browser HTML page with a checkbox interface, a sketch converts the hex to tape, and the badge runs the code. The GitHub readme includes a description of the paper tape format as well as some sample tapes including a badge reset one for when you tire of party mode.
Most of us weren’t lucky enough to make it to Cyphercon and receive a badge. But we’re still impressed by the ingenuity of the badge’s designer, and by the complexity of the CTF game of which it formed a part.
We often think that not enough people are building things with FPGAs. We also love the retrotechtacular posts on old computer hardware. So it was hard to pass up [karlwoodward’s] post about the Chip Hack EDSAC Challenge — part of the 2017 Wuthering Bytes festival.
You might recognize EDSAC as what was arguably the first operational computer if you define a computer as what we think of today as a computer. [Maurice Wilkes] and his team invented a lot of things we take for granted today including subroutines (Wheeler jumps named after a graduate student).
The point to the EDSAC challenge was to expose people to creating designs with FPGAs, particularly using the Verilog hardware description language (HDL). If you want to follow along or run your own Chip Hack, the materials are available on the Web. You can see an FPGA driving a tape punch to create souvenir tapes in the video, below.
For the record, EDSAC was awesome. The execution unit was serial and processed bits that marched in one at a time over a mercury delay line. There is quite a bit of documentation and even some simulators, so if you ever wanted to get your hands into an old computer, this one isn’t a bad one to try.