Prime Time

…and now, for something completely different. (By different, I mean almost useful!)

The Z80 computer is now busy computing prime numbers! I wrote a straightforward BASIC program, which I then compiled using Oshonsoft‘s Z80 simulator suite of utilities. The resulting assembly program was pretty good, but needed some optimization. (BASIC isn’t really geared towards byte manipulations.) I replaced the crude BASIC mod-and-div output routines I had written with four LD and four OUT instructions. Here is the (probably still really inefficient) assembly code.

Some technical progress, too: Loading complex programs is becoming progressively easier with the addition of a hex editor to my toolkit. Instead of toggling code in a byte at a time from the control panel, I can now load it into a serial EEPROM and plug it into the Virtual ROM peripheral. With a few lines of code (which I also copied to the ROM because I’m lazy), this code can be copied into base memory automagically. All that needs to be toggled in to start is a single, 3-byte JUMP command.

For instance, to bootload the prime-number program into base memory:
* Enter Program mode
* Connect the ROM
* Start the clock running
* Load the following instruction into memory:
0000 C3
0001 00
0002 86
* Hold down RESET, exit Program mode, and release RESET.
– The Z80 will jump to 0x8600, which is a quick routine to load the main primes program (8300:854B) into base memory (0000:034B).
– At the end of this routine, a JUMP command will cause it to halt.
* Perform a RESET to start the prime-number program running.

(I actually started loading the bootloader into base memory — but then realized that it would quickly overwrite itself. A workaround, if you don’t have a bootloader written into ROM, would be to toggle in the bootloader at a higher address than you plan to use for the program, then JUMP to that address — for instance, 0x7000h — from 0x0000h.)

I’m using my ancient HP 1630A logic analyzer to look at the output from the program (POD2 connected to the data lines, L clock connected to ~IORQ); it’s calculated the primes through 113 so far.

I also managed to complete Problem 001 from Project Euler (“What is the sum of all numbers less than 1,000 which are multiplies of three or five?”), using the Z80.

I also realized this weekend that my new Gigabyte GA-EX58 Extreme motherboard doesn’t have any RS232 ports. Such is “progress,” I guess. *sigh* Time for an add-in card. (Do they make PCIe RS232 cards??)

Posted in Coding, Digital, DrACo/Z80, Drexel, EET325 | 2 Comments

…and then there were two. Correction, four.

The EET325 class is wrapping up this week, but not before I got Bill’s prototype Z80 core working with the original protoboard control panel. Not only that, but two of the students (Mike and Austin) have finished, working Z80s. So now there are four of them! Can a Beowulf cluster of Z80s be far behind?

Posted in Digital, DrACo/Z80, Drexel, EET325 | Leave a comment

Single-board at last

To paraphrase Emperor Palpatine…

“And now, witness the power of this fully ARMED and OPERATIONAL … Z80 computer!”

OK, so running at the current 40kHz system clock, it’s got more milliamps than megaflops — but at least it’s running properly on one board (CPU, memory, controls, and LEDs all together.)

More about the milliamps to come: it’s currently drawing over half an amp(!) at 5V — almost all of which is going into keeping the 74LS245s warm. The parts should be in tomorrow to give it a quick “Energy Star” upgrade.

Click the image for a larger version. (The dials on the right are, from top to bottom, address-high-byte, address-low-byte, and data.)

Posted in Digital, DrACo/Z80, Drexel, EET325 | Leave a comment

Z80 computer LED display

The Z80 computer now has its name in lights! (See video; I apologize in advance for the horrible low resolution and mp4 artifacts.)

Dr. Rosen and I got approval to buy an Alpha 215R single-line LED display as a demo for the Z80 computer. While it was on the way, I built a second peripheral for the Z80: a specialized RS232 port that accepts strings and reformats them for output to the LED display. (It’s an interesting challenge to build a peripheral based solely on information from a datasheet, without having the actual device available.)

When I finally got to work with the display on Thursday, the interface actually worked — but various electrical gremlins were causing all sorts of problems, when the Z80, interface, control panel, and sign were all connected. The problems eventually turned out to be mostly due to insufficient voltage — as it turns out, 5.5V (rather hot for TTL circuits) at the power supply ends up being a nice, clean 5.0V to 5.1V at the Z80. Those 40-pin ribbon cables keep finding new ways in which to be a Dumb Idea(tm)…

At any rate, it started running very reliably Friday afternoon. The bad news was that this meant that it was time to start programming it. Writing Z80 code to do a demonstration script isn’t too bad; a bit tedious to enter the strings, but still fun.

Toggling some 200 bytes of machine code in, byte by byte, however, is mind-numbingly boring — even if (like me) you actually enjoy programming in assembler. (Note to self: there has GOT to be some source for knobs for those rotary switches SOMEWHERE!)

The script is running, though. Hopefully it will prove inspiring to the EET325 students. (How many college courses out there lead you through building your own computer, chip by chip and wire by wire?)

Posted in Digital, DrACo/Z80, Drexel, EET325 | Leave a comment