8-bit CPU: It's alive!

With updated version of Clock module complete, the only thing missing is the Control Logic. Let's build it to complete the CPU.

Control logic

The main idea of the Control logic is the same as in Ben Eater's CPU, with the difference that I'm using 28C64 EEPROMs. The address line usage is a bit different, through:

  • 3 lines from microstep counter, allowing 8 microsteps in total
  • 4 flags from Flags register
  • 6 lines from Instruction Register, allowing 64 instruction opcodes

This uses all 13 address lines, whole 8 KiB of the EEPROM, no room for byte-select bit, the contents of each ROM will have to be different.

Notice, that I moved Flags bits to the middle of the input address. I like this layout better, because now all bytes for an instruction are grouped together. It also allows for easy expansion to 256 opcodes, the data layout will stay the same, I'll only need to replace EEPROMs with larger ones (28C256) and connect remaining 2 lines from Instruction Register.

I did not bother to decode the microstep counter, as it was mostly for the show, and I'll not use it for counter reset - control line from EEPROM is much more convenient and flexible. I'm, however, expanding the outputs - the IN and OUT signals are (de)multiplexed using a pair of 74HC138 - the technique allows for more efficient use of EEPROMs, allowing more control lines. Also it protects from conditions when (by faulty microcode) multiple devices try to put value on the Bus.


Preparing EEPROMs

My main microcode definitions are in Python code, but I already generate C arrays for inclusion in Test Module's Arduino sketch. Now the same arrays can be used in EEPROM burner to generate the contents for microcode EEPROMs. Eventually, I'd like to generate the ROM images on computer and write them to chips using something more generic, but this should do for now.

There's another EEPROM, requiring some attention. My Memory module also contains an EEPROM, I need to write program binary into it. I've generated a binary, but it's just a file. Did not wanted to spend much time on this either, so I just converted it into C array (using xxd -i utility) and included in the Arduino sketch as well. Another dirty trick, but I'm trying to get first demo working, can think of cleaner approach later.


It's alive!!!

Everything is ready now, I should swap out my Test Module and put the Control Logic in. It sounds easy, but actually is quite fiddly and error prone. Losing the ability to use test suite made me a bit anxious. I had to poke around and single step until I got it right.


It's hard to describe the emotions when display changed for the first time: 2... 3... 5... 7... 11...

It works! It really works on it's own! There's no additional processor involved, just the one I built myself.

13... 33... 35...

Wait! What? Something's wrong! 33 and 35 are not primes. Funny, when something does not work as expected, usually there's problem with software. Not this time, I'm absolutely certain that program is correct, because it ran just fine on several other hardware configurations. It took me a while but finally I found the cause - connection between RAM and GP registers (the rightmost ribbon cable) had bits 4 and 5 swapped.



You may have noticed me releasing a similar demo video in February. Yeah, I said that I was behind with blogging, now it shows by how much 😉

There were some more instabilities, but all of them turned out to be loose wires. Once everything was secure, I decided to push it for speed. If I pull the capacitor from the clock circuit (one for astable clock), clock starts to run as fast as it can. Turns out TLC556 gives me 2.2 MHz signal. My clock circuit divides that in half, so computer gets 1.1 MHz clock. The whole Prime Sieve was repeated about 25 times per second. My HLT signal is not connected anywhere, used it for measurements instead.

How can I be certain it worked faultlessly, if it ran that fast? Usually, if something goes wrong, it does not return to the correct path by itself. So, if I slow the clock down after a while and it still runs, it must have been fine. Ran it this way for over a week, not a single misstep.

Now what?

Some might consider the project complete, it works after all! For me, this was just the first milestone, there's much more I want to add to it. I have to decide on the further direction, though.

Comments

Post a Comment

Popular posts from this blog

8-bit CPU: Clock module

Image
The parts are finally here an I can have some fun! Since nothing runs without clock, I decided to start with that module. It's probably not the most fun one, but I definitely need it, before doing something else. I was planning to follow Ben's design to some point. I had some TS555CN timers at home, so I decided to try those first, before opening the package with the new ones I ordered. Wired up the 555 in basic astable configuration with capacitors, potentiometer and decided to test if it works. So I connected a LED to the output and powered it up. It worked. Well, sort of. LED blinked and I  could adjust the frequency, but then suddenly it started to blink very fast, then again back to normal. What's even stranger I could trigger or suppress the effect by touching either chip or capacitor (just top of the chip, not the leads). I did accidentally connect my power backwards on first try 😓, so I figured it caused some damage or something. Replaced the chip with one of my n
Read more

8-bit CPU: ALU and Flags

Image
Now that I have a pair of devices that can store a byte, I can proceed to do something more interesting. Build a device that add them together, for example. In other words - let's build an ALU. The design follows same basic idea as Ben's - two 4-bit adders, XOR gates and an output buffer. I'm using HC logic here, so I used 74HC283, 74HC86 and 74HC245 chips. Since I've built only one Register and did not want to build another, I connected my Program Counter board as register B. If I keep the counting function disabled, it serves the purpose just fine. It took a lot of wires, but I'm just getting started, let's build Flags register as well.  There were no surprises with Zero flag - 4 NOR and 3 AND gates does the job - just following the Ben's design. Another latch (74HC173) chip to store it, done. The fun starts with the Carry flag: I wanted to support a carry-in signal for the ALU. It is very useful if one wants to perform the addition or subtraction for wid
Read more

8-bit CPU: Memory

Image
Time for another important part of the computer - memory. Here I think I have to come up with my own design. Ben's version has only 16 bytes, uses nowadays-exotic 74189 memory chips and there are DIP switches for programming. For the memory I plan to use 62256 SRAM chip. It can store 32 KiB of data, I initially plan to use just 256 bytes, so I'll connect remaining address pins to GND. I'm also not in a mood for any DIP switch based programming, so I'll add an EEPROM instead. There are several ways how computer can utilize such setup: split the address space into program and data memory. This is how Ben's 6502 breadboard computer works. Some additional logic gates are used for chip selection, the main issue however is that it is not very flexible. use Harvard architecture , where program and data memories are completely separate. Reading and fetching instruction are two different operations: former accesses RAM, latter - ROM. This is how AVR microcontrollers (heart
Read more