New project!

So, the z80 system 2 project being on hold until i get a functioning EPROM burner, I've moved forward on another project: The COSMAC ELF.
Though I've made some hardware mods, it is functionally equivalent of the original ELF. My mods include: 

    - Changing the HEX display to binary LED's; way cheaper.
This mod was actually suggested in the original article.

          - Changed the two 4 bit 2101 RAM's for eight 1 bit 2102 ones.
I had them lying around and besides the "width" they're very similar. Furthermore, they're 1977 vintage - adds something to the design.

    - Sprung for another layout, not wirewrap 
Once again, I'm out of wrap wire, and I kinda wanted it to have more of a Altair 8800 / MIPS 8080 kinda look.

Here it is:

The 8 chips with dual round indents are the RAM.

I have redrawn the schematic into a more reader friendly form than the original, spreading it over 6 pages:

1) CPU and clock

2A) Original RAM

2B) My RAM

3) I/O logic

4) Display

5) Input

6) CPU control

Makes it much easier to debug and alter.

Anyway, so far, I've wired the processor control and power.

Buses are to come.

Diode matrix ROM for the Z80, or: How a silly, not-so optimized idea became a main design choice.

Ok, so the phase one hardware design for the z80 system B is almost done. Even started on expanding, but I would like to have it running first. But alas: having no EPROM's, and no burner for them, i had to think of something for a complete hardware test. So i decided to code three small program snips into a diode matrix ROM for it.

What a beauty! I've expanded the design (see last post) for 32 bytes, using 2 74154 4-16 decoders, and then feeding the lower 4 addresses into those. the next two addresses are fed to a 2-4 decoder, whose 1 and 2 output enables either chip 1 or 2.
The design of the diode matrix itself was a bit tricky. Most designs needs either multiple boards, or 3d arrays of wires, but eventually, i landed on having each trace (32 of them) for each line run all the length of the left half of the board. then, soldering tin/copper wire across the top of the board, and connecting those to the data lines, with pull ups. the result is rather neat, in its own right.
The bytes are read upwards, meaning that A0 is the lowest row, and so on. A diode indicates a 0, while a missing diode is 1. This is stupid, in terms of saving diodes, since 00 is used more often than FF, but yeah. Still needs some bytes, though, i ran out of diodes.

It should be able to mimic a 2716, or any device, really. I may need a tri-state buffer on DATA bus, and have the gate tied to /CS, to keep the bus floating from the pull ups. We'll see.

Once again, the sample programs are some counters and stuff i found on Donn Stewart's z80 page. I still haven't gotten around programming yet.

A ROM substitute / development tool

So, I have run into the problem of needed programmed devices for my computer projects. A CPU cannot (mostly) start proper operation without some lines of code. Thus raising the problem: how to test your system without a ROM? Well, i was reading up on the 74154 IC. It's a 4 to 16 line decoder. So i got the idea, of making a diode prom with it, using four address lines, eight data lines, and dip switches with diodes. The solution looks like this:

An address is entered on the An to An+3 (you can use whichever four addresses the system reads first, it varies with processor) and then, the two chip select and output enable (they're not called that on the 154, i've made the pinout compatible with the 2716), connected as well as the data lines, and then on the 16 x 8 dip switches, you can enter the programs or routines you want. 16 bytes seems infinitely small, but plenty of room for some test, and a HLT or so. a counter maybe. The 74ls240 is just an 8 bit inverting tru state buffer. You might need to connect the /G lines which disables output to /READ. 

Note: This is kinda WIP, i haven't tested or even built this yet, so I'm just throwing it out here for the interested.

EUREKA! - HARDWARE HELLO WORLD!

And thus, without any bugs (so far), the V.1 hardware of the Z80 SYSTEM B is complete.

Ain't that pretty? I have no idea what it's doing, though, it's clearly doing something, and at one point, it read data from port 0, and as you see, it displays something on ports as well. There is no system ROM, so I'm guessing it must be random data stored in the RAM... Anyway the hardware is behaving as expected, so all good so far. Now; for the ROM..

And as a side note: step 2 hardware includes qwerty keyboard and LCD from a early 80's electronic typewriter.

