A guide to EEPROM | Arduino Documentation (2023)

Learn how to use EEPROM, short for electrically erasable programmable read-only memory, on Arduino boards.

LAST REVISION:

10/05/2022, 01:00 PM

The microcontroller on the Arduino boards have 512 bytes of EEPROM: memory whose values are kept when the board is turned off (like a tiny hard drive).

Functions in the EEPROM class is automatically included with the platform for your board, meaning you do not need to install any external libraries.

Hardware Required

All of the following boards have an EEPROM:

  • Arduino UNO Rev.3
  • Arduino UNO WiFi Rev.2
  • Arduino Mega 2560 Rev.3
  • Arduino Nano Every
  • Arduino Micro
  • Arduino Leonardo
  • Arduino Nano

EEPROM Clear

This example illustrates how to set of all of those bytes to 0, initializing them to hold new information, using the EEPROM.write() function.

1/*

2 * EEPROM Clear

3 *

4 * Sets all of the bytes of the EEPROM to 0.

5 * Please see eeprom_iteration for a more in depth

6 * look at how to traverse the EEPROM.

7 *

8 * This example code is in the public domain.

9 */

10

11#include <EEPROM.h>

12

13void setup() {

14 // initialize the LED pin as an output.

15 pinMode(13, OUTPUT);

16

17 /***

18 Iterate through each byte of the EEPROM storage.

19 Larger AVR processors have larger EEPROM sizes, E.g:

20 - Arduino Duemilanove: 512 B EEPROM storage.

21 - Arduino Uno: 1 kB EEPROM storage.

22 - Arduino Mega: 4 kB EEPROM storage.

23 Rather than hard-coding the length, you should use the pre-provided length function.

24 This will make your code portable to all AVR processors.

25 ***/

26

27 for (int i = 0 ; i < EEPROM.length() ; i++) {

28 EEPROM.write(i, 0);

29 }

30

31 // turn the LED on when we're done

32 digitalWrite(13, HIGH);

33}

34

35void loop() {

36 /** Empty loop. **/

37}

EEPROM CRC

A CRC is a simple way of checking whether data has changed or become corrupted. This example calculates a CRC value directly on the EEPROM values. This CRC is like a signature and any change in the calculated CRC means a change in the stored data. The purpose of this example is to highlight how the EEPROM object can be used just like an array.

1/***

2

3 Written by Christopher Andrews.

4

5 CRC algorithm generated by pycrc, MIT licence ( https://github.com/tpircher/pycrc ).

6

7 A CRC is a simple way of checking whether data has changed or become corrupted.

8

9 This example calculates a CRC value directly on the EEPROM values.

10

11 The purpose of this example is to highlight how the EEPROM object can be used just like an array.

12

13***/

14

15#include <Arduino.h>

16#include <EEPROM.h>

17

18void setup() {

19

20 //Start serial

21

22 Serial.begin(9600);

23

24 while (!Serial) {

25

26 ; // wait for serial port to connect. Needed for native USB port only

27

28 }

29

30 //Print length of data to run CRC on.

31

32 Serial.print("EEPROM length: ");

33

34 Serial.println(EEPROM.length());

35

36 //Print the result of calling eeprom_crc()

37

38 Serial.print("CRC32 of EEPROM data: 0x");

39

40 Serial.println(eeprom_crc(), HEX);

41

42 Serial.print("\n\nDone!");

43}

44

45void loop() {

46

47 /* Empty loop */

48}

49

50unsigned long eeprom_crc(void) {

51

52 const unsigned long crc_table[16] = {

53

54 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,

55

56 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,

57

58 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,

59

60 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c

61

62 };

63

64 unsigned long crc = ~0L;

65

66 for (int index = 0 ; index < EEPROM.length() ; ++index) {

67

68 crc = crc_table[(crc ^ EEPROM[index]) & 0x0f] ^ (crc >> 4);

69

70 crc = crc_table[(crc ^ (EEPROM[index] >> 4)) & 0x0f] ^ (crc >> 4);

71

72 crc = ~crc;

(Video) Arduino Programming

73

74 }

75

76 return crc;

77}

