I grew up in the 8-bit computing era. I didn’t know anything about these systems at the time, or even what a bit was. But I knew that when the 16-bit systems started coming out, they were better than the old 8-bit systems were. And today, 64-bit systems are the norm. So, 8-bit technology is outdated and useless, right? Then why are there folks around the world building new modern systems on old 8-bit technology?

One could argue that it’s nostalgia. I’m certain that’s true to some degree. But I’m convinced that there’s something more. You see, 8-bit technology is simpler and more understandable. You can grasp all the opcodes those processors use and understand the architecture well enough to troubleshoot it. In today’s systems, everything is integrated and it’s very complex. There’s something comforting and reassuring about having an 8-bit system.

In this article, I’m going to walk you through how I built a recently designed 8-bit computer, called the CERBERUS 2080.

What is the CERBERUS 2080?

In short, it’s a recently-design 8-bit computer. But it’s also so much more than that. The designer is Bernardo Kastrup, and he has loads of information and videos on how he designed the CERBERUS on his site – https://www.thebyteattic.com. The documentation, schematics, and firmware are all hosted on his GitHub repo here. Definitely go there for more detailed and deeper information. I’m going to give you a high-level overview before I share my experience building the system.

I mentioned that the CERBERUS is so much more than just an 8-bit computer. Bernardo calls it an education platform, and it can certainly serve as one. The design is open source and the amount of documentation available is quite extensive, including a 70-page PDF that demystifies quite a bit of the system’s operation. But one thing that really makes the Cerberus unique is its use of multiple processors. That’s right – there’s more than one CPU in this system. More on that in bit.

After I saw Jan Beta’s video of him building the system, I started looking into it and immediately realized that I had to build one myself.

Architecture of the System

First off, I just have to say that the architecture of the system is beautiful. Here’s the block diagram from the Bernardo’s documentation (from the CERBERUS 2080 Complete Manual in GitHub). Let’s take a minute and explore it a bit.

The Microprocessors

To me, the first things that stick out are the multiple microprocessors. Notice that there are two classic 8-bit processors – the Z80 and the 6502. The CERBERUS has the ability to switch between them, by typing a command! That’s right – you can run programs written for the both the Z80 and 6502. This certainly should help with the developer community porting software over to the system.

There’s also a third processor shown in this diagram, and it’s a more modern one; an ATmega328P, labelled as CAT. Arduino fans should recognize this as the AVR microcontroller that’s used in the Arduino Uno. Though not a “classic” processor, it is an 8-bit CPU, so the claim can be made that there are three 8-bit microprocessors in this system.

Notice that the CAT doesn’t have access to the address or data bus. What it does access are the I/O devices and the SPACER. So, this AVR microcontroller isn’t used for running user-defined code. Rather, it acts as the system BIOS. I really like this approach because it makes the BIOS user extendable by modifying the C code that runs the CAT, and the CERBERUS community has certainly done that and offered up some improvements.

The Z80 and the 6502, however, do both have access to the address and data bus. They operate the same way they do in other systems; they pull instructions from RAM and execute those instructions.

The Memory

As you can see in the architecture diagram above, the memory is split across 3 different purposes. There’s 2KB for video RAM, 2KB for the character RAM, and 64KB of system RAM. The video and character RAM each have a 2KB static RAM IC. The character RAM occupies 0xF000 – 0xF7FF of the address space, and the video RAM occupies 0xF800 – 0xFCAF.

In total, there’s 64KB of RAM in the system, implemented with two 32KB static RAM ICs. After accounting for the video RAM, character RAM, and other reserved addresses for system operation, there’s 60KB remaining for program execution.

The Display Circuitry

I think the display circuitry is one of the more interesting aspects of Bernardo’s design. Here’s the VGA architecture diagram from the CERBERUS documentation.

There are a couple of things worthy of pointing out here. First, there’s a dedicated 25.175MHz clock, which is different than the 16MHz main system clock. This is because the display circuit is actually running in 640 x 480 VGA mode @ 60Hz, and that mode requires a 25.175MHz pixel clock for the timing to work correctly.

