MCF8316AEVM: I2C Register MAP

Hi Ketan,

Thanks for your question on the Motor Drives E2E Forum. 

I will aim to provide an answer on this by the end of the week!

Best,

Robert

Hi,

Thank you for your reply.

Sure No Problem .

Hi, 

Noted. I'll go through the document for I2C register map.

Regarding the I2C. I am trying some i2c example to read the device information from i2c base sensor but looks like i am not able to read the i2c data.

I am using MSP430RF2355 development board and I have a connected external I2C Sensor with P1.3 and P1.2 pin for SCLK and SDA line. I have a set the slave address in I2C register for the master communication. See Initialization part.

Question: 

Polling transmit flag is required after the start the condition ? still slave address not loaded into the tx buffer ?

 //Poll for transmit interrupt flag.
    while (!(HWREG16(baseAddress + OFS_UCBxIFG) & UCTXIFG) && --timeout) {
        ;
    }

void msd_i2c_initialization(void) {

    //SDA line
    GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1, GPIO_PIN2, GPIO_PRIMARY_MODULE_FUNCTION);
    //clock line
    GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P1, GPIO_PIN3, GPIO_PRIMARY_MODULE_FUNCTION);

    EUSCI_B_I2C_initMasterParam i2c_master_init_param = { 0 };
    i2c_master_init_param.selectClockSource = EUSCI_B_I2C_CLOCKSOURCE_SMCLK;      //use SMCLK clock signal
    i2c_master_init_param.i2cClk = CS_getSMCLK();                         //Give SMCLK freq in Hz
    i2c_master_init_param.dataRate = EUSCI_B_I2C_SET_DATA_RATE_400KBPS;   //400KBps datarate
    i2c_master_init_param.byteCounterThreshold = 0;                       //Don't care because 'no auto stop'
    i2c_master_init_param.autoSTOPGeneration = EUSCI_B_I2C_NO_AUTO_STOP;            //We will handle the stop bit manually
    EUSCI_B_I2C_initMaster( EUSCI_B0_BASE, &i2c_master_init_param);
    EUSCI_B_I2C_enable(EUSCI_B0_BASE);  //Enable the I2C bus (i.e. pull it out of reset state)
    EUSCI_B_I2C_setSlaveAddress(EUSCI_B0_BASE, I2C_SLAVE_ADDRESS);
}

static bool start_transfer(uint16_t baseAddress) {

    bool success = false;
    uint8_t timeout = 40;

    //Send start condition.
    HWREG16(baseAddress + OFS_UCBxCTLW0) |= UCTR + UCTXSTT;

    //wait for master send the slave address
    //Poll for transmit interrupt flag.
    while (!(HWREG16(baseAddress + OFS_UCBxIFG) & UCTXIFG) && --timeout) {
        ;
    }

    //Check if transfer timed out
    if (timeout == 0) {
        MSP_LOG("start_transfer() TIMEOUT");
        return success;
    }
    success = true;
    return success;
}

static bool restart_transfer(uint16_t baseAddress) {

    bool success = false;
    uint8_t timeout = 40;

    //wait here
    delay_ms(40);

    //Set USCI in Receive mode
    HWREG16(baseAddress + OFS_UCBxCTLW0) &= ~UCTR;

    //Send start
    HWREG16(baseAddress + OFS_UCBxCTLW0) |= (UCTXSTT + UCTXSTP);

    //Poll for receive interrupt flag.
    while (!(HWREG16(baseAddress + OFS_UCBxIFG) & UCRXIFG) && --timeout) {
        ;
    }

    if (timeout == 0) {
        MSP_LOG("restart_transfer() TIMEOUT");
        return success;
    }
    success = true;
    return success;
}
static void stop_transfer() {
    EUSCI_B_I2C_masterReceiveMultiByteStop(EUSCI_B0_BASE);
}
static bool write_reg(uint16_t baseAddress, uint8_t *data, uint8_t len) {
    //start the transmission now
    //MSP430 send slave address once start bit occur
    bool success = start_transfer(baseAddress);
    if (!success) {
        return 0;
    }

    //send the data to be sent
    uint8_t i = 0;
    for (i = 0; i < len; i++) {
        EUSCI_B_I2C_slavePutData(baseAddress, data[i]);
    }

    //stop the transmission
    stop_transfer();

    return success;
}
static bool read_reg(uint16_t baseAddress, uint8_t *data, uint8_t len) {

    //start the communication
    //restart with received mode
    bool success = restart_transfer(baseAddress);
    if (!success) {
        return 0;
    }
    //start reading now.
    uint8_t i = 0;
    for (i = 0; i < len; i++) {
        *data++ = EUSCI_B_I2C_slaveGetData(baseAddress);
    }

    //stop the transmission
    stop_transfer();
    return success;
}

Hi,

Thank you for you reply.

Yes i am bypassing the existing MSP430RF2355. 

I think I got the answer here. MCF8316AEVM  device slave will be 0x01 always by default ?

Hi,

After drill down you example code.I have question regarding the I2C Read method. 

As per data sheet of MCF8316AEVM, It's accepting 4 byte of control word for reading and writing.

