EEPROM Reading/Writing without Use of Programmer

digital-logiceepromnon-volatile-memory

I am designing a small password based door lock project which is fully made from logic gates and ICs without the use of any sort of programmable devices(it is a simple university project for the Logic Design Course).

And as assigned to me, I need a non volatile memory for this lock in order to store the password, return its value and rewrite it whenever I want. I first thought of EEPROMs but many told me that an EEPROM should be removed from the circuit in order to be reprogrammed which is not acceptable_the memory of the circuit should stay inside the circuit with respect to my project. In addition I was told that the EEPROM is only reprogrammed through a PROGRAMMER.

Here is my problem:
How I could implement the EEPROM so that I can read/write to it data without removing it? that's to say my own circuit should be able to read and write to the EEPROM without using a PROGRAMMER .
So is this possible? Is there a way for such implementation? Or should I think of another non volatile memory other than the EEPROM to store, read and rewrite the password? If there is another way, please let me now.

Any help is appreciated. I am really a beginner.

Best Answer

What you've been told about EEPROM's is ancient history. Modern EEPROM's are readily programmable in-circuit. You should read some datasheets of "typical" EEPROM IC's in order to understand how to use them; if you have any detailed questions, you can ask them here (in a new question).

The easiest way to find examples of EEPROM IC's is to search the websites of some of the major electronics vendors; the three that spring to my mind are Element14, Digikey and Mouser, but there are others as well.

There are two types, serial and parallel. Serial use 2-4 wires to signal data serially. Parallel use 8-16 wires for data, up to 20-odd wires for address and 3 or so for control.

Within the serial options, there are SPI and I2C. Given that you're using hardwired logic, I'd very much avoid I2C. SPI would be manageable though.

EEPROM datasheets generally give a thorough explanation of the low-level protocol required to read and write them.

My advice off the top of my head is that a something like a 25LC040 SPI EEPROM would be feasible.

Related Solutions

Electronic – CRC for eeprom data check

While the suggested approach from PeterJ is fine, its cleaner to decouple the "data layer" logic (EEPROM access) from the CRC routine.

This CRC-32 can be universally used, its not bound to program specific behavior:

// CCITT CRC-32 (Autodin II) polynomial
uint32_t CalcCRC32(uint32_t crc, uint8_t *buffer, uint16_t length) {
    while(length--) {
        crc = crc ^ *buffer++; 

        for (uint8_t j=0; j < 8; j++) { 
           if (crc & 1) 
              crc = (crc >> 1) ^ 0xEDB88320; 
           else 
              crc = crc >> 1; 
        } 
    } 

   return crc; 
}

Then you just feed blocks of data to the CRC function like you see fit and as required by your application.

This usage example is just written down. It uses the fictional function eeprom_read() which reads a block of data from EEPROM. We start at EEPROM address 0.

const uint8_t BLOCKLENGTH = 128;
uint32_t crc32;
uint8_t buffer[BLOCKLENGTH];    // temporary data buffer

crc32 = 0xFFFFFFFF;  // initial CRC value 

for (uint16_t i=0; i < NUMBEROFBLOCKS; i++) {
    eeprom_read(BLOCKLENGTH * i, buffer, BLOCKLENGTH);    // read block number i from EEPROM into buffer
    crc32 = CalcCRC32(crc32, buffer, BLOCKLENGTH);        // update CRC
}

// crc32 is your final CRC here

Note that NUMBEROFBLOCKS is just a placeholder. I hope you get the idea.

EEPROM endurance in energy meter

I would not write every event to EEPROM. Most of the time you will have power, so keep the live count in RAM.

The amount of energy it takes to save the live value from RAM to EEPROM is pretty minimal. Use a capacitor to store enough energy to run the micro long enough after power fail is detected to copy the live data into EEPROM, then shut down cleanly. You should only need a few 10s of ms at most, maybe just a few ms. You also need to be able to detect power fail early enough so that there is still energy in the cap to perform the clean shutdown sequence. This should not be hard though.

For example, let's say the micro requires 20 mA at 3.3 V (that is actually quite high for this kind of application) and that shutdown takes 20 ms. That's (20 mA)(3.3 V)(20 ms) = 1.3 mJ. A 470 µF cap charged to 12 V holds 34 mJ, for example. Let's say you normally keep the cap charged to 12 V, and detect power fail when it gets down to 11 V. At that point it has 28 mJ left. To get 2 more mJ out only requires draining it to 10.6 V.

These are just numbers I pulled out of the air as example. A 470 µF 16 V cap wouldn't be a big deal to add to the device, but even that is clearly more than necessary in this case. The point is to show this method is quite feasible.

Best Answer

Related Solutions

Electronic – CRC for eeprom data check

EEPROM endurance in energy meter

Related Topic