interfacing 24LC128 with MSP430

Hi rupesh,

do you know that TI has a I2C Master (and also a Slave) application note? You can find it here http://focus.ti.com/general/docs/litabsmultiplefilelist.tsp?literatureNumber=slaa382 .

Rgds
aBUGSworstnightmare 

this library is useless even TI people told me the code i posted is working i just want to know how to pass high address byte and low address byte  in 24LC128

Hi rupesh,

even if the library is useless from your point of view, a look at a 24LC128 data sheet wouldn't *g*!

The sequence for doing a Page Write on a 24LC128 is:

START-COMMAND BYTE -> ACK ->ADDRESS HIGH BYTE-> ACK ->ADDRESS LOW BYTE-> ACK -> DATA BYTE0-> ACK -> ... DATA BYTE63-> ACK -> STOP. Also refer to the picture below:

Pls note: Page write operations are limited to writing bytes within a single physical page, regardless of the number of bytes actually being written. Physical page boundaries start at addresses that are integer multiples of the page buffer size (or ‘page size’) and end at addresses that are integer multiples of [page size – 1]. If a Page Write command attempts to write across a physical page boundary, the result is that the data wraps around to the beginning of the current page (over- writing data previously stored there), instead of being written to the next page, as might be expected. It is, therefore, necessary for the application software to prevent page write operations that would attempt to cross a page boundary.

Rgds
aBUGSworstnightmare 

please see the above sample code posted in that code I have done the same thing . the code only writes on 0x50

rupesh

Hi rupesh,

I'm sorry, but I only see you sending the Write-Address 'unsigned char WriteAddr' (UCB0TXBUF = WriteAddr;) to the slave which has the device-address 'unsigned int BlockAdd' (UCB0I2CSA = BlockAdd;).

So, you only send one address byte to the slave and not two as needed.

Rgds
aBUGSworstnightmare 

Rupesh,

A few thoughts...

(1)

Are you trying to do a page write or multiple byte writes?

If you are attempting to do a page write you must take care of the page boundaries in software. If the page boundaries are not adhered to then the page simply gets over- written instead of automatically rolling over to the next page.

For example; if the current page '1' has a page size = 'N' and the length of the string to be written is N+2, the first two bytes of page A get over written instead of rolling over to page B. User software has to ensure that at size N a new I2C transaction is started with the next page address.

(2)

If you have a screen shot that shows the failed transaction it may help. Does reading from 0x51 return incorrect bytes or does it mot work at all? How did you verify that this page is not being written?

(3)

In the EEPROM_Read function, first an address byte is transmitted, followed by a restart condition and then bytes are read out.

Any reason for checking the transmit flag in the read portion of the code?

UCB0CTL1 &= ~UCTR;       //0xEF;//make it reciver
 UCB0CTL1 |= UCTXSTT;                   // I2C TX, start condition
 while((IFG2&0x08)==0x00);                   //check IFG2 for transmit interrupt flag --> Checks for UCB0TXIFG?
        for (i=0;i<10;i++);
 while(UCB0CTL1&UCTXSTT);                    //Send the start condition

(4)

rupesh vishwakarma said:

this library is useless even TI people told me the code i posted is working

The Master and Slave I2C USCI App reports aim to help users get started quickly on development, for any custom application the code provided will need to be modified/customized as required. However if you have any feedback on how we could improve these  application reports or code example you feel can be added please let us know.

Regards,

Priya

hi ,

this is the code on which I am working it ia originally working with 24LC16 .we have 0x50 to 0x57 block address of 24LC16 and this code we provide

unsigned char* ee_buffer= buffer which has to be written like     unsigned char Write_array[]="0123456789bcdefghijklmnopqrstuvwxyz";

unsigned int BlockAdd =address of block which has to be written varries from 0x50 to 0x57

unsigned char NumByteToWrite how many bytes to write

unsigned char WriteAddr 0n given block on which page has to be written like if we have to write on block 50 page 0 then block address is 0x50, page address is 0x00

