CCS/MSP432P401R: Generic I2C coding for MSP432

Kerem Oktem

Prodigy 240 points

Part Number: MSP432P401R

Tool/software: Code Composer Studio

Hello there,

I am trying to write and I2C interface for the mpu6050.

For the IC there shall be single and multi byte receptions and i am trying to write and generic code.

My code does the mutli byte transfers well but single byte transfers doesnot work. Also this code does the i2c transmissions and again the single byte transfers doesnot work.

I would appreciate if you could help me.

I always frustrate when i am writing I2C drivers with texas instruments. I know the I2C protocol so well but when it comes to writing a code for the microcontroller i spend hours.

IS there a way that i could learn how to code for I2C drivers.

Kind Regards

#include <ti/devices/msp432p4xx/driverlib/driverlib.h>

#include "MPU6050.h"

const uint8_t port_mapping_3_3[] =
{
    //Portmapping EUSCI_B0_SPI_I2C.SCL to P3.5, EUSCI_B0_SPI_I2C.SDA to P3.7
    PM_NONE, PM_NONE, PM_NONE, PM_NONE, PM_NONE, PM_UCB0SCL, PM_NONE, PM_UCB0SDA,
};
#define SLAVE_ADDRESS       0x68
uint8_t NUM_OF_REC_BYTES_B0 = 2;
//const uint8_t TXData[] = {0x07};
//const uint8_t TXData[] = {0x00};
//static uint8_t RXData[NUM_OF_REC_BYTES];
uint8_t TXData_B0[256] = {0x07};
uint8_t* TXDataPtr_B0;
uint8_t RXData_B0[256];
static volatile uint32_t xferIndex_B0;
volatile char stopSent_B0;
uint8_t transmitting_B0 = 0;
uint8_t TXByteCtr_B0 = 0;
uint8_t single = 0;

const eUSCI_I2C_MasterConfig i2cConfig_B0 =
{
        EUSCI_B_I2C_CLOCKSOURCE_SMCLK,          // SMCLK Clock Source
        12000000,                                // SMCLK = 3MHz
        EUSCI_B_I2C_SET_DATA_RATE_100KBPS,      // Desired I2C Clock of 100khz
        0,                                      // No byte counter threshold
        EUSCI_B_I2C_NO_AUTO_STOP                // No Autostop
};

void Setup_MPU6050()
{
    // Portmapping the corresponding pins. See above array for details
    MAP_PMAP_configurePorts((const uint8_t *) port_mapping_3_3, P3MAP, 1, PMAP_DISABLE_RECONFIGURATION);
    // Configure P3.5 for EUSCI_B0_SPI_I2C EUSCI_B0_SPI_I2C.SCL
    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P3, GPIO_PIN5, GPIO_PRIMARY_MODULE_FUNCTION);
    // Configure P3.7 for EUSCI_B0_SPI_I2C EUSCI_B0_SPI_I2C.SDA
    MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P3, GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION);

    // Configure as pull-up resistor enabled pins for P5.1
    MAP_GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P5, GPIO_PIN1);
    // Enable interrrupt for P5.1
    MAP_GPIO_enableInterrupt(GPIO_PORT_P5, GPIO_PIN1);
    // Select interrrupt edge (high-to-low) for P5.1
    MAP_GPIO_interruptEdgeSelect(GPIO_PORT_P5, GPIO_PIN1, GPIO_HIGH_TO_LOW_TRANSITION);

    stopSent_B0 = 0;
    I2C_initMaster(EUSCI_B0_BASE, &i2cConfig_B0);
    I2C_setSlaveAddress(EUSCI_B0_BASE, SLAVE_ADDRESS);

    I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_MODE);

    I2C_enableModule(EUSCI_B0_BASE);
    I2C_clearInterruptFlag(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_INTERRUPT0 + EUSCI_B_I2C_RECEIVE_INTERRUPT0);
    Interrupt_enableInterrupt(INT_EUSCIB0);

}

void MPU6050_ReadReg(uint8_t RegAddress, uint8_t length)
{
    stopSent_B0 = 0;
    transmitting_B0 = 0;
    NUM_OF_REC_BYTES_B0 = length;
    if (length == 1)
        single = 1;
    else
        single = 0;
    I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_MODE);
    I2C_masterSendMultiByteStart(EUSCI_B0_BASE, RegAddress);
    I2C_enableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_INTERRUPT0);

    xferIndex_B0 = 0;
    while (!stopSent_B0);

    return ((RXData_B0[0] << 8) + RXData_B0[1]);
    return 0;
}