EEPROM Get

The purpose of this example is to show how the put and get methods provide a different behaviour than write and read, that work on single bytes. Getting different variables from EEPROM retrieve a number of bytes that is related to the variable datatype.

1/***

2

3 eeprom_get example.

4

5 This shows how to use the EEPROM.get() method.

6

7 To pre-set the EEPROM data, run the example sketch eeprom_put.

8

9 This sketch will run without it, however, the values shown

10

11 will be shown from what ever is already on the EEPROM.

12

13 This may cause the serial object to print out a large string

14

15 of garbage if there is no null character inside one of the strings

16

17 loaded.

18

19 Written by Christopher Andrews 2015

20

21 Released under MIT licence.

22

23***/

24

25#include <EEPROM.h>

26

27void setup() {

28

29 float f = 0.00f; //Variable to store data read from EEPROM.

30

31 int eeAddress = 0; //EEPROM address to start reading from

32

33 Serial.begin(9600);

34

35 while (!Serial) {

36

37 ; // wait for serial port to connect. Needed for native USB port only

38

39 }

40

41 Serial.print("Read float from EEPROM: ");

42

43 //Get the float data from the EEPROM at position 'eeAddress'

44

45 EEPROM.get(eeAddress, f);

46

47 Serial.println(f, 3); //This may print 'ovf, nan' if the data inside the EEPROM is not a valid float.

48

49 /***

50

51 As get also returns a reference to 'f', you can use it inline.

52

53 E.g: Serial.print( EEPROM.get( eeAddress, f ) );

54

55 ***/

56

57 /***

58

59 Get can be used with custom structures too.

60

61 I have separated this into an extra function.

62

63 ***/

64

65 secondTest(); //Run the next test.

66}

67

68struct MyObject {

69

70 float field1;

71

72 byte field2;

73

74 char name[10];

75};

76

77void secondTest() {

78

79 int eeAddress = sizeof(float); //Move address to the next byte after float 'f'.

80

81 MyObject customVar; //Variable to store custom object read from EEPROM.

82

83 EEPROM.get(eeAddress, customVar);

84

85 Serial.println("Read custom object from EEPROM: ");

86

87 Serial.println(customVar.field1);

88

89 Serial.println(customVar.field2);

90

91 Serial.println(customVar.name);

92}

93

94void loop() {

95

96 /* Empty loop */

97}

EEPROM Iteration

The purpose of this example is to show how to go through the whole EEPROM memory space with different approaches. The code provided doesn't run on its own but should be used as a surce of code snippets to be used elsewhere.

1/***

2

3 eeprom_iteration example.

4

5 A set of example snippets highlighting the

6

7 simplest methods for traversing the EEPROM.

8

9 Running this sketch is not necessary, this is

10

11 simply highlighting certain programming methods.

12

13 Written by Christopher Andrews 2015

14

15 Released under MIT licence.

16

(Video) Build an Arduino EEPROM programmer

17***/

18

19#include <EEPROM.h>

20

21void setup() {

22

23 /***

24

25 Iterate the EEPROM using a for loop.

26

27 ***/

28

29 for (int index = 0 ; index < EEPROM.length() ; index++) {

30

31 //Add one to each cell in the EEPROM

32

33 EEPROM[ index ] += 1;

34

35 }

36

37 /***

38

39 Iterate the EEPROM using a while loop.

40

41 ***/

42

43 int index = 0;

44

45 while (index < EEPROM.length()) {

46

47 //Add one to each cell in the EEPROM

48

49 EEPROM[ index ] += 1;

50

51 index++;

52

53 }

54

55 /***

56

57 Iterate the EEPROM using a do-while loop.

58

59 ***/

60

61 int idx = 0; //Used 'idx' to avoid name conflict with 'index' above.

62

63 do {

64

65 //Add one to each cell in the EEPROM

66

67 EEPROM[ idx ] += 1;

68

69 idx++;

70

71 } while (idx < EEPROM.length());

72

73} //End of setup function.

