How to Build the Home Micro HM1000

In many cases, other parts can be substituted for the ones listed above. For example, you should be able to use AHC logic instead of HC without any problems. HCT probably also works fine. The parts list shows HC parts because those tend to be easiest to obtain.

For the RAM, make sure that the data lines are high impedance when ce# is high.

For the CPU, you need a 6502 with a bus enable pin. Other variants can be made to work, but you will have to add logic to stop the CPU from driving the address and data buses when bus enable is low. The CPU also needs to be able to run at 1.79MHz. Using the 65C816S allows for the possibility of later reusing it in a more advanced, even 16-bit computer.

Instead of an ATmega328p, you can use an ATmega328 (without the p).

Instead of '574s you can use '374s. They do the same thing, but the pinout is different, so be sure to wire them correctly.

No particularly stringent requirements are put on the diodes connecting to the keyboard. This means that, instead of 1N4148, many other types of diode could be used. Probably the most important thing to pay attention to is the forward voltage drop. If this exceeds 1.3V, the diode cannot pull its anode low enough to read as a logic 0, so you need a diode with a forward voltage drop that's comfortably below 1.3V.

Insert the crystal oscillator. Consult the data sheet for correct wiring. Commonly, crystal oscillators come in dual in-line packages that are the size of a DIP8 or DIP14, but have only 4 leads. Generally you will wire one pin to Vcc, one pin to GND, and one pin will be your output. The remaining pin may be no connect or it may be an enable/disable pin.

You can check that everything is working right on the oscilloscope. You should have a waveform that oscillates at 14.31818MHz or something very close to it, with a minimum of less than 1.6V and a maximum of at least 3.3V. It may look more like a sawtooth wave than like a square wave. If so, that's ok - as long as the frequency is correct and it reaches the required voltages.

Insert the ATmega328p. Wire it as follows:

If all is well, pin 28 (pc5) should output a signal that stays high for 16.656ms, then goes low for 0.064ms, for a frequency of about 59.8Hz. This is the vsync signal. Pin 27 (pc4) should output a signal that stays high for 27.937us, then goes low for 0.629us. This is the hsync signal. Don't worry if the oscilloscope displays slightly different values. If you're getting the signals and your crystal has the right frequency, the signals should be right.

Add the VGA port. For the numbering, if the wide side of the port is up, pin 1 is in the top right, pin 5 in the top left, pin 6 in the middle right, pin 10 in the middle left, pin 11 in the bottom right, and pin 15 in the bottom left:

\----------------------/
 \    5  4  3  2  1   /
  \   10  9  8  7  6 /
   \ 15 14 13 12 11 /
    \--------------/

Wire it as follows:

Of course, we don't actually have red, green, and blue yet. You can temporarily add 1K ohm resistors to pins 1, 2, and 3, and connect those resistors to pin 26 of the ATmega328p.

When you connect the circuit to a VGA monitor and power it on, the monitor should be able to synchronize to the signal. If you connected the red, green, and blue signals as described above, the monitor should display a grey rectangle.

Add a 74HC161. This will be used to divide the 14.318MHz clk14 signal to lower frequencies. Wire it as follows:

Add a 74HC08 to create a signal that goes high when video active and clk3 are both high. We will later use the same '08 to generate the ram# and oe# signals.

We will use a 74HC139 as a load pulse generator. This will generate the ldpix# signal to load pixel data every 8 pixels, and the ldkbrow signal to latch keyboard row data. Wire it as follows:

Connect a 74HC166 shift register. This will be used to shift the pixel data out one bit at a time.

If you made the temporary connection between the ATmega328p and the red, green, and blue lines, remove it now.

Connect each of red, green, and blue to a 1K ohm resistor, and connect those resistors to pin 13 (q7) of the '166.

If you create a bit pattern on the d0..d7 pins of the '166 by temporarily wiring some of the pins low and others high, turning on the power should display the bit pattern, repeated every 8 pixels.

The ATmega328p generates addresses to read pixel data from. Let's use those addresses to control the image we display.

To prevent the ATmega328p from accessing memory at the same time as the CPU, we run the address lines from the ATmega through two 74HC541 buffers. The first handles the lower 8 bits of the address, and is wired as follows:

