Retrotechtacular: Donner 3500 portable analog computer

retrotechtacular-donner3500

What if we told you we had a computer you can take with you? What if it only weighed 28 pounds? This is a pretty hard sell when today you can get a 1.5 GHz quad-core processor packing computer to carry in your pocket which weighs less than 5 ounces. But back in the day the Donner 3500 was something to raise an eyebrow at, especially for tinkerers like us.

The machine was unveiled in 1959 as an analog computer. Instead of accepting programs via a terminal, or punch cards, it worked more like a breadboard. The top of the case features a grid of connectors (they look like banana plugs to us but we’re not sure). The kit came with components which the user could plug into the top to make the machine function (or compute) in different ways.

We’re skeptical as to how portable this actually was. It used vacuum tubes which are not fans of being jostled. Still, coming during the days when most computers were taking up entire buildings we guess the marketing claim holds up. If you’d like to see a bit more about the machine’s internals check out this forum post.

Breadboard friendly FPGAs

fpga

Regular Hackaday readers will be familiar with all the cool things you can do with FPGAs; emulating old video game consoles, cracking encryption protocols, and DIY logic analyzers become relatively simple projects with even a modest FPGA dev board on your workbench. Many FPGA boards aren’t geared towards prototyping, though, and breadboard friendly devices are hard to come by. Here’s a pair of breadboardable FPGAs we’ve found while searching for some related hardware over the past few days

First up is the Mercury FPGA Module. Packaged in a DIP-64 format, the Mercury features a Spartan-3A FPGA with the equivalent of 200k logic gates. Elsewhere on the board is 512kB of RAM and 128kB of Flash storage. There are enough GPIO pins for nearly any project, but sadly only a 10-bit ADC – the same resolution you’d find in an AVR or PIC ‘micro.

Of course the Mercury isn’t the only breadboard-friendly FPGA dev board out there. There’s also the slightly more capable XuLA2 board powered by a Spartan-6 with 32 MB of RAM, 1MB of Flash. Unlike the Mercury, the XuLA2 can also fit in one of those ‘half-sized’ solderless breadboards.

Yes, it’s a different form factor than the commonly recommended Papilio One or the DE0. If you can suggest any other ‘beginners’ (i.e. doesn’t cost an arm and a leg) FPGA boards, leave a note in the comments and we’ll summarize them in another post.

Make dual pin header footprints into breadboard friendly DIP

[John] wrote in with a solution to a prototyping issue that has vexed us for quite some time. Above you can see the DIP friendly solution for dual-row pin headers which he came up with. With just a bit of easy soldering he now has a breadboard friendly device for prototyping.

He starts by soldering a dual row pin header on the board, then clips off all of the legs on the outside row. The row of legs that remain are then inserted into one side of the trench on his breadboard. The other side of the trench has a single row pin header, and he solders them to the outer row on the breakout board using another single pin header aligned horizontally. This isn’t a 100% convenient solution, as it’s still pretty hard to get your jumper wires in the breadboard on the side covered by the breakout board. But if you plan in advance you can place your wires first, then plug in the development board.

Here [John] is working with TI’s eZ430-RF2500 board. We’d like to go back and remove the dual pin socket we soldered on our eZ430-F2013, replacing it with this style of pins.

Breadboarding with a 144-core processor

At the center of that green PCB is a tiny little processor with way too many cores. It’s the GA144 which was taken for a test-drive on a breadboard by [Andrew Back]. We saw a multi-core Kickstarter project last month. This will cost a lot less and get you more than twice the number of cores. But as was mentioned in the comments on that post, the drawback is the programming language. This chip’s IDE uses Forth.

There is a dev board available, but [Andrew] went instead with a QFN-to-Through-Hole adapter board which he hand soldered. Once he has access to the pins the chip can be programmed with an FTDI adapter which is compatible with the 1.8V logic levels. The provided Forth IDE (arrayForth) is a Windows only program but it does run under Wine. We followed the project through to see him twiddling I/O pins. But we still have trouble thinking of applications for it. In a world of complex and inexpensive FPGA chips, what would you use this type of processor for?

Breadboarding a 4-bit ALU

[TGTTGIT] recently took the plunge and decided to build his own computer using logic chips. He just completed a 4-bit ALU which can compute 18 functions. It took a long time to get the wiring right, but in true geek fashion his build was accompanied by an alternating Chapelle’s Show and Star Trek: TNG marathon playing in the background.

This project is the stepping stone for a larger 16-bit version. The experience of wiring up just this much of it has convinced him that an FPGA is the only way to go for the future of the build. But since he had already ordered the chips it was decided that the only thing to do was to see this much through. He used the truth table from The Elements of Computing Systems for the design and posted several times about the project before arriving at this stopping point so you may be interested in clicking through the other post on his blog. There’s also a lot of other TTL computer projects around here worth checking into.

[Read more...]

The easiest way to dive in to ARM programming

[Brad] has been very excited about an ARM Cortex-M0 chip released by NXP; it’s a fully featured ARM microcontroller, and is, quite amazingly, stuffed into a hobbyist and breadboard-friendly DIP-28 package. After finding a supplier for this chip, [Brad] dove in and put together a great tutorial for programming an ARM on the breadboard using open source tools.

The chip in question is NXP’s LPC1114FN28, a 28-pin breadboard friendly chip we’ve posted about before. After finding a single supplier for this microcontroller (only $1.26 for one chip!), [Brad] pulled out his breadboard and started wiring things up.

Because this microcontroller has an on-board oscillator, wiring up a breadboard and putting in a breakout for an FTDI cable was a snap. After configuring a toolchain and writing a bit of code, the only issue was uploading the code to the chip. This was handled by the lpc21isp programming tool, slightly modified and configured by [Brad] to support his favorite microcontroller.

The LPC1114FN28 is an impressive bit of kit, and with free tools to program the damn thing, we can’t wait for a homebrew ARM dev board to show up.

ProtoSynth, the prototyping synthesizer

This project isn’t really a prototype, but a tool for prototyping. [Tymkrs] came up with a unique way to build this synthesizer prototyping tool. They actually patched into the underside of the breadboards in order to keep all of the permanent bits nice and tidy.

In the clip after the break you’ll see all of the build photos that lead up to this point. After cutting out and assembling the wooden pieces for the case they grab a soldering iron and get to work. Two octaves worth of keys were pulled out of an electric keyboard. Ribbon cable is soldered onto each key’s electrical connection, with an SIL pin header as a connector. This mates with another ribbon cable with a SIL socket on one end, and an IDC connector on the other. The real trick is getting that IDC connected to the breadboard. They cut back the adhesive tape on the underside of the board and soldered a surface mount pin header onto it. This way the inputs from the keys, as well as a few 1/4″ jacks from the back of the case are always available in a tidy way on the breadboards. The video goes on to show preliminary synthesizer work on the device.

[Read more...]