74

75void loop() {}

EEPROM Put

The purpose of this example is to show the

EEPROM.put()

method that writes data on EEPROM using also the EEPROM.update() that writes data only if it is different from the previous content of the locations to be written. The number of bytes written is related to the datatype or custom structure of the variable to be written.

1/***

2

3 eeprom_put example.

4

5 This shows how to use the EEPROM.put() method.

6

7 Also, this sketch will pre-set the EEPROM data for the

8

9 example sketch eeprom_get.

10

11 Note, unlike the single byte version EEPROM.write(),

12

13 the put method will use update semantics. As in a byte

14

15 will only be written to the EEPROM if the data is actually

16

17 different.

18

19 Written by Christopher Andrews 2015

20

21 Released under MIT licence.

22

23***/

24

25#include <EEPROM.h>

26

27struct MyObject {

28

29 float field1;

30

31 byte field2;

32

33 char name[10];

34};

35

36void setup() {

37

38 Serial.begin(9600);

39

40 while (!Serial) {

41

42 ; // wait for serial port to connect. Needed for native USB port only

43

44 }

45

46 float f = 123.456f; //Variable to store in EEPROM.

47

48 int eeAddress = 0; //Location we want the data to be put.

49

50 //One simple call, with the address first and the object second.

51

52 EEPROM.put(eeAddress, f);

53

54 Serial.println("Written float data type!");

55

56 /** Put is designed for use with custom structures also. **/

57

58 //Data to store.

59

60 MyObject customVar = {

(Video) Arduino Tutorial | How to Organize your Code using Multi File Tabs on the Arduino IDE

61

62 3.14f,

63

64 65,

65

66 "Working!"

67

68 };

69

70 eeAddress += sizeof(float); //Move address to the next byte after float 'f'.

71

72 EEPROM.put(eeAddress, customVar);

73

74 Serial.print("Written custom data type! \n\nView the example sketch eeprom_get to see how you can retrieve the values!");

75}

76

77void loop() {

78

79 /* Empty loop */

80}

EEPROM Read

This example illustrates how to read the value of each byte EEPROM using the

EEPROM.read()

function, and how to print those values to the serial window of the Arduino Software (IDE).

1/*

2 * EEPROM Read

3 *

4 * Reads the value of each byte of the EEPROM and prints it

5 * to the computer.

6 * This example code is in the public domain.

7 */

8

9#include <EEPROM.h>

10

11// start reading from the first byte (address 0) of the EEPROM

12int address = 0;

13byte value;

14

15void setup() {

16 // initialize serial and wait for port to open:

17 Serial.begin(9600);

18 while (!Serial) {

19 ; // wait for serial port to connect. Needed for native USB port only

20 }

21}

22

23void loop() {

24 // read a byte from the current address of the EEPROM

25 value = EEPROM.read(address);

26

27 Serial.print(address);

28 Serial.print("\t");

29 Serial.print(value, DEC);

30 Serial.println();

31

32 /***

33 Advance to the next address, when at the end restart at the beginning.

34

35 Larger AVR processors have larger EEPROM sizes, E.g:

36 - Arduino Duemilanove: 512 B EEPROM storage.

37 - Arduino Uno: 1 kB EEPROM storage.

38 - Arduino Mega: 4 kB EEPROM storage.

39

40 Rather than hard-coding the length, you should use the pre-provided length function.

41 This will make your code portable to all AVR processors.

42 ***/

43 address = address + 1;

44 if (address == EEPROM.length()) {

45 address = 0;

46 }

47

48 /***

49 As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an

50 EEPROM address is also doable by a bitwise and of the length - 1.

51

52 ++address &= EEPROM.length() - 1;

53 ***/

54

55 delay(500);

56}

