A system that stores data on LEGO bricks

How To Use LEGO Bricks For Data Storage

June 6, 2022 by Robin Kearey 10 Comments

Those old enough to have encountered punch cards in their lifetime are probably glad to be rid of their extremely low data density and the propensity of tall stacks to tip over. But obsolete as they may be, they’re a great tool to show the basics of binary data storage: the bits are easily visible and can even be manipulated with simple tools. As an experiment to re-create those features in a more modern system, [Michael Kohn] made a punch card-like system based on LEGO bricks that stores machine code instructions for a 65C816 CPU, the 16-bit successor to the venerable 6502.

Bits are stored on a white 8×20 stud board, onto which small black pieces are placed. A white background stud encodes a logic “zero”, while a black stud encodes a logic “one”. The bits are read out by an array of reflectance sensors, which conveniently has the same 8 mm pitch as standard LEGO studs. A big wheel driven by a stepper motor slides the data card under the readout circuit along a short stretch of LEGO train tracks.

The optical sensors are read out by an MSP430 series microcontroller, which also drives the motor through a stepper motor driver. Once the data is read out, the bytes are transferred into a WDC W65C265SXB board, which executes them as machine code instructions on its 65C816 CPU. In the video below, you can see a program being loaded that blinks an LED.

We’ve featured educational punch-card systems before, like this Raspberry Pi-based model. If you’ve got a bunch of actual punch cards that need reading out, check out this Arduino-powered readout system.

Continue reading “How To Use LEGO Bricks For Data Storage” →

Your 1958 Punch Card Machine Tested Tubes

June 15, 2021 by Al Williams 12 Comments

We think of punched cards as old-fashioned, but still squarely part of the computer age. Turns out, cards were in use way before they got conscripted by computers. Jacquard looms are one famous example. The U.S. Census famously used punched cards for tabulating the census without anything we’d consider a computer. But in the 1950s, you might have had a punched card machine on your electronics workbench. The Hickok Cardmatic was a tube tester with a difference.

About Tube Testers

While you, as a Hackaday reader, might tear into a busted TV at your house and try to fix it, most people today will either scrap a bad set or pay someone to fix it. That’s fine today. TVs are cheap and rarely break, anyway. But this hasn’t always been the case.

In the “good old days” your expensive TV broke down all the time. Most of the parts were reliable, but the tubes would wear out. If you were the kind of person who would change your own oil, you’d probably look to see if you could spot a burned out tube and try replacing it. If you couldn’t spot it, you’d pull all the tubes out. If you were lucky, there was a diagram glued inside the cover that showed where they all went back. Then you took them to the drugstore.

Continue reading “Your 1958 Punch Card Machine Tested Tubes” →

Open Source Computer Controlled Loom Weaves Pikachu For You

June 18, 2019 by Helen Leigh 17 Comments

The origin story of software takes us back past punch card computers and Babbage’s Difference Engine to a French weaver called Joseph Marie Jacquard. Jacquard created a way to automate mechanical looms, giving weavers the ability to change a loom’s pattern by simply switching punch cards. This invention not only made it possible to produce detailed fabrics in a vastly simplified way, it was an extremely important conceptual step in the development of computer programming, influencing Babbage’s development of the Analytical Engine amongst many other things.

So, when [Kurt] saw his son’s enthusiasm for weaving on a simple loom, he started thinking about how he could pay homage to the roots of software by designing and building an open source computer controlled loom. He knew this was going to be difficult: looms are complex machines with hundreds of small parts. [Kurt] wrestled with wonky carriage movements, cam jams, hook size disasters and plenty of magic smoke from motor control boards. After a year and a half of loom hacking he succeeded in making a 60 thread computer controlled loom, driven by an iPhone app using Bluetooth.

As well as writing up the story of this build on his blog, linked above, [Kurt] has also has made all of his design files, PCB layouts, firmware and code available on GitLab.

We’ve featured a few weaving hacks over the years, including this cheap, simple 3D printable loom and a Jacquard inspired bitmap display.

Fun, informative build video after the cut.

Continue reading “Open Source Computer Controlled Loom Weaves Pikachu For You” →

One Man’s Awesome Collection Of Projects Done Over A Lifetime

June 7, 2016 by Gerrit Coetzee 21 Comments

[Robert Glaser] kept all his projects, all of them, from the 1960s to now. What results is a collection so pure we feel an historian should stop by his house, if anything, to investigate the long-term effects of the knack.

He starts with an opaque projector he built in the third grade, which puts it at 1963. Next is an, “idiot box,” which looks suspiciously like “the Internet”, but is actually a few relaxation oscillators lighting up neon bulbs. After that, the condition really sets in, but luckily he’s gone as far as to catalog them all chronologically.

We especially enjoyed the computer projects. It starts with his experiences with punch cards in high school. He would hand-write his code and then give it to the punch card ladies who would punch them out. Once a week, a school-bus would take the class to the county’s computer, and they’d get to run their code. In university he got to experience the onset of UNIX, C, and even used an analog computer for actual work.

There’s so much to read, and it’s all good. There’s a section on Ham radio, and a very interesting section on the start-up and eventual demise of a telecom business. Thanks to reader, [Itay Ramot], for the tip!