Z80 System B update

So, the only thing lacking hardwarewise on the Z80 system I'm building, is the I/O. Once more, I was very inspired by Donn Stewarts z80 project in my port control logic, though I've made a connector for an external "terminal".

As you see, the "terminal" is really just two ports of LEDS as output and slide switches as input. The cable goes to a 40 pin DIL ribbon connector and socket, to port select and latching, etc.

This is the interface board, using the 74LS139 as address decoder/port selector, and 74LS244 for input buffers, 74LS373 for display latches. Still needs wiring.

And Wouldn't you know: The board cracked! when i was scoring the rectangular cutouts for the switches! The pcb material were.. not good; had a consistency as wet crackers, and flaked like slate, meaning when it cracked (the entire bottom right quarter) it sliced  the palm of my hand right up! but i was able to fix it (the board, that is; the hand takes care of itself) by means of screwing on a little piece of pcb on the underside, and solder some of the traces back. Holds quite well. 

Historic PROM burner: The DATAIO model IX

So, i bought this some time ago, a really interesting artifact of computer/digital electronics history.

It is, as far as my research go, nothing less than the worlds first microprocessor controlled PROM burner!

Yup, that's it. Pretty good condition, except for one missing button cover on the EDIT. It can check memory, copy it, browse through addresses, and many other functions. It has a parallel Dsub25 connector on the back, for "remote operation" - whether that means having "slave" programmers for multiple chips, or the unit being able to be controlled by other systems. I haven't found ANY documentation on this; no manual, nothing. the only reference to it is a note on DATA IO's website, under a company history timeline.

On the same timeline, they state that model 19 is the first microprocessor controlled burner (with MC6800) - That is wrong, since this model is earlier, and IS controlled by a 6800, making THIS the first. Though, whether it's the worlds first or the company's, I really haven't the foggiest.

THE GUTS

The case is in fiberglass, and split color blue/white, and is mounted on a 8 mm aluminum bottom plate - really adds some weight.

The computer part, which is what we want, is mounted in a little rack system, with a backplane bus of chained card-edge connectors on ribbon cable. There are 4 boards, with those lovely "ears" for releasing them from the rack.

************************THE PROCESSOR BOARD************************

If that ain't retro, I don't know what is! The memory is shared over 4 chips - 2x 2708 1K EPROMs, the white ceramic with gold windowframe/legs! i had to cover them, i were afraid the flash of the camera could damage the memory, so the windows are covered with masking tape. The plastic DIP24 with the sticker must be system ROM, and the MC6810 is the typical RAM to go with the MC6800. This RAM, is probably system RAM, there must be a reason why the RAM is split on two boards - more on that later. The shiny can is the MC6871A - an oscillator / two phase clock for the 6800. Not much else, a little logic and some jumpers. Notice how the address range of the memory is labeled in the silk screen: C600-C7FF and so on. That's neat!

************************MEMORY BOARD************************ 

 This is the RAM board. Little more than 2 AM9131ADC 1024x4 SRAM chips - yes, Advanced Micro Devices, AMD. Apparently, This can be expanded, by the two empty sockets. The RAM IC's is in the purple/grey/gold packages - same as the 6800 itself. I believe this RAM is for holding the PROM code in memory.

************************ I/O ************************

The I/O is again, as far as i can tell, very much standard 6800 peripheral stuff:

The 24 pin DIP package is the MC6850 ACIA Asynchronous Communications Interface Adapter, acting as an UART. The 40 pin package is the MC6821 peripherals adapter, driving, by the looks of the bus, the header connector top left, which goes to the front panel. The smaller second card edge connector (right) goes to the DSUB 25 connector. And a baud rate switch for the ACIA - what would happen if you activated more than one?

The main programming cards and IC sockets are connected directly to the main system bus, and consists of a set of two chip specific cards: A digital, dealing with timing and such, and an analog, setting voltages. I have yet to find any references as to what PROM my system is set up for, but changing chip for this model of burner must be quite a challenge. The analog board also needed calibration.

There's much more, so I'll probably do a follow up, but this is a brief description (ha. BRIEF) of the microprocessor/computer based parts.     