void MPU6050_WriteReg(uint8_t RegAddress, uint8_t* TxBuffer, uint8_t length)
{
    transmitting_B0 = 1;
    stopSent_B0 = 0;
    TXByteCtr_B0 = length;
    TXDataPtr_B0 = &TXData_B0[0];
    I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_MODE);
    I2C_masterSendMultiByteStart(EUSCI_B0_BASE, RegAddress);
    I2C_enableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_INTERRUPT0);

    while (!stopSent_B0);
}

void EUSCIB0_IRQHandler(void)
{
    uint_fast16_t status;

    status = MAP_I2C_getEnabledInterruptStatus(EUSCI_B0_BASE);
    MAP_I2C_clearInterruptFlag(EUSCI_B0_BASE, status);

    if (status & EUSCI_B_I2C_TRANSMIT_INTERRUPT0)
    {
        if (transmitting_B0)
        {
            if (TXByteCtr_B0)
            {
                /* Send the next data and decrement the byte counter */
                MAP_I2C_masterSendMultiByteNext(EUSCI_B0_BASE, *TXDataPtr_B0++);
                TXByteCtr_B0--;
            } else
            {
                MAP_I2C_masterSendMultiByteStop(EUSCI_B0_BASE);
                stopSent_B0 = 1;
            }
        }
        else
        {
            I2C_disableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_INTERRUPT0);
            I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_MODE);
            I2C_masterReceiveStart(EUSCI_B0_BASE);
            I2C_enableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
        }
    }
    /* Receives bytes into the receive buffer. If we have received all bytes,
     * send a STOP condition */
    if (status & EUSCI_B_I2C_RECEIVE_INTERRUPT0)
    {
        if (xferIndex_B0 == NUM_OF_REC_BYTES_B0 - 2)
        {
            //MAP_I2C_disableInterrupt(EUSCI_B1_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
            //MAP_I2C_enableInterrupt(EUSCI_B1_BASE, EUSCI_B_I2C_STOP_INTERRUPT);

            /*
             * Switch order so that stop is being set during reception of last
             * byte read byte so that next byte can be read.
             */

                MAP_I2C_masterReceiveMultiByteStop(EUSCI_B0_BASE);
            RXData_B0[xferIndex_B0++] = MAP_I2C_masterReceiveMultiByteNext(
                    EUSCI_B0_BASE);
        }
        else if(xferIndex_B0 == NUM_OF_REC_BYTES_B0 - 1)
        {
            RXData_B0[xferIndex_B0++] = MAP_I2C_masterReceiveMultiByteNext(EUSCI_B0_BASE);
            I2C_disableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
            I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_MODE);
            xferIndex_B0 = 0;
            stopSent_B0 = 1;
        }
        else
        {
            RXData_B0[xferIndex_B0++] = MAP_I2C_masterReceiveMultiByteNext(
                    EUSCI_B0_BASE);
        }
    }
    else if (status & EUSCI_B_I2C_STOP_INTERRUPT)
    {
        MAP_I2C_disableInterrupt(EUSCI_B0_BASE,
                                 EUSCI_B_I2C_STOP_INTERRUPT);
    }
}

over 7 years ago

0 Evan W over 7 years ago

TI__Mastermind 39960 points

Kerem,

A few things. First, sorry about your experience so far with the I2C module. It's always our intention to make it easier on you.

Can you first tell me what hardware you are using? Is it a LaunchPad? If so, is it Red or Black?

Allow me to point you to a few resources. Please let me know if you've referred to any of them in your process.

1) There are a number of I2C examples that we have here:

2) There are also the TI-Drivers examples for an RTOS environment: http://dev.ti.com/tirex/#/?link=Software%2FSimpleLink%20MSP432P4%20SDK%2FExamples%2FDevelopment%20Tools%2FMSP432P401R%20LaunchPad%20-%20Red%202.x%20(Red)%2FTI%20Drivers