Resolution	Refresh Rate	Clock Speed
640 x 480	60 Hz	25.175 MHz
640 x 480	72 Hz	31.500 MHz
640 x 480	75 Hz	31.500 MHz
640 x 480	85 Hz	36.000 MHz
800 x 600	56 Hz	38.100 MHz
800 x 600	60 Hz	40.000 MHz
800 x 600	72 Hz	50.000 MHz
800 x 600	75 Hz	49.500 MHz
800 x 600	85 Hz	56.250 MHz
1024 x 768	60 Hz	65.000 MHz
1024 x 768	70 Hz	75.000 MHz
1024 x 768	75 Hz	78.750 MHz
1024 x 768	85 Hz	94.500 MHz

Also, take a look at the two blocks labelled CAVIA and SCUNK. These are both CPLD chips. If you’re unfamiliar, a CPLD is a Complex Programmable Logic Device. Essentially, it’s a less complex version of an FPGA. A CPLD might have a couple thousand gates, whereas an FPGA could have millions. But the core function is to be able to write code to program those gates to do whatever you want… and that’s what Bernardo does here.

The SCUNK has two overall responsibilities. First, it generates the video signal according to the VGA standards. The following diagram is from the CERBERUS technical document, and shows the timings that are generated by the SCUNK.

The second thing the SCUNK does is provide a PISO (parallel-in, serial-out) shift register for character data. This is an 8-bit shift register, so 8 of the SCUNK pins are allocated for it. These pins are connected to the data pins on the character SRAM chip. The process is slightly complicated, but the gist of it is when a character is ready to be draw on the VGA screen, the character SRAM places the bits representing each pixel on the shift register. This data is then shifted into the register on a single clock cycle (remember, the data is entering the chip in parallel) and then shifted out to the VGA signal serially on subsequent clock cycles. My dumbed-down explanation here isn’t doing justice to the design; Bernardo has come up with a very elegant way to handle this process, which enables native upscaling of the 320 x 240 pixel image onto a 640 x 480 display.

The CAVIA plays an important role in the interchange that I just glossed over. At a high level, it serves two functions. First, it scans the the video memory, causing the character SRAM to be addressed. Second, it uses an internal counter as a memory offset, to direct the character RAM to output each line of the 8 x 8 pixel character into the SCUNK’s shift register. Again, I can’t do the design justice without deep-diving into the architecture with a bunch of diagrams. Thankfully, Bernardo has already done that himself on his YouTube channel. If you’re interested in fully understanding how the video circuit design works, I’d highly recommend watching the following videos of his (in the order listed):

1. Overview of the VGA Generation Circuitry
2. Designing and Testing SCUNK
3. Designing and Testing CAVIA
4. Bringing the VGA Circuit Together

Sourcing Parts

If you want to build a CERBERUS 2080, there are two ways to get parts. First, you can purchase a kit from the Home Computer Museum, which has everything you need included. If you’re just looking to get a CERBERUS up and running quickly to play with, this is probably the best route. The challenge, though, is the availability of these kits is very limited. So, if you want one, you need to pre-order and wait some period of time for them to start shipping again. At the time of this writing, the kits from the Home Computer Museum cost a little over $300 USD.

The second way is to go through the bill of materials and source all the parts yourself. That is what I did… but I’ll tell you, it wasn’t easy finding everything. And for some of the parts, I can only find them in used condition (the CPLD chips). If you decide to go this route, there are a couple of things you need to think about – fabricating a PCB, finding all the components, and acquiring programmers for the ATmega and CPLD chips.

Fabricating a CERBERUS 2080 PCB

Getting a PCB fabricated isn’t very difficult these days. There are several PCB manufacturers that you can get this done at. Some of the more popular ones are PCBWay (notorious for sponsoring maker videos), OSHPark (a US-based company known for their purple PCBs), and JLCPCB. Of these three, I prefer JLCPCB. I’ve been using them for years; the quality of their boards is great and even though they are in China, delivery to the US is super fast.

A Quick Side Story
Earlier this year, I decided to run an experiment and ordered a set of custom PCBs that I made for a project from both JLCPCB and OSHPark. Pricing-wise, JLCPCB was the clear winner. OSHPark charged me $25.50 for three boards, which included shipping (a total of $8.50 per board). JLCPCB, however, charged me a grand total of $10.40 for five boards ($2.08 per board), and that also included shipping!

