8-bit CPU: Wiring and testing the new ALU

Once I had soldered the boards I was eager to test them. At first I "poked around" using jumper wires and boards appeared fine. To be absolutely sure, however, I have to wire them together into a new ALU block and hook it up to my Arduino testing device.

Boards are a bit elevated above the breadboards, so it seemed to be a good idea to run wires underneath the PCBs. To save on wiring, I opted for simple, fixed configuration (same as breadboard prototype and Ben's original), instead of my new, dual-output feature.

I tested the dual-output some time later, adding jumper wires for missing connections. The concept works fine, but it takes 14 control wires to tame the beast. This will have to wait for proper control logic.

The ALU block is not the only piece that is new. My new EEPROM writer features additional pin sockets, giving access to onboard shift register outputs. When no EEPROM needs to be programmed, it can be repurposed to switch control lines. I do not need my ad-hoc control line extender anymore.


Here's another picture from assembly process. I "mocked" the board locations by plugging in spare pin headers. Also, if you look carefully, you may notice a silly mistake - I did not check the power rail orientation. Had to tear it apart and re-assemble in order to fit with the rest of the build.

Testing did not go as smooth as I hoped for either, but probably that was for the best. I found out that my "fancy" Arduino testing module is overengineered and useless, when it comes to diagnostics. It can prove that everything is fine, but adding new test case to pinpoint an issue takes too long. The programming environment also feels somewhat limited. Sure it's C++, but still there's a lot missing.

Back to the drawing board then. The new design is Python code that sends few low-level commands to Arduino:

  • switch the control lines according to bits in control-word
  • put a value on bus
  • read what's on the bus
  • read flags values
  • pulse a clock

The logic that sends these commands is written in Python, so I do not need to recompile and re-flash the Arduino all the time.

At first I wrote a simple cmd-based utility for manual tests. It gives the same level of control as fiddling with jumper wires, the difference being that I can automate it.

The low-level commands were pretty tedious, so I stated to combine them together in higher-level functions. Suddenly they started to resemble assembly instructions. For example: to load a number into register A, code sends signals to enable A's LOAD line, puts the value on the Bus and pulses the clock. In other words - it's microcode. Microcode written in Python!

Another thing with Python is that now I can use Unit Test frameworks to organize and run tests. I initially used Python's built-in unittest library, but eventually switched to pytest for its features.

People keep stressing the importance of automated tests in software projects. In a hardware project like this one, it might have even higher value. Ability to run couple dozen test cases in just few seconds really gives confidence about the build. If wire comes loose, I should be able to spot that instantly.

Comments

Post a Comment

Popular posts from this blog

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: 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: 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