3) The driverlib API documentation: http://dev.ti.com/tirex/#/?link=Software%2FSimpleLink%20MSP432P4%20SDK%2FDocuments%2FDriverLib%2FDriverlib%20User's%20Guide

A lot of people don't realize that we have individual APIs that do single and multibyte transfers.

4) There is also a really helpful API that we have that uses driverlib code that we use to interface with this boosterpack: http://www.ti.com/tool/BOOSTXL-SENSORS

Here is the link to the project that uses this API: http://dev.ti.com/tirex/#/?link=Software%2FSimpleLink%20MSP432P4%20SDK%2FExamples%2FDevelopment%20Tools%2FMSP432P401R%20LaunchPad%20-%20Red%202.x%20(Red)%2FDemos%2Fboostxl_sensors_sensorgui_msp432p401r%2FNo%20RTOS%2FCCS%20Compiler%2Fboostxl_sensors_sensorgui_msp432p401r

Here are the code files that I'm specifically referencing:

/cfs-file/__key/communityserver-discussions-components-files/166/7701.i2c_5F00_driver.c

/cfs-file/__key/communityserver-discussions-components-files/166/5153.i2c_5F00_driver.h

I think the above files will be really helpful in your efforts, but please let me know what your thoughts are and we can dive deeper if needed.

0 Kerem Oktem over 7 years ago in reply to Evan W

Prodigy 240 points

Dear Evan,

Thank you very much for your valuable and highly desciptive response.

I believe that these shall lead to the results. I should have told that i am trying to develop a motion sensor application right now with the msp432 launchpad blackk (but i do have the red one too,

although i could understand what the difference is) and then shall have the final product with CC2650 in the future.

I shall take a look at the solutions that you have provided.

Thank you for your help

kind regards

0 Evan W over 7 years ago in reply to Kerem Oktem

TI__Mastermind 39960 points

Kerem,

One note then if you are using a black launchpad. The Black LaunchPad contains Rev B silicon which is experimental, pre-production silicon that we no longer support. Between Rev B and Rev C, we fixed a number of hardware bugs in the silicon and progressed the software to be fully CMSIS compliant. You can find more information in Section 3 of this document: www.ti.com/.../slaa700a.pdf

Please be sure to use your red LaunchPad, which contains rev C silicon and is fully supported by our SimpleLink MSP432 SDK. www.ti.com/.../simplelink-msp432-sdk

The SDK also features plug-ins which might be helpful in your effort to adding CC2650.
www.ti.com/.../simplelink-sdk-bluetooth-plugin

The SimpleLink™ SDK Bluetooth Plugin is a companion software package that enables the use of a Bluetooth radio on any standard SimpleLink MSP432™ microcontroller (MCU). This software package supports CC2650MODA and CC2640 Bluetooth low energy Network Processors. This software package works in tandem with the SimpleLink MSP432 software development kit (SDK) to provide a portable and expandable Bluetooth programming suite. By being able to seamlessly and modularly add Bluetooth low energy functionality to an embedded system, a programmer can enable their embedded device to become a gateway to various IoT infrastructures.

However, this is explicitly only support on rev C and beyond for MSP432 (red launchpad).

0 Kerem Oktem over 7 years ago in reply to Evan W

Prodigy 240 points

Well thank you so much for the information.

Currently i have 2 black and 1 red versions of the msp432 launchpad.

Can replace the micrcontroller on the black launch pad with a newer msp432 the one on the red one.

So that my black launchpad's become red at least functionally.

Kind regards

Kerem

0 Evan W over 7 years ago in reply to Kerem Oktem

TI__Mastermind 39960 points

Kerem,

I don't think that would be a problem. There are definitely changes to the LP that we've made between black and red but nothing that will effect the i2c to my knowledge.

Please be sure to use a Rev C or greater piece of silicon when updating the black launchpad.

Also know that the newest launchpad is only 13 or so dollars :)

http://www.ti.com/tool/msp-exp432p401r

0 Kerem Oktem over 7 years ago in reply to Evan W

Prodigy 240 points

Dear Evan,
thank you very much for your help and time.
I ordered a red launchpad just now. It is indeed a faster solution to the problem.

Kind Regards

Kerem OKTEM

**Attention** This is a public forum

MSP low-power microcontrollers

MSP low-power microcontroller forum

CCS/MSP432P401R: Generic I2C coding for MSP432