How to piss off a board house



Just in case you were wondering, that’s how you piss off a board house. It’s a blank expansion board for my backplane computer. Basically, it’s simple a bunch of holes to mount wire-wrap sockets in. The main build area is 32×48, giving me 1,536 holes. The power rails (3.3V, 5V, 12V, -12V, and GND) have 44 holes. Including the pads for the eurocard connector and 2×32 breakout pads and mounting holes, this board has 1,881 holes. Does anyone know what the mean time before failure for PCB drills is?

A Backplane Computer

I have an on-again, off-again hobby of building small retro computers. I built this piece of crap, but the design process of making a small, single-board computer is wretchedly slow. First you need to design the circuit, then you need to do the schematic capture, make a PCB, send that off to a board house, wait a month, and finally solder everything together. If you get something wrong in the first step, start over from the beginning. It’s a tremendous amount of work for something that’s not guaranteed to work when you power it up, but that’s a hobby for you.

One alternate solution to this process is building everything on a breadboard. It’s much, much faster, but building circuits that are faster than a few megahertz is just simply impossible, and breadboards go bad. I’m not for debugging something where the thing you’re building your computer on can just go bad. That’s just not cool.

There is one solution to both these problems: A backplane design with wire-wrapped boards. Classic, and perfect for these retro circuits I’m putting together. There are hundreds of old computers that use a backplane design – just look at the S100 bus. It’s fast enough to keep up with anything faster than a Z80, and the modular design means I can build the CPU on one card, the RAM on another, a serial interface on a third, and some sort of storage on another.

The processor I’d like to use for this computer (The Motorola 68000 or 68010) aren’t really well suited for existing backplane designs. The S100 bus has 8 data lines and 16 address lines, while the 68k is a 16/24 machine. I’ll need to roll by own backplane design.

Mechanical considerations


Yes, figuring out what case I’m going to use for this computer before drawing a single schematic is very stupid. However, without a case I currently have no limitations on what my design will be. I don’t like working without any limitations. There’s too many options.

I’ve decided to go with a Hammond enclosure, specifically the 1458VD4B. That will give me a 7″ x 3 3/4″ front panel to attach the backplane, and space enough for eight inch long cards. Also, this case looks cool. And it’s blue. It could have jumped right out of the late 70s, so it’s perfect.

With this limitation, I can figure out my backplane will be 7.26 x 3.9 inches. Here’s the layout of of the backplane:


Those mounting holes you see line up with the front panel of the Hammond enclosure.

Electronic considerations

There are two things a backplane needs: connectors, and some sort of power input. For the power I’ll need 5 V and probably 12 V. The supply also needs to be tiny. Instead of rolling my own, I’ve chosen a PicoPSU, a freakin’ tiny ATX power supply that can provide 80 Watts of power for my computer. It’s overkill, but it’s also tiny and twenty five dollars. Can’t beat that.

I also need a way to turn the computer on and off. With an ATX supply, that’s easy. Just connect the PS_ON line on the power supply to ground. A simple switch (and a LED attached to the PS_OK line) takes care of that.

Lastly, I need some sort of connector. You might think the easiest solution would be to get a board-to-board connector with as many pins as possible. This works in theory, but falls apart when you need to design a board to hold all these connectors. Anything over two layers on a PCB gets expensive very quickly, especially considering I’m only ever going to need one of these backplanes.

I’ve chosen regular ‘ol Eurocard connectors (for the backplane and for the individual cards) each with 64 connections. They’re just about the right length to be mounted vertically on my backplane, and with the power supply I can manage to fit seven connectors in this computer.

The designs for the backplane, including the schematic, board files, and gerbers, are all up on my Gits. Next post will be about designing and building a the electronics necessary for this to be a user-friendly device. Namely, the on/off and reset circuits.


On testing the limits of GPS

I may be involved soon with a project that stretches the limits of GPS systems.

As I’m sure anyone reading this is aware, the GPS system has a few built-in limitations for civilian equipment. Namely, it is not allowed to give a fix if (the GPS unit is above 60,000 feet) AND (the GPS unit is travelling faster than 1000 kts). Because basic logic is either very hard or very easy for GPS module designers, a common practice to implement these features is to not return a fix iff the module is above 60,000 feet. This solution keeps everything kosher with the US government and doesn’t violate an ITAR agreement. Some modules, however, follow the guideline exactly and given many of these modules are designed and manufactured in China, it’s quite probable that some GPS modules don’t test for altitude and velocity at all.

I need to find these unrestricted modules.

Finding GPS modules that work above 60,000 feet is easy – just put it on a high altitude balloon and have it write to an SD card. Finding a GPS module that doesn’t take both altitude and velocity into account is a little harder.

