➯ https://www.arduino.cc/en/Reference/EEPROM

• ATmega328P : 1KB (1024 bytes)
• ATmega168 & ATmega8 : 512 bytes
• ATmega1280 & ATmega2560 : 4 KB (4096 bytes)
• Arduino & Genuino 101 : emulated EEPROM space of 1KB (1024 bytes)

/*
 * EEPROM Clear
 *
 * Sets all of the bytes of the EEPROM to 0.
 * Please see eeprom_iteration for a more in depth
 * look at how to traverse the EEPROM.
 *
 * This example code is in the public domain.
 */
 
#include <EEPROM.h>
 
void setup() {
  // initialize the LED pin as an output.
  pinMode(13, OUTPUT);
 
  /***
    Iterate through each byte of the EEPROM storage.
 
    Larger AVR processors have larger EEPROM sizes, E.g:
    - Arduno Duemilanove: 512b EEPROM storage.
    - Arduino Uno:        1kb EEPROM storage.
    - Arduino Mega:       4kb EEPROM storage.
 
    Rather than hard-coding the length, you should use the pre-provided length function.
    This will make your code portable to all AVR processors.
  ***/
 
  for (int i = 0 ; i < EEPROM.length() ; i++) {
    EEPROM.write(i, 0);
  }
 
  // turn the LED on when we're done
  digitalWrite(13, HIGH);
}
 
void loop() {
  /** Empty loop. **/
}

/*
 * EEPROM Write
 *
 * Stores values read from analog input 0 into the EEPROM.
 * These values will stay in the EEPROM when the board is
 * turned off and may be retrieved later by another sketch.
 */
 
#include <EEPROM.h>
 
/** the current address in the EEPROM (i.e. which byte we're going to write to next) **/
int addr = 0;
 
void setup() {
  /** Empty setup. **/
}
 
void loop() {
  /***
    Need to divide by 4 because analog inputs range from
    0 to 1023 and each byte of the EEPROM can only hold a
    value from 0 to 255.
  ***/
 
  int val = analogRead(0) / 4;
 
  /***
    Write the value to the appropriate byte of the EEPROM.
    these values will remain there when the board is
    turned off.
  ***/
 
  EEPROM.write(addr, val);
 
  /***
    Advance to the next address, when at the end restart at the beginning.
 
    Larger AVR processors have larger EEPROM sizes, E.g:
    - Arduno Duemilanove: 512b EEPROM storage.
    - Arduino Uno:        1kb EEPROM storage.
    - Arduino Mega:       4kb EEPROM storage.
 
    Rather than hard-coding the length, you should use the pre-provided length function.
    This will make your code portable to all AVR processors.
  ***/
  addr = addr + 1;
  if (addr == EEPROM.length()) {
    addr = 0;
  }
 
  /***
    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an
    EEPROM address is also doable by a bitwise and of the length - 1.
 
    ++addr &= EEPROM.length() - 1;
  ***/
 
 
  delay(100);
}

/***
    eeprom_get example.
 
    This shows how to use the EEPROM.get() method.
 
    To pre-set the EEPROM data, run the example sketch eeprom_put.
    This sketch will run without it, however, the values shown
    will be shown from what ever is already on the EEPROM.
 
    This may cause the serial object to print out a large string
    of garbage if there is no null character inside one of the strings
    loaded.
 
    Written by Christopher Andrews 2015
    Released under MIT licence.
***/
 
#include <EEPROM.h>
 
void setup() {
 
  float f = 0.00f;   //Variable to store data read from EEPROM.
  int eeAddress = 0; //EEPROM address to start reading from
 
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
  Serial.print("Read float from EEPROM: ");
 
  //Get the float data from the EEPROM at position 'eeAddress'
  EEPROM.get(eeAddress, f);
  Serial.println(f, 3);    //This may print 'ovf, nan' if the data inside the EEPROM is not a valid float.
 
  /***
    As get also returns a reference to 'f', you can use it inline.
    E.g: Serial.print( EEPROM.get( eeAddress, f ) );
  ***/
 
  /***
    Get can be used with custom structures too.
    I have separated this into an extra function.
  ***/
 
  secondTest(); //Run the next test.
}
 
struct MyObject {
  float field1;
  byte field2;
  char name[10];
};
 
void secondTest() {
  int eeAddress = sizeof(float); //Move address to the next byte after float 'f'.
 
  MyObject customVar; //Variable to store custom object read from EEPROM.
  EEPROM.get(eeAddress, customVar);
 
  Serial.println("Read custom object from EEPROM: ");
  Serial.println(customVar.field1);
  Serial.println(customVar.field2);
  Serial.println(customVar.name);
}
 
void loop() {
  /* Empty loop */
}

/***
    eeprom_iteration example.
 
    A set of example snippets highlighting the
    simplest methods for traversing the EEPROM.
 
    Running this sketch is not necessary, this is
    simply highlighting certain programming methods.
 
    Written by Christopher Andrews 2015
    Released under MIT licence.
***/
 
#include <EEPROM.h>
 
void setup() {
 
  /***
    Iterate the EEPROM using a for loop.
  ***/
 
  for (int index = 0 ; index < EEPROM.length() ; index++) {
 
    //Add one to each cell in the EEPROM
    EEPROM[ index ] += 1;
  }
 
  /***
    Iterate the EEPROM using a while loop.
  ***/
 
  int index = 0;
 
  while (index < EEPROM.length()) {
 
    //Add one to each cell in the EEPROM
    EEPROM[ index ] += 1;
    index++;
  }
 
  /***
    Iterate the EEPROM using a do-while loop.
  ***/
 
  int idx = 0;  //Used 'idx' to avoid name conflict with 'index' above.
 
  do {
 
    //Add one to each cell in the EEPROM
    EEPROM[ idx ] += 1;
    idx++;
  } while (idx < EEPROM.length());
 
 
} //End of setup function.
 
void loop() {}