EEPROM Programmer

I really need an eeprom programmer, but their quite expensive and I have heard some break within just a couple of weeks! Anyway I have had my arduino uno for a while and havn't found a project for it yet so I want to try making my own eeprom programmer with it.

I already know that it sends the program on the PC to one of the chips on the board via USB, where it is programed on like when copying a file to a memory card, so I know it is capable of programming onto chips.

So my question is this, would it be posible to somehow attach a chip to the bread board with a socket or something and get it to program a certain file to that?

If so, would it need to use the USB thats already on there to get the file or would that not be possible, so it would need some sort of other way, like attaching an SD card via this method: (Scroll down to the second picture and the table)

Thanks in advance.

What EEPROM chip? Any part numbers? The UNO should be able to do it with ease. I've worked with 24LC256 series. Not hard at all.

EePrOm: I really need an eeprom programmer

Hmmm---A Problem looking for a Solution.

EePrOm: ...I have had my arduino uno for a while and hav(e)n't found a project for it yet

Ahhh---A Solution looking for a Problem!

EePrOm: so I want to try making my own eeprom programmer with it.

OK---Now we're talking: A proposal for a marriage of Problem and Solution!

EePrOmwould: would it be po(s)sible to somehow attach a chip to the bread board with a socket or something and get it to program a certain file to that?

Before I burn a bunch of bandwidth giving information that you might not need, maybe you can give us a few details on what, exactly you have in mind.

What kind of EEPROM? The I2C serial ones like 24C04, 24C256, or what? Do you want to program small ones (up to 24C16) or larger ones (24C32 or larger)? The programming sequence is slightly different.