As per the example code, It sending 4 byte of control word and reading data from the register. Firstly configuring into the transmission mode for the write control word with automatic stop condition through the @byteCounterThreshold but what about the reading case, at end of the reading not using stop condition for end transmission, So that mean @byteCounterThreshold count will generate the stop condition again at end ot reading ?

As per my understanding, @byteCounterThreshold will generate stop condition once writing count reach to the @byteCounterThreshold count which is already reached while sending the control word so it's not necessary now to generate the stop condition once it's received. ?

bool I2C_read32(unsigned long addr, unsigned long *result, uint32_t timeout) {
    // Temp variables
    uint8_t val;
    unsigned long r = 0;

    EUSCI_B_I2C_initMasterParam param = {0};
    param.selectClockSource = EUSCI_B_I2C_CLOCKSOURCE_SMCLK;
    param.i2cClk = CS_getSMCLK();
    param.dataRate = EUSCI_B_I2C_SET_DATA_RATE_400KBPS;
    param.byteCounterThreshold = 4;
    param.autoSTOPGeneration = EUSCI_B_I2C_SEND_STOP_AUTOMATICALLY_ON_BYTECOUNT_THRESHOLD;
    EUSCI_B_I2C_initMaster(EUSCI_I2C_BASE, &param);

    //Enable I2C Module to start operations
    EUSCI_B_I2C_enable(EUSCI_I2C_BASE);

    // Construct the 24 bit control word (refer to datasheet section 7.6.2.1)
    char control_word[3] = {0x90, 0x00, addr&0xFF};

    /* Set slave Address */
    EUSCI_B_I2C_setSlaveAddress(EUSCI_I2C_BASE,
                SLAVE_ADDR
            );

    /* Set master to transmit mode */
    EUSCI_B_I2C_setMode(EUSCI_I2C_BASE,
        EUSCI_B_I2C_TRANSMIT_MODE);

    EUSCI_B_I2C_masterSendStart(EUSCI_I2C_BASE);

    __delay_cycles(INTER_BYTE_DELAY);

    /* Send bits CW23-CW16 of the control word */
    if (!EUSCI_B_I2C_masterSendMultiByteNextWithTimeout(EUSCI_I2C_BASE, control_word[0], timeout))
        return 0;

    __delay_cycles(INTER_BYTE_DELAY);

    /* Send bits CW15-CW8 of the control word */
    if (!EUSCI_B_I2C_masterSendMultiByteNextWithTimeout(EUSCI_I2C_BASE, control_word[1], timeout))
        return 0;

    __delay_cycles(INTER_BYTE_DELAY);

    /* Send bits CW7-CW0 of the control word */
    if (!EUSCI_B_I2C_masterSendMultiByteNextWithTimeout(EUSCI_I2C_BASE, control_word[2], timeout))
        return 0;

    __delay_cycles(INTER_BYTE_DELAY);

    /*
     * Set master to receive mode and generate Start condition
     * This sends out the slave address and continues to read
     * until you issue a STOP
     */
    EUSCI_B_I2C_masterReceiveStart(EUSCI_I2C_BASE);

    __delay_cycles(INTER_BYTE_DELAY);

    val = EUSCI_B_I2C_masterReceiveSingle(EUSCI_I2C_BASE);
    r |= val;
    __delay_cycles(INTER_BYTE_DELAY);

    val = EUSCI_B_I2C_masterReceiveSingle(EUSCI_I2C_BASE);
    r |= ((unsigned long)val)<<8;
    __delay_cycles(INTER_BYTE_DELAY);

    val = EUSCI_B_I2C_masterReceiveSingle(EUSCI_I2C_BASE);
    r |= ((unsigned long)val)<<16;
    __delay_cycles(INTER_BYTE_DELAY);

    val = EUSCI_B_I2C_masterReceiveSingle(EUSCI_I2C_BASE);
    r |= ((unsigned long)val)<<24;
    *result = r;
    __delay_cycles(INTER_BYTE_DELAY);

    return 1;
}

Hi,

That means the threshold count can be use for the both the operation like reading and writing. 

So first operation when writing is done, threshold count generates the stop condition and when reading start using restart the i2c operation using i2c start the flag, again once number bytes reader as per the threshold count, device generates the stop condition for end of the operation. Right?

Hi,

Noted. that means i should not issue extra stop condition for reading the shadow register because which will handle by the @byteCounterThreshold.

Is shadow register is always be available for reading and writing through I2C Communication or any restriction is there for reading and writing?

 what about the slave address ?

ketan vadodariya said:

that means i should not issue extra stop condition for reading the shadow register

Correct.

The shadow registers are always available for reading and writing through I2C unless a read or write operation is already occurring. For best practices, please review our datasheet that covers EEPROM access and the I2C interface.

Best,

Robert

Hi,

Thank you for your update. 

I'm able to read the shadow register through I2C without writing anything. 

Preloaded GUI code for MSP340FR2355 is available on TI?

Hi Ketan,

I am unsure of this, please direct this question to the MSP E2E forum.

If I have answered all of your questions regarding our motor driver, please help by marking this thread as resolved.

Best,

Robert