Category: Projects

Ah.  My 16 bit computer. I’m still working on this one so I’ll add more media as I complete the project. Here is a picture of what I have so far:

This time I was determined to have a computer with a full instruction set. I wanted a computer that the control logic would do a 16 bit multiplication and division with 1 opcode, so I would need at least 1 32bit shift register to do those types of calculations. The ALU would also need to do a bit more than just add subtract so I plan on using 4 4bit ALU IC’s for this project just so save space. The registers them selfs barely fit on a single breadboard:

So to make the ALU I wire up 2 registers into the ALU chips and have an output LED desplay for each (Makes the computer really interesting when its working):

Next I lay out chips for the Memory module. This time I’m planning on having only 1 RAM fetch per opcode cycle and use pointers for large operands, this will limit the number of large operands to 256 but I just cant seem to think of a reason why I’m going to need more than 256 large immediate values. I can also use those extra micro-cycles for the multiplication and division operations. Here’s the computers ALU and shift register, display and RAM chips all ready for wiring:

In the RAM module i added a few shift registers so I can program the computer using an Arduino or other Micro-Controller. I still had the old dip-switch method too so i could quickly throw in some op codes and see if they work as expected.

The Output display I used a small LCD display and I programmed a ATMEGA256 chip to convert the the binary number into a readable number and display it. The LCD had 2 lines so I added a previous number just in case I missed the halt switch while debugging

I also Added a usable counter to my list of things this computer needed so i added it below the RAM module.

Now the computer was getting too big to move around so i Glue it to a piece of wood. This also makes it hang able for some super nerdy tech art for the wall.

I added the control logic chips and finished the bus so each module can can communicate.

Now its testing time I made this video of every component working with the lights down. Even the micro-cycle counter is up and running:

Finally I got everything wired and ready to be programmed:

Now the tedious task of programming the control logic EEPROM’s to control each module to perform their tasks. First I did the load, and Add/Sub features. Here is an add load 13 add program running in a loop:

Now just for Testing I wrote a program to use each module  then loop:

This is still a work in progress but I’m almost done. My current Issues are saving into RAM from the registers and Jump Condition Logic.

 

My first experiment with Integrated circuits. I was trying to get a deeper understanding of how computers do what they do. So I built this 8 bit breadboard computer:

This 1 MHz computer was limited to say the least but an extremely intoxicating project. It could add and subtract with 256 bytes of RAM and display the results in an output register that converted the binary number to a decimal.

I Made the ALU using an 2 4-bit Full Adder IC’s and a few logic gates. Here is a video of my computer’s ALU being tested by adding 1 each clock cycle:

Next I created a memory module with an address register and a way to program the computer’s memory. Here is a video of the add and subtract of the ALU and then how the memory module is programmed:

This is a slow process to program the computer (I’ll fix this in my next project).

All that is left to make is some control logic and a display module. The display only has to display a maximum number of 256 because the biggest number 8 bits can represent is 256, (unsigned) so ill use 3 7 segment displays, and controler IC’s for the displays and 2 EEPROM’s to decode the data for the controllers, and a few more EEPROM’s and some logic gates to make the control logic module.

Here is a video of my fully completed Computer doing the Fibonacci sequence:

Some notes on my design:

I Had a 2 byte fetch cycle for instructions so i could store the instruction in address 0 and the operands in address 1. This way I had full range over the address space in the memory module.  The Op code is 4 bits wide and operands are a full 8 bits.

The ALU was missing a few key features to make this a real computer in my books. The ability to shift and compare is most obvious needs and all I made was a carry flag for jump conditions. My next project will not have these short commings.

This project is well over 10 years old now, and has now been put into a state of low maintenance. Yet still I find myself showing the project to people to try and get them interested in the way 3D software packages work.

This C# application will render a scene (mainly rendering quadratic shapes) and do a non-physically based shading technique.

Click  here ->BLSpaceRay<- for the source code.

Here is a screen shot of the scene it renders.