• State Resolved
  • Locked Locked
  • Replies 18 replies
  • Subscribers 31 subscribers
  • Views 2447 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.

I2C Problem - Stellaris LM4F120H5QR

Alessandro Mendes
Prodigy 100 points
Other Parts Discussed in Thread: TM4C123GH6PZ

Hi,

I am trying to send only one byte by I2C without sucess.

I saw the I2C example to write and read a ATMEL EEPROM, this works but I could not work with only one byte then I write a simple code for this.

Can someone help me?

My code is bellow:

int
main(void)
{

//
// 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.
//
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);

//
// The I2C0 peripheral must be enabled before use.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0);

//
// 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(SYSCTL_PERIPH_GPIOB);

//
// 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(GPIO_PB2_I2C0SCL);
GPIOPinConfigure(GPIO_PB3_I2C0SDA);

//
// 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.
//
GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_2 | GPIO_PIN_3);

//
// 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.
//
I2CMasterInitExpClk(I2C0_MASTER_BASE, SysCtlClockGet(), false);

//
// Tell the master module what address it will place on the bus when
// communicating with the slave. Set the address to SLAVE_ADDRESS
// (as set in the slave module). The receive parameter is set to false
// which indicates the I2C Master is initiating a writes to the slave. If
// true, that would indicate that the I2C Master is initiating reads from
// the slave.
//
I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x69, false);   // The address of the Slave is 0x69

//
// Place the data to be sent in the data register
//
I2CMasterDataPut(I2C0_MASTER_BASE, 0x10);       // I am trying send 0x10

//
// Initiate send of data from the master. Since the loopback
// mode is enabled, the master and slave units are connected
// allowing us to receive the same data that we sent out.
//
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_SINGLE_SEND);

//
while(I2CMasterBusy(I2C0_MASTER_BASE));

//
return(0);
}

Alessandro

  • 0
    Guru 117855 points

    The GPIOPinType function has changed for these new LX4F MCUs.  Below is a basic set-up we have used with success across multiple LX4Fs.  If you search this forum under I2C you will see a detailed I2C code listing I provided several months back - which has enjoyed success with multiple users... (link found - below)

    http://e2e.ti.com/support/microcontrollers/stellaris_arm_cortex-m3_microcontroller/f/473/p/169023/681525.aspx#681525

    void   
    i2c_setup(void)
    {
            ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C1);
        
            GPIOPinTypeI2CSCL(GPIO_PORTA_BASE, GPIO_PIN_6);   //   I2CSCL 
            ROM_GPIOPinTypeI2C(GPIO_PORTA_BASE, GPIO_PIN_7);   
       
            ROM_GPIOPinConfigure(GPIO_PA6_I2C1SCL);   
            ROM_GPIOPinConfigure(GPIO_PA7_I2C1SDA);
    }

  • 0 in reply to cb1_mobile
    Prodigy 100 points

    cb1_mobile,

    Now its working.

    Thank you very much!


    Alessandro

  • 0 in reply to Alessandro Mendes
    Guru 117855 points

    Ciao Alessandro-

    Grazie - buona fortuna...

  • 0 in reply to cb1_mobile
    Prodigy 160 points

    Hi,

    I am interfacing EEPROM AT24C04 to my LM4F120 launchpad. I read this post for I2C communication. I am able to write and read with success.

    Here's my code, I want to write data at two memory locations and read from one.

    int
    main(void)
    {
    unsigned long data;
    //
    // 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.
    //
    SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
    SYSCTL_XTAL_16MHZ);

    //
    // The I2C0 peripheral must be enabled before use.
    //
    SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0);

    //
    // 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(SYSCTL_PERIPH_GPIOB);

    //
    // 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.
    //
    //GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_2 | GPIO_PIN_3);
    GPIOPinTypeI2CSCL(GPIO_PORTB_BASE, GPIO_PIN_2); // I2CSCL
    GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_3);

    //
    // 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(GPIO_PB2_I2C0SCL);
    GPIOPinConfigure(GPIO_PB3_I2C0SDA);

    //
    // 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.
    //
    I2CMasterInitExpClk(I2C0_MASTER_BASE, SysCtlClockGet(), false);

    //
    // Tell the master module what address it will place on the bus when
    // communicating with the slave. Set the address to SLAVE_ADDRESS
    // (as set in the slave module). The receive parameter is set to false
    // which indicates the I2C Master is initiating a writes to the slave. If
    // true, that would indicate that the I2C Master is initiating reads from
    // the slave.
    //

    while(1)
    {
    I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x50, false); // The address of the Slave is 0x69

    //
    // Place the data to be sent in the data register
    //
    I2CMasterDataPut(I2C0_MASTER_BASE, 0x10); // Addr 0x10

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START);

    //
    while(I2CMasterBusy(I2C0_MASTER_BASE));


    I2CMasterDataPut(I2C0_MASTER_BASE, 0x10); // Data 0x10

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);

    //
    while(I2CMasterBusy(I2C0_MASTER_BASE));

    I2CMasterDataPut(I2C0_MASTER_BASE, 0x11); // Addr 0x11

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);

    //
    while(I2CMasterBusy(I2C0_MASTER_BASE));


    I2CMasterDataPut(I2C0_MASTER_BASE, 0x1A); // data 0x10

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);

    //
    while(I2CMasterBusy(I2C0_MASTER_BASE));

    ///////////////////////////////////////////////////////////////
    // Read at address 0x11
    I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x50, false);

    I2CMasterDataPut(I2C0_MASTER_BASE, 0x11); // Addr 0x11

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_SINGLE_SEND);

    //
    while(I2CMasterBusy(I2C0_MASTER_BASE));


    I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x50, true);
    data = I2CMasterDataGet(I2C0_MASTER_BASE); //Receive

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE);

    //
    while(I2CMasterBusy(I2C0_MASTER_BASE));

    }
    return(0);
    }

     

    I would appreciate any kind of help.

    Thank you in advance.

  • 0 in reply to Vedashree Vidwans
    TI__Guru**** 244400 points

    Hello Vedashree,

    See the attached file as the new code for doing what you expect from the code.

    Fullscreen 8637.newcode.c Download 
    int
