• State TI Thinks Resolved
  • Locked Locked
  • Replies 5 replies
  • Answers 1 answer
  • Subscribers 31 subscribers
  • Views 300 views
  • Users 0 members are here
Support feedback
Options
Options
Related

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

MSP432E401Y: i2c issue

Raja Venkateshwaran
Prodigy 75 points
Part Number: MSP432E401Y
Other Parts Discussed in Thread: INA237

Tool/software:

Hi team,

Greetings...
I am facing issues to read/write to a register address. I attached my code for your reference. Please suggest me some tips to resolve this.

#include <ti/devices/msp432e4/driverlib/driverlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include "uartstdio.h"
#include "pinout.h"


#define SLAVE_ADDRESS   0x4A // I2C address
#define I2C_NUM_DATA    2    // Number of bytes to read
#define TIMEOUT         10000 // Timeout value in iterations

uint8_t registerAddress = 0x05; // REGISTER ADDRESS

uint8_t writeData[2] = {0xBF, 0xD0}; // {HIGH_BYTE(15-8),LOW_BYTE(7-0)}




uint32_t g_ui32SysClock;
uint8_t getData[I2C_NUM_DATA] = {0x00};  // Buffer to hold the receiving data
uint32_t timeoutCounter;



void ConfigureUART(void) {
    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
    MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
    MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
    MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
    UARTStdioConfig(0, 115200, g_ui32SysClock);
}

void I2C_ReadRegister(uint8_t regAddress, uint8_t *data) {
      uint8_t dataIndex = 0;

    // Send register address
    MAP_I2CMasterSlaveAddrSet(I2C3_BASE, SLAVE_ADDRESS, false);
    MAP_I2CMasterDataPut(I2C3_BASE, regAddress);
    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_SINGLE_SEND);

    timeoutCounter = 0;
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT)
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    MAP_SysCtlDelay(3000);

    // Read data
    MAP_I2CMasterSlaveAddrSet(I2C3_BASE, SLAVE_ADDRESS, true);
    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_START);

    timeoutCounter = 0;
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT)
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    data[dataIndex++] = MAP_I2CMasterDataGet(I2C3_BASE);
		
		
		
		
		 MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_CONT); // Rx another
		
		timeoutCounter = 0;
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT)
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }
		
		if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }
		
    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_FINISH);
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT)
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    data[dataIndex++] = MAP_I2CMasterDataGet(I2C3_BASE);
}

void I2C_WriteRegister(uint8_t regAddress, uint8_t *data, uint8_t length) {


while (MAP_I2CMasterBusy(I2C3_BASE)) {}

    MAP_I2CMasterSlaveAddrSet(I2C3_BASE, SLAVE_ADDRESS, false);
    MAP_I2CMasterDataPut(I2C3_BASE, regAddress);
    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_SEND_START);

    timeoutCounter = 0;
    while (MAP_I2CMasterBusy(I2C3_BASE)) {
        if (++timeoutCounter > TIMEOUT) {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE) {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    for (uint8_t i = 0; i < length; i++) {
        MAP_I2CMasterDataPut(I2C3_BASE, data[i]);

        if (i == length - 1) {
            MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
        } else {
            MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);
        }

        timeoutCounter = 0;
        while (MAP_I2CMasterBusy(I2C3_BASE)) {
            if (++timeoutCounter > TIMEOUT) {
                UARTprintf("TRANSFER TIMEOUT\n");
                return;
            }
        }

        if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE) {
            UARTprintf("TRANSFER ERROR\n");
            return;
        }
    }



}


void writeOperation(){
	int w = 0;

while(w<20){
	
	uint32_t systemClock;
   g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 12000000);

 //g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); // 120 MHz

    PinoutSet(false, false);
    ConfigureUART();

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPION)));
    MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
    MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOK)));
    MAP_GPIOPinConfigure(GPIO_PK4_I2C3SCL);
    MAP_GPIOPinConfigure(GPIO_PK5_I2C3SDA);
    MAP_GPIOPinTypeI2C(GPIO_PORTK_BASE, GPIO_PIN_5);
    MAP_GPIOPinTypeI2CSCL(GPIO_PORTK_BASE, GPIO_PIN_4);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_I2C3)));
    MAP_I2CMasterInitExpClk(I2C3_BASE, g_ui32SysClock, false);
	
	w++;
   
    I2C_WriteRegister(registerAddress, writeData, 2);

    UARTprintf("Data written to Register 0x%02X: 0x%02X 0x%02X\n", registerAddress, writeData[0], writeData[1]);




    UARTprintf("########################################################################################################################");

}

