rj32

Jan 14, 2021

In this video I build out the program memory store from an EEPROM and build a simple programming interface for it. I also add a diagnostic output for the one instruction currently supported. This is to support building out more instructions very soon.

As always, the video is available here:

Jan 11, 2021

In this video I build out the register file, and upgrade the instructions to allow specifying a source register and destination register for the add. The CPU has grown to this:

The decoder is updated to this:

And here's the new Register File module:

And here's the video:

Jan 5, 2021

Computers can do a lot more than just add two numbers. Let's figure out how to add multiple sets of numbers!

I introduce multiplexers, a program counter, a demultiplexer, d-flip-flops (aka registers) and encounter a timing glitch!

Here's what the CPU looks like after this episode:

And here's the video:

Jan 3, 2021

Well, you gotta start somewhere, right?

This video is mostly introducing some of the basics of Digital. I introduce how wires work, some of the components, embedded circuits (modules), etc. Eventually I get the beginnings of a decode and execute unit going. You can see the execute unit above, and the other units are just wires really. Here's a high level diagram:

And here's the decode unit:

Pretty humble.

If you'd like to see this in video form and get the tutorial, you can watch that here:

Jan 2, 2021

At this point I have been building rj16 and recording videos of it. rj16 is a pipelined 16-bit 5 stage RISC processor, built in Go (golang). It had 127 instructions planned and was largely inspired by the SH-2 and M*Core processors. It was a grandiose design of epic proportions.

But I realized allowing rampant feature creep was not the way to finish a project. Plus I got a craving to maybe one day build this CPU in discrete logic chips on PCBs. If I wanted to ever have any hope of that, I needed to scale down.

I also wanted to build an OS for this processor, and at the time I was having difficulty finding anything that could fit in 64 KB (an issue I have since resolved). So I decided 32-bits would be easier for that goal.

So, because all I had of rj16 was a simulator in Go, I decided to start from scratch building rj32, a 32-bit version of the processor. This would internally be a 16-bit processor (like the m68k), but with a 32-bit instruction set, and all operations would happen on pairs of 16-bit registers.

And this time I decided to actually publish the videos on youtube for the first time. I had been recording for a while but too chicken to actually put those videos out there. But I decided that needed to change.

So with that rj32 was born.

I decided to build it in Digital with the intention of having it run on an FPGA, and keep it simple enough that maybe one day I could implement it with discrete 7400 series logic chips. And the whole journey would be recorded on youtube. Here is the very first video:

Note: This was remastered after a couple weeks to be more concise and more appropriately represent the series as a whole