The second one handles the upper 8 bits of the address and is wired like so:

The pinout for the RAM chip shown here is for the Alliance AS6C2008. Other SRAM chips should have similar pinouts. Check your datasheet to make sure. Note that the address pins in the datasheet of the chip do not match the address bit numbers on the bus. This is ok, as long as every bus address maps to a unique and valid address on the chip.

On the AS6C4008, pin 1 is a18 and pin 30 is a17. Wiring it the same way as an AS6C2008 should work.

On the AS6C1008, pin 1 is no connect instead of a17 and you should leave it unconnected.

To test, you can temporarily wire we# high, oe# low, and ce# low. This gives you a circuit that reads an image from memory and displays it. Of course, there is no way to control what is in that memory, so the image you see will be random. It may change when you turn the power off and back on. However, it should not change while the machine is powered on. Undo the temporary wiring after testing.

Add the ROM chip. Consult the datasheet for the proper wiring. The wiring in the table below is for the Microchip SST39SF0{1,2,4}0. The references to pin numbers on the RAM chip correspond to those on the AS6C2008, and may differ if you are using a different RAM chip.

To test, you can temporarily wire the ROM's ce# and oe# low (make sure the RAM chip isn't also driving the data bus, e.g. by removing it or temporarily wiring its ce# high). This causes the video circuit to read from ROM. The displayed image should look like some random noise, some white blocks (corresponding to the memory value $ff), and part of the display should show the machine's character set. If you power the machine off and power it back on, you should see the same pixels as before. After testing, undo the temporary wiring.

Consult your CPU's data sheet for the proper wiring. Wiring for the 65C816S is shown below. This assumes the ROM chip pinout of the SST39SF0{1,2,4}0; if your ROM chip is different, adjust the ROM chip pin numbers accordingly.

Note that pins a13, a14, and a15 (pins 23, 24, and 25) connect to the RAM chip rather than to the ROM chip, because we don't use those address lines when addressing ROM.

When using the 65C02S, pin 3 is an output and should be left unconnected.

The address decoder is a circuit that uses the address on the bus to decide if we're accessing RAM, ROM, or I/O. This will be built using a 74HC10 and the 74HC08 that was added earlier. Wire the 74HC10 like so:

Add the remaining connections on pins 8 through 13 of the 74HC08:

At this point, you should have a computer that can execute boot code from ROM and read from and write to RAM. The memory check should show there are 48 kilobytes of addressable RAM.

So far, addresses $0000..$bfff map to RAM and addresses $e000..$ffff map to ROM. We will use $d000..$dfff for I/O, reserving $c000..$cfff for future use. I/O devices each get an address. We decode those addresses with 74HC138. Wiring is shown below.

The effect of this is that we have I/O addresses 0 through 7 at $d000 through $d007. The rest of the $c000..$dfff range should not be used. The way we built it, it contains copies of I/O addresses 0 through 7, but future versions of the computer may use those addresses for other purposes.

To implement the serial protocol for reading from and writing to cartridges, add a 74HC161 pre-settable counter. Wiring is shown in the table below.

To receive bits from the cartridge wire a 74HC299 universal shift register like this:

Next, add the wiring for the cartridge. The cartridge is a DIP8 with the following pinout:

At this point, booting the computer without a cartridge inserted should result in a "insert cartridge" diagnostic. Booting the computer with a cartridge inserted should load and run the program on the cartridge.

The keyboard works by selecting a row by writing to an I/O register, then reading which columns are active in that row from another I/O register. We implement the row register using a 74HC574 flip-flop, wired as show below:

Here is the wiring for the keyboard column buffer, a 74HC541:

There are two possibilities for connecting the keyboard row register and keyboard column buffer to an actual keyboard. The recommended way is to use a PS/2 keyboard. Alternatively, you can make your own keyboard. Both of these options are described in more detail in the keyboard design document.

Once the keyboard is connected, the computer should be able to detect key presses. You can check this with the testkeys program from the source code repository.

If you have made it this far, congratulations! You have built a working microcomputer.