UARTprintf("Now writing different data");

}


void readOperation(){
	
	int i = 0;
	
	while (i<20) {
			
			
		uint32_t systemClock;
  
			
		g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); // 120 MHz

		PinoutSet(false, false);
		ConfigureUART();

		MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
		while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPION)));
		MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
		MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);

		MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
		while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOK)));
		MAP_GPIOPinConfigure(GPIO_PK4_I2C3SCL);
		MAP_GPIOPinConfigure(GPIO_PK5_I2C3SDA);
		MAP_GPIOPinTypeI2C(GPIO_PORTK_BASE, GPIO_PIN_5);
		MAP_GPIOPinTypeI2CSCL(GPIO_PORTK_BASE, GPIO_PIN_4);

		MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
		while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_I2C3)));
		MAP_I2CMasterInitExpClk(I2C3_BASE, g_ui32SysClock, false);
					
        I2C_ReadRegister(registerAddress, getData);
        uint16_t rawValue = (getData[0] << 8) | getData[1];

        UARTprintf("Register 0x%02X High Byte: 0x%02X\n", registerAddress, getData[0]);
        UARTprintf("Register 0x%02X Low Byte: 0x%02X\n", registerAddress, getData[1]);
        UARTprintf("Register 0x%02X Combined Value: 0x%04X\n", registerAddress, rawValue);
        UARTprintf("**********************************\n");

        combinedValues[i] = rawValue;

       // MAP_SysCtlDelay(g_ui32SysClock / 3);
				MAP_SysCtlDelay(g_ui32SysClock / 13); ///////////////////////// CHANGED FROM   MAP_SysCtlDelay(g_ui32SysClock / 3)  TO   MAP_SysCtlDelay(g_ui32SysClock / 13) TO DECRESE THE DELAY FOR READING.
        MAP_SysCtlDelay(20);
				i++;
    }

    uint8_t k = 0;
    UARTprintf("Combined Values Array:\n");
    for (k = 0; k < 20; k++) {
        UARTprintf("combinedValues[%d]: 0x%04X\n", k, combinedValues[k]);
    }

    uint16_t firstDifferentValue = findFirstDifferent(combinedValues, 20);
    UARTprintf("Read Operation Result : 0x%04X\n", firstDifferentValue);
		
}

char getUserInput() {
    char inputChar = UARTgetc();
    return inputChar;
}



int main(void) {

    uint32_t systemClock;
    g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 12000000);



    PinoutSet(false, false);
    ConfigureUART();

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPION)));
    MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
    MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOK)));
    MAP_GPIOPinConfigure(GPIO_PK4_I2C3SCL);
    MAP_GPIOPinConfigure(GPIO_PK5_I2C3SDA);
    MAP_GPIOPinTypeI2C(GPIO_PORTK_BASE, GPIO_PIN_5);
    MAP_GPIOPinTypeI2CSCL(GPIO_PORTK_BASE, GPIO_PIN_4);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_I2C3)));
    MAP_I2CMasterInitExpClk(I2C3_BASE, g_ui32SysClock, false);

    
    UARTprintf("################################################## ????????????????????????????????????????????????? ########################################\n");

		

	UARTprintf("Enter 'y' or 'Y' to perform read and write operation. Enter 'n' or 'N' to perform only read operation: ");
    char input = getUserInput();
		
	if ((input == 'y' || input == 'Y')) {
		  readOperation();
	writeOperation();
		
			
	}
	
	else if ((input == 'n' || input == 'N')) {
		readOperation();
		
	}
	
	else {
		UARTprintf("Invalid input. Please enter 'y' or 'Y' for read and write operation, or 'n' or 'N' for only read operation.\n");
	}

    return 0;
 

}

I also attach the external pullup of 3.8k to SCL and SDA of MSP432E401y.
I didnt have two MSP's to try "mastermode simple transfer" code availabe in driverlib(but i followed the steps of both the example program and i2c Application Report
SLAA776).

Please assist me ASAP.

