# Partial Relay-Based Calculator Puts The Click Where It Counts

It looks like [Michal Zalewski] is raising the next generation the right way. First, his eldest son asks for help building a one-bit computer from discrete transistors. Not to be left behind, his little brother then asked for help with an even more retro project, which resulted in this partially relay-based calculator. Maybe there is some hope for the future.

Now, purists will no doubt notice the ATmega64 microcontroller sitting in the middle of the main PCB on this project and cry “Foul!” But perfect is the enemy of done, and as [Michal] explains, at \$6 a pop for the Omron relays he and his son chose, there’s only so far you can go with relay logic before you’re taking out a second mortgage. So the relays are limited to the ALU of the calculator, along with the drivers for the six seven-segment LED displays. The microcontroller is just there for housekeeping functions like scanning the keyboard and decoding digits. All the actual calculations are in the relay logic, not silicon. And we’d be remiss not to praise his son’s stylistic choices for this design — that it uses relays with clear covers, and that it has single-sided PCBs with curvy, hand-drawn traces traces that look hand-drawn on old-school yellow substrate. [Michal]’s heart must swell with pride to have fathered someone with such exquisite taste.

For his part, [Mikal] did some really good documentation for this build, including excellent descriptions of Boolean math with half- and full-adders and how relays are used to create the basic logic gates that comprise them. The calculator itself is still a work in progress, with microcontroller code still in development, but it’s working enough that you can enjoy the display driver’s clickiness in the video below. If that doesn’t do it for you, we’ve got other relay calculators to scratch that click itch. Continue reading “Partial Relay-Based Calculator Puts The Click Where It Counts”

# Hackaday Prize 2023: Building A Relay ALU

There’s much truth in the advice that, to truly understand something, you need to build it yourself from the ground up. That’s the idea behind [Christian]’s entry for the Re-engineering Education category of the 2023 Hackaday Prize. Built as an educational demonstrator, this is a complete arithmetic-logic unit (ALU) using discrete relays — and not high-density types either — these are the big honking clear-cased kind.

The design is neatly, intentionally, partitioned along functional lines, with four custom PCB designs, each board operating on 4-bits. To handle a byte-length word, boards are simply cascaded, making a total of eight. The register, adder, logic function, and multiplex boards are the heart of the build with an additional two custom boards for visualization (using an Arduino for convenience) and IO forming the interface. After all, a basic CPU is just an ALU and some control around it, the magic is really in the ALU.

The fundamental logical operations operating upon two operands, {A, B} are A, ~A, B, ~B, A or B, A and B, A xor B, can be computed from just four relays per bit. The logic outputs do need to be fed into a 7-to-1 bit selector before being fed to the output register, but that’s the job of a separate board. The adder function is the most basic, simply a pair of half-adders and an OR-gate to handle the chaining of the carry inputs and generate the carry chain output.

3D printed cable runs are a nice touch and make for a slick wiring job to tie it all together.

For a more complete relay-based CPU, you could check out the MERCIA relay computer project, not to mention this wonderfully polished build.

# A NOR Gate For An ALU?

If you know anything about he design of a CPU, you’ll probably be able to identify that a critical component of all CPUs is the Arithmetic Logic Unit, or ALU. This is a collection of gates that can do a selection of binary operations, and which depending on the capabilities of the computer, can be a complex component. It’s a surprise then to find that a working CPU can be made with just a single NOR gate — which is what is at the heart of [Dennis Kuschel]’s My4th single board discrete logic computer. It’s the latest in a series of machines from him using the NOR ALU technique, and it replaces hardware complexity with extra software to perform complex operations.

Aside from a refreshingly simple and understandable circuit, it has 32k of RAM and a 32k EPROM, of which about 9k is microcode and the rest program. It’s called My4th because it has a Forth interpreter on board, and it has I2C and digital I/O as well as a serial port for its console.

This will never be a fast computer, but the fact that it computes at all is ts charm. In 2023 there are very few machines about that can be understood in their entirety, so this one is rather special even if it’s not the first 1-bit ALU we’ve seen.

Thanks [Ken Boak] for the tip.

# The Q2, A PDP8-Like Discrete Transistor Computer

[Joe Wingbermuehle] has an interest in computers-of-old, and some past experience of building computers on perfboard from discrete transistors, so this next project, Q2, is a complete implementation of a PDP8-like microcomputer on a single PCB. Like the DEC PDP-8, this is a 12-bit machine, but instead of the diode-transistor logic of the DEC, the substantially smaller Q2 uses a simple NMOS approach. Also, the DEC has core memory, but the Q2 resorts to a pair of SRAM ICs, simply because who wants to make repetitive memory structures with discrete 2N7002 transistors anyway?

Like the PDP-8, this machine uses a bit-serial ALU, which allows the circuit to be much smaller than the more usual ALU structure, at the expense of needing a clock cycle per bit per operation, i.e. a single ALU operation will take 12 clock cycles. For this machine, the instruction cycle time is either 8 or 32 clocks anyway, and at a maximum speed of 80 kHz it’s not exactly fast (and significantly slower than a PDP-8) but it is very small. Small, and perfectly formed.

