Home / Questions / 185271
Accepted
Emiliano Torres
Asked: 2020-08-01 10:35:45 +0800 CST 2020-08-01 10:35:45 +0800 CST

Arduino - Error erasing EEPROM memory in MEGA

  • 772

I'm new to Arduino and I'm having a problem with Arduino...I have 2 boards. One is an Arduino UNO and one is an Arduino Mega. I run the following little program in both, the only thing it does is clean the EEPROM memory and show how it turned out. The idea is that the output should always be 0 because memory is being erased. I put the code and the different outputs.

#include <EEPROM.h>

void EEPROMWriteInt(int address, int value); //2 Bytes, LE DIGO COMO GUARDAR
int EEPROMReadInt(int address);  

int32_t numberSens = 0; 
int32_t numberDESP = 0; 
int32_t numberGI = 0;
int32_t numberGD = 0;

void setup() {
  Serial.begin(9600);
  for (int nL = 0; nL < EEPROM.length(); nL++) { 
    EEPROM.write(nL, 0);
  }

  numberSens = EEPROMReadInt(1);
  numberDESP = EEPROMReadInt(3);
  numberGI = EEPROMReadInt(5);
  numberGD = EEPROMReadInt(7);

  Serial.print("numberSens ");
  Serial.println(numberSens);
  Serial.print("numberDESP ");
  Serial.println(numberDESP);
  Serial.print("numberGI ");
  Serial.println(numberGI);
  Serial.print("numberGD ");
  Serial.println(numberGD);
}

void loop() {

}

void EEPROMWriteInt(int address, int value) {
  byte hiByte = highByte(value);
  byte loByte = lowByte(value);

  EEPROM.write(address, hiByte);
  EEPROM.write(address + 1, loByte);   
}

int EEPROMReadInt(int address)
{
  byte hiByte = EEPROM.read(address);
  byte loByte = EEPROM.read(address + 1);

  return word(hiByte, loByte); 
}

So the output on Arduino UNO is:

numberSens 0
numberDESP 0
numberGI 0
numberGD 0

The output on Arduino MEGA is:

numberSens 4353
numberDESP 1408
numberGI 0
numberGD 256

Does anyone have an idea or a clue why this might be happening? I thank you in advance.

c++

2 Answers

  1. The write() method works with bytes, if you are going to use different types of variables, such as int or even data structures, use the put() and get() methods:

    #include <EEPROM.h>
const int NEXT_POS = sizeof(int) + 1; // siguiente posicion a escribir de la eeprom para valores int
const int MAX_REGISTERS = EEPROM.length()/sizeof(int); // Maximo de registros segun el tipo de variable,en este caso int
const int FIRST_POS = 0; // Primer registro eeprom
void setup() {
  Serial.begin(9600);
  int position = 0;
  for(int cont = 0;cont < MAX_REGISTERS;cont++){ // Pone un 0 en todos los registros
    EEPROM.put(position,0);
    position += NEXT_POS; 
    delay(10);
  }
  position = 0;
  int value;
   for(int cont = 0;cont < MAX_REGISTERS;cont++){ // Lectura
    EEPROM.get(position,value);
    position += NEXT_POS; 
    Serial.println(value);
    delay(10);
  }
}

void loop() {
  // put your main code here, to run repeatedly:

}

    I haven't tried it on the mega, it should work.

    • 1
  2. Best Answer

    your example worked fine on one and poorly on mega. BUT I found the problem(s). The first problem is that the MEGA has the bytes in front (0 to 6 approx. damaged). I realized this since the same example I do save in higher memory locations and it works correctly. The second problem was that int32_t occupies 4 bytes and in my example I am trying to write it in 2 bytes, so the first number saves it well, but from the second it starts to overlap. To solve it, I used a read method and a write method that use the number of bytes according to the data type. I leave the code in case it helps someone. Thank you all.

    template <class T> int EEPROM_write(int ee, const T& value);
template <class T> int EEPROM_read(int ee, T& value);

template <class T> int EEPROM_write(int ee, const T& value)
{
    const byte* p = (const byte*)(const void*)&value;
    unsigned int i;
    for (i = 0; i < sizeof(value); i++)
          EEPROM.write(ee++, *p++);
    return i;
}

template <class T> int EEPROM_read(int ee, T& value)
{
    byte* p = (byte*)(void*)&value;
    unsigned int i;
    for (i = 0; i < sizeof(value); i++)
          *p++ = EEPROM.read(ee++);
    return i;
}
    • 0