Regards,
Raja Venkateshwaran

  • 0 in reply to Charles Tsai
    Prodigy 75 points 

    void I2C_ReadRegister(uint8_t regAddress, uint8_t *data) {
      uint8_t dataIndex = 0;

    // Send register address
    MAP_I2CMasterSlaveAddrSet(I2C3_BASE, SLAVE_ADDRESS, false);
    MAP_I2CMasterDataPut(I2C3_BASE, regAddress);
    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_SINGLE_SEND);

    timeoutCounter = 0;
	while (!MAP_I2CMasterBusy(I2C3_BASE)){UARTprintf("read_reg_1\n");} //TI suggests
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT) 
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    MAP_SysCtlDelay(3000);

    // Read data
    MAP_I2CMasterSlaveAddrSet(I2C3_BASE, SLAVE_ADDRESS, true);
    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_START);

    timeoutCounter = 0;
		while (!MAP_I2CMasterBusy(I2C3_BASE)){UARTprintf("read_reg_2\n");} //TI suggests
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT)
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    data[dataIndex++] = MAP_I2CMasterDataGet(I2C3_BASE);
		
		
		
		
		 MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_CONT); // Rx another
		
		timeoutCounter = 0;
		while (!MAP_I2CMasterBusy(I2C3_BASE)){UARTprintf("read_reg_3\n");} //TI suggests
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT)
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }
		
		if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

		
		
		
		
		
		
		
		

    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_FINISH);
		while (!MAP_I2CMasterBusy(I2C3_BASE)){UARTprintf("read_reg_4\n");}
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT)
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    data[dataIndex++] = MAP_I2CMasterDataGet(I2C3_BASE);
}
    Hi Charles,

    I added the line  while (!MAP_I2CMasterBusy(I2C3_BASE)){}
    Now I am keep on getting "read_reg_2" in my console.

    #include <ti/devices/msp432e4/driverlib/driverlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include "uartstdio.h"
#include "pinout.h"





#define SLAVE_ADDRESS   0x4A // I2C address
#define I2C_NUM_DATA    2    // Number of bytes to read
#define TIMEOUT         10000 // Timeout value in iterations

uint8_t registerAddress = 0x0C; // REGISTER ADDRESS

uint8_t writeData[2] = {0xBF, 0xD0};  //if you have 0x4412 then uint8_t writeData[2] = {0x44, 0x12}  {HIGH_BYTE(15-8),LOW_BYTE(7-0)}




uint32_t g_ui32SysClock;
uint8_t getData[I2C_NUM_DATA] = {0x00};  // Buffer to hold the receiving data
uint32_t timeoutCounter;
uint16_t combinedValues[20]; // Array to store combined values



uint16_t findMostFrequent(uint16_t arr[], int size) {
    uint16_t mostFrequentElement = arr[0];
    int maxCount = 0;

    for (int i = 0; i < size; i++) {
        int count = 0;
        for (int j = 0; j < size; j++) {
            if (arr[j] == arr[i]) {
                count++;
            }
        }

        if (count > maxCount) {
            maxCount = count;
            mostFrequentElement = arr[i];
        }
    }

    return mostFrequentElement;
}

uint16_t findFirstDifferent(uint16_t arr[], int size) {
	
	//FOR NOW I COMMENTED THE BELOW LINE AFTER I PUT PULLUPS ON SDA AND SCL.
//    for (int i = 0; i < size; i++) {
//        uint8_t highByte = (arr[i] >> 8) & 0xFF;
//        uint8_t lowByte = arr[i] & 0xFF;
//       
//        if (highByte != lowByte) {
//            return arr[i];
//        }
//    }

    // If all elements have the same high and low bytes, return most frequent element 
    return findMostFrequent(arr , size);
}





void ConfigureUART(void) {
    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
    MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
    MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
    MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
    UARTStdioConfig(0, 115200, g_ui32SysClock);
}

