Saving arrays in EEPROM using ARDUINOMEGA

EEPROM.write() and EEPROM.read() operate on bytes. To save an int:

EEPROM.write(0, highByte(reference));
EEPROM.write(1, lowByte(reference));

To read an int:

int val = (EEPROM.read(0) << 8) + EEPROM.read(1);

You might want to look at the EEPROM_readAnything() and EEPROM_writeAnything() functions:
http://www.arduino.cc/playground/Code/EEPROMWriteAnything

Ok didn't know this....
So I am using 2 addresses inside the EEPROM now?

That is a problem....

So I am using 2 addresses inside the EEPROM now?

So you've got at least 510 more to play with

That's not a problem - read and understand reply #11

No it is a problem...
The integer of the reference # varies from 322 to 500 (so in this case it the above procedure needs to be done, if I am correctly understanding)
While the gas # varies from 500 to 1200. Which means I am taking more than one and more addresses

But I need to save these #s in an array which is proportional to the reference # and gas

meaning array[reference] = gas

So how can I know which address it is if each refernce # and gas amount is different entered by the user??

I don't know If I described it correctly....

Make it simple - always store and recover "int"s.
Read reply #11.
Really, there is no problem.

I don't know about the application and description of the needs, but simple way to get high and low byte would be like this.

If your integer is 1234, just do 1234/256=4
4 is the value of your highbyte

Then next you take (4256) out from your original int; 1234 - (4256) =210
210 is your lower byte.

Then, when you need to know the address your about to write these values.

If the pointer in the array is, lets say 51, so you have value 1234 in YourArray[51], you write it to eeprom;
EEPROM.write( (251) , lowByte );
EEPROM.write( ( (2
51) + 1) , highByte );

I'm a bit tired, so there's probably errors in my text, please, don't hesitate to say that was bull...it.

Cheers,
Kari

EDIT. I have never used eeprom library, that maybe wrong syntax...

Yes i read it.
So do I put the writeanyting and readanyting as functions in my program?
Can I save them in a library of some sort?

tnx

Can I save them in a library of some sort?

You could put them in a simple header file - they are simple templates.
As long as you know how big your objects are, you can store and read back any size, up to the maximum size of the EEPROM on your processsor.
I'd probably recommend describing a single struct to store all the values you need to save, so a single call will save/restore all your values, though I'd probably rewrite "writeAnything" to only write a byte if it had changed (read it first to compare)

The "readAnything", is not working prop...

This is my code:

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

template <class T> int EEPROM_readAnything(int ee, T& value)
{
    byte* p = (byte*)(void*)&value;
    int i;
    for (i = 0; i < sizeof(value); i++)
	  *p++ = EEPROM.read(ee++);
    return i;
}
void setup()
{
  Serial.begin(9600);
  int reference = 323;
  int gas = 1234;
  int serial;
  int serial1;
  
  
    EEPROM_writeAnything(0, reference);
    serial = EEPROM_readAnything(0,reference);
    
   
   Serial.print(serial);
    
    
}
void loop()
{
    
}

2 is displayed now.

Does it work properly???

Yes it works perfectly.
"reference" is two bytes long, so 2 is printed

Did you mean to print the value of "reference" you read back from the EEPROM?

(Is your question mark key a bit sticky?)

Hehe no it ain't im just stupid lol.
Ok so it prints 2 since its 2 bytes....(and NO . mark key aint sticky :P)

Yes how can I print the value stored in the EEPROM?
tnx

Yes how can I print the value stored in the EEPROM?

Serial.print(reference);

because that's the last value you read back

Yes but not like that!
I need to know the address and if it has been correctly stored in EEPROM...

I need to know the address and if it has been correctly stored in EEPROM

Only YOU know the address, but if you want to see what was read back, try

EEPROM_writeAnything(0, reference);
EEPROM_readAnything(0,serial);
Serial.print(serial);

2...
But how can it be that I am storing the reference # inside address 0 only?(I dont think it is...)
since if i write
serial = eeprom.read(0)
323 is not displayed

2...

Now your full-stop (period) key is sticking.
Turn your keyboard over and give it a shake.

Let me post the sketch as I have it at the moment, just so there is no further misunderstanding:

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

template <class T> int EEPROM_readAnything(int ee, T& value)
{
    byte* p = (byte*)(void*)&value;
    int i;
    for (i = 0; i < sizeof(value); i++)
	  *p++ = EEPROM.read(ee++);
    return i;
}
void setup()
{
  Serial.begin(9600);
  int reference = 323;
  int serial;
 
  EEPROM_writeAnything(0, reference);
  EEPROM_readAnything(0,serial);
       
  Serial.print(serial);
}
void loop()
{}

SRY AAAAAAA,I didn't upload it (getting late shit)!!
Ok so 323 :smiley:
One more question before you kill me please.
So 323 is stored in address 0?

tnx again

So 323 is stored in address 0?

Don't be afraid, I won't kill you!

No, 323 cannot be stored in address zero because 323 is too big to be stored in a single byte, so it is stored in address 0 and address 1.

No, 323 cannot be stored in address zero because 323 is too big to be stored in a single byte, so it is stored in address 0 and address 1.

Which is why EEPROM_readAnything returned 2. That is the next available address to write to/read from.

It is stored in address 0 1 and 2 i think.

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

template <class T> int EEPROM_readAnything(int ee, T& value)
{
    byte* p = (byte*)(void*)&value;
    int i;
    for (i = 0; i < sizeof(value); i++)
	  *p++ = EEPROM.read(ee++);
    return i;
}
void setup()
{
  Serial.begin(9600);
  int reference = 323;
  int serial;
 
  EEPROM_writeAnything(0, reference);
  //EEPROM_readAnything(0,serial);
  serial = EEPROM.read(0) + EEPROM.read(1) + EEPROM.read(2);
       
  Serial.print(serial);
}
void loop()
{}

serial = EEPROM.read(0) + EEPROM.read(1) + EEPROM.read(2);
Removing read(2) will not give 323