A 4-bit Computer From Discrete Transistors

November 22, 2014 by Brian Benchoff 23 Comments

Anyone reading this uses computers, and a few very cool people have built their own computer out of chips, [zaphod] is doing something even cooler over on hackaday.io: he’s building a computer from discrete transistors.

Building a computer from individual components without chips isn’t something new – Minecraft players who aren’t into cheaty command blocks do it all the time, and there have been a few real-life builds that have rocked our socks. [zaphod] is following in this hallowed tradition by building a four-bit computer, complete with CPU, RAM, and ROM from transistors, diodes, resistors, wire, and a lot of solder.

The ROM for the computer is just a bunch of 16 DIP switches and 128 diodes, giving this computer 128 bits of storage. the RAM for this project is a bit of a hack – it’s an Arduino, but that’s only because [zaphod] doesn’t want to solder 640 transistors just yet. This setup does have its advantages, though: the entire contents of memory can be dumped to a computer through a serial monitor. The ALU is a 4-bit ripple-carry adder/subtractor, with plans for a comparison unit that will be responsible for JMP.

The project hasn’t been without its problems – the first design of the demux for the ROM access logic resulted in a jungle of wires, gates, and connections that [zaphod] couldn’t get a usable signal out of because of the limited gate fan-out of his gates. After looking at the problem, [zaphod] decided to look at how real demuxes were constructed, and eventually hit upon the correct way of doing things – inverters and ANDs.

It’s a beautiful project, and something that [zaphod] has been working for months on. He’s getting close to complete, if you don’t count soldering up the RAM, and already has a crude Larson scanner worked out.

The KIM-1 Computer Minified

November 7, 2014 by Brian Benchoff 18 Comments

The KIM-1 wasn’t the first microcomputer available to computer hobbyists and other electron aficionados, but it was the first one that was cheap. It was also exceedingly simple, with just a 6502 CPU, a little more than 1k of RAM, 2k of ROM, a hexadecimal keypad and a few seven-segment displays. Still, a lot of software was written for this machine, and one of these boards can be found in every computer history museum.

[Oscar] thought the KIM-1 was far too cool to be relegated to the history books so he made his own. It’s not a direct copy – this one uses an Arduino for the brains, only breaking out some buttons, a pair of four-digit seven-segment displays, and the I2C and SPI pins on the ‘duino. The KIM-1 is emulated by the Arduino, allowing for the same interface as an original connected up to an old teletype, and [Oscar] got his hands on the original code for Microchess and the first 6502 disassembler from [Woz] and [Baum].

[Oscar] put the schematics for his version of the KIM-1 up, and has the PCBs up on SeeedStudio. If you’re looking for an awesome replica of a vintage computer and a nice weekend project, here ‘ya go.

A Clever Cardboard Computer

October 14, 2014 by Ethan Zonca 18 Comments

Back in the 70’s when computers were fairly expensive and out of reach for most people, [David Hagelbarger] of Bell Laboratories designed CARDIAC: CARDboard Illustrative Aid to Computation. CARDIAC was designed as an educational tool to give people without access to computers the ability to learn how computers work.

The CARDIAC computer is a single-accumulator single-address machine, which means that instructions operate on the accumulator alone, or on the accumulator and a memory location. The machine implements 10 instructions, each of which is assigned a 3-digit decimal opcode. The instruction set architecture includes instructions common to simple Von Neumann processors, such as load, store, add/subtract, and conditional branch.

Operating the computer is fairly simple–the cardboard slides guide you through the operation of the ALU and instruction decoder, and the flow chart shows you which stage to go to next. The program counter is represented by a cardboard ladybug which is manually moved through the program memory after each instruction completes.

Even though the CARDIAC is dated and very simplistic, it is still a useful tool to teach how microprocessors work. Although modern processors include multi-stage pipelines, finely-tuned branch predictors, and numerous other improvements, the basic principles of operation remain the same.

Feeling adventurous? Print out your own CARDIAC clone and try writing your first cardboard computer program.

[via Reddit]

Low-Level Computing With Entry-Level Difficulty: DUO Light

September 20, 2014 by Mike Szczys 27 Comments

The hardware can’t get much simpler. The DUO Light uses an ATmega328 (commonly found on Arduino boards) along with an external SRAM chip to provide a low-level computer programming experience that will suit those new to programming and some more experienced tinkerers.

At the time of writing the modest Kickstarter goal of $1100 was just $18 shy of success. We’d wager that this is partly due to the availability of so much support material on [Jack’s] website. (fyi- a lot of the links on that page are zip files)

The SD card slot accepts a FAT16 card with byte code for the programs. The available Psuedo C compiler, and assembler let you pick your poison, or you can simply dig into the byte code directly. We didn’t see a schematic, but the firmware and BOM are both available. You should be able to easily figure out connections from those.