void I2C_EE_PageWrite(unsigned char* ee_buffer, unsigned char WriteAddr, unsigned char NumByteToWrite, unsigned int BlockAdd)
{
 int i;   
       //Block Address
            UCB0I2CSA = BlockAdd; 
            UCB0CTL1 |= UCTR + UCTXSTT;                 // I2C TX, start condition
            while((IFG2&0x08)==0x00);
            for (i=0;i<10;i++); 
            UCB0TXBUF =  WriteAddr ;      //0x00;
            for (i=0;i<10;i++); 
            while((IFG2&0x08)==0x00);
           for(i=0;i<NumByteToWrite;i++)
     {
  UCB0TXBUF = *ee_buffer;
  ee_buffer++;
  while((IFG2&0x08)==0x00);               //check IFG2 for transmit interrupt flag
     } 
 
     UCB0CTL1 |= UCTXSTP;
 
     while(UCB0CTL1&UCTXSTP);                    //Send the start condition
 
     for (i=0;i<10000;i++);      //delay

}

This code works good for any block address 0x50 to 0x57 in case 24LC16

now in case of 24LC128 when the block address is 0x50 page address 0x00 it works fine
now suppose I want to write on block 0x51 with page address 0x00 then it does not work
I tied to modify inthis manner

void I2C_EE_PageWrite(unsigned char* ee_buffer, unsigned char WriteAddr, unsigned char NumByteToWrite, unsigned int BlockAdd)
{
 int i;   
       //Block Address
            UCB0I2CSA = BlockAdd>>8;//hi address 
            UCB0CTL1 |= UCTR + UCTXSTT;                 // I2C TX, start condition
            while((IFG2&0x08)==0x00);
            for (i=0;i<10;i++); 
     UCB0I2CSA = BlockAdd&0xFF;//low address 
            UCB0CTL1 |= UCTR + UCTXSTT;                 // I2C TX, start condition
            while((IFG2&0x08)==0x00);
            for (i=0;i<10;i++); 
            UCB0TXBUF =  WriteAddr ;      //0x00;
            for (i=0;i<10;i++); 
            while((IFG2&0x08)==0x00);
           for(i=0;i<NumByteToWrite;i++)
     {
  UCB0TXBUF = *ee_buffer;
  ee_buffer++;
  while((IFG2&0x08)==0x00);               //check IFG2 for transmit interrupt flag
     } 
 
     UCB0CTL1 |= UCTXSTP;
 
     while(UCB0CTL1&UCTXSTP);                    //Send the start condition
 
     for (i=0;i<10000;i++);      //delay

}

is the above method correct to pass hi address and low address?
if yes then also this is not working

then what I did as the following as given in the post

void I2C_EE_PageWrite(unsigned char* ee_buffer, unsigned char WriteAddr, unsigned char NumByteToWrite, unsigned int BlockAdd)
{
     int i,start_address;   
            start_address=((BlockAdd * 64) + WriteAddr) & 0x3FFF;     //Block Address
            UCB0I2CSA = BlockAdd; 
            UCB0CTL1 |= UCTR + UCTXSTT;                 // I2C TX, start condition
            while((IFG2&0x08)==0x00);
            for (i=0;i<10;i++); 
            UCB0TXBUF = (start_address)>>8;      //0x00;
            for (i=0;i<10;i++); 
            while((IFG2&0x08)==0x00);
             UCB0TXBUF =  start_address ;      //0x00;
            for (i=0;i<10;i++); 
            while((IFG2&0x08)==0x00);
           for(i=0;i<NumByteToWrite;i++)
     {
  UCB0TXBUF = *ee_buffer;
  ee_buffer++;
  while((IFG2&0x08)==0x00);               //check IFG2 for transmit interrupt flag
     } 
 
     UCB0CTL1 |= UCTXSTP;
 
     while(UCB0CTL1&UCTXSTP);                    //Send the start condition
 
     for (i=0;i<10000;i++);      //delay
}

This case also does not work with 24LC128 with block address 0x51

regards

rupesh

Hi rupesh,

could you please answer one simple question: Do you have more than one I2C slaves or not?

If yes, what is BlockAdd?? Is it the address of your I2C slave or not (i.e. first device (slave) is at 0x50, second device (slave) is at 0x51, ..)??

UCB0I2CSA holds the address of the I2C slave to be addressed, so if you only have one slave connected to the bus it must only be written once since the slave address doesn't change during application run time. If you have more than one then you need to change it.