EEPROM Update

The purpose of this example is to show the

EEPROM.update()

method that writes data only if it is different from the previous content of the locations to be written. This solution may save execution time because every write operation takes 3.3 ms; the EEPROM has also a limit of 100,000 write cycles per single location, therefore avoiding rewriting the same value in any location will increase the EEPROM overall life.

1/***

2 EEPROM Update method

3

4 Stores values read from analog input 0 into the EEPROM.

5 These values will stay in the EEPROM when the board is

6 turned off and may be retrieved later by another sketch.

7

8 If a value has not changed in the EEPROM, it is not overwritten

9 which would reduce the life span of the EEPROM unnecessarily.

10

11 Released using MIT licence.

12 ***/

13

14#include <EEPROM.h>

15

16/** the current address in the EEPROM (i.e. which byte we're going to write to next) **/

17int address = 0;

18

19void setup() {

20 /** Empty setup **/

21}

22

23void loop() {

24 /***

25 need to divide by 4 because analog inputs range from

26 0 to 1023 and each byte of the EEPROM can only hold a

27 value from 0 to 255.

28 ***/

29 int val = analogRead(0) / 4;

30

31 /***

32 Update the particular EEPROM cell.

33 these values will remain there when the board is

34 turned off.

35 ***/

36 EEPROM.update(address, val);

37

38 /***

39 The function EEPROM.update(address, val) is equivalent to the following:

40

(Video) Nextion+Arduino Tutorial #1 Beginner's Guide

41 if( EEPROM.read(address) != val ){

42 EEPROM.write(address, val);

43 }

44 ***/

45

46

47 /***

48 Advance to the next address, when at the end restart at the beginning.

49

50 Larger AVR processors have larger EEPROM sizes, E.g:

51 - Arduino Duemilanove: 512 B EEPROM storage.

52 - Arduino Uno: 1 kB EEPROM storage.

53 - Arduino Mega: 4 kB EEPROM storage.

54

55 Rather than hard-coding the length, you should use the pre-provided length function.

56 This will make your code portable to all AVR processors.

57 ***/

58 address = address + 1;

59 if (address == EEPROM.length()) {

60 address = 0;

61 }

62

63 /***

64 As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an

65 EEPROM address is also doable by a bitwise and of the length - 1.

66

67 ++address &= EEPROM.length() - 1;

68 ***/

69

70 delay(100);

71}

EEPROM Write

This example illustrates how to store values read from analog input 0 into the EEPROM using the

EEPROM.write()

function. These values will stay in the EEPROM when the board is turned off and may be retrieved later by another sketch.

1/*

2

3 * EEPROM Write

4

5 *

6

7 * Stores values read from analog input 0 into the EEPROM.

8

9 * These values will stay in the EEPROM when the board is

10

11 * turned off and may be retrieved later by another sketch.

12

13 */

14

15#include <EEPROM.h>

16

17/** the current address in the EEPROM (i.e. which byte we're going to write to next) **/

18int addr = 0;

19

20void setup() {

21

22 /** Empty setup. **/

23}

24

25void loop() {

26

27 /***

28

29 Need to divide by 4 because analog inputs range from

30

31 0 to 1023 and each byte of the EEPROM can only hold a

32

33 value from 0 to 255.

34

35 ***/

36

37 int val = analogRead(0) / 4;

38

39 /***

40

41 Write the value to the appropriate byte of the EEPROM.

42

43 these values will remain there when the board is

44

45 turned off.

46

47 ***/

48

49 EEPROM.write(addr, val);

50

51 /***

52

53 Advance to the next address, when at the end restart at the beginning.

54

55 Larger AVR processors have larger EEPROM sizes, E.g:

56

57 - Arduno Duemilanove: 512b EEPROM storage.

58

59 - Arduino Uno: 1kb EEPROM storage.

60

61 - Arduino Mega: 4kb EEPROM storage.

62

63 Rather than hard-coding the length, you should use the pre-provided length function.

64

65 This will make your code portable to all AVR processors.

66

67 ***/

68

69 addr = addr + 1;

70

71 if (addr == EEPROM.length()) {

72

73 addr = 0;

74

75 }

76

77 /***

78

79 As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an

80

81 EEPROM address is also doable by a bitwise and of the length - 1.

82

83 ++addr &= EEPROM.length() - 1;

84

85 ***/

86

87 delay(100);

88}