void I2C_ReadRegister(uint8_t regAddress, uint8_t *data) {
      uint8_t dataIndex = 0;

    // Send register address
    MAP_I2CMasterSlaveAddrSet(I2C3_BASE, SLAVE_ADDRESS, false);
    MAP_I2CMasterDataPut(I2C3_BASE, regAddress);
    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_SINGLE_SEND);

    timeoutCounter = 0;
	while (!MAP_I2CMasterBusy(I2C3_BASE)){UARTprintf("read_reg_1\n");} //TI suggests
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT) 
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    MAP_SysCtlDelay(3000);

    // Read data
    MAP_I2CMasterSlaveAddrSet(I2C3_BASE, SLAVE_ADDRESS, true);
    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_START);

    timeoutCounter = 0;
		while (!MAP_I2CMasterBusy(I2C3_BASE)){UARTprintf("read_reg_2\n");} //TI suggests
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT)
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    data[dataIndex++] = MAP_I2CMasterDataGet(I2C3_BASE);
		
		
		
		
		 MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_CONT); // Rx another
		
		timeoutCounter = 0;
		while (!MAP_I2CMasterBusy(I2C3_BASE)){UARTprintf("read_reg_3\n");} //TI suggests
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT)
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }
		
		if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

		
		
		
		
		
		
		
		

    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_RECEIVE_FINISH);
		while (!MAP_I2CMasterBusy(I2C3_BASE)){UARTprintf("read_reg_4\n");}
    while (MAP_I2CMasterBusy(I2C3_BASE))
    {
        MAP_SysCtlDelay(1000);
        if (++timeoutCounter > TIMEOUT)
        {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE)
    {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    data[dataIndex++] = MAP_I2CMasterDataGet(I2C3_BASE);
}

void I2C_WriteRegister(uint8_t regAddress, uint8_t *data, uint8_t length) {

while (!MAP_I2CMasterBusy(I2C3_BASE)){}
while (MAP_I2CMasterBusy(I2C3_BASE)) {}

    MAP_I2CMasterSlaveAddrSet(I2C3_BASE, SLAVE_ADDRESS, false);
    MAP_I2CMasterDataPut(I2C3_BASE, regAddress);
    MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_SEND_START);

    timeoutCounter = 0;
	while (!MAP_I2CMasterBusy(I2C3_BASE)){}
    while (MAP_I2CMasterBusy(I2C3_BASE)) {
        if (++timeoutCounter > TIMEOUT) {
            UARTprintf("TRANSFER TIMEOUT\n");
            return;
        }
    }

    if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE) {
        UARTprintf("TRANSFER ERROR\n");
        return;
    }

    for (uint8_t i = 0; i < length; i++) {
        MAP_I2CMasterDataPut(I2C3_BASE, data[i]);

        if (i == length - 1) {
            MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
        } else {
            MAP_I2CMasterControl(I2C3_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);
        }

        timeoutCounter = 0;
				while (!MAP_I2CMasterBusy(I2C3_BASE)){}
        while (MAP_I2CMasterBusy(I2C3_BASE)) {
            if (++timeoutCounter > TIMEOUT) {
                UARTprintf("TRANSFER TIMEOUT\n");
                return;
            }
        }

        if (MAP_I2CMasterErr(I2C3_BASE) != I2C_MASTER_ERR_NONE) {
            UARTprintf("TRANSFER ERROR\n");
            return;
        }
    }



}


void writeOperation(){
	int w = 0;

while(w<20){
	
	uint32_t systemClock;
   g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 12000000);

 //g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); // 120 MHz

    PinoutSet(false, false);
    ConfigureUART();

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPION)));
    MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
    MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOK)));
    MAP_GPIOPinConfigure(GPIO_PK4_I2C3SCL);
    MAP_GPIOPinConfigure(GPIO_PK5_I2C3SDA);
    MAP_GPIOPinTypeI2C(GPIO_PORTK_BASE, GPIO_PIN_5);
    MAP_GPIOPinTypeI2CSCL(GPIO_PORTK_BASE, GPIO_PIN_4);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_I2C3)));
    MAP_I2CMasterInitExpClk(I2C3_BASE, g_ui32SysClock, false);
	
	
	
	
	
	
w++;
   
    I2C_WriteRegister(registerAddress, writeData, 2);

    UARTprintf("Data written to Register 0x%02X: 0x%02X 0x%02X\n", registerAddress, writeData[0], writeData[1]);




    UARTprintf("########################################################################################################################");

}

UARTprintf("Now writing different data");

}


void readOperation(){
	
	int i = 0;
	
	while (i<20) {
			
			
			 uint32_t systemClock;
  
			
 g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); // 120 MHz

    PinoutSet(false, false);
    ConfigureUART();

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPION)));
    MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
    MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOK)));
    MAP_GPIOPinConfigure(GPIO_PK4_I2C3SCL);
    MAP_GPIOPinConfigure(GPIO_PK5_I2C3SDA);
    MAP_GPIOPinTypeI2C(GPIO_PORTK_BASE, GPIO_PIN_5);
    MAP_GPIOPinTypeI2CSCL(GPIO_PORTK_BASE, GPIO_PIN_4);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_I2C3)));
    MAP_I2CMasterInitExpClk(I2C3_BASE, g_ui32SysClock, false);
		
		
		
			
			
			
        I2C_ReadRegister(registerAddress, getData);
        uint16_t rawValue = (getData[0] << 8) | getData[1];

        UARTprintf("Register 0x%02X High Byte: 0x%02X\n", registerAddress, getData[0]);
        UARTprintf("Register 0x%02X Low Byte: 0x%02X\n", registerAddress, getData[1]);
        UARTprintf("Register 0x%02X Combined Value: 0x%04X\n", registerAddress, rawValue);
        UARTprintf("**********************************\n");

        combinedValues[i] = rawValue;

       // MAP_SysCtlDelay(g_ui32SysClock / 3);
				MAP_SysCtlDelay(g_ui32SysClock / 13); ///////////////////////// CHANGED FROM   MAP_SysCtlDelay(g_ui32SysClock / 3)  TO   MAP_SysCtlDelay(g_ui32SysClock / 13) TO DECRESE THE DELAY FOR READING.
        MAP_SysCtlDelay(20);
				i++;
    }

    uint8_t k = 0;
    UARTprintf("Combined Values Array:\n");
    for (k = 0; k < 20; k++) {
        UARTprintf("combinedValues[%d]: 0x%04X\n", k, combinedValues[k]);
    }

    uint16_t firstDifferentValue = findFirstDifferent(combinedValues, 20);
    UARTprintf("Read Operation Result : 0x%04X\n", firstDifferentValue);
		
		
		
		
	
}



