Hackaday Prize 2023: Building A Relay ALU

June 1, 2023 by Dave Rowntree 9 Comments

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.

What Next For The SBC That Has Everything?

May 31, 2023 by Jenny List 113 Comments

In the decade-and-a-bit since the first Raspberry Pi was launched we’ve seen an explosion of affordable single-board computers (SBCs), but as the prices creep up alongside user expectation and bloat, [Christopher Barnatt] asks where the industry will go next.

The Pi started with an unbeatable offer, $35 got you something similar to the desktop PC you’d had a decade earlier — able to run a Linux desktop on your TV from an SD card. Over the years the boards have become faster and more numerous, but the prices for ARM boards are now only nominally as affordable as they were in 2012, and meanwhile the lower end of x86 computing is now firmly in the same space. He demonstrates how much slower the 2023 Raspberry Pi OS distribution is on an original Pi compared to one of the early pre-Raspbian distros, and identifies in that a gap forming between users. From that he sees those people wanting a desktop heading towards the x86 machines, and the bare-metal makers at the lower end heading for the more powerful microcontrollers which simply weren’t so available a decade ago.

We have to admit that we agree with him, as the days when a new Raspberry Pi board was a special step forward rather than just another fast SBC are now probably behind us. In that we think the Pi people are probably also looking beyond their flagship product, as the hugely successful lunches of the RP2040 and the industrial-focused Compute Module 4 have shown.

What do you think about the SBC market? Tell us in the comments.

Continue reading “What Next For The SBC That Has Everything?” →

Hackaday Prize 2023: Scratch Made 8-Bit Educational Computer

May 29, 2023 by Joseph Long 6 Comments

To demonstrate the functionality of an 8-bit computer processor at a very basic level, [Mazen Gomaa] assembled a Homemade 8-Bit Educational Computer using common CMOS logic chips, a handful of prototyping boards, and an impressive number of carefully connected wires. [Mazen] was inspired by Ben Eater’s 8-bit TTL Breadboard Computer but opted to solder the chips and other components onto proto boards instead of using solderless breadboards.

The 8-Bit computer is based on the Simple-As-Possible (SAP) computer architecture described in the book “Digital Computer Electronics” by [Paul Malvino] and [Jerald Brown]. These useful educational examples demonstrate data, computer logic, and even programming in the context of basic electronic components. Tinkering with such simple computers provides a real “zeros and ones” exposure to computation.

[Mazen] added some additional features and functionality to his computer, including an instruction keypad, an address keypad, a dot matrix memory data viewer, a Schottky diode matrix ROM, and a boot loader that initializes the RAM with data stored in ROM. With clock speeds up to 100 Hz, the computer consumes around 300-500 mA of current.

Future plans include expanding the memory and instruction set from the present 128-bit (8×16) RAM, 64-bit (8×8) ROM, and a set of ten instructions. Already, this project is a great addition to an ever-growing catalog of homemade solderless breadboard computers, LCD snake games, and VGA video cards.

Continue reading “Hackaday Prize 2023: Scratch Made 8-Bit Educational Computer” →

Intel Suggests Dropping Everything But 64-Bit From X86 With Its X86-S Proposal

May 21, 2023 by Maya Posch 140 Comments

In a move that has a significant part of the internet flashing back to the innocent days of 2001 when Intel launched its Itanium architecture as a replacement for the then 32-bit only x86 architecture – before it getting bludgeoned by AMD’s competing x86_64 architecture – Intel has now released a whitepaper with associated X86-S specification that seeks to probe the community’s thoughts on it essentially removing all pre-x86_64 features out of x86 CPUs.

While today you can essentially still install your copy of MSDOS 6.11 on a brand-new Intel Core i7 system, with some caveats, it’s undeniable that to most users of PCs the removal of 16 and 32-bit mode would likely go by unnoticed, as well as the suggested removal of rings 1 and 2, as well as range of other low-level (I/O) features. Rather than the boot process going from real-mode 16-bit to protected mode, and from 32- to 64-bit mode, the system would boot straight into the 64-bit mode which Intel figures is what everyone uses anyway.

Where things get a bit hazy is that on this theoretical X86-S you cannot just install and boot your current 64-bit operating systems, as they have no concept of this new boot procedure, or the other low-level features that got dropped. This is where the Itanium comparison seems most apt, as it was Intel’s attempt at a clean cut with its x86 legacy, only for literally everything about the concept (VLIW) and ‘legacy software’ support to go horribly wrong.