(Video) M5Stack Arduino IDE Setup in 5 minutes

FAQs

How do you write and interpret EEPROM? ›

Reading from the EEPROM basically follows the same three step process as writing to the EEPROM: Send the Most Significant Byte of the memory address that you want to write to. Send the Least Significant Byte of the memory address that you want to write to. Ask for the data byte at that location.

How many times can you write to an EEPROM? ›

EEPROM is specified to handle 100,000 read/erase cycles. This means you can write and then erase/re-write data 100,000 times before the EEPROM will become unstable.

How do I declare EEPROM? ›

It is very easy. You essentially use the EEPROM. write() function, and iterate over the length of the EEPROM, and write 0 at each address.

How many times EEPROM can be erased? ›

EEPROM technology evolved to address these challenges. Based on the existing EPROM structure, EEPROM can be erased and programmed electrically. Most EEPROM chips have a life span of 10,000 to 100,000 write cycles, which is considerably greater than the write cycles of EPROM chips.

What does P mean in EEPROM? ›

EEPROM stands for Electrically Erasable Programmable Read-Only Memory.

How do you store values in EEPROM? ›

Saving a value to EEPROM
  1. Don't write multiple values on the same address, otherwise you will lose the previously written number (unless that's what you want to do)
  2. A memory location can only store one byte of data. ...
  3. Don't write a value to the EEPROM inside an infinite loop without any delay or check for user input.

What are the major drawbacks of EEPROM? ›

Drawbacks or disadvantages of EEPROM

EEPROM requires different voltages for erasing, reading and writing the data. ➨EEPROM has limited data retention time period which is approx. 10 years for most of the devices. ➨External serial EEPROM type requires long time to access.

Can EEPROM be corrupted? ›

An EEPROM data corruption can be caused by two situations when the voltage is too low. First, a regular write sequence to the EEPROM requires a minimum voltage to operate correctly. Second, the CPU itself can execute instructions incorrectly, if the supply voltage is too low.

Does EEPROM store data permanently? ›

This is a small space that can store byte variables. The variables stored in the EEPROM kept there, event when you reset or power off the Arduino. Simply, the EEPROM is permanent storage similar to a hard drive in computers.

How many cycles are allowed to a EEPROM? ›

1000 write cycles are allowed to EPROM.

How long does EEPROM store data? ›

Data saved in an EEPROM chip is permanent, until the client chooses to delete and replace the data that it contains. The information saved in an EEPROM chip is not lost even when power is turned off. Here only one external power supply device is used . Write and erase operation are performed on byte basis.

What is the difference between EEPROM and EEPROM? ›

There is a basic difference between EPROM and EEPROM. One can erase the data from EPROM using the UV (Ultra Violet) rays. On the other hand, erasing data from EEPROM requires the usage of electric signals.

Why do EEPROMs fail? ›

Weak cells” are most likely responsible for early EEPROM failures. “Weak cells” can be induced by process and/or poorly programmed timing and/or noise margin. properly. margin needs to be extensively analyzed to avoid possible program timing induced weak cells, which in turn may become early bit failures.

How long does EEPROM memory last without power? ›

All EEPROMs (Flash ROM), and EPROMs chips have a finite data retention time. Typically 10-15 years and after that they just start to forget their data.