Burning EPROMS the stupid way

So I'm reaching a point where I'll need to work on my ROM. Step one involves little more than some tests and the ability to punch in programs via the input ports. The system ROM is a 2716 EPROM, because i think it's neat because it's pin compatible with my RAM, so i can reuse the board later on. I found my EPROM burner, and wept. I completely forgot, it works, but it is.. not my fines piece of DIY gear. ADDR and DATA is set with a sharp pencil and DIP-switches, and binary data readout on the little floating board.

The only thing even remotely nice about it is the genuine 3M TEXTOOL socket, (not installed on the pic).

Since I'm only at 60-100 bytes at the moment, this abomination is adequate, but i really need to make a more optimized one. With HEX rotary switches, 7seg readouts, and "jump to next address" button.

Z80 computer update

It ALMOST lives. I'm currently working on the IO interface, which is just some latches and buffer logic with two ports of 8 LEDS and 8 switches. This "terminal" is connected via rainbow ribbon to a socket on the IO board:

The board is yet to be wired, which will be done in the style of the memory board.

The system as of writing looks like this:

The card labeled "memory card" is the memory card, and likewise with the others. You probably guessed that, though. I haven't made/bought the PSU yet, so it is powered by a variable psu, adjusted with a DMM. The ribbon is supposed to go to an angled front plate.

Memory circuit wired

This is the memory card for my Z80 system. It contains a single 8x2k SRAM, the 6116-2, one of my favorite SRAM's, because its name is a palindrome. A 2716 EPROM of same size (and pin compatible, by the way) is used as system ROM. Address decoding for chip select with a 74139. Memory decoding entirely after Donn Stewart's Z80 computer. A more refined point-to-point wiring technique than with the indicator card, and i think it's really neat! Maybe even more so than wire-wrap. 

Using the same wire to make little ties for the wire bundles. 

For this method, start by wiring power, then control logic, and THEN DATA and ADDRESS buses, as you see, they are the ones who takes up space. Make sure that the wires are approximately the right length to be routed, and then after soldering of a bundle, begin "neating" with wire ties, either free floating or though holes in the PCB. excess length can be huddled up at one end (here, at the connector).  

Some tips for starting a microcomputer project

When setting out to build a microcomputer, especially for a first computer project, there are a lot of unknowns. There's a lot of project schematics out there, some more advanced than others, and a lot of them seems like just a schematic with no notes attached. 

Since none of my projects are in any state near "complete", this is simply some of the points I've noticed so far. 

 - Decide on a processor  
You'll probably need to base your computer around a microprocessor. Wiring your own is an interesting idea, but leagues ahead of most computer hobbyists (assuming they still exist). 

I'd recommend an 8-bit processor, since that's basically all you need, and there's no need adding to the complexity.

Popular ones include the ZILOG Z80, my favorite. It is fairly easy to interface to other hardware, only needs a single phase clock, and the instruction set (for programming) seems rather intuitive to me. The MOS 6502, made famous by the Commodore and Acorn computers is also pretty easy, and has found many applications in DIY computers in the past, though it does need a two phase clock, and the instruction set is a little more confusing ( i MAY be biased on this, if you started learning 6502 assembly, you'd probably feel the same way about the z80's).
The RCA COSMAC 1802 , notably used in the COSMAC ELF DIY computer, is very easy to interface, and RUNS WITHOUT A ROM, which eliminates the need for a device programmer, is very rare, and although classic and awesome, i really wouldn't recommend it for first time builders. The COSMAC ELF articles talk about a video interface on a chip, which is even harder to find. Don't bother, unless you REALLY want to.

 - Learning to program 
You'll need to be able to program your ROM, so you'll need to learn %PROCESSORNAME% assembly. So explained in BASIC:

10 you build a microcomputer to learn assembly, 
20 for which you need a microcomputer 
30 goto 10

