Arduino based parallel EEPROM programmer

For my upcoming 6502 CPU based homebrew computer project I need the possibility to program EPROMs and EEPROMs. These chips are parallel memory chips with a 13 to 15 bit wide address bus and a 8 bit databus. Additionally some control lines like /WRITE, /OUTPUT and /ENABLE need to be connected to the EEPROMs.

You can buy a programmer, but they are too expensive for just a simple project. And self made is always much more fun. The whole thing is based on an Arduino Nano, because of the small form factor, the good price and (very important) and already available serial connection via USB.

For 15 address lines, 8 data lines and 3 control lines I need 26 I/O pins, too much for the Nano. But the address lines are only needed as output, so I decided to use 2 74HC595 shift registers to reduce the needed I/O pins from 15 to 3.

The only internal PORT of the Atmeg328 on the Nano that can be completely used with 8 data bits is PORTD (digital Pins 0 to 7). But unfortunately I need pin 0 and 1 for RX/TX, making it a little bit harder to set 8 data bits for the EEPROM.

Here is a picture of the prototype with the Nano V3, 2 74HC595 and a ZIF socket for the EEPROM.

The Nano is stacked on a 600mil DIP socket, that I cut down to 30 pins. So the Nano can be removed and used for other projects.

The "firmware" on the Nano excepts and delivers data through a serial connection to the host computer, using a simple protocol for sending and reading data from and to the EEPROM.

I also wrote a small Java GUI that interacts with my little programmer. At the moment the following features are implemented:

Current Arduino firmware features are:

  • Communication at 57600 baud
  • Read content of EEPROM as hex data
  • Read content of EEPROM as binary data
  • Write data binary to EEPROM
  • Provide "Version String" with supported commands

Current Java Client Features:

  • Load ROM-Files (max 32k) into the application
  • select COM-Port
  • select EEPROM type (8k,16k,32k) (has influence on the number of bytes read/written)
  • burn loaded ROM image to EEPROM
  • load data from EEPROM binary to internal buffer
  • read hex data from EEPROM (directly written to console window for testing)
  • count number of different bytes between internal rom image and data on EEPROM
  • clear EEPROM with 0x00
  • get the Version Sting from the MEEPROMMER

Features to come:

  • Import and Export data in Intel-HEX format
  • write only parts of the eeprom instead of the whole chip (from address to address)
  • split large ROM images for burning several small EEPROMS with the complete data
  • doing "differential" writes (writing only bytes that are different between ROM image and EEPROM)

On the Arduino side I use an 1024 byte buffer to store the data bytes before they are written to the eeprom. An 8k EEPROM can be written within 8 seconds. Fairly fast enough to meet my requirements for a good development life-cycle for the 6502 firmware that should be stored on the EEPROMS.

Here's a short collection of screenshots from the GUI:

GUI after start, selecting different EEPROM types, getting Version String, clearing EEPROM and loading a 8k ROM image:

GUI after making a diff between the cleared EEPROM and the loaded 8k ROM image, showing all 8192 bytes as different:

GUI after writing the ROM image to the EEPROM and then making a diff again.

Now showing that all bytes are equal:

The plan is to build a PCB at the end with some additional features

  • MAX232 and DSUB9 connector for RS232 communication without the Arduino USB
  • DIP-switches / jumpers for setting the speed of the serial connection
  • 20 pin - port with all data, address, RX/TX and control lines for direct access with any other hardware
  • external 5V and GND powersupply lines (also on the 20-pin port)

Beside the Java GUI Tool another guy from the forum is working on python based command line tools that can be used with the programmer.

Are you willing to release the Arduino source? I'm working on a Atmega32 based programmer for custom chips in my truck lol.

The complete project is available as open source. You can find the actual files for the firmware, the simple java client and the current circuit schema at my website:

Currently only in german, but after our holidays I will add a english version.

Hi, can this be used to program a PM25LD010C-SCE chip? This chip is from a computer graphics card I broke by flashing with a bad rom. Thanks

No, your chip is a serial one, that is accessed by an SPI bus. You should be able to connect it through an level shifter to the arduino. (because your chips runs with 3.3V)
The rest is simple "bit banging" following the protocol shown in the datasheet of the chip.

You should be able to reuse my software by adjusting the functions that write the data to the chip.


Ah thanks for the reply Mario. I think that's going to be quite an involved project for me as I don't have any experience in this area.

Very nice work btw =)

thanks for this great piece of work. I built the circuit on a protoboard and have tested it with a 28C64 and with a little bit of re wiring also reading a 27C64. I thought i would add a few tips for those like me who are newbies. They may well be obvious to others but they did trip me up.

When connecting to an UNO R3 you must click on the port in java GUI even if only one is showing, or the software reports no programmer found. This may be blindly obvious, but it wasn't to me .

It's also worth noting that the RXTX software has a readme or install file in the zip / rar . It gives instructions on where to place the files. Without it you may have trouble running the software (win 7 in my case) It's worth having a zip utility to look at the RAR files to see the read me. Just clicking on the RAR didn't work for me.

