TM4C1294KCPDT: TM4C1294 EVK

This is the same example I run on EK-TM4C1294XL LaunchPad. Below is the terminal output.

What do you see on the terminal output? 

When you said you run EVK board, do you mean you run on EK-TM4C1294XL board?

I also want to make sure in your project property, you are NOT selecting a TM4C123 device. Below is selecting TM4C129. 

this is the print iam getting

yes i run on  EK-TM4C1294XL board only

this is my predefined symbols settings

please correct me any changes need to be done 

can you also tell the difference between RA0 and RA1 etc...

After this terminal output program gets aborted

getting into the error here and aborted

please help to resolve the issue

Your code is running normal. The reason in mine, I put a while(1) to repeat the I2C transactions. If I were to remove the while(1) to repeat the transactions, I would have also exited to abort() which is absolutely normal. main() is no different from any other function from C language stand point of view. When it finishes the last line of code in main() it needs to go somewhere and it just go abort routine. In a real application, you would not have the program exited main().

 Refer to this link about return(0) from main(). 

https://www.tutorialspoint.com/What-should-main-return-in-C-and-Cplusplus#:~:text=The%20return%20value%20for%20main,non%2Dzero%20codes%20are%20interpreted.

I tried to run inside while but it get struck here after first set of data transmitted and could not able to transmit  data second time 

can you please suggest what need to be done further

debug log for your refernce

I could to able to see data transfer in I2C1 in terminal , but some times it got struck need to check why

But when I tried to check in digital oscilloscope (DSO) with pull up (10 k resistor in I2C1 CLK  and I2C1 DATA, PG0 and PG1 pins) i could not see any wave forms  and frequency value , can you confirm that if we probe those lines we could able see I2C waveform since it is internal loopback code.

if possible can you please share I2C waveforms using this code 

could not able to capture 100 Kbps I2C clock waveform , any adjustments in system clock or PLL calculation need to be made in function I2CMasterInitExpClk(),

so that will get capture clear I2C clock and data waveform

Hi,

bala sund said:

But when I tried to check in digital oscilloscope (DSO) with pull up (10 k resistor in I2C1 CLK  and I2C1 DATA, PG0 and PG1 pins) i could not see any wave forms  and frequency value , can you confirm that if we probe those lines we could able see I2C waveform since it is internal loopback code.

if possible can you please share I2C waveforms using this code 

If you are in loopback mode then you cannot see bus activities. The example I showed was for I2C0. Do you have any problem running it?

HI 

I am using this code but still I could not send the data in I2c  iam getting the following error 

when I tried to write first time the data is written to the slave which i could able to capture in I2c analayzer

but when i continuously try to write the next configuration register 

iam getting I2c error  

Can you please help me to  check the code any changes to be made in the code