Are the EEPROMS capable of operating from +5 Volts? (There are low-voltage versions of some of them that won't tolerate +5 Volts. They can still be programmed from an Arduino UNO with a slight modification of the Wire library and no additional components.)

Are the EEPROMS in a DIP-8 package? If they are DIPs, you can plug them directly on your solderless breadboard (or you can get a socket if it makes you feel better). If they re not in DIPs, you will have to work out some kind of transition board that takes a SOIC socket (or whatever package you want to accommodate).


You don't need a separate processor on the solderless breadboard. You will need a couple of resistors a capacitor and some jumpers to connect power, ground and a couple of data signals from the Arduino Uno to the solderless breadboard.

If you are going to store the file (binary or Intel Hex, or, perhaps Motorola S-Record) on SD, you will (obviously) need an SD card interface to the Arduino. I have used Adafruit Data Logger Shield, the Wave Shield, and various of my own designs that are topologically similar to them. And of course you need for your Arduino software to read bytes or lines from the data file to be able to send them to the EEPROM.

It is also possible to write a program on the PC (Processing language or Python or C/C++ or whatever) that can transfer the file a "chunk" at a time over the USB/Serial port to the Arduino board so that the Uno doesn't need the SD card interface to do the deed. (Of course, that requires a complementary program on the Arduino that can accept the chunks and program groups of bytes. A little more "interesting," but eliminates the need for extra hardware.) Note that the program on the PC doesn't need to know about USB or do any USB-Stuff. The Arduino just appears as a serial port object to the PC.

Bottom line: It is doable in several forms that I have suggested. (And, undoubtedly, in a lot of forms that haven't even occurred to me.)

So: Maybe you can give us a few more details on what you have in mind. he cool (really cool) thing about doing it this way is that you can start with simple software (and/or simple hardware) and build a complete productized widget a little at a time. If you change your mind during development, or you want to enhance the functionality by taking another approach, nothing is thrown away. (You can recycle everything you learn about software, right? And there is precious little hardware in a project like this that can't be used for other things, later on down the line...)



Thanks for the info everyone! (And the spelling corrections)

I guess I wasn't specific enough for you, I want it to program onto a 32-pin flash chip, (any from the following list I don't really mind:)


And I don't want it to program C, C++ or C# code, I want it to store normal files like a txt or zip, like a memory card.

Sorry, I am unsure of the volts it can handle.

And finally, I will go with the SD card idea thanks, so that then I can put on a micro sd adapter so that I wont need to solder the pins on the actual micro sd, just the adapter which I don't really need anyway. And also it will be portable that way as well, XD lol

I want it to store normal files like a txt or zip, like a memory card.

That puts a whole lot of other stuff into the mix. To do this you also need a file operating system to be on the device as well as the actual data.

Flash memory is quite easy to program, just get hold of the data sheet and see what you have to flip up and down to get it to program. These are parallel devices and will need a port expander to be put on the arduino to get sufficient pins.

It might also be possible to program it using JTAG again the data sheet should tell you.

If it is a Flash memory then why did you entitle the topic EEPROM programmer these are totally different devices.

EePrOm: ...I guess I wasn't specific enough for you

Apparently not. The title that you gave the thread is "EEPROM Programmer" but those chips are not EEPROMs, they are Flash memory devices. (Nowadays, we usually call them "NOR Flash" to distinguish them from those new-fangled upstart "NAND Flash" devices.)

Now you are telling us:

EePrOm: I want it to program onto a 32-pin flash chip, . . . ATMEL AT49F040 . . Sorry, I am unsure of the volts it can handle.

Ummm--- You are proposing a project and you haven't even read the data sheet(s)?????

Oh, well... It's an interesting enough project that I'll take it a little farther.

First things first: The connections.

If you are working with a DIP package you can plug it into a solderless breadboard, or get a socket and use it. (A ZIF socket would be the "only way to go" if you are going to make this project a "product," but before committing to that, you can breadboard it. Use some bypass capacitors on the device. For starters, confirm (by reading the specific data sheet for your specific device) that it will work with a 5 Volt supply. (Some older types of similar devices require higher voltages when programming.)

If you expect to program TSOP devices you will need an adapter board and a (rather pricey) ZIF socket. For PLCC packages, you might be able to find a socket that converts to wire-wrap pins or thru-hole PC board pins.

So: you need something like 19 output pins for address, three output pins for control, and eight data pins that are sometimes outputs and sometimes inputs.

If this is an Arduino with a '328 processor, there aren't enough pins. If it is a Mega board (or anything using a processor with enough I/O pins), I would just connect them directly.

Anyhow, for an Arduino with not so many pins:

I would use a shift register to hold the address bits. (There is lots and lots of information on the Arduino forum and playground about how to do this.)

I would use eight Arduino pins (maybe 2-9) for data and three pins (maybe 10-13) for the control signals.

Now the fun part: The software. Now if you are just going to program the device by writing some bytes, see the data sheet for the sequence.

I'll summarize: The "default" mode goes like this: Make Chip Select and Output enable go low and make Write Enable go high. Apply an address. The data byte from that address will be presented for your reading pleasure. Give it a new address and it gives you some new data.

To do more interesting things, you have to give it a certain Magical Mystery sequence of Address/Data/Control settings to tell the device that you are going to be writing a byte or erasing a sector. Stuff like that. Each data sheet has flow diagrams that you can use to build your software. I have done this a time or three. The "driver" software that manufacturers sometimes make available may be appropriate for PC-based applications, but for Arduino stuff, just follow the flow charts in the data sheet(s). The devices in the family that you refer to are "pretty much the same," but after you get the first one working, if you want to try a different one (from a different manufacturer) read the new data sheet too. Really. Read the data sheet.

Note that there are various versions of the devices with somewhat different characteristics. The basic structure of a program to write data to these devices may have certain special branches, depending on the exact device.

Some have "boot block" sectors that have different rules for writing. The Boot Block sectors have different protection bits so that "ordinary" programs can't accidentally erase them with a "normal" program sequence. The sector lengths are usually different from "normal" sectors. Stuff like that. Some devices are available in different versions. with some having the boot block at the high end of the memory space, and other versions having it at the low end.

So, here's the drill:

Pick a device that you want to start with. Read the data sheet. Really. Hook it up. Try reading it. Unprogrammed devices will read 0xff for all bytes, so it's possible to fool your self if you do it wrong. (Leaving CS or OE high for example will show you all ones, since you will have pullups on the data lines.) If you have a 'scope or other test equipment that can read the address lines, make sure the shift register (and associated software) are working properly.

Try to program some byte of your choosing at an address of your choosing. Follow the flow chart in the data sheet.

Try to read the byte back.

If there are questions, you can ask. But be specific. Describe your hardware setup and show the entire program that you are trying to get working.

Maybe someone can help.

If you are still interested, I think that's enough to get you started on the basics of Flash memory reading and writing. See Footnote:



Footnote: But (and this is a Big But): What are you going to do with these things after you program them?I If you are going to write files (of any kind), then you have to keep track of where they are located. That implies some kind of "directory" that associates a block of memory with a particular file. The directory contains (at least) the "name' of the file, the starting address in Flash and the length of the file.

People typically devote a certain amount of device memory to this directory (fixed length and at a fixed location), and each time they want to write a file, call a function that looks for an unused block of the desired length. The program enter the name and starting address and length in the directory.

Then, to read a file, you would tell the program what the name is and the program would look in the directory to find out where it is.

The big deal is, again, what are you going to do with the data from the file?

For example: If the file consists of 16-bit samples of a monaural .WAV file, you could get 16-bit values from successive bytes in Flash and feed the bytes to a D/A converter.

Stuff like that.

Ok, I am really new to this, I just want to find out what I need for device that can program a single file, (SNES ROM) onto any of those flashchips I previously mentioned, so I can nip down to the store and buy those components and set it up so I can use it like from about 1-5 times.

I am sorry, I just didn't know what the difference was so just called it eeprom.

Really, what I am trying to aim for is to program a couple of these: But ensted of the socket, put it in the inside of the cart.

If it all goes well I will try and do it with my old gameboy using this tutorial:

I need this because SNES flashcarts are over $100! And I only really want a couple games on it anyway. Maby I could program a menu for it and make it take SD cards?

It seems really complicated now everything has been fully explained, but I still want to go for it!

Anyway thanks again, hopefully I am more clear now.

So what would I need to make something to program one of those chips?

I'm really stuck! And if it helps, I have decided to go with an NEC D43256AGX, as I know for sure that it supports 5 volts.

So are there any tutorials at all?

Also I am using an uno, not mega.

EePrOm: I'm really stuck!...

Speaking for myself: So am I!

The NEC uPD43256AGX is RAM (Volatile read/write memory. It loses its mind when power is removed.) It's not something that you build a "programmer" for.

Your most recent post before that was concerning an EPROM device. (Not the same as EEPROM; not the same as Flash memory.) EPROMs are easier to program than EEPROMs, and much easier to program than the "NOR" Flash chips that I thought you were talking about after your response to my first ramblings.

But---and this is important---where are you going to get the bits that you want to write into the new device?

If you are just going to copy one device to the other, and they are the same type of device (both EPROMs, for example), you could make a test fixture that lets them share address, data, write-enable and output-enable pins but with different chip-enable pins. Then you could read a few bytes at a time (limited by the memory in the Arduino CPU) and write those bytes to the other device. You would have a way to tell the Arduino where in memory to start (maybe address zero) and how many bytes to copy. That could be done easily from a serial terminal.


You could have an Arduino sketch that communicates through the serial port with a program on the PC (Python, Processing, C/C++, whatever...). The program on the PC gives a command (or series of commands) to the Arduino sketch that reads all of one device and stores the bytes in a file on the PC. Then another program on the PC (or a branch in the reading program) could communicate with the Arduino so that the program on the PC tells the Arduino (same sketch or a new sketch that just writes the stuff) to write to the EPROM and then feeds a few bytes at a time to the Arduino. The program on the Arduino could respond to a few simple commands (you design them) to set an address, read a byte, write a byte, etc... The program on the PC would ask the user for a file name and EPROM starting address and number of bytes to read or write.



Footnote: You asked about tutorials.

Tutorials about what? I wasted some fair amount of your time and board bandwidth talking about EEPROMs (since that was the title that you gave the thread), and there are some examples using I2C EEPROMs.

I haven't seen anything about EPROM programmers (if that's what you really need---I'm not sure where you are going with this), but there may be some out there. One issue is: Not enough ATmega328 pins for all of those address bits, so you will probably use a shift register to hold the address bits. There are numerous examples of this.

The actual control sequence to read and write bytes to EPROMs is quite simple, but the big deal (and I hate to repeat myself) is: Where are the data coming from? A file on the PC? (What kind of file? How was it created?) Or another, similar, device that you are copying? Or what?

The other big question is: How are you going to use the device that you programmed? Plug it into/onto some kind of game cartridge? Or what?

Ok, I'm really sorry. I have researched what I am doing now, and now feel prapared enough to try this.

What I actually need is an EPROM writer, not E[u]E[/u]PROM [u]programmer[/u]. I need it to take:

27C801-120 8MBit UV-Erasable Eproms

I am using an arduino uno, not mega.

I am using an arduino uno

Then you will need some sort of port expander so that you can set the right logic levels on all the pins. You will need a ZIF socket for the EPROM and you also need a 12V supply and some sort of transistor to switch that supply. Then you need a program on the PC side to feed the bytes to the arduino and do the handshaking so you don't feed them it too fast. So all in all quite a project for an absolute beginner. As not many people here are into ripping off games consoles then I would be surprised if anyone has a step by step guide to doing this.

I would be surprised if anyone has a step by step guide to doing this.

No, I found a guide and know exactly what to do now, the only thing I need help with is building the EPROM programmer. So are there any tutorials for that?

I already have these things:

Arduino uno, A slight knolage of what I need to do, A zif socket, An EPROM.

Could you be a bit more specific than:

some sort of transistor



Let's go back to the first part of the first sentence in your first post ...

I really need an eeprom programmer...

This is where you threw us off track because what you really need is a prom programmer. An 'e' in the prefix refers to the fact that after the device has been programmed it is then possible to erase the device so that it can be programmed again. An 'ee' in the prefix means that the device can be (quickly) electrically erased as opposed to using a lengthy process involving an ultraviolet light source. The white pieces of paper on your devices cover the quartz window through which you would shine the ultraviolet light to erase your uv-erasable eproms.

You should probably be looking for a lawyer as well.


Could you be a bit more specific

Well any sort, there are thousands to choose from.
A 2N2222 would do.

Ok, the only other thing you have mentioned is a:

port expander

Once again, I am quite new, so please expand on what that is if possible, and name a specific type.

Oh yeah, and then the 12volt supply. Is that just the wire you plug into the arduino that leads to the mains or the battery? Because I have one of those as well.

Here are some links that could be useful:

This is an example of how to create the Address/Data bus that an (e)prom is designed to use:

Some background info on one persons progress using the Arduino to program proms.

Ed also has some articles related to the EPROM programmer in issues of the magazine "Circuit Cellar" April 09, I believe.