Andy
I think your code writes a buffer of data and reads a buffer of data but doesn't control the EEPROM's internal address. That means that (assuming after a power cycle) it will write to the page address 0, 1, 2,3,..n and then read back from the address n+1, n+2, n+3 etc. which will not read back the data that has been written (and the compare will fail).
This means that you need to control the internal address pointer (the first byte of the data sent when writing and also write it just before reading back again, as described in the EEPROM's data sheet).
The uTasker project includes support for the EEPROM that you are using (it also simulates it) and below is the reference code to write and read to/from page 3 (for example).
#define ADD_EEPROM_READ (0xa1 + (3 << 1)) // read address of EEPROM (page 3)
#define ADD_EEPROM_WRITE (0xa0 + (3 << 1)) // write address of EEPROM (page 3)
#define OUR_I2C_CHANNEL 0 // use I2C 0
static QUEUE_HANDLE I2CPortID = NO_ID_ALLOCATED; // handle of I2C interface
// Open I2C interface to communicate with an EEPROM, RTC, etc.
//
static void fnConfigI2C_Interface(void)
{
I2CTABLE tI2CParameters;
tI2CParameters.Channel = OUR_I2C_CHANNEL;
tI2CParameters.usSpeed = 100; // 100k
tI2CParameters.Rx_tx_sizes.TxQueueSize = 64; // transmit queue size
tI2CParameters.Rx_tx_sizes.RxQueueSize = 64; // receive queue size
tI2CParameters.Task_to_wake = 0; // no wake on transmission
if ((I2CPortID = fnOpen(TYPE_I2C, FOR_I_O, &tI2CParameters)) != NO_ID_ALLOCATED) { // open the channel with defined configurations
static const unsigned char ucSetEEPROMAddress0[] = {ADD_EEPROM_WRITE, 0}; // command to set address to read to 0
static const unsigned char ucReadEEPROM[] = {16, ADD_EEPROM_READ, OWN_TASK}; // command to start a read of 16 bytes with the task scheduled when the read has completed
fnWrite(I2CPortID, (unsigned char *)ucSetEEPROMAddress0, sizeof(ucSetEEPROMAddress0)); // write the EEPROM address to read
fnRead(I2CPortID, (unsigned char *)ucReadEEPROM, 0); // start the read process of 16 bytes
}
}
Reception handler
if (fnMsgs(I2CPortID) != 0) { // if I2C message waiting
while ((Length = fnRead(I2CPortID, ucInputMessage, MEDIUM_MESSAGE)) != 0) {
static const unsigned char ucSetWriteEEPROM1[] = {ADD_EEPROM_WRITE, 3, 5}; // prepare write of one byte to address 3
static const unsigned char ucSetWriteEEPROM2[] = {ADD_EEPROM_WRITE, 5, 3, 4, 5, 6, 7, 8, 9, 10}; // prepare write of multiple bytes to address 5
int x = 0;
while (x < Length) { // display received bytes
fnDebugHex(ucInputMessage[x++], (WITH_LEADIN | WITH_SPACE | 1));
}
fnDebugMsg("\r\n");
// Now change the contents using two writes
//
fnWrite(I2CPortID, (unsigned char *)&ucSetWriteEEPROM1, sizeof(ucSetWriteEEPROM1)); // start single byte write
fnWrite(I2CPortID, (unsigned char *)&ucSetWriteEEPROM2, sizeof(ucSetWriteEEPROM2)); // start page write
}
}
On first use it reads and display the first 16 bytes in the page, then write 0x05 to address 3, followed by 3,4,5,..0xa to a addresses 5..12.
After a power cycle the values written (to verify they are non-volatile) are shown to be there as expected.
A binary file to do this on the FRDM-K64F is attached, whereby the I2C connections are on PTE24 and PTE25 and the debug interface on OpenSDA COM at 115200Baud.
Regards
Mark
Complete K64 solutions, training and support: http://www.utasker.com/kinetis.html
Kinetis K64:
- http://www.utasker.com/kinetis/FRDM-K64F.html
- http://www.utasker.com/kinetis/TWR-K64F120M.html
- http://www.utasker.com/kinetis/TEENSY_3.5.html
- http://www.utasker.com/kinetis/Hexiwear-K64F.html