Can EEPROM wear out? ›

For a device like the 16F88, the typical eeprom endurance is 1M ee-writes. When using 4 writes a second, the eeprom will wear out in approx. 3 days...

Does EEPROM need a battery? ›

No, the EEPROM Memory Cassette does not require a battery.

Is EEPROM rewritable? ›

(Electrically Erasable Programmable Read Only Memory) A rewritable storage chip that holds its content without power. EEPROMs are byte addressable but must be erased before being rewritten.

How do you identify a EEPROM chip? ›

The chip could have several numbers including date codes, but the important one has 24, 25 or 93 in it. It will usually start with a letter for manufacturer (AT for Atmel, M for STM etc) but not always and may be followed by a letter or two for series. It will end in a number giving the memory size, in bits not bytes.

What happens when EEPROM wears out? ›

Cell overuse and wear out

Exceeding a Flash sector's or an EEPROM cell's guaranteed erase/write cycles will eventually burn through the memory cell's gate insulation, causing permanent damage and resulting in the inability of the memory cell to retain programmed data.

How do you destroy data on EEPROM? ›

Unlike PROM (Programmable Read only Memory) It is possible to erase the data from a volatile EPROM by exposing it to a high-powered ultraviolet light source through a device known as an EPROM eraser. Programmers use an EPROM programmer to write data on the EPROM.

What is the default value of EEPROM? ›

The default value of bytes in the EEPROM is 255 (hexadecimal 0xFF) so reading an object on a new device will return an object filled with 0xFF.

What is the life of EEPROM? ›

The EEPROM memory has a specified life of 100,000 write/erase cycles, so you may need to be careful about how often you write to it.

Why is EEPROM called read-only memory? ›