//============================================================================
// Name        : i2cAPI.c
// Author      :
// Version     :
// Copyright   : Your copyright notice
// Description : Tiva i2c in C++, Ansi-style
//============================================================================
/*
 * i2cAPI.c
 * Implementation of a i2c interface
 *
 * Copyright
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL I
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


#include <stdbool.h>
#include <stdint.h>
#include "inc/hw_i2c.h"
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/gpio.h"
#include "driverlib/i2c.h"
#include "driverlib/pin_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/uart.h"
#include "utils/uartstdio.h"
#include "i2cAPI.h"
#include "drivers/pinout.h"


// TivaWare includes
#include "driverlib/sysctl.h"
#include "driverlib/debug.h"
#include "driverlib/rom.h"
#include "driverlib/rom_map.h"


#define SLAVE_ADDRESS 0x14

#define I2C_BASE                I2C1_BASE
#define I2C_SYSCTL              SYSCTL_PERIPH_I2C1

#define I2C_SCL_SYSCTL_PERIPH   SYSCTL_PERIPH_GPIOG
#define I2C_SCL_GPIO_PORT_BASE  GPIO_PORTG_BASE
#define I2C_SCL                 GPIO_PIN_0
#define I2C_SCL_CFG             GPIO_PG0_I2C1SCL

#define I2C_SDA_SYSCTL_PERIPH   SYSCTL_PERIPH_GPIOG
#define I2C_SDA_GPIO_PORT_BASE  GPIO_PORTG_BASE
#define I2C_SDA                 GPIO_PIN_1
#define I2C_SDA_CFG             GPIO_PG1_I2C1SDA

uint32_t i2c_init(uint32_t ui32SysClock)
{



    //
    // Set the clocking to run directly from the external crystal/oscillator.
    // TODO: The SYSCTL_XTAL_ value must be changed to match the value of the
    // crystal on your board.
    //
/*
#if defined(TARGET_IS_TM4C129_RA0) ||                                         \
    defined(TARGET_IS_TM4C129_RA1) ||                                         \
    defined(TARGET_IS_TM4C129_RA2)
    ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
                                       SYSCTL_OSC_MAIN |
                                       SYSCTL_USE_PLL |
                                       SYSCTL_CFG_VCO_240), 80000000);
#else
    SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
                   SYSCTL_XTAL_16MHZ);
#endif
*/

    //
    // The I2C0 peripheral must be enabled before use.
    //
    SysCtlPeripheralDisable(I2C_SYSCTL);
    SysCtlPeripheralReset(I2C_SYSCTL);
    SysCtlPeripheralEnable(I2C_SYSCTL);

    while(!SysCtlPeripheralReady(I2C_SYSCTL));
    //
    // For this example I2C0 is used with PortB[3:2].  The actual port and
    // pins used may be different on your part, consult the data sheet for
    // more information.  GPIO port B needs to be enabled so these pins can
    // be used.
    // TODO: change this to whichever GPIO port you are using.
    //
    SysCtlPeripheralEnable(I2C_SCL_SYSCTL_PERIPH);
    SysCtlPeripheralEnable(I2C_SDA_SYSCTL_PERIPH);
    while(!SysCtlPeripheralReady(I2C_SCL_SYSCTL_PERIPH));
    while(!SysCtlPeripheralReady(I2C_SDA_SYSCTL_PERIPH));


    //
    // Configure the pin muxing for I2C0 functions on port B2 and B3.
    // This step is not necessary if your part does not support pin muxing.
    // TODO: change this to select the port/pin you are using.
    //
    GPIOPinConfigure(I2C_SCL_CFG);
    GPIOPinConfigure(I2C_SDA_CFG);

    //
    // Select the I2C function for these pins.  This function will also
    // configure the GPIO pins pins for I2C operation, setting them to
    // open-drain operation with weak pull-ups.  Consult the data sheet
    // to see which functions are allocated per pin.
    // TODO: change this to select the port/pin you are using.
    //
    GPIOPinTypeI2CSCL(I2C_SCL_GPIO_PORT_BASE, I2C_SCL);
    GPIOPinTypeI2C(I2C_SDA_GPIO_PORT_BASE, I2C_SDA);



    I2CMasterGlitchFilterConfigSet(I2C_BASE, I2C_MASTER_GLITCH_FILTER_2);

    //
    // Enable and initialize the I2C0 master module.  Use the system clock for
    // the I2C0 module.  The last parameter sets the I2C data transfer rate.
    // If false the data rate is set to 100kbps and if true the data rate will
    // be set to 400kbps.  For this example we will use a data rate of 100kbps.
    //

#if defined(TARGET_IS_TM4C129_RA0) ||                                         \
    defined(TARGET_IS_TM4C129_RA1) ||                                         \
    defined(TARGET_IS_TM4C129_RA2)
    I2CMasterInitExpClk(I2C_BASE, ui32SysClock, false);
#else
    I2CMasterInitExpClk(I2C_BASE, SysCtlClockGet(), false);
#endif

    //
    // Enable the I2C0 slave module. This module is enabled only for testing
    // purposes.  It does not need to be enabled for proper operation of the
    // I2Cx master module.
    //
    //I2CSlaveEnable(I2C_BASE);

    //
    // Set the slave address to SLAVE_ADDRESS.  In loopback mode, it's an
    // arbitrary 7-bit number (set in a macro above) that is sent to the
    // I2CMasterSlaveAddrSet function.
    //
    //I2CSlaveInit(I2C_BASE, SLAVE_ADDRESS);

}


//read specified register on slave device
uint32_t I2CReceive(uint32_t slave_addr, uint8_t reg)
{
    //specify that we are writing (a register address) to the
    //slave device
    I2CMasterSlaveAddrSet(I2C_BASE, slave_addr, false);

    //specify register to be read
    I2CMasterDataPut(I2C_BASE, reg);

    //send control byte and register address byte to slave device
//    I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_BURST_SEND_START);
    I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_SINGLE_SEND);
    SysCtlDelay(3000);
    //wait for MCU to finish transaction
    while(I2CMasterBusy(I2C_BASE));
//    //Check for errors in the I2C8 Module
//    while (I2CMasterErr(I2C_BASE)){
//        UARTprintf("I2c_errror\r\n");
//    }
    //specify that we are going to read from slave device
    I2CMasterSlaveAddrSet(I2C_BASE, slave_addr, true);

    //send control byte and read from the register we
    //specified
    I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE);

    //wait for MCU to finish transaction
    while(I2CMasterBusy(I2C_BASE));

    //return data pulled from the specified register
    return I2CMasterDataGet(I2C_BASE);
}

