0. Introduction

For most MCUs, I2C has become a long-standing problem. Since the 51 era, software simulation of I2C has become the mainstream. Even today when ARMCortex M3 is popular, software simulation of I2C is still the most widely used method. Although software simulation can solve all problems, it always feels that the hardware resources inside the MCU are not fully utilized. After consulting all the books about the MSP430F5 series, there is no application code for hardware I2C. I have explored it through debugging, summarized my experience and shared it with you. I hope you like it. At the same time, the use of I2C can be divided into waiting method and interrupt method. From the perspective of understanding, the waiting method is clear and easy to use. From the perspective of power consumption, the interrupt method can flexibly enter the low power mode, but it is not easy to understand. This article starts with the waiting method.

The use of hardware I2C of the MSP430F5 series generally has the following problems:

[I2C address setting] Generally, the 7-bit address of I2C is written as 8-bit length, and the lowest bit is invalid. For example, the I2C address of AT24C02 is 0xA0, but the real 7-bit address is 0x50. And MSP430 needs to fill in the 7-bit address 0x50.

[I2C stop bit sending] During the I2C read operation, the MCU should send a no response to the slave after reading the last byte. The MSP430F5 series MCU will automatically complete the no response operation. This means that when reading the last byte, the stop bit related register should be operated first.

[I2C start bit transmission] If you carefully analyze the MSP430F5 reference manual, you will find that the I2C start bit is slightly different when sending read and write operations. When writing, you need to write data to TXBUF first, and then you can wait for the TXSTT flag to become 0, which is slightly different from the read and write operations.

【AT24C02 operation timing diagram】

view plain  copy 

1. while( UCB0CTL1& UCTXSTP );  

2. UCB0CTL1 |= UCTR; // write mode  

3. UCB0CTL1 |= UCTXSTT; // Send start bit  

4. // Wait for UCTXSTT=0 to change, but unfortunately the change will not be sent  

5. while(UCB0IFG& UCTXSTT);  

6. UCB0TXBUF = word_addr; // Send byte address  

3. Write multiple bytes

3.1 Code Implementation

1. uint8_teeprom_writepage( uint8_t word_addr, uint8_t *pword_buf, uint8_t len)  

2. {  

3.   while( UCB0CTL1& UCTXSTP );  

4.   UCB0CTL1 |= UCTR; // write mode  

5.   UCB0CTL1 |= UCTXSTT; // Send start bit  

6.    

7.   UCB0TXBUF = word_addr; // Send byte address  

8.   // Wait for UCTXIFG=1 and UCTXSTT=0 to change at the same time and wait for a flag bit  

9.   while(!(UCB0IFG& UCTXIFG))  

10.   {  

11.     if(UCB0IFG& UCNACKIFG) // If no response UCNACKIFG=1  

12.     {  

13.       return 1;  

14.     }  

15.   }    

16.    

17.   for( uint8_t i= 0; i < len; i++)  

18.   {  

19.     UCB0TXBUF = *pword_buf++; // Send register content  

20.     while(!(UCB0IFG& UCTXIFG)); // Wait until UCTXIFG=1     

21.   }  

22.    

23.   UCB0CTL1 |= UCTXSTP;  

24.   while(UCB0CTL1& UCTXSTP); // Wait for sending to complete  

25.    

26.   return 0;  

27. }  

3.2 Code Analysis

      The multi-byte write function is similar to the single-byte write function and will not be explained in detail.

4. Read a single byte

The single-byte read function is the most complex of the four read and write functions. The reason for the complexity is that the UCTXSTP flag needs to be operated before reading the last byte.

4.1 Code Implementation

1. uint8_teeprom_readbyte( uint8_t word_addr, uint8_t *pword_value)  

2. {  

3.   UCB0CTL1 |= UCTR; // write mode  

4.   UCB0CTL1 |= UCTXSTT; // Send start bit and write control byte  

5.    

6.   UCB0TXBUF = word_addr; //Send byte address, TXBUF must be filled first  

7.   // Wait for UCTXIFG=1 and UCTXSTT=0 to change at the same time and wait for a flag bit  

8.   while(!(UCB0IFG& UCTXIFG))  

9.   {  

10.     if(UCB0IFG& UCNACKIFG) // If no response UCNACKIFG=1  

11.     {  

12.       return 1;  

13.     }  

14.   }                         

15.    

16.   UCB0CTL1 &= ~UCTR; //Read mode  

17.   UCB0CTL1 |= UCTXSTT; // Send start bit and read control byte  

18.    

19.   while(UCB0CTL1& UCTXSTT); // Wait until UCTXSTT=0  

20.   // If no response UCNACKIFG = 1  

21.   UCB0CTL1 |= UCTXSTP; //Send stop bit first  

22.    

23.   while(!(UCB0IFG& UCRXIFG)); // Read byte content  

24.   *pword_value = UCB0RXBUF; // Read BUF register after sending stop bit  

25.    

26.   while( UCB0CTL1& UCTXSTP );  

27.    

28.   return 0;  

29. }  

4.2 Code Analysis