Electrically erasable programmable read-only memory (EEPROM) is based on a similar semiconductor structure to EPROM, but allows its entire contents (or selected banks) to be electrically erased, then rewritten electrically, so that they need not be removed from the computer (whether general-purpose or an embedded ...

Does EEPROM lose memory when turned off? ›

A programmed EPROM can retain its data for 10 to 20 years. Some EPROMs can retain data for even longer. The data is retained even when power is cut off and can be retrieved after the power is turned back on, making it a type of non-volatile memory. To erase and reprogram the EPROM, UV light is required.

Is BIOS stored in EEPROM? ›

In modern PCs the BIOS is stored in rewritable EEPROM or NOR flash memory, allowing the contents to be replaced and modified. This rewriting of the contents is sometimes termed flashing.

Which is faster RAM or EEPROM? ›

RAM (Random Access Memory) is typically volatile, meaning that if the power goes away so does the memory's contents. The big advantage with RAM is that the access time for read and write is far faster than any EPROM or EEPROM.

How do you read EEPROM data? ›

Reading from the EEPROM basically follows the same three-step process as writing to the EEPROM: Send the Most Significant Byte of the memory address that you want to write to. Send the Least Significant Byte of the memory address that you want to write to. Ask for the data byte at that location.

How do you know if an EEPROM is empty? ›

Is an EEPROM location ever empty ? Use the first few bytes of the EEPROM as a signature word (2-8 bytes). If they are all 0xff, ,then the EEPROM is "empty". Initialize it as you want, then set the signature word to a unique value.

How do you calculate EEPROM size? ›

One byte per address is (32768 * 8 ) = 262144 bits.

Is EEPROM NAND or NOR? ›

Flash uses NAND-type memory, while EEPROM uses NOR type. Flash is block-wise erasable, while EEPROM is byte-wise erasable.

How much memory does EEPROM have? ›

EEPROM capacity is measured in bits and not bytes. A 256K EEPROM will hold 256Kbits of data, in other words, just 32KB.

What devices use EEPROM? ›

EEPROM is mainly used in devices (like digital potentiometers, digital temperature sensors and real-time clocks) to save calibration or similar data that is required when the power is switched off or removed. EEPROMs are recognized as arrays of floating gate transistors.

Can you reset EEPROM? ›

The memory can be reset after a power loss, a system reset or an interruption in protocol. The project resets memory after a write and read operation continuously. To reset memory, EEPROM is clocked nine times followed by the start condition.

Can you use EEPROM as RAM? ›

EEPROM is not suitable as a substitute (or extension of) a computer's internal RAM, since as another answer pointed out, it takes much longer to write than to read, and you can eventually wear it out. External RAM (Random Access Memory) is like the RAM inside your computer chip, except that it is harder to access.

How do you write an EEPROM string? ›

To save a String into the EEPROM, we'll have to write each byte separately, one by one. Also, when you write the String, you know how long it is. But if you upload another program to read a String you previously stored, how can you know how many bytes you have to read from EEPROM?

What is EEPROM and how does it work? ›

EEPROM (also called E2PROM) stands for electrically erasable programmable read-only memory and is a type of non-volatile memory used in computers, usually integrated in microcontrollers such as smart cards and remote keyless systems, or as a separate chip device to store relatively small amounts of data by allowing ...

What is EEPROM understood for? ›

EEPROM is non-volatile memory used in electronic devices to store data that must be saved when power is removed. This non-volatile memory is particularly important when an application requires different start- up configurations than the factory default settings.

How do I edit EEPROM data? ›

Changing a Specific Byte
  1. Open the Project Properties window.
  2. Select your programming tool window and select 'Memories to Program' menu.
  3. Choose the 'Manually select memories and ranges'.
  4. Check the 'Preserve EEPROM Memory' box and then select the range of memory to leave untouched. ...
  5. Click Apply and OK to close the window.

How data is erased in EEPROM? ›

To erase data from an EEPROM device, a negative pulse is applied, which causes the electrons to tunnel back out and return the floating gate to near its original state. With the COMSOL® software, you can simulate this program and erase process and calculate many different EEPROM device characteristics.

What happens when EEPROM fails? ›

What Does an 'EEPROM Test Failed' Error Mean? If there are errors found in the memory, the "EEPROM Test Failed" error will be displayed. One potential issue caused by faulty EEPROM chips includes incorrect processing of printer command code: which may lead to data errors and incorrect physical output.

Is EEPROM obsolete? ›

It's found a nice niche as a replacement for battery-backed SRAM and in heavily used dataloggers, but it's not ready to obsolete EEPROM.

Can EEPROM be overwritten? ›

EEPROM: Electrically Erasable Programmable Read-Only Memory. Can be erased or re-written under program control.

Videos

1. Arduino MASTERCLASS | Full Programming Workshop in 90 Minutes!
(Programming Electronics Academy)
2. Arduino Tutorial: Using external voltage reference
(NestedLoop)
3. Arduino Course for Beginners - Open-Source Electronics Platform
(freeCodeCamp.org)
4. Arduino Tutorial 11: Understanding the Arduino Serial Port and Print Commands
(Paul McWhorter)
5. Arduino Tutorial 4: Understanding Arduino Variables
(Paul McWhorter)
6. You can learn Arduino in 15 minutes.
(Afrotechmods)
Top Articles
Latest Posts
Article information

Author: Margart Wisoky

Last Updated: 03/30/2023

Views: 5761

Rating: 4.8 / 5 (58 voted)

Reviews: 89% of readers found this page helpful

Author information

Name: Margart Wisoky

Birthday: 1993-05-13

Address: 2113 Abernathy Knoll, New Tamerafurt, CT 66893-2169

Phone: +25815234346805

Job: Central Developer

Hobby: Machining, Pottery, Rafting, Cosplaying, Jogging, Taekwondo, Scouting

Introduction: My name is Margart Wisoky, I am a gorgeous, shiny, successful, beautiful, adventurous, excited, pleasant person who loves writing and wants to share my knowledge and understanding with you.