//sends an I2C command to the specified slave
void I2CSend(uint8_t slave_addr, uint8_t num_of_args, ...)
{
    // Tell the master module what address it will place on the bus when
    // communicating with the slave.
    I2CMasterSlaveAddrSet(I2C_BASE, slave_addr, false);

    //stores list of variable number of arguments
    va_list vargs;

    //specifies the va_list to "open" and the last fixed argument
    //so vargs knows where to start looking
    va_start(vargs, num_of_args);

    //put data to be sent into FIFO
    I2CMasterDataPut(I2C_BASE, va_arg(vargs, uint32_t));

    //if there is only one argument, we only need to use the
    //single send I2C function
    if(num_of_args == 1)
    {
        //Initiate send of data from the MCU
        I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_SINGLE_SEND);

        SysCtlDelay(1000);
        // Wait until MCU is done transferring.
        while(I2CMasterBusy(I2C_BASE));

        //Check for errors in the I2C8 Module
        while (I2CMasterErr(I2C_BASE)){
            UARTprintf("I2c_errror\r\n");
        }

        //"close" variable argument list
        va_end(vargs);
    }

    //otherwise, we start transmission of multiple bytes on the
    //I2C bus
    else
    {
        //Initiate send of data from the MCU
        I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_BURST_SEND_START);
        SysCtlDelay(1000);
        // Wait until MCU is done transferring.
        while(I2CMasterBusy(I2C_BASE));

        while (I2CMasterErr(I2C_BASE)){
                    UARTprintf("I2c_errror\r\n");
                }

        //send num_of_args-2 pieces of data, using the
        //BURST_SEND_CONT command of the I2C module
        uint8_t i = 0;
        for (i = 1; i < (num_of_args - 1); i++)
        {
            //put next piece of data into I2C FIFO
            I2CMasterDataPut(I2C_BASE, va_arg(vargs, uint32_t));
            //send next data that was just placed into FIFO
            I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);

            SysCtlDelay(1000);

            // Wait until MCU is done transferring.
            while(I2CMasterBusy(I2C_BASE));

            while (I2CMasterErr(I2C_BASE)){
                                UARTprintf("I2c_errror\r\n");
                            }

        }

        //put last piece of data into I2C FIFO
        I2CMasterDataPut(I2C_BASE, va_arg(vargs, uint32_t));
        //send next data that was just placed into FIFO
        I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
        // Wait until MCU is done transferring.

        SysCtlDelay(1000);
        while(I2CMasterBusy(I2C_BASE));

        while (I2CMasterErr(I2C_BASE)){
            UARTprintf("I2c_errror\r\n");
         }

        //"close" variable args list
        va_end(vargs);
    }
}

//sends an array of data via I2C to the specified slave
void I2CSendString(uint32_t slave_addr, char array[])
{

    // Tell the master module what address it will place on the bus when
    // communicating with the slave.
    I2CMasterSlaveAddrSet(I2C_BASE, slave_addr, false);

    //put data to be sent into FIFO
    I2CMasterDataPut(I2C_BASE, array[0]);

    //if there is only one argument, we only need to use the
    //single send I2C function
    if(array[1] == '\0')
    {
        //Initiate send of data from the MCU
        I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_SINGLE_SEND);

        // Wait until MCU is done transferring.
        while(I2CMasterBusy(I2C_BASE));
    }

    //otherwise, we start transmission of multiple bytes on the
    //I2C bus
    else
    {
        //Initiate send of data from the MCU
        I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_BURST_SEND_START);

        // Wait until MCU is done transferring.
        while(I2CMasterBusy(I2C_BASE));

        //initialize index into array
        uint8_t i = 1;

        //send num_of_args-2 pieces of data, using the
        //BURST_SEND_CONT command of the I2C module
        while(array[i + 1] != '\0')
        {
            //put next piece of data into I2C FIFO
            I2CMasterDataPut(I2C_BASE, array[i++]);

            //send next data that was just placed into FIFO
            I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);

            // Wait until MCU is done transferring.
            while(I2CMasterBusy(I2C_BASE));
        }

        //put last piece of data into I2C FIFO
        I2CMasterDataPut(I2C_BASE, array[i]);

        //send next data that was just placed into FIFO
        I2CMasterControl(I2C_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);

        // Wait until MCU is done transferring.
        while(I2CMasterBusy(I2C_BASE));
    }
}

Iam using the following function to write the data to slave

HI charles

I am trying to access the I2C  from the DRV2605L haptics  EVM-CT with the changes you ask to make but still I could not access the slave (0xA5)

when i tried to write the mode register (0x01) to "0"  the write is not working ,the code struck at this place which you ask to add.

when i tried to capture the with I2c beagle analyzer i am getting like this data transaction, but no data is available 

This is the haptic EVK we are used for testing

https://www.digikey.in/en/products/detail/texas-instruments/DRV2605EVM-CT/3902120?cur=INR&lang=en&utm_adgroup=&utm_source=google&utm_medium=cpc&utm_campaign=PMax%20Shopping_Product_High%20ROAS&utm_term=&productid=3902120&gclid=Cj0KCQjwi7GnBhDXARIsAFLvH4k8Bd09PYBjO3qScILr9iTHxg_zlhPL4jx7rOR1WIPPLFwkyPqUQtIaAqB-EALw_wcB

please help me to solve the issue 

I don't know any connection between tm4c129x EVK and haptic EVK which causing the I2C busy issue ?

Hi,

  Can you use preferably a logic analyzer or a scope to capture the I2C bus waveforms.   They are an invaluable tool to debug I2C.  Please show both SCL and SDA buses.