Part 5 Flip-chips: The PDP-8 building blocks
If you haven’t checked out From NAND to Tetris, do yourself a favour and head on over. Starting with the most basic elements, the author builds up from gates to flip-flops to registers, control logic eventually building up to a computer. All this is possible from basic logic elements; you just need a lot of them.
May I present a lot of them otherwise known as the PDP-8 processor and memory:
Each of these (mostly) red handled modules are basic building blocks. Indeed, some are NAND gates. Others are flip-flops, buffers etc.
If you are familiar with TTL 74 series logic chips, you’ll recognise the types of building blocks that we are talking about. For example, the S107 module has seven inverters (logical NOT gates) making it similar to the 7404 chip which has six.
Life wasn’t meant to be simple so there are some pretty significant differences. To someone who cut their teeth on the 74 series or the 4000 series CMOS devices there are also some eye watering differences:
- Power supply rails: +10V, -15V and GND
- Logic levels: Logic ‘0’ is 0V. logic ‘1’ is -3V. Yes minus three.
- Non-standard logic symbols (by modern standards at least)
This causes serious confusion when the documentation discusses a “high” signal. In some instances this can mean a Logic ‘1’ and in others it can mean zero volts (which is indeed a “higher” voltage than the -3V).
Also, rather than Transistor-Transitor-Logic (TTL) topology, these feature Diode-Transistor-Logic (DTL).
Twelve is enough
The great thing about a computer like the PDP-8 is that you can really see the CPU. In fact this first side of the computer is the CPU or at least most of it and it is named the “processor side”. It features very familiar components:
Some examples:
- Accumulator (Green)
- Register bank (Blue)
The PDP-8 is a 12-bit machine. For it, the universe is 12 bits wide. Choose a number… that’s 12-bits, take another, add them together and the result should fit in 12 bits (ok, technically there’s some more bits to cope with this) As such, Registers in the PDP-8 are…you guessed it… 12 bits wide.
As well as the accumulator, the PDP-8 also has a register file made up of the Program Counter(PC), Memory Address(MA) and Memory Buffer(MB) registers which are of course (say it with me now…) 12 bits wide. Each of the twelve R211 flip-chips contains a single bit-wide “slice” of this register file.
Each “slice” features three flip flops with each of these made from two back-to-back transistors. The rest of the components are for controlling them and copying the their values around including between registers. For example there is a signal that will copy the value of the MB flip-flop to the PC flip-flop. When that signal is sent to all twelve modules simultaneously, the entire Program Counter is updated, meaning the next instruction will be read from the new address which is how the machine “jumps” to a new address.
From simple(ish) to complex
The Flip-Chips vary from the straight forward R107 (above) to the admittedly complex R211.
They feature a mix of components; some still available and some built from “unobtainium”. Much like the power supply, we want to do some testing to get the lay of the land. Much like the power supply, I won’t just be replacing all the capacitors willy-nilly.
A major reason for testing is that circuits such as these not only need to hit their logic ‘1’ and logic ‘0’ voltages, they also need to sink a specified amount of current. This is to ensure that a single output from a gate or block is able to drive the required number of inputs to which it may be attached. This is known as fan-out of the output.
It is not uncommon for a component in its twilight years to lose its oomph. Anecdotally, I’ve seen reports that this type of failure is even more common with germanium components than in silicon. But I’ve also observed it in 74 series devices (particularly 74S series). For these failures, a diode tester will report forward voltage drop and reverse bias voltage looking just fine. However, try to sink the amount of current claimed in the datasheet and all of a sudden it impersonates a resistor and creates a big old voltage drop. The consequence is that an output driving a lot of inputs may not hit that logic level consistently resulting in bizarre behaviour and intermittent faults.
So that is the problem, what the heck do we do about it?
BRS-TESTER
I stumbled across the magnificent brs-tester by Anders Sandahl with contributions from Michael Thompson and Mattis Lind. As I understand it, the brs-tester was designed to do exactly the job of testing B, R and S series flip-chips used on a PDP-9.
Anders has very kindly posted schematics, gerbers and a BOM in the repo and so after placing orders with JLCPCB and Digikey, I had a massive assembly job on our hands building and testing about twenty PCBs. After a few weekends of soldering and testing, the system was working!
It’s a complex beastie operating as an enormous relay based multiplexer. This mux can simultaneously connect any pin on the flip-chip to either a signal voltage for logic level or to a measurement bus to enable an ADC to read it. It sounds simple but we are only just beginning. A configurable load resistor can be connected to any pin along with a second ADC and a shunt resistor means any pin can be measured for the current being drawn.
All of this means flip-chips can be presented with logic levels and check if their NAND gates are NANDing and if their flip-flops are flipping and flopping. Every single input can be tested to make sure that it isn’t drawing too much current. And outputs can crucially be tested to ensure that they can sink as much current as required for normal operation!
Perhaps my favourite feature of all is the self-test allowing each channel of the tester to be looped back and verified; a massive quality of life improvement as the unit is being constructed.
Here is a short video of the tester self-testing.
The system is controlled by a Raspberry Pi which has orders of magnitude more horsepower than our PDP-8. But it offers a very rapid development environment to build the test vectors for each flip-chip. Each set of test vectors specifies the expected load presented by inputs, the expected drive strength from the outputs and of course a long list of binary values exercising all the inputs and confirming the corresponding expected outputs.
In the case of flip-flops, this can get very involved as you “clock in” values in one set of sequences and then confirm that they haven’t changed in later ones. For anyone who has played with logic chips on a breadboard using switches to control inputs along with LEDs to observe outputs, you’ll know what I’m talking about.
Here is a short video of one of the more simple tests for an inverter
Next Steps
So for anyone thinking the project had stalled, it certainly hasn’t. Instead, I’ve been going module by module building new test vectors and testing each flip-chip.
Each of the tagged flip-chips has been tested and its all progressing well. Most appear to be working while some are indeed faulty and so will need repair or replacing.
The next immediate step is to test all of the accumulator and register file flip-chips. If you are in the neighbourhood, drop by the museum on April 18th, 2026 to watch it live and may be test a module or two with me.
Once the flip-chips are assessed, I’ll be moving on to the front panel ahead of starting to fire up the computer as a whole. Exciting times ahead very soon!
To be continued…