Further below in your latest post you're talking of page address 0x00. So, is this the number of the page (page size is 64bytes) you want to write to (i.e. if you want to write the 70th byte in the EEPROM which is located on page 1 then your page address is 0x01)? If so, you need to send this address to the EEPROM (as pointed out above) and not add it to your device address.

Rgds
aBUGSworstnightmare 

P.S. Here is the link to the I2C-Bus specification http://www.nxp.com/acrobat_download2/literature/9398/39340011.pdf. Put it to good use!

hi,

no I have only one 24LC16 , actually in my application i have to write different data on different locations of 24LC16  it has address range from 0x50 to 0x57 .actually it has 8 blocks on which we cam write data that is what I am passing it  as slave address

rupesh

Dear praval

thanks very much to take the attention that 24LC128 is not block addressed and with your help the code is finally working thanks a lot once again

here is the working code of 24LC128

void I2C_EE_PageWrite(unsigned char* ee_buffer, unsigned int WriteAddr, unsigned char NumByteToWrite, unsigned int BlockAdd)
{
     int i,start_address;
            start_address=(((BlockAdd - 0x50) * 256) + WriteAddr) & 0x3FFF; 
            UCB0I2CSA = 0x50; 
            UCB0CTL1 |= UCTR + UCTXSTT;                 // I2C TX, start condition
            while((IFG2&0x08)==0x00);
            for (i=0;i<10;i++); 
            UCB0TXBUF = (start_address)>>8;     //0x00;
            for (i=0;i<10;i++); 
            while((IFG2&0x08)==0x00);
      
            UCB0TXBUF = start_address;     //0x00;
            for (i=0;i<10;i++); 
            while((IFG2&0x08)==0x00);
             for(i=0;i<NumByteToWrite;i++)
     {
  UCB0TXBUF = *ee_buffer;
  ee_buffer++;
  while((IFG2&0x08)==0x00);               //check IFG2 for transmit interrupt flag
     } 
 
     UCB0CTL1 |= UCTXSTP;
 
     while(UCB0CTL1&UCTXSTP);                    //Send the start condition
 
     for (i=0;i<10000;i++);      //delay

}

void I2C_EE_BufferRead(unsigned char* ee_buffer, unsigned char ReadAddr, unsigned int NumByteToRead, unsigned int BlockAdd)
{ 
 int i,start_address;   
   UCB0I2CSA = 0x50;
        start_address=(((BlockAdd - 0x50) * 256) + ReadAddr) & 0x3FFF; 
 UCB0CTL1 |= UCTR + UCTXSTT;                 // I2C TX, start condition
 while((IFG2&0x08)==0x00);                   //check IFG2 for transmit interrupt flag
       
       for (i=0;i<10;i++);       //delay
 UCB0TXBUF =  (start_address)>>8;
 while(UCB0CTL1&UCTXSTT);                    //Send the start condition
 while((IFG2&0x08)==0x00);                   //check IFG2 for transmit interrupt flag
        UCB0TXBUF = start_address;
 while(UCB0CTL1&UCTXSTT);                    //Send the start condition
 while((IFG2&0x08)==0x00);                   //check IFG2 for transmit interrupt flag
       
 UCB0CTL1 &= ~UCTR;       //0xEF;//make it reciver
 UCB0CTL1 |= UCTXSTT;                   // I2C TX, start condition
 while((IFG2&0x08)==0x00);                   //check IFG2 for transmit interrupt flag
        for (i=0;i<10;i++);
 while(UCB0CTL1&UCTXSTT);                    //Send the start condition
 for(i=0;i<(NumByteToRead-1);i++)
 {
  while((IFG2&0x04)==0x00);                      //check IFG2 for transmit interrupt flag
  *ee_buffer = UCB0RXBUF;
  ee_buffer++;
 } 
 UCB0CTL1 |= UCTXSTP;
 while((IFG2&0x04)==0x00);                      //check IFG2 for transmit interrupt flag
 *ee_buffer = UCB0RXBUF;
 while(UCB0CTL1&UCTXSTP);                    //Send the start condition 
} 

thanks a lot

regards

rupesh