The Sol-1: A 16-bit Computer In 74HC Logic With C Compiler And Unix-like OS

December 11, 2023 by Maya Posch 15 Comments

Sol-1 system pictured from the front. {Credit: Paulo Constantino)

While the concept of a computer system implemented in discrete logic ICs is by itself not among the most original ideas, the way some machines are executed certainly makes them stick out. This is the case with [Paulo Constantino]’s Sol-1, which not only looks extremely professional, but also comes with a lot of amenities that allow for system development, including a C compiler and assembler, a Unix-like OS (in development), DMA, and a whole host of interfaces to interact with the system and peripherals (serial, parallel, IDE, etc.). Not to mention a SystemVerilog model and an emulator, all of which can be found on [Paulo]’s GitHub.

More photos and videos can be found on [Paulo]’s YouTube channel, as well as the Sol-1 website, which shows off the intricate wire wrap work on the back of each PCB. In terms of the ISA, there are 5 general purpose registers (one scratch) which can also be used as two 8-bit registers each. Most operations are supported, except for floating point. For future improvements and additions, Sol-1’s OS will get more features added, and the first major software to be ported to the Sol-1 should be Colossal Cave Adventure and similar text-based adventure (dungeon) games.

An Arduino Enhances This 7400 CPU

September 22, 2019 by Jenny List 10 Comments