To experimentally test a suite of GPS modules, the first thought is to build a rocket, strap on some GPS units, and record what they do during the flight. Going beyond 60,000 feet with an amateur rocket is pretty hard, and a whole lot of effort for just a simple experiment.

There is another option, though. All you need is something that goes faster than 1000 knots above 60,000 feet. Nobody said anything about which direction it has to be going.

Here’s the plan: launch a high altitude balloon, and when it gets really, really high, release a payload. At these altitudes air resistance is negligible, and the payload will quickly pick up enough speed to surpass the 1000 knt limit on GPS.




There’s your answer. 1000 kts is about 514 m/s, so the payload has to fall for a little less than a minute before it gets to that speed. How high does it need to be? Only about 106,000 feet. That’s well within the range of amateur high altitude balloons.


  • Build a circuit with several GPS units. A microcontroller records all the data coming from these units to an SD card
  • Put this board inside a rocket-shaped airframe, attached to a balloon by its ass end
  • Launch the balloon
  • Above 110k feet, cut the tether between the balloon and the ‘impactor’
  • Record GPS data as the vehicle descends
  • Recover it, read the SD card, and see which modules work.

I’m actually a little proud of this idea. It’s brilliantly simple, and save for the difficulties of actually getting a balloon to 110k feet, it’s very, very doable. Orders of magnitude more likely to succeed than doing the same experiment with the GPS modules going up.

Building a new VT100 power supply


A while back I found one of these – a VT100 serial terminal from 1979 – on eBay for cheap. $40 and a whole lot of waiting later, I had it on my desk. I turned it on, and… nothing.

I expected this. The auction said it didn’t work. After tearing it apart and seeing what *could* be wrong, I found the switching transistor (yes, this thing actually used a switching power supply in 1979. It’s a really well engineered piece of equipment) was dead. If anyone knows where I can get an IR 92-O350 transistor – it looks exactly like this – drop me a line.

Instead of rebuilding the power supply with incredibly difficult to find parts, I found this tutorial for improvising a VT100 power supply with a normal, off the shelf ATX computer power supply. The circuit is fairly simple, although the non-volatile RAM in the VT100 requires -23 Volts. No big deal, just make a crappy linear supply for that.

Whelp, I pulled up Eagle and slapped this together:


Two lessons learned: Making card edge slots by hand sucks. If you don’t know how to make parts in Eagle, you don’t know how to use Eagle.

I’ll get a few boards fabbed, slap one of these together and see how it goes. It’s a big board, but unlike most of my electronic projects there actually is a small market for this over on the Vintage Computer Forum. I’ll get a git repo, BOM, and the schematics up later. Pester me if I don’t.

Also, woo, VT100 art I made:


A little somethin’ I’m working on

Well here’s something pretty cool:




Raspberry Pi 7-segment controller



I’ve updated my previous seven-segment controller for the Raspberry Pi.

There were a few problems with the earlier version. First, only two seven-segment displays were supported. This is a consequence of connecting the displays directly to the GPIO pins; it’s easy to design, but it is very limiting. This version uses ’595 shift registers, so theoretically it should be possible to extend this display even further.

The next big change is moving over to larger (and cheaper) displays. I have a few 1″ common cathode displays I picked up from Futurlec around my workbench, so they were the obvious choice.

Even though I’m using larger seven segment displays, the board is cheaper to produce this time around. That’s a consequence of moving the ‘analog’ part of the ‘Days Since’ counter to something that isn’t a PCB. I’ll probabaly mount this in a piece of foam display board or something. Maybe laser cut plywood if I’m feeling fancy.


A disk drive!




My computer won’t be much use to me – or anyone – without some form of storage. Right now, the design includes 16 kB of ROM. Even though I can’t imagine writing enough code to fill that space, I should probably have some means of easily-accessable storage. Floppy disk drives are the preferred solution for a period-accurate replica of a 1970s computer system, but that leaves the problem of transferring files between my regular desktop and my homebrew project.

There’s another solution, though. IDE hard drives.

I came across Daryl Rictor’s SPI to IDE interface. Basically, I can bitbang an SPI port on my homebrew computer and use it as an IDE interface. The circuit is fairly simple – just an ATMega644p attached to the SPI port and a 40-pin IDE port. With this, I’ll be able to attach an IDE hard drive or a compact flash card with the appropriate adapter.

The schematic, board, and BOM are up on my git.

Interestingly, this SPI to IDE adapter only uses four pins out of a total of 32 expansion pins connected to the VIAs on my computer. In this design, I’ve (arbitrarily) designated an entire 8-pin port for SPI communications, so these 8 pins will be able to control up to five SPI devices. I have no idea what I’m going to do with the rest of these. Maybe Ethernet?

Finally, the design is done


After a whole lot of procrastinating, the design of my 6502 single board computer is done. There’s nothing like the relief of clicking on the ratsnest button in Eagle and seeing the words, “nothing to do.”

