The AT24C provides , bits of serial electrically erasable and programmable. The device. The devices are available in space-saving. In addition, the entire family is available in 5. Pin Configurations. Pin Name.

Author:Mogis Bragul
Language:English (Spanish)
Published (Last):19 July 2008
PDF File Size:7.36 Mb
ePub File Size:6.31 Mb
Price:Free* [*Free Regsitration Required]

Track My Order. Frequently Asked Questions. International Shipping Info. Send Email. Mon-Fri, 9am to 12pm and 1pm to 5pm U. Mountain Time:. Chat With Us. EEPROM , or E lectrically E rasable P rogrammable R ead- O nly M emory, is a type of device that allows you to store small chunks of data and retrieve it later even if the device has been power cycled.

To follow along with this tutorial, you will need the following materials. You may not need everything though depending on what you have. Add it to your cart, read through the guide, and adjust the cart as necessary. Resistors are a good thing, in fact, they're actually crucial in a lot of circuit designs. The only problem seems to be that …. This is your tried and true white solderless breadboard.

It has 2 power buses, 10 columns, and 30 rows - a total of tie i…. This is a USB 2. These are 6" long jumper wires with male connectors on both ends. Use these to jumper from any female header on any board, to…. Before continuing with this guide, we recommend you be somewhat familiar with the concepts in the following tutorials:. That said, if you don't nerd-out on computer history it's probably safe to skip that section.

Read-Only Memory ROM is a type of computer memory which, generally speaking, is only programmed once or very occasionally and then gets read from the rest of the time. This is because it's very slow — or impossible — to write new data to ROM. The trade-off for very slow write times — traditionally — is that it's also non-volatile meaning that the data doesn't go away when power is removed from the device. This makes it ideal for things like firmware which need to be "remembered" by the computer, but never actually change.

This was memory made up of discrete semiconductor diodes placed on a specially organized PCB. This gave way to Mask ROM with the advent of integrated circuits. This meant, however, that you couldn't just move a couple of diodes around with a soldering iron and reprogram it. Mask ROM had to be programmed by the manufacturer and was thereafter not alterable.

Unfortunately, Mask ROM was expensive and took a long time to produce because each new program required a brand new device to be manufactured by a foundry. That meant manufacturers could produce millions of the same unprogrammed device which made it cheaper and more practical. PROM, however, could only be written to once using a high-voltage programming device. After a PROM device was programmed, there was no way to return the device to its unprogrammed state.

A UV Erasable Microcontroller. The window gives it away. This changed in with the invention of EPROM Erasable Programmable ROM which — besides adding another letter to the acronym — brought with it the ability to erase the device and return it to a "blank" state using a strong UV light source.

That's right, you had to shine a bright light on the IC to reprogram it, how cool is that? Well, it turns out it's pretty cool unless you're a developer working on firmware in which case you'd really like to be able to reprogram the device using electrical signals. In most applications the pros outweigh the cons, but you should be aware of them before incorporating EEPROM into your next design.

This has to do with electrons becoming trapped in the transistors that make up the ROM and building up until the charge difference between a "1" and a "0" is unrecognizable. That said, this usually occurs over the course of years although it can be accelerated by heat. In this example, we'll use 4. You could just ground them all, but we'll be wiring them so that we can drop in a higher-capacity device later in the tutorial.

We'll use a breadboard to connect everything together. That's it! Now we can move on to the code. Most of the time when you're using an EEPROM in conjunction with a microcontroller you won't actually need to see all of the contents of the memory at once. You'll just read and write bytes here and there as needed. In this example, however, we're going to write an entire file to EEPROM and then read all of it back off so we can view it on our computer.

This should get us comfortable with the idea of using EEPROM and also give us a feeling for how much data can really fit on a small device. To send and receive files using the example Arduino sketches below, you'll need a terminal program such as TeraTerm. Once you have that downloaded and installed, we can get down to business.

Our example sketch will simply take any byte that comes in over the serial port and write it to the EEPROM, keeping track along the way of how many bytes we've written to memory.

