Cerberus 2080 — Three-Headed Retro Computing Project

For seven months, [Bernardo Kastrup] at [TheByteAttic] has been realizing his childhood dream of building his own computer. It was this dream that steered him into the field of computer design at the age of 17. After thirty years in the industry, he finally has some time to design the computer he dreamt about as a kid. His requirements are ambitious: fully open design, gate-level details, thru-hole or PLCC for easy hacking, well-established processors with existing tool chains, low-cost development tools for CPLDs, no FPGA, standard ITX case compatible, and so on. He quite reasonably decides to use more modern electronics for video (VGA), keyboard (PS/2), and program storage (flash drive). Along the way, he chooses to put three processors on the board instead of one:

  • Zilog Z84C0010 (Z80)
  • WDC W65C0256 (6502)
  • AVR ATMEGA328 (RISC Controller)

When coming up with the concept and requirements, [Bernardo] had a fictitious alternate history in mind — one where there were follow-ups to the ZX80, PET/CBM, or TRS-80 from the late 1970s that were extensions to the original systems. But he also wanted a clean design, without cost-cutting gimmicks, in order to make it easier for learners to focus on computing itself — a didactic architecture, as he describes it. Turn the crank for seven long months, and we have the Cerberus 2080. [Bernardo] has put the design on GitHub, and made a video series out of the whole process, of which the introduction video is below the break. There’s even an online emulator developed by retro hacker  [Andy Toone].

We wrote about the 6502-based ERIC-1 project back in 2014 which shared the bus with an ATMEGA simulating ROM. The Minty Z80 project from 2019 also uses a similar technique. Thanks to [Frédéric] for sending us the tip.

Continue reading “Cerberus 2080 — Three-Headed Retro Computing Project”

Gorgeous 6502 Celebrates Craftsmanship Of The Early Homebrewers

The days when a computer had a front panel bristling with switches and LEDs are long gone, and on balance that’s probably for the better in terms of ease of use, raw power, and convenience. That’s not to say there aren’t those who long for the days of flipping switches to enter programs, of course, but it’s a somewhat limited market. So unless you can find an old IMSAI or Altair, chances are you’ll have to roll your own — and you could do a lot worse than this aluminum beauty of a 6502 machine.

The machine is named PERSEUS-8 by its creator, [Mitsuru Yamada]. It follows earlier machines bearing the PERSEUS badge, all of them completely homebrewed and equally gorgeous. The PERSEUS-8 would have been an impressive machine had it come along 45 years ago — the 2 MHz version of the 6502, a full 16-bit memory address space, and 16 kB of battery-backed RAM. But the mechanical and electrical construction methods and the care and craftsmanship taken are where this build really shines. The case is fabricated out of aluminum sheets and angles and looks like it could have come from a server rack. The front panel is to die for — [Mitsuru] carefully brushed the aluminum before drilling the dozens of holes needed for the toggle switches and LEDs. And the insides are equally lovely — socketed chips neatly arranged on perfboard with everything wired up using period-correct wirewrap methods. Even the labels, both on the front panel and even on the motherboard, are a joy to behold.

Builds like this are the ones that really inspire us to take the extra steps needed to make our projects not only work, but also to be beautiful. We’ve seen this kind of craftsmanship from [Mitsuru] before — recall this serial terminal that never was, or the machine that came before the PERSEUS-8.

Diving Into The Details Of Keyboard Interfaces At The Gate-Level

Never doubt the value of a good teacher. Even if you know — or think you know — the material being presented, a good teacher can open your eyes to new ways of looking at things that will pay dividends you never expected.

That’s the feeling we got while watching [Ben Eater]’s latest video on building a keyboard interface (embedded below) for his breadboard 6502 computer. On the face of it, getting a keyboard to talk to a computer should be a simple job. [Ben] had previously looked at the serial protocol used by the old PS/2 keyboard and even built a wildly complex circuit out of discrete shift register chips to visualize the data being sent by the keyboard. The video below continues that work, this time concentrating on using the keyboard with his 6502 breadboard computer.

After some instructive preliminaries on interrupt programming, [Ben] dives into the logic-level details of teasing useful signals from the keyboard. His signal processing starts with some inverters and an RC network to turn multiple clock pulses into one logic level transition. Walking through this circuit step by step was the really interesting bit; even if you know that the answer is eventually going to be “Schmitt trigger,” getting to that point was really instructive.

Of course, what [Ben]’s videos mainly accomplish is making us want to follow along with him and build a breadboard computer of our own. From a low-rez VGA card to a reliable UART, following along with his discrete chip builds is always educational.