main(void)
{
unsigned long data;
//
// 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.
//
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);

//
// The I2C0 peripheral must be enabled before use.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0);

//
// 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(SYSCTL_PERIPH_GPIOB);

//
// 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.
//
//GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_2 | GPIO_PIN_3);
GPIOPinTypeI2CSCL(GPIO_PORTB_BASE, GPIO_PIN_2); // I2CSCL
GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_3);

//
// 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(GPIO_PB2_I2C0SCL);
GPIOPinConfigure(GPIO_PB3_I2C0SDA);

//
// 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.
//
I2CMasterInitExpClk(I2C0_MASTER_BASE, SysCtlClockGet(), false);

//
// Tell the master module what address it will place on the bus when
// communicating with the slave. Set the address to SLAVE_ADDRESS
// (as set in the slave module). The receive parameter is set to false
// which indicates the I2C Master is initiating a writes to the slave. If
// true, that would indicate that the I2C Master is initiating reads from
// the slave.
//

while(1)
{
I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x50, false); // The address of the Slave is 0x69

//
// Place the data to be sent in the data register
//
I2CMasterDataPut(I2C0_MASTER_BASE, 0x10); // Addr 0x10

//
// Initiate send of data from the master. Since the loopback
// mode is enabled, the master and slave units are connected
// allowing us to receive the same data that we sent out.
//
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START);

//
while(I2CMasterBusy(I2C0_MASTER_BASE));


I2CMasterDataPut(I2C0_MASTER_BASE, 0x10); // Data 0x10

//
// Initiate send of data from the master. Since the loopback
// mode is enabled, the master and slave units are connected
// allowing us to receive the same data that we sent out.
//
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);

//
while(I2CMasterBusy(I2C0_MASTER_BASE));

#if 0
I2CMasterDataPut(I2C0_MASTER_BASE, 0x11); // Addr 0x11

//
// Initiate send of data from the master. Since the loopback
// mode is enabled, the master and slave units are connected
// allowing us to receive the same data that we sent out.
//
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);

//
while(I2CMasterBusy(I2C0_MASTER_BASE));
#endif

I2CMasterDataPut(I2C0_MASTER_BASE, 0x1A); // data 0x10

//
// Initiate send of data from the master. Since the loopback
// mode is enabled, the master and slave units are connected
// allowing us to receive the same data that we sent out.
//
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);