Hackaday Prize Entry: A Numerically Controlled RepRap

June 4, 2016 by Brian Benchoff 14 Comments

The story for permanent storage for computers begins with the Jacquard loom. Hackaday commenters that are less clever than a Wikipedia article may argue that it was the earlier Bouchon and de Vaucanson looms, but either way we owe permanent storage methods to loom designers. So the story goes that punched cards for weaving brocades and damask patterns in cloth turned into punched cards for tabulating a census, calculating artillery trajectories, and ends with hundreds of gigabytes of storage in a thumbnail-sized micro SD card.

This story glosses over one important fact. The automated looms of the 17th century were simply a way to make a manufacturing process faster. These automated looms were the forebears of numerically controlled machine tools. These machines, first a lathe, followed by mills and all sorts of metalworking tools, first appearing in the 1950s, used punched tape to store the commands required to mill a part out of metal. Just like the SD card on a modern 3D printer.

For [will.stevens’] Hackaday Prize entry, he’s going back to the roots of automated manufacturing and building a punched card reader for his 3D printer. Is the idea sound? Yes. Is it going to be easy? No, [will] is creating his punched card reader on his 3D printer. It’s the ultimate expression of the RepRap philosophy of self-replication, and an interesting engineering challenge, too.

[will]’s idea for a punch card print controller uses relays. It’s a simple control system that encodes the individual steps for the X and Y axes, along with a length of a line. This printer won’t be able to create lines that go in every direction, instead, there are only 48 possible angles this printer can use out of 360 degrees. At large scales, prints and plots will have the jaggies, but at smaller scales, this control system will be able to print something resembling a circle.

[will] has a PDF of his proposed control system, and he’s already hard at work creating the 3D printed relays and solenoids. [will]’s goal for this year’s Hackaday Prize is to create a 2D plotter – just one axis short of a 3D printer, and he’s well on his way to printing off his own punched cards.

The HackadayPrize2016 is Sponsored by:

Split-flap Train Display Uses Punch Cards; Serviced With Station Ingenuity

April 20, 2016 by Donald Papp 36 Comments

A short but highly detailed documentary by [Krzysztof Tyszecki] explores the split-flap display system in place at the Łódź Kaliska train station in Poland as well as the efforts needed by the staff to keep it running and useful to this day. Split-flap displays might be old technology, but many are still in use throughout the world. But even by those standards, the unit at Łódź Kaliska is a relic you wouldn’t expect to see outside a museum. “I doubt you’ll find an original anywhere else,” says a staff member. It requires constant upkeep to remain operational, and meeting the changing demands of a modern station within the limitations of the original system takes some cleverness. “In general the failure rate of the device is terrible,” he adds.

The system runs on punch cards. You can’t buy them anymore, so a local printer makes them – several hundred are needed every time there is a schedule change. The punching pliers (which also can no longer be purchased) get so worn out they replace the pins with custom-made ones from a local locksmith. The moving parts of the card reader have split-pins which need to be replaced every week or two – the stress of repeated movement simply wears them away. There’s nothing to do but replace them regularly. The assembly needs regular cleaning since dust accumulates on the cards and gets into the whole assembly. The list goes on… and so does the station.

There is no computation in the modern sense – it’s an electromechanical signing system managed and updated by human operators. It has more in common with a crossbar switch based telephone exchange than anything else. The punch cards are just a means of quickly, accurately, and repeatedly setting the displays to known states.

The short documentary goes into a lot of detail about every part of the system. The cards themselves are described in detail (1:07), as is the operator’s routine (2:27). We even see the back end controller (9:41), as well as see a split-flap module taken apart and tested (14:33) with an old tester the staffer isn’t sure will even work – but as with everything else we see, of course it does.

Split-flap displays are fascinating pieces of technology. We have even seen people build their own split-flap displays from scratch!

Continue reading “Split-flap Train Display Uses Punch Cards; Serviced With Station Ingenuity” →

The Most Powerful Bitcoin Mining Rig Yet

May 29, 2015 by Bryan Cockfield 18 Comments

In days of yore, one could mine Bitcoin without much more than an AMD graphics card. Now, without specialized hardware it’s unlikely that you’ll make any appreciable headway in the bitcoin world. This latest project, however, goes completely in the other direction: [Ken] programmed a 55-year-old IBM mainframe to mine Bitcoin. Note that this is technically the most powerful rig ever made… if you consider the power usage per hash.

Engineering wordplay aside, the project is really quite fascinating. [Ken] goes into great detail about how Bitcoin mining actually works, how to program an assembly program for an IBM 1401 via punch cards, and even a section about networking a computer from this era. (Bonus points if he can get retro.hackaday.com to load!) The IBM boasts some impressive stats for the era as well: It can store up to 16,000 characters in memory and uses binary-coded decimal. All great things if you are running financial software in the early ’60s or demonstrating Bitcoin in the mid-2010s!

If it wasn’t immediately obvious, this rig will probably never mine a block. At 80 seconds per hash, it would take longer than the lifetime of the universe to do, but it is quite a feat of computer science to demonstrate that it is technically possible. This isn’t the first time we’ve seen one of [Ken]’s mainframe projects, and hopefully there are more gems to come!