Well, you figure that since OSHPark is in the US and JLCPCB is in China, OSHPark would beat JLCPCB in shipping speed for sure. Nope! I placed the OSHPark order on March 27, 2022 and it arrived on April 9. I placed the JLCPCB order on March 28 (the following day) and it arrived on April 7… two days earlier than OSHPark. In fact, every order I’ve placed from JLCPCB has been in my hands within 10 days.

The final nail in the coffin is that I’ve had some quality issues with OSHPark, but never with JLCPCB.

So, I turned to JLCPCB to make a run of CERBERUS PCBs for me. I submitted the minimum order (5 boards) for a total cost of $77.80 ($15.56 per board). This is a great price, especially considering the size of the board.

If you’re curious, I did upload the Gerbers to OSHPark as well to see a price comparison, and it quoted me $924.40 for 3 boards ($308.13 per board)!

Finding the Components

Most of the components were easy to find. I purchased the bulk of the parts (76% of them) from Digi-Key in a single order. This included all the passive components (resistors, capacitors, transistors, etc.), all the sockets, the Z80 and ATmega CPUs, and a few other miscellaneous components. Digi-Key didn’t have the 6502 CPU in stock, so I turned to Mouser for that.

I also ended up sourcing a couple of parts from Amazon – namely, the PS2 keyboard connector and the Micro SD Card adapter. While there, I also picked up a set of stand-offs and an acrylic micro-ATX display case. Those parts aren’t necessary, but it’s well worth the extra money to make the CERBERUS a nice display piece.

The parts I had the most trouble finding were the CPLD chips, the two SRAM modules for the video and character RAM, and the two 74HC244N buffers. I found some 1504 CPLDs on AliExpress for $2.40 each, and I was able to pick up the 1508 CPLDs from eBay for $9.69 each. As time goes on and chip manufacturing grows to keep pace with the demand, you may have an easier time finding these parts.

Overall, the total cost I paid for all the components, including the PCB (but excluding the acrylic case) was $171.25 per system. However, keep in mind that to get to that price point, I had to purchase many of the parts in bulk (especially the passives). So in reality, I did spend more money than that. That did, however, give me enough parts to build two complete systems, and have several spares parts on top of that.

Programmers for the ATmega and CPLD Chips

As you’re acquiring parts, one other thing to keep in mind is that you’re going to need the right equipment to program the ATmega and CPLD chips. If you don’t have this equipment, or don’t want to buy it, then you’re best off ordering the kit from the Home Computer Museum, as those chips come pre-programmed. If you do end up purchasing the programming equipment for both the ATmega and CPLD chips, expect to spend another $100 or so.

For programming the ATmega chip (the CAT), you’re going to need two things. First, you’re going to need a standard Arduino. If you’re like me, you probably have a box full of them somewhere in your house. I’ll talk about this more in Part 2 of this series, but you’re going to use the Arduino as an in-system programmer to load the Arduino bootloader onto the ATmega328P chip. This enables the CPU to run Arduino code. To accomplish this, you’ll also need a breadboard and some jumper wires. You’ll also need a 10uF capacitor, a 10KOhm resistor, and a 16MHz crystal oscillator, but you already have all 3 of those from the CERBERUS BOM (just be sure to burn the Arduino bootloader onto the ATmega before you solder up your CERBERUS board). If you don’t want to use the parts going into the CERBERUS, you can pick these all up for a few pennies from Digi-Key or Mouser, or select one of the many breadboard kits on Amazon (such as this one), which will give you a few other things to play with.

The second thing you need for the CAT is an FTDI adapter. This is a small device that converts your USB connector to an RS-232 connector. The FTDI chip onboard translates the USB protocol messages into serial messages that the Arduino bootloader can understand. FTDI adapters are really inexpensive – you can pick them up for as little as $2.00, such as in the case of this 5-pack from Amazon for $11. Even if you don’t want to buy one, there’s a way to use an Arduino as an FTDI adapter, as well.

While you can program the ATmega chip cheaply, the CPLDs are a different matter, as you need an actual CPLD programmer. I purchased the Microchip ATDH1150USB (the same one mentioned in the CERBERUS manual) from the Microchip website for around $80.

Conclusion

Ok, that’s a wrap for part 1 of this series on the CERBERUS 2080. In part 2, I’m going to share some photos from my assembly, give you some assembly tips, and go into some detail on programming the CAT and CPLDs. I’ll also show you how to load a couple of the community-developed BIOS images, as well as how to run a some of the games and software that others have created.