This code gives the illusion that the MSP430 sends a stop bit first and then reads a byte. In fact, this is not the case. During an I2C read operation, after the host reads the last byte, it should send a no-acknowledgement NACK (no-acknowledgement is different from an acknowledgement) to the slave, and then the host sends a stop bit. In order to complete this combined action, the MSP430 requires the user to operate the UCTXSTP flag in advance, and perform a "combined action" of sending NACK and the I2C stop bit after reading RXBUF.

1. while(!(UCB0IFG& UCRXIFG));  

2. *pword_value = UCB0RXBUF; // Read BUF register after sending stop bit  

3. UCB0CTL1 |= UCTXSTP; // Send stop bit  

      The above code may cause subsequent I2C operations to fail.

5. Read multiple bytes

5.1 Code Implementation

1. uint8_t eeprom_readpage(uint8_t word_addr, uint8_t *pword_buf, uint8_t len ​​)  

2. {  

3.   while( UCB0CTL1& UCTXSTP );  

4.   UCB0CTL1 |= UCTR; // write mode  

5.   UCB0CTL1 |= UCTXSTT; // Send start bit and write control byte  

6.    

7.   UCB0TXBUF = word_addr; // Send byte address  

8.   // Wait for UCTXIFG=1 and UCTXSTT=0 to change at the same time and wait for a flag bit  

9.   while(!(UCB0IFG& UCTXIFG))  

10.   {  

11.     if(UCB0IFG& UCNACKIFG) // If no response UCNACKIFG=1  

12.     {  

13.       return 1;  

14.     }  

15.   }    

16.    

17.   UCB0CTL1 &= ~UCTR; // Read mode  

18.   UCB0CTL1 |= UCTXSTT; // Send start bit and read control byte  

19.    

20.   while(UCB0CTL1& UCTXSTT); // Wait until UCTXSTT=0  

21.   // If no response UCNACKIFG = 1  

22.    

23.   for( uint8_t i= 0; i< len -1; i++)  

24.   {  

25.     while(!(UCB0IFG& UCRXIFG)); // Read byte content, excluding the last byte content  

26.     *pword_buf++= UCB0RXBUF;  

27.   }  

28.    

29.   UCB0CTL1 |= UCTXSTP; // Send stop bit before receiving the last byte  

30.    

31.   while(!(UCB0IFG& UCRXIFG)); // Read the last byte  

32.   *pword_buf = UCB0RXBUF;  

33.    

34.   while( UCB0CTL1& UCTXSTP );  

35.    

36.   return 0;  

37. }  

5.2 Code Analysis

      Reading a single byte is similar to writing a single byte. The only thing to note is that the write operation needs to fill the TXBUF first, while the read operation does not have this problem. Imagine that when an I2C write operation is performed, a byte of content must be written to the I2C slave, so it is reasonable to fill the TXBUF first. After filling the TXBUF, the MSP430 will perform a series of actions - sending the I2C start bit, the I2C read controller, and writing the first byte of the slave.

6 Unit Testing

      The unit test is divided into two parts. The single-byte write function and the single-byte read function are grouped together. First, use the single-byte write function to write something to a certain address, and then use the single-byte read function to read something. If the written parameters are the same as the read content, the test passes. The multi-byte write function and the multi-byte read function are grouped together. The test process is similar, except that the content written changes from one to 8 consecutive bytes. Please note that the page size of AT24C02 is 8. If starting from the page header address, the maximum number of bytes to write is 8.

      In addition, there needs to be a 10ms delay after the EEPROM write operation, otherwise the write and read operations will not be possible. Please refer to the AT24C02 data sheet for details.

6.1 Test Code

1. void eeprom_config()  

2. {  

3. #ifDEBUF_EEPROM_I2C  

4.    

5.   uint8_t test_byte1 =0x0B;  

6.   uint8_t test_byte2 = 0x01;  

7.    

8.   /* 

9.     Step 1 Write a value to address 0x00, for example 0x0B 

10.           Then read the address 0x00 and determine whether the value is 0x0B 

11.   */  

12.   eeprom_writebyte(0x00, test_byte1);   

13.   delay_ms(10);  

14.   eeprom_readbyte(0x00,&test_byte2);  

15.   assert_param( test_byte1== test_byte2 );  

16.    

17.   if( test_byte1 == test_byte2 )  

18.   {  

19.     printf( "Byte Read andByte Write Test Pass\r\n" );     

20.   }  

21.    

22.   /* 

23.     Step 2: Use address 0x08 as the starting address and write 8 bytes of data continuously 

24.           Then read 8 bytes from the starting address and compare the written and read bytes. 

25.           The condition for success is that the contents of the bytes written and read are the same 

26.   */  

27.   uint8_t test_buf1[8]= {1,2,3,4,5,6,7,8};  

28.   uint8_t test_buf2[8]= {0,0,0,0,0,0,0,0};  

29.    

30.   eeprom_writepage(0x08, test_buf1, 8);  

31.   delay_ms(10);  

32.   eeprom_readpage(0x08, test_buf2, 8);  

33.   assert_param( memcmp( test_buf1, test_buf2,8) == 0 );  

34.    

35.   if(!memcmp(test_buf1, test_buf2,8))  

36.   {  

37.     printf("Page Read andPage Write Test Pass!\r\n");     

38.   }  

39.    

40. #endif  

41. }  

6.2 Test Results