![\"SPI](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/25_EEPROMs-1024x258.jpg\")
<\/a>I will not go into the general basics of EEPROMs again. I have already written a lot about this in parts 1 and 2 of this series.<\/p>\r\n\n
Pinout<\/h3>\n\n
Typically, the SPI EEPROMs have the following pins:<\/p>\r\n
<\/a>- \r\n
- CS<\/strong>: Chip Select, active-low.<\/li>\r\n
- SO<\/strong>: Slave Out, to connect to MISO.<\/li>\r\n
- WP<\/strong>: Write Protect, active-low.\r\n
- \r\n
- Works only in combination with the WPEN bit (unlike the 24 series)<\/li>\r\n<\/ul>\r\n<\/li>\r\n
- GND (VSS) \/ VCC<\/strong>: Power supply.\r\n
- \r\n
- “LC\/C” variants tolerate up to 5.5 volts, “A” variants usually have a limit of 3 volts.<\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Hold<\/strong>: Hold pin, active-low, pauses the data transfer.<\/li>\r\n
- SCK<\/strong>: SPI Clock, to connect to SCK.<\/li>\r\n
- SI<\/strong>: Slave input, to connect to MOSI.<\/li>\r\n<\/ul>\r\n\n
Connection to the microcontroller<\/h3>\n\n
As an example, I show how you connect the SPI-based EEPROM, provided it can tolerate 5 volts, with an Arduino Nano:<\/p>\r\n
\n![\"Connection](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/Wiring_25LC512_Arduino_Nano-1024x659.png\")
<\/a>A 25LC512 connected to an Arduino Nano<\/figcaption><\/figure>\n<\/div>\n I use the HOLD-pin in only one example. Since probably few of you will use the feature, I connected it to VCC here. If you do not have enough pins available, you can also set the WP pin to HIGH. <\/p>\r\n\n
Page Writing<\/h3>\n\n
The memory of an EEPROM is divided into pages. The pages usually have a size of 16, 32, 64 or 128 bytes. You can find this value in the data sheet.<\/p>\r\n
Writing to EEPROMs is a very slow process. If you write a single byte to the EEPROM, you need the so-called “Write Cycle Time”, which is usually specified as 5 milliseconds. To speed up writing, the EEPROMs have a buffer memory the size of the pages. You can write this “in one go” (burst or bulk write). From this buffer memory, the individual memory addresses can be written to in parallel. This increases the write speed by a factor that is at most equal to the page size (in bytes).<\/p>\r\n
The boundaries of the pages are fixed, and you are not allowed to write beyond them in burst write. I discussed this quite intensively in the last post.<\/p>\r\n\n
Writing and reading SPI EEPROMs without library<\/h2>\n\n
Let’s get started. First, I’ll show you how to write to and read from SPI EEPROMs without a library. If you’re not interested, you can skip this section.<\/p>\r\n
In this simple example, we write two integer values to EEPROM addresses 4 and 6 and then read them out.<\/p>\r\n
I will not go into the basic SPI functions in this post. If necessary, you will find a brief introduction here<\/a>.<\/p>\r\n
Here is the sketch:<\/p>\r\n\n
\r\n#include <SPI.h>\r\n#define READ 0x03\r\n#define WRITE 0x02\r\n#define WREN 0x06 \/\/ write enable\r\n\r\nconst int csPin = 10;\r\nconst int wpPin = 9; \/\/ For this sketch you could also leave the wpPin unconnected\r\nconst int writeCycle = 5;\r\n\r\nvoid setup(){\r\n pinMode(csPin, OUTPUT);\r\n digitalWrite(csPin, HIGH);\r\n pinMode(wpPin, OUTPUT);\r\n digitalWrite(wpPin,HIGH);\r\n SPI.begin();\r\n Serial.begin(9600);\r\n \r\n int intToWrite = 42;\r\n eepromWriteInt(4, intToWrite);\r\n intToWrite = -1111;\r\n eepromWriteInt(6, intToWrite);\r\n \r\n int intToRead = 0;\r\n intToRead = eepromReadInt(4);\r\n Serial.print(\"intToRead (Address = 4): \");\r\n Serial.println(intToRead);\r\n intToRead = 0;\r\n intToRead = eepromReadInt(6);\r\n Serial.print(\"intToRead (Address = 6): \");\r\n Serial.println(intToRead);\r\n}\r\n\r\nvoid loop(){}\r\n\r\nvoid eepromWriteEnable(){\r\n digitalWrite(csPin, LOW);\r\n SPI.transfer(WREN); \r\n digitalWrite(csPin, HIGH);\r\n}\r\n\r\nvoid eepromWriteInt(int addr, int value){\r\n eepromWriteEnable();\r\n \/\/ If you want to change the SPI clock speed, uncomment the following line and adjust\r\n \/\/SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));\r\n digitalWrite(csPin, LOW);\r\n SPI.transfer(WRITE);\r\n SPI.transfer((byte)(addr>>8));\r\n SPI.transfer((byte)(addr&0xFF));\r\n SPI.transfer((byte)(value>>8));\r\n SPI.transfer((byte)(value&0xFF));\r\n digitalWrite(csPin, HIGH);\r\n \/\/SPI.endTransaction(); \/\/ Uncomment if you have uncommented SPI.beginTransaction()\r\n delay(writeCycle);\r\n}\r\n\r\nint eepromReadInt(int addr){\r\n byte MSB = 0;\r\n byte LSB = 0;\r\n int value = 0; \r\n \/\/SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));\r\n digitalWrite(csPin, LOW);\r\n SPI.transfer(READ); \r\n SPI.transfer((byte)(addr>>8));\r\n SPI.transfer((byte)(addr&0xFF));\r\n MSB = SPI.transfer(0x00);\r\n LSB = SPI.transfer(0x00);\r\n digitalWrite(csPin, HIGH);\r\n \/\/SPI.endTransaction();\r\n value = (int)((MSB<<8)|LSB);\r\n return value;\r\n}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
And here is the expected output:<\/p>\r\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/output_spi_eeprom_without_lib.png\")
<\/a>Output of spi_eeprom_without_lib.ino<\/figcaption><\/figure>\n\n Just a few explanations:<\/p>\r\n
- \r\n
- The SPI EEPOMs “understand” up to eleven different instructions. The sketch uses three of them:\r\n
- \r\n
- WREN<\/strong> (Write Enable): Sets the write enable bit in the status register of the EEPROM. After a successful write process, the bit is disabled.<\/li>\r\n
- WRITE<\/strong>: Initiates the write operation.<\/li>\r\n
- READ<\/strong>: Initiates the read operation.<\/li>\r\n<\/ul>\r\n<\/li>\r\n
- After sending the data to be written, i.e. each time the chip select pin goes HIGH again, you must wait for the write cycle time.<\/li>\r\n
- The sketch will not work if you split an integer so that it is written to two pages. Try it out: For example, if the page size of your SPI EEPROM is 128 bytes, then write an integer to the address 127. When reading, you get an incorrect value.<\/li>\r\n<\/ul>\r\n\n
This issue is not the only shortcoming of the sketch. If you use other variable types such as strings, floats, or arrays instead of integer values, you’ll need to adjust it accordingly. In addition, there are several features such as write protection and the hold function that have not yet been considered here. All this could be added “manually” to the sketch, but the easier way is to use a library. <\/p>\r\n\n
Library for SPI EEPROMs<\/h2>\n\n
My library EEPROM_SPI_WE can be found here<\/a> on GitHub, or you can install it via the library manager of the Arduino IDE. Using a few example sketches, I introduce its functions. The example sketches are part of the library, so you can also access them directly from the Arduino IDE.<\/p>\r\n\n
Reading and writing different types of variables<\/h3>\n\n
If you have connected your SPI-based EEPROM to the microcontroller of your choice, then take the following sketch and adjust the CS and WP pins if necessary. This sketch does not require the WP pin. You can leave it unconnected if you like. <\/p>\r\n
setPageSize()<\/code> will tell the library the page size of your SPI EEPROM. You can adjust the SPI clock rate usingsetSPIClockSpeed()<\/code>. The default I have implemented is 8 MHz. However, there is a problem if your EEPROM is incompatible with 8 MHz. Therefore, you can also pass the desired SPI clock rate when creating the EEPROM_SPI_WE object.<\/p>\r\nThere are several options for creating the EEPROM_SPI_WE objects. If you want to use the two available SPI interfaces of an ESP32, then you can pass the SPI objects to the EEPROM_SPI_WE objects<\/p>\r\n\n
\r\n#include <SPI.h>\r\n#include <EEPROM_SPI_WE.h>\r\nconst int csPin = 10; \/\/ Chip select pin\r\nconst int wpPin = 9; \/\/ Write protect pin (optional)\r\n\r\n\/* There are different options to create your EEPROM_SPI_WE object:\r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin, wpPin, spiClockSpeed); \/\/ e.g. uint32t spiClockSpeed = 4000000\r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin, wpPin);\r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin); \r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(&SPI, csPin, wpPin, spiClockSpeed); \r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(&SPI, csPin, wpPin); \r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(&SPI, csPin); \r\n * If you don't define the wpPin and you connect it to GND or VCC, \r\n * then protectStatusRegister() is the only function that won't work.\r\n * Passing the SPI object allows you, for example, to use both SPI \r\n * interfaces on the ESP32.\r\n *\/\r\n EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin, wpPin);\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n if(myEEP.init()){\r\n Serial.println(\"EEPROM connected\");\r\n }\r\n else{\r\n Serial.println(\"EEPROM does not respond\");\r\n while(1);\r\n }\r\n \/* You can change the SPI clock speed also after you have created your \r\n * object. The default is 8 MHz. Check the data sheet which clock speed is \r\n * allowed. The frequency limit migh also depend on the voltage. \r\n *\/\r\n \/\/myEEP.setSPIClockSpeed(4000000); \/\/ use AFTER init()!\r\n \r\n \/* Select the page size of your EEPROM.\r\n * Choose EEPROM_PAGE_SIZE_xxx, \r\n * with xxx = 16, 32, 64, 128 or 256\r\n *\/\r\n myEEP.setPageSize(EEPROM_PAGE_SIZE_32);\r\n\r\n byte byteToWrite = 42; \r\n myEEP.write(10, byteToWrite); \/\/ write a byte to EEPROM address 10\r\n byte byteToRead = myEEP.read(10);\r\n Serial.print(\"Byte read: \");\r\n Serial.println(byteToRead);\r\n\r\n int intToWrite = -4242; \r\n int intToRead = 0;\r\n myEEP.put(10, intToWrite); \/\/ write an integer to EEPROM address 10\r\n myEEP.get(10, intToRead);\r\n Serial.print(\"Integer read: \");\r\n Serial.println(intToRead);\r\n\r\n float floatToWrite = 42.42; \r\n float floatToRead = 0.0; \r\n myEEP.put(10, floatToWrite);\r\n myEEP.get(10, floatToRead);\r\n Serial.print(\"Float read: \");\r\n Serial.println(floatToRead);\r\n\r\n char charArrayToWrite[] = \"This is no poetry, I am just a simple char array\"; \r\n myEEP.put(110, charArrayToWrite); \/\/ write stringToWrite to address 110\r\n char charArrayToRead[60] = \"\"; \/\/ reserve sufficient space \r\n myEEP.get(110, charArrayToRead);\r\n Serial.print(\"Char array read: \");\r\n Serial.println(charArrayToRead);\r\n\r\n String stringToWrite = \"Hello, I am a test string\";\r\n unsigned int nextAddr = myEEP.putString(200, stringToWrite); \/\/ String objects need a different put function\r\n \r\n String stringToRead = \"\";\r\n myEEP.getString(200, stringToRead);\r\n Serial.print(\"String read: \");\r\n Serial.println(stringToRead);\r\n Serial.print(\"Next free address: \");\r\n Serial.println(nextAddr);\r\n\r\n int intArrayToWrite[20];\r\n int intArrayToRead[20];\r\n for(unsigned int i=0; i<(sizeof(intArrayToWrite)\/sizeof(int)); i++){\r\n intArrayToWrite[i] = 10*i;\r\n } \r\n myEEP.put(250, intArrayToWrite);\r\n myEEP.get(250, intArrayToRead);\r\n for(unsigned int i=0; i<(sizeof(intArrayToRead)\/sizeof(int)); i++){\r\n Serial.print(\"intArrayToRead[\");\r\n Serial.print(i);\r\n Serial.print(\"]: \");\r\n Serial.println(intArrayToRead[i]);\r\n } \r\n}\r\n \r\nvoid loop(){}\r\n<\/pre>\r\n\u00a0<\/p>\r\n<\/div>\r\n\n
The sketch provides the following output:<\/p>\r\n\n
![\"SPI](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/05\/output_EEPROM_SPI_WE_basic_read_write-1.png\")
<\/a>Output of EEPROM_SPI_WE_basic_read_write.ino<\/figcaption><\/figure>\n\n Just a few explanations:<\/p>\r\n
- \r\n
write()<\/code> writes a variable of type “byte”.<\/li>\r\n- With
read()<\/code> you read a variable of type “byte”.<\/li>\r\nput()<\/code> writes a variable to a specific (start) address.\r\n- \r\n
- The function is flexible regarding variable types.<\/li>\r\n
- You don’t have to worry about the page sizes and limits. The library manages cross-page writing in the background.<\/li>\r\n<\/ul>\r\n<\/li>\r\n
- With
get()<\/code> you can read different variable types from the EEPROM.<\/li>\r\nputString()<\/code> \/getString()<\/code> are the put\/get equivalents for string objects.<\/li>\r\n<\/ul>\r\n\nUsing small EEPROMs<\/h3>\n\n
Small EEPROMs like the 25LC0x0 or ST950x0 series (with x = 1, 2, 4) are addressed differently than their larger siblings. In addition, the range of functions is smaller. If you use these EEPROMS, then you have to add a
setSmallEEPROM()<\/code> in the sketch. The library contains an example sketch.<\/p>\r\n\nSpeed up writing with continuousPut()<\/h3>\n\n
After a write() statement, a put() statement, or when the current page is full, you must wait for the write cycle to complete. The library does this in the background by querying the WIP bit (Write in Progress) in the status register of the EEPROM. This is slightly faster than using the
delay()<\/code> maximum write cycle time.<\/p>\r\nImagine you want to write the measured values of a sensor in high frequency to the EEPROM, and do this one by one with the put() instruction. The write cycle times will add up to considerable values. A remedy could be found by buffering the values in an array and then transferring the array to the EEPROM. Depending on the size of the array, you will consume a corresponding amount of RAM.<\/p>\r\n
I have therefore implemented a function
continuousPut()<\/code> that does not complete the write process. You have to initiate it withcontinuousPutEnable()<\/code> and complete it withcontinuousPutDisable()<\/code>. In between, you can execute as manycontinuousPut()<\/code> instructions as you want. The write cycle time only comes into play when changing the page or when executingcontinuousPutDisable()<\/code>.<\/p>\r\nAnd now imagine that your sensor is also connected via SPI and via the same MISO, MOSI and SCK lines as the EEPROM. To switch between the EEPROM and the sensor, the microcontroller would have to switch the CS line to the EEPROM to HIGH. This would complete an ongoing write process and require a write cycle waiting time. This is where the HOLD-pin comes into play. On LOW, it pauses the write process and does not complete it.<\/p>\r\n
The following sketch explains the use of the functions and shows the time saved by
continuousPut()<\/code>:<\/p>\r\n\n\r\n#include <SPI.h>\r\n#include <EEPROM_SPI_WE.h>\r\nconst int csPin = 10; \/\/ Chip select pin\r\nconst int wpPin = 9; \/\/ Write protect pin (optional)\r\nconst int holdPin = 5; \/\/ Hold pin, pauses SPI transaction if LOW\r\n\r\nEEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin, wpPin);\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n pinMode(holdPin,OUTPUT);\r\n digitalWrite(holdPin, HIGH);\r\n if(myEEP.init()){\r\n Serial.println(\"EEPROM connected\");\r\n }\r\n else{\r\n Serial.println(\"EEPROM does not respond\");\r\n while(1);\r\n }\r\n \/* You can change the SPI clock speed. The default of is 8 MHz *\/\r\n \/\/myEEP.setSPIClockSpeed(4000000); \/\/ use AFTER init()!\r\n \r\n \/* Select the page size of your EEPROM.\r\n * Choose EEPROM_PAGE_SIZE_xxx, \r\n * with xxx = 16, 32, 64, 128 or 256\r\n *\/\r\n myEEP.setPageSize(EEPROM_PAGE_SIZE_128);\r\n\r\n unsigned int address = 0;\r\n unsigned long writeDuration = 0;\r\n unsigned long startTime = millis();\r\n\r\n \/* Conventional way of writing: \r\n * For each call of put() you have to wait the write cycle \r\n * time (~4 ms).\r\n *\/\r\n myEEP.put(125,0);\r\n myEEP.put(127, 1111);\r\n myEEP.put(129, 2222);\r\n myEEP.put(131, 3333);\r\n myEEP.put(133, 4444);\r\n myEEP.put(135, 5555);\r\n myEEP.put(137, 6666);\r\n myEEP.put(139, 7777);\r\n myEEP.put(141, 8888);\r\n myEEP.put(143, 9999);\r\n writeDuration = millis() - startTime;\r\n Serial.print(\"Time needed for discontinuous writing [ms]: \");\r\n Serial.println(writeDuration); \r\n \r\n \/* Continuous writing: \r\n * You only need to wait the write cycle time when a page is \r\n * completed and when calling continuousPutDisable().\r\n * In this example the page is completed after writing to address 127.\r\n *\/\r\n address = 125;\r\n startTime = millis();\r\n myEEP.continuousPutEnable(address); \/\/ start address\r\n myEEP.continuousPut(9999);\r\n myEEP.continuousPut(8888);\r\n myEEP.continuousPut(7777);\r\n myEEP.continuousPut(6666);\r\n myEEP.continuousPut(5555);\r\n myEEP.continuousPut(4444);\r\n myEEP.continuousPut(3333);\r\n myEEP.continuousPut(2222);\r\n myEEP.continuousPut(1111);\r\n myEEP.continuousPut(0);\r\n myEEP.continuousPutDisable();\r\n writeDuration = millis() - startTime;\r\n \r\n Serial.print(\"Time needed for continuous writing incl. page change [ms]: \");\r\n Serial.println(writeDuration);\r\n \/* Just to check that writing worked fine: *\/\r\n int intToRead;\r\n address = 125;\r\n for(unsigned int i=0; i<10; i++){\r\n myEEP.get(address, intToRead);\r\n address += sizeof(int);\r\n Serial.println(intToRead);\r\n }\r\n \r\n \/* Another continuous writing: \r\n * Here writing starts at address 0. If your page size is >= 32 you will write\r\n * everything into one page. So, only one write cycle waiting time is needed at \r\n * the end. \r\n *\/\r\n address = 0;\r\n startTime = millis();\r\n myEEP.continuousPutEnable(address);\r\n myEEP.continuousPut(0);\r\n myEEP.continuousPut(1111);\r\n myEEP.continuousPut(2222);\r\n myEEP.continuousPut(3333);\r\n myEEP.continuousPut(4444);\r\n myEEP.continuousPut(5555);\r\n myEEP.continuousPut(6666);\r\n myEEP.continuousPut(7777);\r\n myEEP.continuousPut(8888);\r\n myEEP.continuousPut(9999);\r\n myEEP.continuousPutDisable();\r\n writeDuration = millis() - startTime;\r\n Serial.print(\"Time needed for continuous writing without page change [ms]: \");\r\n Serial.println(writeDuration); \r\n\r\n \/* The next example shows how to use the hold pin *\/ \r\n address = 0;\r\n myEEP.continuousPutEnable(address);\r\n myEEP.continuousPut(999);\r\n myEEP.continuousPut(888);\r\n myEEP.continuousPut(777);\r\n myEEP.continuousPut(666);\r\n digitalWrite(holdPin,LOW);\r\n \/* With the hold pin low you can now use the SPI lines to control other \r\n devices. The current SPI transaction with the EEPOM is just paused \r\n (CS pin is still LOW). After the hold Pin is back to HIGH you can continue \r\n the former transaction.\r\n *\/\r\n digitalWrite(holdPin,HIGH);\r\n myEEP.continuousPut(555);\r\n myEEP.continuousPut(444);\r\n myEEP.continuousPutDisable();\r\n \/* Just to show that writing worked fine: *\/\r\n address = 0;\r\n for(unsigned int i=0; i<10; i++){\r\n myEEP.get(address, intToRead);\r\n address += sizeof(int);\r\n Serial.println(intToRead);\r\n } \r\n}\r\n \r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
Here is the output:<\/p>\r\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/Output_EEPROM_SPI_WE_continuous_put.png\")
<\/a>Output of EEPROM_SPI_WE_continuous_put.ino<\/figcaption><\/figure>\n\n Interpretation<\/h4>\n\n
The sketch contains four writing sequences. Since I choose the start address 125 in the first two writing sequences, there will definitely be a page change. For the third write sequence (start at address 0) there is no page change, unless you use an EEPROM with a page size of 16 bytes. The result:<\/p>\r\n
- \r\n
- 45 milliseconds for: 10 x put() + 2 write cycle times<\/li>\r\n
- 8 milliseconds for: 10 x continuousPut() + 2 write cycle times<\/li>\r\n
- 4 milliseconds for: 10 x continuousPut() + 1 write cycle time<\/li>\r\n<\/ul>\r\n\n
The last write sequence only shows how to use the hold pin. <\/p>\r\n\n
Sleep mode and write protection <\/h3>\n\n
With the following sketch, I want to show how to send the EEPROM to sleep mode and how to write protect its memory or status register.<\/p>\r\n
- \r\n
deepPowerDown()<\/code> initiates the deep sleep of the SPI EEPROM.\r\n- \r\n
- The sketch shows that the EEPROM cannot be read in deep sleep.<\/li>\r\n<\/ul>\r\n<\/li>\r\n
powerUpAndReadID()<\/code> wakes up the EEPROM and provides its ID.<\/li>\r\nwriteProtect(parameter)<\/code> enables the write protection of the EEPROM.\r\n- \r\n
- You can protect it completely, only the upper half of the address space or the upper quarter.<\/li>\r\n
- The parameter
PROTECT_NONE<\/code> disables the write protection.<\/li>\r\n- Setting the WP-pin to LOW alone does not enable write protection. In addition<\/strong>, the WPEN bit (Write Protect Enable Bit) must be set in the status register.<\/li>\r\n<\/ul>\r\n<\/li>\r\n
protectStatusRegister(true\/false);<\/code> enables read-only protection for the status register, but this only applies to the WPEN bit and the bits for setting the address space to be protected. <\/li>\r\n<\/ul>\r\nIt’s a bit confusing to understand what
protectStatusRegister()<\/code> exactly does it. I hope the following sketch makes it a bit clearer.<\/p>\r\n\n\r\n#include <SPI.h>\r\n#include <EEPROM_SPI_WE.h>\r\nconst int csPin = 10; \/\/ Chip select pin\r\nconst int wpPin = 9; \/\/ Write protect pin (needed for this example sketch)\r\n\r\n\/* There are different options to create your EEPROM_SPI_WE object:\r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin, wpPin);\r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin); \r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(&SPI, csPin, wpPin); \r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(&SPI, csPin); \r\n * If you don't define the wpPin and you connect it to GND or VCC, \r\n * then protectStatusRegister() is the only function that won't work.\r\n * Passing the SPI object allows you, for example, to use both SPI \r\n * interfaces on the ESP32.\r\n *\/\r\n EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin, wpPin);\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n if(myEEP.init()){\r\n Serial.println(\"EEPROM connected\");\r\n }\r\n else{\r\n Serial.println(\"EEPROM does not respond\");\r\n while(1);\r\n }\r\n \/* You can change the SPI clock speed. The default of is 8 MHz *\/\r\n \/\/myEEP.setSPIClockSpeed(4000000); \/\/ use AFTER init()!\r\n \r\n \/* Select the page size of your EEPROM.\r\n * Choose EEPROM_PAGE_SIZE_xxx, \r\n * with xxx = 16, 32, 64, 128 or 256\r\n *\/\r\n myEEP.setPageSize(EEPROM_PAGE_SIZE_128);\r\n\r\n int testInt = 42;\r\n myEEP.put(50, testInt);\r\n Serial.print(\"testInt: \");\r\n Serial.println(testInt);\r\n Serial.println(\"Going in deep power down mode...\");\r\n myEEP.deepPowerDown();\r\n Serial.println(\"Trying to read testInt... \");\r\n myEEP.get(50, testInt);\r\n Serial.print(\"testInt: \");\r\n Serial.println(testInt);\r\n Serial.println(\"Releasing from deep power down mode...\");\r\n byte id = myEEP.powerUpAndReadID();\r\n Serial.print(\"testInt: \");\r\n myEEP.get(50, testInt);\r\n Serial.println(testInt);\r\n Serial.print(\"Device ID: 0x\");\r\n Serial.println(id, HEX);\r\n Serial.println(\"\");\r\n\r\n\/* You can write protect the device. The following options are available:\r\n * PROTECT_ALL Complete write protection;\r\n * PROTECT_UPPER_QUARTER Protect the upper quarter; \r\n * PROTECT_UPPER_HALF Protect the upper half;\r\n * PROTECT_NONE No write protection\r\n *\/\r\n myEEP.writeProtect(PROTECT_ALL);\r\n Serial.println(\"Protecting Device, trying to overwrite testInt...\");\r\n myEEP.put(50, 4321);\r\n myEEP.writeProtect(PROTECT_NONE);\r\n Serial.print(\"testInt: \");\r\n myEEP.get(50, testInt);\r\n Serial.println(testInt);\r\n Serial.println(\"Protection removed, trying to overwrite testInt again...\");\r\n myEEP.put(50, 4321);\r\n myEEP.get(50, testInt);\r\n Serial.print(\"testInt: \");\r\n Serial.println(testInt);\r\n Serial.println(\"\");\r\n\r\n Serial.println(\"Protecting status register...\");\r\n myEEP.protectStatusRegister(true); \/\/protects the non-volatile bits of status register\r\n Serial.println(\"Trying to protect device...\");\r\n myEEP.writeProtect(PROTECT_ALL);\r\n Serial.println(\"Now overwriting testInt...\");\r\n myEEP.put(50, 1234);\r\n myEEP.get(50, testInt);\r\n Serial.print(\"testInt: \");\r\n Serial.println(testInt);\r\n Serial.println(\"Status register protection prevented changing the device protection!\");\r\n myEEP.protectStatusRegister(false);\r\n}\r\n \r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
Here is the output:<\/p>\r\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/output_EEPROM_SPI_WE_sleep_and_protect.png\")
<\/a>Output of EEPROM_SPI_WE_sleep_and_protect.ino<\/figcaption><\/figure>\n\n Despite calling
myEEP.writeProtect(PROTECT_ALL)<\/code>, testInt can be overwritten at the end of the sketch because the status register was previously write-protected. <\/p>\r\n\nErase functions<\/h3>\n\n
The larger SPI EEPROMs have erase functions. If in doubt, check the data sheet to see if this applies to your EEPROM – or try out the next sketch.<\/p>\r\n
- \r\n
erasePage(address)<\/code> deletes the page in which “address” is located. Which address you specify within the page does not matter.<\/li>\r\neraseSector(address)<\/code> deletes the sector where the address is located. For example, the 25LC512 has 4 sectors.<\/li>\r\neraseCompleteEEPROM()<\/code> does what the name suggests: the entire EEPROM is deleted.<\/li>\r\n<\/ul>\r\nWhat does “delete” actually mean? There is always a value at any address. That is why the term is somewhat misleading. For the functions described here, 255 (0xFF) is written to each memory address to be erased. If you read an integer value from a deleted memory, you will get 0xFFFF = -1.<\/p>\r\n\n
\r\n#include <SPI.h>\r\n#include <EEPROM_SPI_WE.h>\r\nconst int csPin = 10; \/\/ Chip select pin\r\nconst int wpPin = 9; \/\/ Write protect pin (optional)\r\n\r\n\/* There are different options to create your EEPROM_SPI_WE object:\r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin, wpPin);\r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin); \r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(&SPI, csPin, wpPin); \r\n * EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(&SPI, csPin); \r\n * If you don't define the wpPin and you connect it to GND or VCC, \r\n * then protectStatusRegister() is the only function that won't work.\r\n * Passing the SPI object allows you, for example, to use both SPI \r\n * interfaces on the ESP32.\r\n *\/\r\n EEPROM_SPI_WE myEEP = EEPROM_SPI_WE(csPin, wpPin);\r\n\r\nvoid setup(){\r\n Serial.begin(9600);\r\n if(myEEP.init()){\r\n Serial.println(\"EEPROM connected\");\r\n }\r\n else{\r\n Serial.println(\"EEPROM does not respond\");\r\n while(1);\r\n }\r\n \/* You can change the SPI clock speed. The default of is 8 MHz *\/\r\n \/\/myEEP.setSPIClockSpeed(4000000); \/\/ use AFTER init()!\r\n \r\n \/* Select the page size of your EEPROM.\r\n * Choose EEPROM_PAGE_SIZE_xxx, \r\n * with xxx = 16, 32, 64, 128 or 256\r\n *\/\r\n myEEP.setPageSize(EEPROM_PAGE_SIZE_128);\r\n\r\n int testInt = 42;\r\n myEEP.put(10, testInt);\r\n myEEP.get(10, testInt);\r\n Serial.print(\"testInt: \");\r\n Serial.println(testInt);\r\n Serial.println(\"Erasing page....\");\r\n myEEP.erasePage(3); \/\/ choose any address within the page you want to erase\r\n myEEP.get(10, testInt);\r\n Serial.print(\"testInt: \");\r\n Serial.println(testInt);\r\n Serial.println(\"\");\r\n\r\n testInt = 42;\r\n myEEP.put(10, testInt);\r\n myEEP.get(10, testInt);\r\n Serial.print(\"testInt: \");\r\n Serial.println(testInt);\r\n Serial.println(\"Erasing sector....\");\r\n myEEP.eraseSector(7); \/\/ choose any address within the sector you want to erase\r\n myEEP.get(10, testInt);\r\n Serial.print(\"testInt: \");\r\n Serial.println(testInt);\r\n Serial.println(\"\");\r\n \r\n testInt = 42;\r\n myEEP.put(10, testInt);\r\n myEEP.get(10, testInt);\r\n Serial.print(\"testInt: \");\r\n Serial.println(testInt);\r\n Serial.println(\"Erasing complete EEPROM....\");\r\n myEEP.eraseCompleteEEPROM();\r\n myEEP.get(10, testInt);\r\n Serial.print(\"testInt: \");\r\n Serial.println(testInt);\r\n\r\n Serial.print(\"testInt, MSB: \");\r\n Serial.println(myEEP.read(10), BIN);\r\n Serial.print(\"testInt, LSB: \");\r\n Serial.println(myEEP.read(11), BIN);\r\n Serial.println(\"Erasing means writing 0xFF to all addresses\"); \r\n}\r\n \r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
Here is the output:<\/p>\r\n\n
![\"Deleting](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/output_EEPROM_SPI_WE_erase.png\")
<\/a>Output of EEPROM_SPI_WE_erase.ino<\/figcaption><\/figure>\n\n Reference – SPI EEPROMs internal<\/h2>\n\n
This section is intended for those who are particularly interested but do not feel like reading the data sheet.<\/p>\r\n\n
Instruction Set<\/h3>\n\n
The SPI EEPROMs have a rather limited set of functions (instructions):<\/p>\r\n\n
![\"SPI](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/Instruction_Set-1024x437.png\")
<\/a>SPI EEPROMs Instruction Set<\/figcaption><\/figure>\n\n Not every EEPROM has implemented all of these features. This is especially true for the erase functions.<\/p>\r\n\n
Status register<\/h3>\n\n
![\"Status](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/Status_Reg-1024x122.png\")
<\/a>Status register of SPI EEPROMs<\/figcaption><\/figure>\n\n The status register is the only register of the SPI EEPROM. The WPEN bit (Write Protection Enable) and the two BP bits (Block Protection) are not volatile, i.e. the values are retained even after a disconnection from the supply voltage. However, I have set my library so that all bits are set to zero on restart.<\/p>\r\n
If you want to write to the EEPROM, you have to set the WEL bit (Write Enable Latch). It is deleted after a successful write or delete operation, a restart or by the WRDI instruction.<\/p>\r\n
The BP bits have the following effect (in combination with WPEN):<\/p>\r\n\n
![\"Effect](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/Protection-1024x273.png\")
<\/a>Effect of block protection bits<\/figcaption><\/figure>\n\n Write protection<\/h3>\n\n
![\"SPI](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2022\/03\/Write_Protection-1024x213.png\")
<\/a>Write protection for the EEPROM and its status register<\/figcaption><\/figure>\n\n The table above describes the effect of the WEL bit, WPEN bit, and WP pin on read-only protection for the EEPROM and its status register.<\/p>\r\n\n
Acknowledgement <\/h2>\n\n
- Setting the WP-pin to LOW alone does not enable write protection. In addition<\/strong>, the WPEN bit (Write Protect Enable Bit) must be set in the status register.<\/li>\r\n<\/ul>\r\n<\/li>\r\n
- With
- WRITE<\/strong>: Initiates the write operation.<\/li>\r\n
- WREN<\/strong> (Write Enable): Sets the write enable bit in the status register of the EEPROM. After a successful write process, the bit is disabled.<\/li>\r\n
- SCK<\/strong>: SPI Clock, to connect to SCK.<\/li>\r\n
- SO<\/strong>: Slave Out, to connect to MISO.<\/li>\r\n