If you imagine all of the bytes in a Kbit EEPROM standing in a line from 0 to — because there are 8 bits to a byte and therefore you can fit bytes on a Kbit EEPROM — then a memory address is the place in line where you would find a particular byte. Because there are possible places in a Kbit EEPROM — and because is the largest number you can encode in one byte — we need to send this address in two bytes.

Because this is how the device expects to receive them, that's all. Writing one byte at a time is fine, but most EEPROM devices have something called a "page write buffer" which allows you to write multiple bytes at a time the same way you would a single byte. We'll be taking advantage of this in our example sketch. The EEPROM uses an internal counter that automatically increases the memory location with each following data byte it receives.

Once a memory address has been sent we can follow it with up to 64 bytes of data. The EEPROM assumes rightly that an address of followed by 10 bytes will record byte 0 at address , byte 1 at address , byte 2 at address , and so on. Walk through the comments in the code for an explanation about what's going on. Upload this code to your Arduino board and open the terminal program that you installed earlier.

For the purposes of this tutorial, I'll assume you're using TeraTerm. You'll need to select the serial port that your Arduino is connected to. Now you should be seeing a bunch of zeros appearing in your terminal window. This is our sketch telling us how many bytes we've written.

So far we've written nothing; let's change that! For testing purposes, I suggest using the complete text of the Ghostbusters theme as written and performed by Ray Parker Jr. You can get the text file below. Ghostbusters TXT. Select that file and be sure to click on the "binary" button, so that the file is written byte-for-byte over the serial port.

When you press "Open" you'll see a file transfer window for just a moment as the file is dumped to the terminal. Now the number in your terminal window should be , representing the memory location that we're sitting at after writing the complete text of the Ghostbusters theme as written and performed by Ray Parker Jr.

You can go ahead and close TeraTerm, it worked! Now load this sketch onto your Arduino and open TeraTerm again. Once again, you'll need to open the correct serial port but before we set the correct baud rate and get things moving, let's create a file to store all the memory that we're about to read.

Make sure to uncheck the "Append" option and check the "Binary" option. This makes sure that the terminal will start a fresh logfile and write to it byte-for-byte what comes over the terminal. When you press "Save" another dialog window will appear but it may pop under the current window Go find it, it will come in handy in a second. Check the logfile window and see how many bytes have been transferred. Once we've transferred bytes, we've got everything on the chip.

Now close everything and open up that logfile in a text editor. You should now be face to face with, you guessed it, the complete text of the Ghostbusters theme as written and performed by Ray Parker Jr. Oh yeah, plus a bunch of junk that represents the unwritten space in memory. So what if the thing that we want to store is bigger than complete text of the Ghostbusters theme as written and performed by Ray Parker Jr?

For instance, the Microchip 24LC can store up to Kbits! That's KB, enough space to have some real fun with! Because the memory space is so much larger, two bytes is no longer enough to represent the memory address that we want to modify. To get around this problem, the 24LC splits up the memory addresses into two separate blocks. When you address the chip, you send the block selector for the block that you want to manipulate in place of where you'd usually send the first bit of the chip address.

You'll notice that we've already tied A2 to 5V in our previous example, so you could use the same example circuit to hook it up! Along with that change to our Arduino hookup, we'll also need to add to our code in order to switch the block select when we reach above a certain memory address.

Here's what that operation looks like when we're writing:. It's just that easy! You can get the complete Arduino example sketches here if you want to play with it yourself:. Why stop at song lyrics? Why not store journals or bitmaps Actually, to think of it, sensor readings are probably the most practical thing to use it for But wait, if you're mad with power and want even more storage for your Arduino then you should check out this awesome tutorial on the MicroSD Card Breakout!


24C512 EEPROM. Datasheet pdf. Equivalent

Track My Order. Frequently Asked Questions. International Shipping Info. Send Email. Mon-Fri, 9am to 12pm and 1pm to 5pm U. Mountain Time:.




Related Articles