The machine is constructed from 1094 transistors, with logic in an NMOS configuration, using 10 K pullup resistors. This is not a fast way to build a circuit, but it is very compact. By looking at the logic fanout, [Joe] spotted areas with large fanouts, and reduced the pull-up resistors from 10 K to 1 K. This was done in order to keep the propagation delay within bounds for the cycle time without excessive power usage. Supply current was kept to below 500 mA, allowing the board to be powered from a USB connector. Smart!

Memory is courtesy of two battery-backed 6264 SRAMs, with the four 12-bit general purpose registers built from discrete transistors. An LCD screen on board is a nice touch, augmenting the ‘front panel’ switches used for program entry and user input. A 40-pin header was added, for programming via a Raspberry Pi in case the front panel programming switches are proving a bit tedious and error prone.

In terms of the project write-up, there is plenty to see, with a Verilog model available, a custom programming language [Joe] calls Q2L, complete with a compiler and assembler (written in Rust!) even an online Q2 simulator! Lots of cool demos, like snake. Game of Life and even Pong, add some really lovely touches. Great stuff!

We’ve featured many similar projects over the years; here’s a nice one, a really small 4-bit one, and a really big one.

# Virtual Eurorack Based CPU Computes To The Beat Of A Different Drum Module

In Arthur C. Clarke’s 1972 story “Dial F for Frankenstein”, the worlds first global network of phone exchanges was created by satellite link, and events happened that caused the characters in the story to wonder if the interconnected mesh of machinery had somehow become sentient. And that’s what we wondered when we saw this latest virtual CPU construction built by GitHub user [katef] and made from a virtual analog synthesizer software called VCV Rack.

Analogous to a Redstone computer in Minecraft, there’s no physical hardware involved. But instead of making crazy synth sounds for a music project, [katef] has built a functioning CPU complete with an Arithmetic Logic Unit, an adder, and other various things you’ll find in a real CPU such as registers and a clock.

While no mention is made of whether the construct is sentient, [katef] fully documented the build on their GitHub page, and so go check that out for animated pictures, links to more information, and more. It’s quite impressive, if not just a little bonkers. But most good hacks are, right?

We love unique CPU builds, and you might get a kick out of this one made from- that’s right- 555 timers. Thanks to [Myself] on the Hackaday Discord server for the tip, and be sure to send in your favorite outrageous projects to the Hackaday tip line!

# An ALU As A Desktop Calculator Has Stunning Style From Days Gone By

Those of you with an interest in microcomputer history will know that there is a strong crossover between the path of electronic calculator evolution and the genesis of the integrated CPU. Intel’s 4000 was famously designed for a calculator, and for a while in the 1970s these mathematical helpers were seen as the wonder of the age. [Simon Boak]’s calculator is a curious throwback to that era, as it’s not a decimal calculator as we’d know it but a hexadecimal device that simply computes using the functions of the famous 74181 ALU chip.

An ALU, or to give it its full name an Arithmetic Logic Unit, is a component of a CPU with two inputs and one output that can perform any of a range of binary functions upon the two inputs and return the result on the output. This calculator has two of them for eight bits of raw adding power, with a hexadecimal keypad for setting the inputs and a set of 7-segment displays for showing the results. It’s housed in an achingly retro folded sheet metal console case with wooden end pieces that would have graced any engineer’s desk with pride back in about 1975. We may not need one, but we really want one!

If the 74181 is a mystery to you then fear not, because chip master [Ken Shirriff] has produced some handy explanation work on its operation.

Thanks [Ted Yapo] for the tip.

# Thousands Of Discrete MOSFETs Make Up This Compact CPU-Less Computer

How long has it been since a computer could boast about the fact that it contained 2,500 transistors? Probably close to half a century now, at a guess. So in a world with a couple of billion transistors per chip, is a 2,500-transistor computer really something to brag about? Yes. Yes, it is.

The CPU-less computer, called the TraNOR by its creator [Dennis Kuschel], is an elaboration on his previous MyNOR, another CPU-less machine that used a single NOR-gate made of discrete transistors as the core of its arithmetic-logic unit (ALU). Despite its architectural simplicity, MyNOR was capable of some pretty respectable performance, and even managed to play a decent game of Tetris. TraNOR, on the other hand, is much more complicated, mainly due to the fact that instead of relying on 74HC-series chips, [Dennis] built every single gate on the machine from discrete MOSFETs. The only chips on the four stacked PCBs are a trio of memory chips; we don’t fault him at all for the decision not to build the memory — he may be dedicated, but even art has its limits. And TraNOR is indeed a work of art — the video below shows the beautiful board layouts, with seemingly endless arrays of SMD transistors all neatly arranged and carefully soldered. And extra points for using Wintergatan’s marble machine melody as the soundtrack, too.

As much as we loved the original, TraNOR is really something special. Not only is it beautiful, but it’s functional — it’s even backward-compatible with MyNOR’s custom software. Hats off to [Dennis] for pulling off another wonderful build, and for sharing it with us.