Continue reading “Diving Into The Details Of Keyboard Interfaces At The Gate-Level”

Everything Old Is New Again: Another 6502 Board Is Born

[Jeff] says that designing your own 6502 computer is a rite of passage, and he wanted the experience. His board can accept a real 6502 or the newer CMOS variant that is still available. There are a few modern conveniences such as USB power and provisions for using a USB serial port.

We are spoiled today with microcontrollers having everything in one package, but with this class of CPU you need your own memory, I/O devices, and other support chips. [Jeff] took a traditional approach, but picked components that are still easy to obtain. Some designs now push all the support functions to a more modern processor like an Arduino, which is very simple to do, but doesn’t feel as authentic, somehow.

Continue reading “Everything Old Is New Again: Another 6502 Board Is Born”

Another Kind Of “Bare Metal”: 6502 Computer Powers RPN Calculator

[Mitsuru Yamada] states that one of the goals for this 6502 computer build was to make it strong enough to survive real-world usage. In that regard alone we’d call this a success; the die-cast aluminum enclosures used a little blast from the past and lend a nice retro industrial look to the project. The main chassis of the computer fairly bristles with LEDs and chunky toggle switches for setting the data and address busses. The interior is no less tidy, with the 6502 microprocessor — date code from 1995 — and associated support chips neatly arranged on perf board. The construction method is wire wrapping, in keeping with the old-school look and feel. Even the hand-drawn schematic is a work of art — shades of [Forrest Mims].

As for programming, this machine is as low-level as it gets. Nothing but 6502 machine language here, entered manually with the toggle switches, or via an externally programmed ROM. The machine can only address 1k of memory, a limit which the code to support the RPN calculator add-on [Yamada] also built brushes up against, at 992 bytes. The calculator keypad has a 20-key matrix pad and an eight-digit dot-matrix LED display, and can do the four basic operations on fixed-point binary-coded decimal inputs. The brief video below shows the calculator in action.

We love the look of this build and we’re eager to see more like it. We’ve seen a ton of 6502 builds from discrete chips lately, and while we love those too, it’s nice to see one of the big old DIPs put back in action for a change.

Continue reading “Another Kind Of “Bare Metal”: 6502 Computer Powers RPN Calculator”

Vectron Adds Basic And Christmas Tree Control

Not content to leave things alone, [Nick Bild] has updated his nearly practical breadboard 6502 Vectron project once again by adding Tiny Basic and home tree automation. Instead of using an LCD module like last time, or his custom-built VGA output using 7400-series logic, [Nick] chose to go modern this time and implemented a VGA output using a TinyFPGA BX.

Tiny Basic was one of the first versions of Basic released after Bill Gates famous open letter to hobbyists in 1976. While Altair Basic was selling for $150, Tom Pittman wrote Tiny Basic for the 6800 and sold it for only $5 (don’t worry, Tom has since made it free to use). We got a kick out of browsing the Tiny Basic manual and learning that our serial number can be found on the paper tape leader, and that a Teletype will generally receive one more character, at least, after getting the X-OFF control signal.

In the video, you can see [Nick] running a short Basic program and operating his Christmas tree lights from the Vectron, although it’s only on-off control. He suggests that a PCB version is in the works, but he’s having trouble deciding when to quit adding features.  That’s a conundrum we know all too well.

Continue reading “Vectron Adds Basic And Christmas Tree Control”

“Brain In A Vat” 6502

The 6502 was a revolutionary processor for its time. Offered at a small fraction of the cost of other processors available when it was released, it became adopted in such iconic computers at the Atari 2600, the Apple II, the NES, and the Commodore 64. For that reason it’s still extremely popular among retrocomputing enthusiasts who will often go to great lengths to restore these computers or build them from scratch. [jamesbowman] had an idea to build a 6502-based computer with the processor only, leaving the rest of the computer up to an FPGA.

He describes the system as a “brain in a vat” since a real 6502 is used as the “brain” and all other functions are passed off to the FPGA. In his build he uses an FPGA board with built-in graphics abilities, but the truly interesting part of this build is how the FPGA handles memory. If a particular value is placed on the data bus of the 6502, it loops forever through the entire memory and executes all of the instructions it finds. This saved a lot of time getting this system up and running, and he is able to demonstrate it by showing a waveform on the video output of the device.

Of course you can take an FPGA and emulate an entire computer based on a 6502, but using the actual silicon in a build like this really ensures that the user can learn and understand the hardware involved without some of the other tedium of doing things such as converting old video signals to HDMI for example. It’s a great take on retrocomputing that we expect to see more of in the future.