next topic »

[Reply #15 on:]

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

[Reply #16 on:]

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 (4*256) out from your original int; 1234 - (4*256) =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( (2*51) , 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...

[Reply #17 on:]

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

[Reply #18 on:]

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)

[Reply #19 on:]

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

This is my code:

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???

[Reply #20 on:]

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?)

[Reply #21 on:]

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

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

[Reply #22 on:]

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

Code:

Serial.print(reference);

because that's the last value you read back

[Reply #23 on:]

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

[Reply #24 on:]

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

Code:

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

[Reply #25 on:]

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

[Reply #26 on:]

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:

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 serial;
 
  EEPROM_writeAnything(0, reference);
  EEPROM_readAnything(0,serial);
      
  Serial.print(serial);
}
void loop()
{}

[Reply #27 on:]

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

tnx again

[Reply #28 on:]

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.

[Reply #29 on:]

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.