We’ve been a fan of [Jack’s] work for quite some time. His TTL computer and 16-core ATmega-based offerings are sure to delight, even if you remember seeing them go by the first time. This isn’t his first stab at educational models either. Though we still found his logic chip computer a bit daunting.

Fixing A BASIC Calculator

August 3, 2014 by Brian Benchoff 26 Comments

The early days of modern computing were downright weird, and the HP 9830B is a strange one indeed: it’s a gigantic calculator, running BASIC, on a CPU implemented over a dozen cards using discrete logic. In 2014 dollars, this calculator cost somewhere in the neighborhood of $50,000. [Mattis] runs a retrocomputer museum and recently acquired one of these ancient machines, and the walkthrough of what it took to get this old machine running is a great read.

There were several things wrong with this old computer when it arrived: the keyboard had both missing key caps and broken switches. The switches were made by Cherry, but no one at Cherry – or any of the mechanical keyboard forums around the Internet – have ever seen these switches. Luckily, the key cap connector isn’t that complex, and a little bit of bent wire brings the switches back up to spec. The key caps were replaced from a few collectors around the globe.

Getting as far as booting the machine, [Mattis] found some weirdness when using this old calculator: the result of 2+2 was 8.4444444, and 3+1 was 6.4444444. Simply pressing the number 0 and pressing execute resulted in 2 being displayed. With a little bit of guesswork, [Mattis] figured this was a problem with the ALU, and inspecting the ROM on that board proved to be correct: the first 128 nibbles of the ROM were what they were supposed to be, and the last 128 nibbles were the OR of the last half. A strange error, but something that could be fixed with a new replacement ROM.

After hunting down errors with the printer and the disk drive, [Mattis] eventually got this old calculator working again. For such an astonishingly complex piece of equipment, the errors were relatively easy to hunt down, once [Mattis] had the schematics for everything. You can’t say that about many machines only 10 years younger than this old calculator, but then again, they didn’t cost as much as a house.

Retrotechtacular: The Cryotron Computer

April 15, 2014 by Mike Szczys 14 Comments

04WBuckNewPhotoHand-1395161077806

Have you ever heard of a Cryotron Computer before? Of course not. Silicon killed the radio star: this is a story of competing technologies back in the day. The hand above holds the two competitors, the bulkiest one is obviously the vacuum tube, and the three-legged device is what became a household name. But to the right of that tube is another technological marvel that can also be combined into computing machines: the cryotron.

[Dudley Allen Buck] and his contributions to early computing are a tale of the possible alternate universe that could have been cryotrons instead of silicon transistors. Early on we find that the theory points to exotic superconductive materials, but we were delighted to find that in the conception and testing stages [Buck] was hacking. He made his first experimental electronic switches using dissimilar metals and dunking them in liquid helium. The devices were copper wire wrapped around a tantalum wire. The tantalum is the circuit path, the copper wire acts as the switch via a magnetic field that alters the resistance of the tantalum.

The name comes from the low temperature bath necessary to make the switches work properly. Miniaturization was the key as it always is; the example above is a relatively small example of the wire-wound version of the Cryotron, but the end goal was a process very familiar to us today. [Buck] was searching for the thin film fabrication techniques that would let him shoe horn 75,000 or more into one single computing platform. Guess who came knocking on his door during this period of his career? The NSA. The story gets even more interesting from there, but lest we rewrite the article we leave you with this: the technology may beat out silicon in the end. Currently it’s one of the cool kids on the block for those companies racing to the quantum computing finish line.

[Thanks Frederick]

Retrotechtacular is a weekly column featuring hacks, technology, and kitsch from ages of yore. Help keep it fresh by sending in your ideas for future installments.

How Do You Build A Relay CPU?

October 13, 2013 by Brian Benchoff 48 Comments

relay

The Hackaday tips line is always full of the coolest completed projects, but only rarely do we see people reaching out for help on their latest build. We’ll help when we can, but [Tim]’s relay-based CPU has us stumped.

[Tim] already has the design of his relay CPU completed with a 12-bit program counter, sequencer, ALU, and a transistor-based ROM. The problem he’s having deals with the mechanics and layout of his homebuilt CPU. Right now, all the relays (PC pin, we guess) are glued top-down to a piece of cardboard. This allows him to easily solder the wires up and change out the inevitable mistakes. This comes with a drawback, though: he’s dealing with a lot of ‘cable salad’ and it’s not exactly the prettiest project ever.

The ideal solution, [Tim] says, would be a PCB with through-hole plating, but this isn’t easy or cheap for the home fab lab. We’d suggest some sort of wire wrap setup, but proper wire wrap sockets and protoboards are for some reason unreasonably expensive.

If you have an idea on how to do the mechanical layout and connections of a relay-based computer, drop a note in the comments. [Tim] has a very cool project here, and it would be a shame if he were to give up on it due to a lack of tools.

Video below, and if you’re having a problem with a project, feel free to send it in.

Continue reading “How Do You Build A Relay CPU?” →