If using different size or type Eprom - EEprom's be carefull with wiring when using the schema. Some pins have different functions. Pin 1 on the 27c64 is PGM and I tied mine to 5v for the read function.

If there are still PCB's available i would love to get one.

I have built the circuit purely to educate myself. Though my main goal is to modify an old Renix ECU that uses a Bi polar prom 82S147AN. I need to read the old eprom and then modify the old ecu to fit a more modern 28C. So the next work is to get your programmer to read an 82S147 and then to be able to transfer the 4k rom to the 8k one. I am a little unsure of how to do that ?

You are overdoing it.

27xxx can be programmed directly from the parallelport of a PC.

Why did you stick the AVR inbetween?

And how many modern PCs has a parallell-port?

You are overdoing it.

27xxx can be programmed directly from the parallelport of a PC.

Why did you stick the AVR inbetween?

True, didnt think of that :frowning:

If there are still PCB's available i would love to get one.

The first batch I made sold out, I've got a new batch with the revised schematic that includes a boost circuit for higher voltage programming. They're on their way back from China now, should have them by Christmas. Maybe much sooner. I'll post back when I've got them assembled and ready to go. :slight_smile:

I might be interested in a bare PCB as well. I build a shield already and it appears to work (though I haven't had a chance to actually write to the EEPROMS that came in the mail this past week). I have come across one in my bin that requires 12v to write though, so that feature might come in handy.

FWIW: the EEPROMS I got were PH29EE010 chips, I tested the one I had (comparing pinout and reading it) before ordering a bunch more. Seems to be compatible; I'll edit or post back if writing is a problem, but I don't see why it would be.

Keep us posted; and thanks for all the great work.

Hi, i'm trying to write a dreamcast bios over a 29LV160TMC-90, do you think that i can do it wuth this programmer?


Kind of resurrecting an old thread here.. I understand the need for the shift registers to hold the address, but I've gone the MEGA2560 route, using the high data ports (22-53) as data (22-29), address (30-49, &h00000 to &hFFFFF, yes, up to 1 solid 8-bit megabyte!) and 4 handshake lines (pgm, wp, ce, oe). Basing the idea off someone else's project of reading old EPROMs (the old 27xxx's).. (NY-Resistor 'stick a Straw in it' project)

Yes, the parallel port did carry a +V, but I rarely think it was +12V (which was used by a lot of CMOS EPROMs, Some required upwards of +21-23V PGMv, and the USB -> Centronics dongles never produced that kind of voltage!)

In answer to Scarrizo's question about the 29LV160TMC-90 chips, (sorry, didn't read this til almost 2 years later) Since they're technically more flash-RAM more than EEPROM, most definitely! You would have to add an additional shift registers, as well if you intended to write 16-bit words instead of bytes, a 2ndary 8-bit latch to hold the upper & lower bytes... Otherwise, I'd stick to a 8-bit data bus, and build on the address bus shift registers, and keep the BYTE line low to prevent the chip from reading the upper data bus (Q8-Q15)

Very nice project, but I have one question, where do you get your EEPROM chips? There everywhere online but I need DIP packages, not SMD. Any help is appreciated.

Very nice project, but I have one question, where do you get your EEPROM chips? There everywhere online but I need DIP packages, not SMD. Any help is appreciated.

Hi mkl!! This is great! I am also willing to do something with a z80. Apart from your homepage, have you any profile in or a place like that. I would like to "follow you". Thank you!



I am very interested in this design but the page link always shows as 'under maintenance'.
Is there an active link available?

In the meantime I have designed (modified/borrowed from other's) a circuit and PCB using an Arduino Uno and am proceeding with that.

The read works OK and write works quickly enough for page operation but I'm only working with a RAM chip so far.

To do: Interface to on-board serial EEPROM. PC software to control it better than serial monitor.


Webarchive has some snapshot

Unfortunately it didn't archived the sketch and the java program...

Many thanks for your reply and link.

The circuit shown for the burner is similar to mine but I am using hardware SPI to drive the shift registers and my data bus is split differently.
(Was based on GitHub - beneater/eeprom-programmer: Arduino EEPROM programmer)

The Java program would have been most useful but unfortunately that is one of the things not archived as you say. (See below though)

I have now done the Serial EEPROM interface (I2C) and updated the PCB design. (The DIP socket pin holes were too small for a ZIF socket and a few other corrections)

Next is to write a PC side program and modify the Arduino side to play nice with it.

Thanks again


PS: Digging around in the link and doing a search on an address for 'MEEPROMMER simple jBURN'
led to
https://github.comMEEPROMMER simple jBURN/mkeller0815/MEEPROMMER/tree/master/SimpleJBurn/bin.

It may be that backing up the tree from there I can get the Java part and the rest of the project too.
(GitHub - mkeller0815/MEEPROMMER: EEPROM / EPROM programmer based on Arduino hardware)

All is not lost!! (I hope)