EEPROM (E²PROM) is very easy to work with, since it just acts like a block of SRAM. No special voltages, no mystical voodoo or anything.

I designed this EEPROM programmer after I came to the conclusion that I was too broke to buy a real one, and that even if I wasn't too broke, they're a complete rip off. Most of them run $200 for something that can only be maybe an order of magnitude more complex than my $5 programmer.

In my design, two 74x164s provide the address lines to the EEPROM, while one 74x299 universal shift register provides both read and write access to the data lines of the EEPROM. The parallel port is used to control all the 74-series components and the EEPROM.

Before you get the schematics, please note that they are in the public domain, and are provided without warranty, and I disclaim all responsbility for everything that happens to anything. Be warned that if you wire it up wrong, you could destroy your computer's parallel port, or maybe even more. (Especially if you've got a laptop.) Notably, this circuit doesn't work with my laptop, since its parallel port seems to provide some odd (CMOS-esque) voltages. It didn't blow my laptop up, though, for what its worth.

A PNG image and Xfig figure of the schematics are available. (I use the Fairchild Semiconductor naming scheme for the pins, by the way). Pin numbers are provided since all of these parts are heavily standardized. Power and ground aren't shown. Two pictures of the programmer are available (Top view and bottom view) I convinently color coded all the wiring. :) V_cc is red, ground is black, address lines are green, data lines are blue, clock and reset are white, and random signalling is yellow.

Note that the schematic doesn't address where you get your power from. I used some right-angle header pins that work nicely with the floppy drive power connector on a PC power supply. I added an LED for a power light.

My C code isn't very pretty. There is also a bunch of cruft in there from testing and attempts at strange things. (Like support for the page-write mode of the particular EEPROM I was using.)

To allow me to provide reasonable sleep times for signals (clock pulses and whatnot) I make use of the nanosleep() system call. The problem with nanosleep is that it requires soft realtime priority levels to actually get anything approaching nanosecond timing accuracy. So, my programming program uses soft realtime priority for itself. This requires root permissions, but, it already requires root to access the parallel port. During the write, the only times where the programming program gives up the CPU is when it is waiting for the EEPROM write cycle to complete (minimum of 5ms, but the Linux scheduler has to give something else a minimum 10ms, so we always wait that long).

To do: I'd like to make a comparable simple PIC programmer design, and then a new EEPROM programmer that requires a simple PIC. Loading 256 kilobits via the parallel port takes an awfully long time. The PIC would be able to integrate a UART for serial communications. (Potentially even USB.)