I’ve updated the schematic and board files in my git and added a zipped gerber folder containing all the files any board house should need to fab this computer.

There are a few extra things I added to the board since the last update. First, I’ve put a silkscreen image of Ada Lovelace underneath the CPU. Also, I’ve put an image of BMO from Adventure Time in the top layer of copper underneath the Molex connector:


He wants to be a real boy

The final board dimensions are 140.6652 x 67.6402 mm, according to OSH park, where the board will cost $73.70 for three. I’m not too keen on spending that much for something that probably won’t work the first time, so I’m probably going to go with Seeed Studio. That seems to be the cheapest at around $45 for five boards.

As far as the toolchain for developing on this computer goes, after looking around the forums I’ve decided to go with this really cool 6502 macro assembler and simulator. While I’m sure this is a competent simulator, I’ll also be verifying ROM images in this 6502 emulator. The Symon emulator includes an emulated ACIA tied to a serial console, but the memory address for the ACAI in Symon and my computer differ. That shouldn’t be too hard to code around.

I’ve also started work on my first ‘shield’ for this computer. It’s basically four octal buffers tied to each of the VIA I/O ports. Each of the outputs on the buffers will be tied to a LED. It’s an easy way to verify that everything is working.


Now it’s just an issue of waiting a month until the SBC board arrives from a month-long trip from China. Just as well, though. I’ve got a lot of writing to catch up on, and now that I’m not designing a computer from scratch I probably won’t be as distracted (ha!).

6502 Single board computer

One of the things on my bucket list is building a computer from scratch. The eventual goal is a 68020-based machine running something that resembles UNIX (with networking, VGA out, and all that fun stuff). You need to learn to crawl before you can walk, so to prepare for the ’020 build, I’m making a smaller, simpler computer for my first run. It’s not much, just a 6502 CPU, a little RAM, ROM, and a few additional chips to talk to the outside world.


The specs for this computer are pretty austere; only 32 kilobytes of RAM, 16 k ROM, two 6522 VIAs providing four 8-bit IO ports, and a single 6551 ACIA and MAX3232 giving me an RS232 connection to the outside world. Not much, but at least on par with an Apple I. Hell, if I do things right, I might be able to fit an IDE hard drive on the VIAs.

Unlike a lot of other single board computers I’ve seen, I’m not using a GAL or other programmable logic. All the address decoding is done with 74HCT-series logic. One 7400 quad NAND and one 7404 hex inverter gives me all the address decoding I need. Speaking of address decoding, here’s the memory map:

  • $0000 – $7FFF    RAM
  • $9800 – $980F    VIA 0
  • $9400 – $940F    VIA 1
  • $9200 – $920F    ACIA
  • $C000 – $FFFF    ROM

There’s a lot of wasted space in there, but meh. I’d much rather have a single board computer that worked instead of something that’s overly complicated.

For now, the schematic, BOM, and board files (Eagle, natch) are up on my git. The board file isn’t completely done, but anyone enterprising enough to steal it should be able to connect the last few pads. I’ll update that when I’m done and post the gerbers as well.

Of course getting a board fabbed means I’ll have a month of downtime for this project while it’s being delivered to me on a slow boat from China. That’ll be more than enough time to get a 6502 emulator running and start writing some software.

…since I cared about commentors on the Internet

If you read the comments on Hackaday… god help you… you’ll eventually come across a few tropes that show up pretty frequently. The first is the ‘not a hack’ comment. An unusually insightful observation when it’s posted, no doubt. The second is the, “this is a new low for Hackaday.” This sort of comment usually comes up when someone does something new, but not difficult. Installing OpenCV on a Raspberry Pi, for instance. Or the marijuana hacks that showed up on the front page recently. Or anything to do with sex. That sort of thing.

I’ve been wanting to track how often these phrases are mentioned in the comments for a while now, and I think I have a solution.

boardIt’s a ‘shield’ for a Raspberry Pi. There’s not much to it – just two 7-segment displays connected directly to the GPIO pins. The shield is the same size as the Raspberry Pi PCB, so there should be plenty of space to write your own message in dry erase marker on the large silk rectangle.

The code for driving the 7-segments is easy. I’ll be writing a demo for this thing and hopefully getting it to interact with WordPress comments.

Of course you could use this for just about anything. Set it up to scan the closed captioning on Fox News to see how many days they can go without saying the word ‘socialism’. Point it at CNN to see how many days go by without a new cure for cancer. You could set it up to see how often issues of social mobility and class discrimination are mentioned in the media, but unfortunately the PCB isn’t big enough for that many digits.

Schematic, board, and eventually the code are up on my git.



Get every new post delivered to your Inbox.

Join 101 other followers