char getUserInput() {
    char inputChar = UARTgetc();
    return inputChar;
}



int main(void) {


// Example write operation
   

    uint32_t systemClock;
    g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 12000000);



    PinoutSet(false, false);
    ConfigureUART();

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPION)));
    MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
    MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOK)));
    MAP_GPIOPinConfigure(GPIO_PK4_I2C3SCL);
    MAP_GPIOPinConfigure(GPIO_PK5_I2C3SDA);
    MAP_GPIOPinTypeI2C(GPIO_PORTK_BASE, GPIO_PIN_5);
    MAP_GPIOPinTypeI2CSCL(GPIO_PORTK_BASE, GPIO_PIN_4);

    MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
    while (!(MAP_SysCtlPeripheralReady(SYSCTL_PERIPH_I2C3)));
    MAP_I2CMasterInitExpClk(I2C3_BASE, g_ui32SysClock, false);

    
    UARTprintf("################################################## ????????????????????????????????????????????????? ########################################\n");

		

		UARTprintf("Enter 'y' or 'Y' to perform read and write operation. Enter 'n' or 'N' to perform only read operation: ");
    char input = getUserInput();
		
		if ((input == 'y' || input == 'Y')) {
			  readOperation();
        writeOperation();
			
				
		}
		
		else if ((input == 'n' || input == 'N')) {
			readOperation();
			
		}
		
		else {
			UARTprintf("Invalid input. Please enter 'y' or 'Y' for read and write operation, or 'n' or 'N' for only read operation.\n");
		}
 
    
		
		
		
		
		
		
		

  // WRITING LOGIC 
		


		//main();

    return 0;
 

}

    Also attached the complete code.

    I checked the device address with another microcontroller (it is 0x4A only) and also checked the register address(valid only).

    what may be issue.?

    Regards,
    Raja Venkateshwaran


  • 0 in reply to Raja Venkateshwaran
    TI__Guru**** 191906 points

    You did not mention what I2C device you are trying to read. During read, you seem to send the register address as a data to the device and then ended the I2C transaction because I see you use I2C_MASTER_CMD_SINGLE_SEND. When you use I2C_MASTER_CMD_SINGLE_SEND, the I2C transaction will end with a STOP bit. Is this what you want? You then restart a new I2C transaction with I2C_MASTER_CMD_BURST_RECEIVE_START -> I2C_MASTER_CMD_BURST_RECEIVE_CONT -> I2C_MASTER_CMD_BURST_RECEIVE_FINISH sequence. I know some I2C devices require you not ending the I2C transaction but rather using a 'Repeated Start' between specifying a register address and then read the data. You need to go over your I2C device datasheet to know what it requires. 

    This I2C app note will help. https://www.ti.com/lit/pdf/slaa776

    This post will also help. https://e2e.ti.com/support/microcontrollers/arm-based-microcontrollers-group/arm-based-microcontrollers/f/arm-based-microcontrollers-forum/865334/ccs-ek-tm4c1294xl-i2c-on-a-tivac-1294-launchpad/3203729#3203729

  • 0 in reply to Charles Tsai
    Prodigy 75 points

    I am reading from custom board of INA237 (power monitoring IC from TI) .It also have pull up resistors of 3.3K and my msp also has pullup resistors of 4k.(externally i soldered to sda and scl pins).

    The custom board(INA237) is working fine for other microcontrollers(I checked it).

    I also attached the INA237 datasheet(please see page no:19).


    ina237.pdf

    Regards,
    Raja Venkateshwaran

  • 0 in reply to Raja Venkateshwaran
    TI__Guru**** 191906 points

    Do you have a logic analyzer capture? It will greatly reveal the cause of the problem.