//
while(I2CMasterBusy(I2C0_MASTER_BASE));

///////////////////////////////////////////////////////////////
// Read at address 0x11
I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x50, false);

I2CMasterDataPut(I2C0_MASTER_BASE, 0x11); // Addr 0x11

//
// Initiate send of data from the master. Since the loopback
// mode is enabled, the master and slave units are connected
// allowing us to receive the same data that we sent out.
//
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START);

//
while(I2CMasterBusy(I2C0_MASTER_BASE));


I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x50, true);

//
// Initiate send of data from the master. Since the loopback
// mode is enabled, the master and slave units are connected
// allowing us to receive the same data that we sent out.
//
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE);

//
while(I2CMasterBusy(I2C0_MASTER_BASE));

data = I2CMasterDataGet(I2C0_MASTER_BASE); //Receive

}
return(0);
}

    Regards

    Amit

  • 0 in reply to Amit Ashara
    Guru 117855 points

    Amit Ashara said:
    newcode.c

    My friend, "newcode.c" may not clearly/completely convey meaning - especially after few weeks/months/rainy seasons!

    And - is not the vast amount of current/recent code - ever other than, "new?"

    Clarity of thought starts w/proper subject/title.  (haste should not overwhelm your usual discipline...)

  • 0 in reply to cb1_mobile
    TI__Guru**** 244400 points

    Hello cb1_mobile,

    Always appreciate your feedback. Will edit my post with the inputs on the original code.

    Regards

    Amit

  • 0 in reply to Amit Ashara
    Prodigy 160 points

    Hey Amit,

    Thanks a lot. The code is working fine. :)

    Regards,

    Vedashree

  • 0 in reply to Vedashree Vidwans
    TI__Guru**** 244400 points

    Hello Vedashree,

    Was it the code that I sent or did you have to tweak the code? Such data/info would be useful while I draft the correct explanation as well.

    Regards

    Amit

  • 0 in reply to Amit Ashara
    Prodigy 160 points

    Amit,

    The code which you sent is working fine with my EEPROM.

    Regards,

    Vedashree

  • 0 in reply to Vedashree Vidwans
    TI__Guru**** 244400 points

    Hello All,

    An explanation on what the code modified was for

    1. The write operation to the slave device was to write to the two words

    With the Start Command the Slave Address and the byte to which the write is to be done is sent. The next write is auto-sequential, i.e. the Byte put after the address will be written to the address and the next byte will be put at Address+1 and so on. With the second write the Stop condition is put on the bus so that the Second Byte is written to the Address+1 and then the I2C Transaction is completed

    2. The Read was only to be one word

    With the Start Command the Slave Address and the bye from which read is to be done is sent. Then a Repeat Start is issued with the Slave Address and Read bit set in the frame, following which the next data is read by the Master from the Slave device and a Stop condition put.

    Regards

    Amit

  • 0 in reply to Amit Ashara
    Prodigy 160 points

    Hi Amit,

    Now I am trying to interface the EEPROM 24C04 chip with TM4C123GH6PZ custom board, using the JTAG Debug out feature on the LM4F120 launchpad. The custom board uses internal crystal oscillator. I am able to step debug through the code using the Stellaris In-circuit Debug Interface.

    I have changed all the required settings for the TM4C123GH6PZ board. But I am Unable to communicate with the EEPROM.

    Here's my code,

    #include <stdbool.h>
    #include <stdint.h>
    #include "inc/hw_ints.h"
    #include "inc/hw_memmap.h"
    #include "inc/hw_types.h"
    #include "inc/hw_i2c.h"
    #include "driverlib/debug.h"
    #include "driverlib/gpio.h"
    #include "driverlib/interrupt.h"
    #include "driverlib/sysctl.h"
    #include "driverlib/i2c.h"
    #include "driverlib/pin_map.h"


    void
    main(void)
    {
    unsigned long data;
    //
    // 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.
    //
    SysCtlClockSet(SYSCTL_SYSDIV_2 | SYSCTL_USE_PLL | SYSCTL_OSC_INT |
    SYSCTL_OSC_MAIN);

    //
    // The I2C0 peripheral must be enabled before use.
    //
    SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0);

    //
    // 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(SYSCTL_PERIPH_GPIOB);

    //
    // 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.
    //GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_2 | GPIO_PIN_3);

    GPIOPinTypeI2CSCL(GPIO_PORTB_BASE, GPIO_PIN_2); // I2CSCL
    GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_3);

    //
    // 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(GPIO_PB2_I2C0SCL);
    GPIOPinConfigure(GPIO_PB3_I2C0SDA);

    //
    // 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.
    //
    I2CMasterInitExpClk(I2C0_BASE, SysCtlClockGet(), false);

    //
    // Tell the master module what address it will place on the bus when
    // communicating with the slave. Set the address to SLAVE_ADDRESS
    // (as set in the slave module). The receive parameter is set to false
    // which indicates the I2C Master is initiating a writes to the slave. If
    // true, that would indicate that the I2C Master is initiating reads from
    // the slave.
    //

    while(1)
    {
    I2CMasterSlaveAddrSet(I2C0_BASE, 0x50, false); // The address of the Slave is 0x69

    //
    // Place the data to be sent in the data register
    //
    I2CMasterDataPut(I2C0_BASE, 0x10); // Addr 0x10

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_START);

    //
    while(I2CMasterBusy(I2C0_BASE));


    I2CMasterDataPut(I2C0_BASE, 0x10); // Data 0x10

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);

    //
    while(I2CMasterBusy(I2C0_BASE));
    #if 0
    I2CMasterDataPut(I2C0_BASE, 0x11); // Data 0x10

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);

    //
    while(I2CMasterBusy(I2C0_BASE));
    #endif
    I2CMasterDataPut(I2C0_BASE, 0x1C); // data 0x10

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);

    //
    while(I2CMasterBusy(I2C0_BASE));

    ///////////////////////////////////////////////////////////////
    // Read at address 0x11
    I2CMasterSlaveAddrSet(I2C0_BASE, 0x50, false);

    I2CMasterDataPut(I2C0_BASE, 0x11); // Addr 0x11

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_START);

    //
    while(I2CMasterBusy(I2C0_BASE));


    I2CMasterSlaveAddrSet(I2C0_BASE, 0x50, true);

    //
    // Initiate send of data from the master. Since the loopback
    // mode is enabled, the master and slave units are connected
    // allowing us to receive the same data that we sent out.
    //
    I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE);

    //
    while(I2CMasterBusy(I2C0_BASE));

    data = I2CMasterDataGet(I2C0_BASE); //Receive

    }

    }

     

     

    I would appreciate your guidance.

    Thank you in advance.

     

    Regards

    Vedashree

  • 0 in reply to Vedashree Vidwans
    Guru 47900 points

    Vedashree Vidwans said:
    I would appreciate your guidance.

    More correctly - his "further" guidance!

    Have you emplaced pull-up resistors upon both I2C lines?

  • 0 in reply to cb1
    TI__Guru**** 244400 points

    Hello cb1,

    That was the first thing I would have asked as well.

    Hello Vedashree,

    Since it is a custom board now, schematics is the first line of analysis

    Regards

    Amit

  • 0 in reply to Amit Ashara
    Prodigy 160 points

    Hello cb1 and Amit,

    Thank you for your replies.

    The SDA and SCL lines are directly connected to the I/O pads in the custom board. I am connecting the pull-up registers externally with the EEPROM. 

    Regards,

    Vedashree

  • 0 in reply to Vedashree Vidwans
    TI__Guru**** 244400 points

    Hello Vedashree

    This does not look right

    SysCtlClockSet(SYSCTL_SYSDIV_2 | SYSCTL_USE_PLL | SYSCTL_OSC_INT |
    SYSCTL_OSC_MAIN);

    The minimum value of SYSDIV when using PLL is SYSCTL_SYSDIV_2_5

    Regards

    Amit

  • 0 in reply to Amit Ashara
    Prodigy 160 points

    Hi,

    I changed the SYSDIV to SYSCTL_SYSDIV_2_5. But it does not help communicate with the EEPROM chip.

    I also compiled and debugged it using SYSCTL_USE_OSC with SYSCTL_SYSDIV_2 but no use. :(

     

    Regards,

    Vedashree

  • 0 in reply to Vedashree Vidwans
    TI__Guru**** 244400 points

    Hello Vedashree,

    I would request the schematics at this point.

    Regards

    Amit