Central European Computer Collecting

During Hackaday’s short trip to Czech, we were lucky enough to run into someone who had recently had one of his projects featured on Hackaday. It’s [Martin]’s multi-target IDE for 8-bit CPUs, written entirely in JavaScript, and a full development suite for anything with a 6502, 6800, 6809, Z80, 8080, and 8085. [Martin] was kind enough to sit down and give us the scoop on why he’s interested in old computers, and why he developed his 8-bit IDE project, ASM80.

[Martin] grew up in the days of computer magazines, and originally wanted to build his own computer. That plan didn’t work out, but his parents did get him a Speccy in 1986, but the love of old hardware is still there. Over the years, this evolved into computer collecting, with the old ZX Spectrum, an Commodore 64, ORICs, and Acorns rounding out his collection. As we learned at the Computeum, there the middle of Europe had computers that just aren’t seen on the English-speaking Internet, and [Martin]’s collection is no exception.

In addition to doing some very cool stuff for some very old computers, [Martin] also donated something to the Hackaday Hackaspace. It’s a PMI-80, a single board computer made for university computer science students, and basically a KIM-1, but based on a Czechoslovak clone of the Intel 8080 made by Tesla. There is 1k of RAM and 1k of ROM on this board, a calculator keypad, and a few seven segment displays. For the time, it was a great ‘student’ computer, and not really rare in Europe, but this is the first one I’ve seen on my side of the Atlantic.

You can see some pics of the PMI-80 below with [Martin]’s interview. [Martin] also promised to write-up a short history of classic central european computers, a subject there isn’t much written about in the anglosphere. We’ll post a link to that when he finishes that up.

Continue reading “Central European Computer Collecting”

A 4-bit Computer From Discrete Transistors

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

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

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

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

HPThe 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

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.