How to write a LONG to EEPROM??

[PCM programmer]

My idea is, don't re-invent the wheel. I think your problem is that
you are re-writing low-level code that is already done in the CCS
eeprom driver files. So you're distracted from the actual problem,
which is how to split up a word into bytes for writing, and how to
re-join the two bytes together after reading. Notice in the code
below that by using the existing driver, all effort is put into solving
the actual problem and not into low-level i2c stuff. Also, the two
things you want to do, are made into functions. These can then
be re-used in the future, whereas your inline low-level stuff is not
easily re-usable. Making things into routines and re-using them
later is a key point in being a productive programmer.

[Ttelmah]

As a comment, are you sure you are using the same compiler version that worked for the floats?. There was a fault some time ago, with the CCS compiler, _incorrectly_ incrementing pointers by 1, rather than the element size, and this would explain the previous code working. However with the casts, it should work OK....
Using 'make8/make16' or a union, seems much simpler to me.
Your 'Hi' macro, PCM, would have the same problem as the original code, if the compiler correctly handled pointer arithmetic...

Best Wishes

[Mark]

Not that this is the problem, but %ld is for signed numbers and long is unsigned by default.

In your original code, what happens if the address is 0x00FF and you write 2 bytes. Answer, the upper byte gets written to 0x0000.

[weg22]

Okay, I followed "newguy's" example code and now I get the output as getData=-1. Am I doing something wrong?

Thanks again,
-weg

[heath.g]

Just going back to your original issue. I have had the same problems. When working with INT16 and INT32 variables and needing to send them to an external device either serial or otherwise on a 8 bit data stream in a pain.

CCS assumes pointers arn't static so whenever you typecast a variable as a pointer it always uses the FSR.

So if you write:

INT8 i;
INT32 Address;

i = *(int)&Address + 1;

It will give you the 2nd byte in Address but at the expense of excessive instructions.

To overcome this I use a union and declare any INT16 or INT32 to their own union.

union uINT16
{
int16 INT16Data;
int8 Data[2];
};

When I declare the procedure:
void FRAMWrite(union uINT16 Address, int DataSize)

When calling the procedure just pass the address as a long. When you want to access the bytes in the Address do it like this:

SPI_WRITE2(Address.Data[1]); // set address high
SPI_WRITE2(Address.Data[0]); // set address low

Its a long winded way of getting the data but it works, and as in the previous example it cuts code space by half or more as the compiler now uses the constant value to retrieve the data.

I anybody has a better way I would be more than glad to see it.

[Mark]

Which EEPROM are you using?

[weg22]

Ttelmah: Yes, I am using an older version of PCM and that's probably why my code worked for floating point numbers.

Mark: I am using Microchip's 24FC515 EEPROM chip.

[PCM programmer]