See the problem? Yeah, you NEED an actual computer to learn to program (or an emulator, but that's cheating).
You can get decent priced micro's still, use Wikipedia to find which mico's uses your processor. I've learned z80 assembler on a SINCLAIR ZX spectrum +2, which i found at a flea market.

 - READ
You need to find literature on system architecture. many books on this matter were published in the late 70's and the 80's. A lot of electronics can be learned by "monkey see monkey do" but understanding memory interfacing, I/O mapping (and some logic) will help you immensely.

Something else entirely

This is NOT Z80 stuff! This is an artifact of early computing, something i found at a flea market for next to free:

This is a program! It may be hard to recognize, but this is a plugboard from an IBM tabulating machine. You actually connect the processor structure to do different stuff, no microinstructions! - I've yet to understand completely how this works, but nevertheless, this is almost a work of art! It is not made by IBM, but a company called MAC PANEL in Belgium. There was a label on it stating that it is from 1970, so even at that time, it would've been obsolete, these were popular in the late 40's to the 60's. Presumably for the IBM 421 tabulating machine. The little grey plastic boxes are IBM branded hubs, interconnecting up to 3 of the plugs, which by the way, are 4mm banana plugs, though longer and "pointy". The program seems intact, no wires looks to have been tampered with (there's no dust on the edge of holes where plugs has been seated), so perhaps it's still executable!

Definitely a keeper.

The indicator card done

The indicator card made, with a different construction technique, since i wanted to exercise different prototyping methods for digital hardware. Okay, okay; I ran out of wire wrap wire.

Thiss is 26 AWG wire, thicker than W-W. wire, but not much. Still so thin the insulation goes through the standard PCB holes. gives a good deal of strain relief, and allows for use as wire binders.

Not much more to tell about this:

    

The processor card

The processor card is basically just a z80 with buffered buses and some functions. A clean reset circuit, and two clocks are on board as well. A manual step clock, and a slow clock ( a couple of Hz). This board, the clock and reset in particular, is inspired by CPUville's homebrew z80 project. This also served as the inspiration for this project. 

This is the card. The red % button is the reset, and the toggle switch is the manual clock. the header matrix to the left of the processor is to select the clock via jumper, so you don't accidentally switch on two clocks at the same time. 

Wire color code: RED: When it was closest. BLUE: When that was closest. Power is mainly routed on the solder side.

Computer base and indicator card!

OK, so these come pretty close one after another, since i'm actually past these steps, but behind on making a blog about it.

Well, the base is made, as mentioned from wood, and the Indicator card is made.

Well this is the indicator /bus display card. It is nothing fancy, just a binary readout of the entire bus. Upper row are DATA (7-0 in reading order), the two rows are ADDRESS(15-0), and the lower six are: Reset, Clock, Memrq, IOrq, RD and WR.

the four chips, 74LS241, is simply set up as noninverting buffers, which has some problems, since most of the control signals are active low. Good thing that won't confuse me when this machine doesn't do a thing!

   

Here be the base of the computer, the two cards installed. The dip socket on the bus card is to access the data bus, since i got the idea of wanting a little plug with pull-down resistors, to put the processor into free-run mode (just counting addresses, executing NOP's). Room is made for binary I/O, PSU, later: QWERTY keyboard, floppy drive, hard drive. 

Z80 microcomputer (SYSTEM B)

This is the progress on my Z80 computer project! I've recently received the needed components, and has begun construction.

The idea is, to make a eurocard (that's a PCB standard size) and backplane based microcomputer, which can be operated as simply as possible, but that also will allow for infinite expansions. 

Phase 1 consists on little more than a buffered CPU card with clock, and a bus display card, showing the logic level of the address and data bus as well as some control bus signals.

The "enclosure" is made of wood, to give that 70's homebrew feel, and the plan is not to use any component that didn't exist in the early to mid-80's.

Above can be seen the first card to be plugged into the backplane. The connectors are DIN 41617 connectors, because i like how the pins match up with regular stripboard. The card pcb's is IC-island types, FR4 material. The 4 20-pin packages are simply buffers for various busses.

I use a mix of prototyping techniques, here it's wire-wrap, though i use standard 0.1-inch header pins as wrap posts. This has two major advantages, 1) The card becomes very low-profile, with the height being about 1,5 cm instead of the almost 4 with ordinary wrap sockets. 2) each socket costs a fraction of a wire-wrap one. The connection might not be as good, though. I've yet to experience problems with that.