How quickly could you make an entire computer from 74 series logic, from scratch? [Richard Grafton had only 30 days until the UK’s Retro Computer Festival and set out to design and build his Cambridge-1 computer in that time. The result is a machine spread across several breadboards, with neatly placed wiring and unexpectedly an Arduino Micro sitting in the corner. Isn’t the little Italian board a cheat? Not so, he says, because instead of being part of the computer itself it serves as a program loader to make putting software onto the machine from a PC as easy as possible.

The machine itself is simple enough, a 4-bit design with 8-bit data and address busses. There are only 16 instructions, and the clock speed is a relatively pedestrian 40Hz. This does, however, allow the many blinkenlights to show the machine’s state in a more visible manner. There’s a video which we’ve placed below the break, and if you have further questions you might like to look at the GitHub repository.

We like the Cambridge-1, and we see no problem with the Arduino being part of it. It doesn’t take away from the 74-driven nature of the machine. Instead, it enhances the usefulness of the device by facilitating coding on it. We’ve had huge quantities of TTL computers here over the years so it’s difficult to pick one to send you towards, however you may want to consider the 7400 as the original in the series.

Continue reading “An Arduino Enhances This 7400 CPU” →

A TTL CPU, Minimising Its Chip Count

June 23, 2019 by Jenny List 19 Comments

By now we should all be used to the astonishing variety of CPUs that have come our way created from discrete logic chips. We’ve seen everything from the familiar Von Neumann architectures to RISC and ever transport-triggered architecture done in 74 TTL derivatives, and fresh designs remain a popular project for many people with an interest in the inner workings of a computer.

[Warren Toomey]’s CSCvon8 is an interesting machine that implements an 8-bit computer with a 64-bit address space using only 17 chips, and without resorting to any tricks involving microcontrollers. It implements a fairly conventional Von Neumann architecture using TTL with a couple of tricks that use modern chips but could have been done in the same way in decades past. Instruction microcode is stored in an EEPROM, and the ALU is implemented in a very large EPROM that would probably once have been eye-wateringly expensive. This in particular removes many discrete TTL chips from the total count, in the absence of the classic 74181 single-chip part. To make it useful there is 32k each of RAM and EEPROM, and also a UART for serial access. The whole is brought together on a neat PCB, and there is a pile of demo code to get started with. Everything can be found in the project’s GitHub repository.

At the start of this article we mentioned a couple of unconventional TTL CPUs. The transport triggered one we featured in 2017, and the RISC one is the Gigatron which has appeared here more than once.

Afroman Makes A UHF Oscillator From A Potato

April 30, 2017 by Jenny List 18 Comments

If you have ever worked with simple logic gates, there is a good chance that at some point you will have built a ring oscillator from a chain of inverters. With the addition of a resistor and a capacitor, you can easily make a square wave oscillator up into the megahertz range with standard logic chips.

[Afroman] received some rather special logic chips, from an unexpectedly named company, Potato Semiconductor. They specialise in making versions of common 74 series logic that smash the usual 100+ MHz barrier of the faster conventional 74 series chips, and extend their bandwidth up to over 1 GHz. Using one of their 74GU04 parts, he made a ring oscillator relying only on the stray capacitances of its gate inputs for its timing, and while he didn’t manage to achieve a GHz he did measure it at about 373 MHz. He took a look with a spectrum analyser, and as you might expect from a logic circuit found strong harmonics in the GHz range.

Now normally there would be no news in someone making a ring oscillator with a 7404. It really wouldn’t be a hack with a run-of-the-mill 74LS or 74HC part. But this Potato part is sufficiently unusual that it deserves a bit of attention in its own right. After all, we’re not used to logic chips that can work at those kinds of frequencies.

We’ve put his video below the break. Meanwhile, the Potato Semiconductor website makes for an interesting browse, and proves that there is plenty of life left in the venerable 74 series.

Continue reading “Afroman Makes A UHF Oscillator From A Potato” →

An 8-Bit Transport Triggered Architecture CPU In TTL

April 21, 2017 by Jenny List 37 Comments

When we are introduced to the internals of a microprocessor, it is most likely that we will be shown something like one of the first generation of 8-bit CPUs from the 1970s. There will be the familiar group of registers and counters, an arithmetic and logic unit (ALU), and an instruction decoder with associated control logic. A complex instruction set causes the decoder to marshal registers and ALU to perform all the various functions in the right order. CPUs may have moved on in many ways since the 1970s, but the block diagram of an 8080 or similar still provides a basic grounding for the beginner.

So when we tell you about another home-made CPU using TTL logic chips, you might expect it to follow this well-worn path. Fortunately though the hardware hacking community is always capable of springing surprises upon us, and [Szoftveres] has done just that with his design. It’s a one-instruction-set machine following a transport triggered architecture, and that means it deviates sharply from the conventional architecture described above. Each instruction is a move between the different physical functions of the processor, and computation is achieved by the physical functions working on the data as it is moved into them and presenting the result on their outputs ready to be moved elsewhere. The result is a computer that is in its own way beautifully simple, though at the expense of some inflexibility and lack of some hardware functions we take for granted in more conventional processors.

This machine has been built on a piece of stripboard, and has an accompanying board with display, keypad, and a modem. There is a small board based upon an ATmega8 microcontroller which performs the function of fast program loading, and can be removed once the code is loaded. Software can be written in a C-like language anc compiled using the compiler in his GitHub repository, and he has produced a YouTube video of the machine in operation. This project is well worth reading through in-depth, for its introduction to this slightly unusual architecture.

Continue reading “An 8-Bit Transport Triggered Architecture CPU In TTL” →

The Fastest Rise Time In The West: Making A Truly Quick Pulse Edge

October 3, 2016 by Jenny List 62 Comments

When we are taught about oscillators as newbie engineers, we are shown a variety of waveforms on an oscilloscope or in a textbook. This is a sine wave, they say, this is a sawtooth, this is a square wave, and so on. We’re taught to look at the lines on the screen as idealised, a square wave is truly square, and the transition from low to high voltage and back again is instantaneous.

In most cases this assumption is harmless. If we look into the subject a little deeper we learn that what seemed an instantaneous cliff-face is in fact a very steep slope, but when a circuit does its business in milliseconds there is usually no harm in ignoring a transition time measured in nanoseconds. The glue logic for your Arduino project can take its time.

Sometimes though, the rise time of a logic transition is important. The application that prompted this article was the measurement of oscilloscope bandwidth by looking at how quickly the ‘scope catches up with a pulse that exceeds its bandwidth, for example. When the instrument can happily measure the transition times of all your usual pulse generators, something out of the ordinary is called for. So it’s worth taking a look at the rise times you’d expect from everyday circuitry, examining a few techniques for generating rise times that are much faster.
Continue reading “The Fastest Rise Time In The West: Making A Truly Quick Pulse Edge” →

8-bit Computer Made Solely From NAND Gates

February 24, 2016 by Jenny List 55 Comments

As an electronics rookie, one of the first things they tell you when they teach you about logic gates is, “You can make everything from a combination of NAND gates”. There usually follows a demonstration of simple AND, OR, and XOR gates made from NAND gates, and maybe a flip-flop or two. Then you move on, when you want a logic function you use the relevant device that contains it, and the nugget of information about NAND gates recedes to become just another part of your electronics general knowledge.

Not [Alexander Shabarshin] though. He’s set himself the task of creating an entire CPU solely from NAND gates, and he’s using 74F00 chips to give a hoped-for 1MIPS performance. His design has an 8-bit data bus but a 4-bit ALU, and an impressive 2-stage pipeline and RISC instruction set which sets it apart from the computers most of us had when 74-series logic was a much more recent innovation. So far he has completed PCBs for a D-type flip-flop and a one-bit ALU, four of which will work in parallel in the final machine

Unsurprisingly, we have maintained a keen interest in TTL computers here at Hackaday for a very long time. You might say that we have featured so many for the subject to deserve a review article of its own. There is the ASAP-3, the Magic-1, the Duo Basic, the Apollo181, the unnamed CPU made by [Donn Stewart], the BMOW, and a clone of the Apollo Guidance Computer. But what sets [Alexander’s] project aside from all these fine machines is his bare-metal NAND-only design. The other 74-series CPU designers have had the full range of devices such as the 74181 ALU at their disposal. By studying the building blocks at this most fundamental level a deeper understanding can be gained of the inner workings of parts normally represented just as black boxes.

One of the briefs for writing a Hackaday article is that if the subject makes the writer stop and read rather than skim over it then it is likely to do so for the reader too. This project may not yet have delivered a working CPU, but its progress so far is interesting enough for an in-depth read. Definitely one to watch.