Although X86-S seems much less ambitious than Itanium, it would nevertheless be interesting to hear AMD’s thoughts on the matter.

Here’s How To Build A Tiny Compiler From Scratch

May 21, 2023 by Donald Papp 27 Comments

Believe it or not, building a tiny compiler from scratch can be as fun as it is accessible. [James Smith] demonstrates by making a tiny compiler for an extremely simple programming language, and showing off a hello world.

Here’s what happens with a compiler: human-written code gets compiled into low-level machine code, creating a natively-executable result for a particular processor. [James]’ compiler — created from scratch — makes native x64 Linux ELF binary executables with no dependencies, an experience [James] found both educational and enjoyable. The GitHub repository linked below has everything one needs, but [James] also wrote a book, From Source Code to Machine Code, which he offers for sale to anyone who wants to step through the nitty-gritty.

The (very tiny) compiler is on GitHub as The Pretty Laughable Programming Language. It’s tiny, the only data types are integers and pointers, and all it can do is make Linux syscalls — but it’s sufficient to make a program with. Here’s what the code for “Hello world!” looks like before being fed into the compiler:

; the write() syscall: ; ssize_t write(int fd, const void *buf, size_t count); (syscall 1 1 "Hello world!\n" 13) 0

Working at such a low level can be rewarding, but back in the day the first computers actually relied on humans to be compilers. Operators would work with pencil and paper to convert programs into machine code, and you can get a taste of that with a project that re-creates what it was like to program a computer using just a few buttons as inputs.

Mythic I: An Exploration Of Artisanal Computing

May 17, 2023 by Tom Nardi 14 Comments

While computers have become ever faster and more capable over the years, it’s hard to say they’ve become any more exciting. In fact, they’ve become downright boring. Desktop, laptop, or mobile, they’re all more or less featureless slabs of various dimensions. There’s not even much in the way of color variation — the classic beige box is now available with white, black, or metallic finishes.

Believing that such a pedestrian appearance isn’t befitting a device that puts the world’s collected knowledge at our fingertips, [Keegan McNamara] started exploring a more luxurious approach to computing. Gone is the mass produced injection molded plastic, in its place is hand-carved maple and Tuscan leather. Common computing form factors are eschewed entirely for a swooping console inspired by fine furniture and classic sports cars. The final result, called the Mythic I, is equal parts art and science. Not just a bold reimaging of what a computer can be, but an object to be displayed and discussed. Continue reading “Mythic I: An Exploration Of Artisanal Computing” →

A DR-DOS console showing the IDLE command

Missing DR-DOS Power Management Source Code Found In Patent

May 14, 2023 by Robin Kearey 20 Comments

Modern processors come with all kinds of power management features, which you don’t typically notice as a user until you start a heavy program and hear the CPU fan spin up. Back in the early 1990s however, power management was largely unheard of, meaning that a CPU with nothing to do would run through an idle loop that dissipated about as much power as a real computing task. [Michal Necasek] noticed this while experimenting with DR-DOS 6.0 in a virtual machine – his laptop fan would start running on full blast whenever he opened the VM. His search for a solution to this annoyance led him down a fascinating journey into the intricacies of DOS power management.

As it turned out, DR-DOS 6.0 does have functionality built in for putting the CPU in power saving mode when it’s idle. This feature is not complete, however: Digital Research required each computer manufacturer to develop an IDLE driver customized to their specific hardware platform in order to enable power management. Sadly, no manufacturer ever bothered to do so, leaving [Michal] with no option other than writing a driver himself. While there was some documentation available, it didn’t include any example code or sufficient detail to write a driver from scratch.

What it did include was a reference to U.S. Patent No. 5,355,501. Normally this sort of information is of interest only to those planning to sell a competing system, but this specific patent happens to include dozens of pages of well-documented but poorly-scanned x86 assembly code, including source code for a basic IDLE86.SYS driver. As [Michal] wasn’t looking forward to chasing bugs caused by OCR errors, he simply copied the source code by hand, then ran it through an assembler. The end result was a working IDLE driver, which is now available for download from his website.

[Michal]’s blog post also includes lots of details on early power saving implementations, including all the DOS interrupt calls involved in the process. Patents might seem boring in contrast, but they sometimes contain surprising amounts of usable information. You might find enough details to reverse-engineer a wireless protocol, or even to help track down an obscure instrument’s original designer.