• State TI Thinks Resolved
  • Locked Locked
  • Replies 3 replies
  • Answers 1 answer
  • Subscribers 30 subscribers
  • Views 587 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.

CCS/TM4C123GH6PM: I have problem with my i2c Driver

Mahmoud Morgan
Prodigy 20 points
Part Number: TM4C123GH6PM

Tool/software: Code Composer Studio

i have problem that all configuration is done except I2CMDR and I2CMCS are not modified even Iam writing to them

there Screenshots for all registers

  • 0
    TI__Guru 72500 points
    Ok, can you provide some more details? What does your software look like? Are you using the TivaWare drivers?
  • 0 in reply to Bob Crosby
    Prodigy 20 points

    no Iam writing my own drivers from zero
    I wrote GPIO TIMERS UART drivers ad they are working properly

    an there is I2c.c

    /*
 * ICC.c
 *
 *  Created on: Oct 30, 2018
 *      Author: Morgan
 */

#include"ICC.h"


gICCError_t initAppropriateICCPins(sICC_t ICC)
{
    gICCError_t state=ICC_PASS;
    if(ICC==ICC0_MOD)
    {
        //PB2 PB3
        clockGatingICC(ICC0_MOD);
        clockGating(GPIOB);
        pinAlternateFunctionSel(BASE_B, 2, HIGH);
        pinAlternateFunctionSel(BASE_B, 3, HIGH);
        pinDigitalEnable(BASE_B, 2, HIGH);
        pinDigitalEnable(BASE_B, 3, HIGH);
        GPIOPinControl(BASE_B, 2, 3);
        GPIOPinControl(BASE_B, 3, 3);
        pinOpenDrainEnable(BASE_B, 3, TRUE);

    }else if(ICC==ICC1_MOD)
    {
        //PA6  PA7
        clockGatingICC(ICC1_MOD);
        clockGating(GPIOA);
        pinAlternateFunctionSel(BASE_A, 6, HIGH);
        pinAlternateFunctionSel(BASE_A, 7, HIGH);
        pinDigitalEnable(BASE_A, 6, HIGH);
        pinDigitalEnable(BASE_A, 7, HIGH);
        GPIOPinControl(BASE_A, 6, 3);
        GPIOPinControl(BASE_A, 7, 3);
        pinOpenDrainEnable(BASE_A, 7, TRUE);

    }else if(ICC==ICC2_MOD)
    {
        //PE4 PE5
        clockGatingICC(ICC2_MOD);
        clockGating(GPIOE);
        pinAlternateFunctionSel(BASE_E, 4, HIGH);
        pinAlternateFunctionSel(BASE_E, 5, HIGH);
        GPIOPinControl(BASE_E, 4, 3);
        GPIOPinControl(BASE_E, 5, 3);
        pinOpenDrainEnable(BASE_E, 5, TRUE);
    }else if(ICC==ICC3_MOD)
    {
        //PD0 PD1
        clockGatingICC(ICC3_MOD);
        clockGating(GPIOD);
        pinAlternateFunctionSel(BASE_D, 0, HIGH);
        pinAlternateFunctionSel(BASE_D, 1, HIGH);
        GPIOPinControl(BASE_D, 0, 3);
        GPIOPinControl(BASE_D, 1, 3);
        pinOpenDrainEnable(BASE_D, 1, TRUE);
    }else
        state=ICC_MODULE_NOT_EXIST;
    return state ;
}
gICCError_t initMaster(uint32 icc)
{
    gICCError_t state = ICC_PASS ;
    if((icc==ICC0)||(icc==ICC1)||(icc==ICC2)||(icc==ICC3))
    {
        HW_WRITE_BIT(icc+I2CMCR, 4, HIGH);
    }else
        state=ICC_MODULE_NOT_EXIST;
    return state;
}
gICCError_t setSCLclock(uint32 icc,gICC_CLOCK_t speed,uint8 sysclockinMHZ)
{
    uint8 temp =0;
    gICCError_t state=ICC_PASS;
    if((icc==ICC0)||(icc==ICC1)||(icc==ICC2)||(icc==ICC3))
    {
        if(speed==STANDARD_MODE)
           {
            if(sysclockinMHZ==2||sysclockinMHZ==4||sysclockinMHZ==8||
                    sysclockinMHZ==16||sysclockinMHZ==20||sysclockinMHZ==40||
                    sysclockinMHZ==80)
            {
                temp= (sysclockinMHZ/2)-1;
                HW_WRITE_REG_32BIT(icc+I2CMTPR,temp);
            }else
                state=WRONG_SYS_CLOCK;
           }else if(speed==HIGHSPEED_MODE)
           {
               if(sysclockinMHZ==40)
               {
                   HW_WRITE_REG_32BIT(icc+I2CMTPR,1);
               }else if(sysclockinMHZ==80)
               {
                   HW_WRITE_REG_32BIT(icc+I2CMTPR,3);
               }else
                   state=WRONG_SYS_CLOCK;
           }else
               state=WRONG_SPEED_MODE;
    }else
        state=ICC_MODULE_NOT_EXIST;
    return state;

}
gICCError_t setMasterSlaveAddress(uint32 icc , uint8 slave)
{
    gICCError_t state= ICC_PASS;
    if((icc==ICC0)||(icc==ICC1)||(icc==ICC2)||(icc==ICC3))
    {
        HW_WRITE_MASKED_REG(icc+I2CMSA,slave,1,0xFE);
    }else
        state=ICC_MODULE_NOT_EXIST;
    return state;
}
gICCError_t selectOperation(uint32 icc,gICC_OPERATION_t operation)
{
    gICCError_t state = ICC_PASS;
    if ((icc == ICC0) || (icc == ICC1) || (icc == ICC2) || (icc == ICC3))
    {
        if(operation==TRANSMIT)
        {
            HW_WRITE_BIT(icc+I2CMSA, 0, 0);
        }else if(operation==RECIEVE)
        {
            HW_WRITE_BIT(icc+I2CMSA, 0, 1);
        }else
            state=WRONG_ICC_OPERATION;
    }
    else
        state = ICC_MODULE_NOT_EXIST;
    return state;
}

gICCError_t readI2CErrorBit(uint32 icc,uint8 *error)
{
    gICCError_t state = ICC_PASS;
    if ((icc == ICC0) || (icc == ICC1) || (icc == ICC2) || (icc == ICC3))
    {
        *error=HW_READ_BIT(icc+I2CMCS, 1);
    }else
        state=ICC_MODULE_NOT_EXIST;
    return state;
}
gICCError_t readI2CBusyBit(uint32 icc,uint8 *busy)
{
    gICCError_t state = ICC_PASS;
    if ((icc == ICC0) || (icc == ICC1) || (icc == ICC2) || (icc == ICC3))
    {
        *busy=HW_READ_BIT(icc+I2CMCS, 0);
    }else
        state=ICC_MODULE_NOT_EXIST;
    return state;
}
gICCError_t writeByte(uint32 icc,uint8 data,uint8 START,uint8 RUN,uint8 STOP)
{
    gICCError_t state = ICC_PASS;
    uint8 busy=0;
    uint8 error;
    if ((icc == ICC0) || (icc == ICC1) || (icc == ICC2) || (icc == ICC3))
    {
        HW_WRITE_REG_32BIT(icc+I2CMDR,data);
        HW_WRITE_BIT(icc+I2CMCS, 0, RUN);
        HW_WRITE_BIT(icc+I2CMCS, 1, START);
        HW_WRITE_BIT(icc+I2CMCS, 2, STOP);
        readI2CBusyBit(icc, &busy);
        while(busy!=0);
        readI2CErrorBit(icc, &error);
        if(error==1)
        {
            HW_WRITE_BIT(icc+I2CMCS, 2, STOP);
            UARTprintf("error sending over i2c");
        }
    }else
        state = ICC_MODULE_NOT_EXIST;
    return state;
}
gICCError_t MasterReadByte(uint32 icc,uint8 *data,uint8 START,uint8 RUN,uint8 STOP)
{
    gICCError_t state = ICC_PASS;
    uint8 busy=0;
    uint8 error;
    if ((icc == ICC0) || (icc == ICC1) || (icc == ICC2) || (icc == ICC3))
    {
        HW_WRITE_BIT(icc+I2CMCS, 0, RUN);
        HW_WRITE_BIT(icc+I2CMCS, 1, START);
        HW_WRITE_BIT(icc+I2CMCS, 2, STOP);
        if(STOP==0)
        {
            HW_WRITE_BIT(icc+I2CMCS, 3, 1);
        }else if(STOP==1)
        {
            HW_WRITE_BIT(icc+I2CMCS, 2, 0);
        }
        readI2CBusyBit(icc, &busy);
        while(busy!=0);
        readI2CErrorBit(icc, &error);
        if(error==0)
        {
            *data = HW_READ_MASKED_BYTE_REG(icc+I2CMDR, 0, 0xFF);
        }else
        {
            HW_WRITE_BIT(icc + I2CMCS, 2, STOP);
            UARTprintf("error sending over i2c");
        }
    }else
        state = ICC_MODULE_NOT_EXIST;
    return state;
}

gICCError_t ICCenableLoopBack(uint32 icc)
{
    gICCError_t state = ICC_PASS ;
    if((icc==ICC0)||(icc==ICC1)||(icc==ICC2)||(icc==ICC3))
    {
        HW_WRITE_BIT(icc+I2CMCR, 0, HIGH);
    }else
        state=ICC_MODULE_NOT_EXIST;
    return state;
}
gICCError_t ICCInitSlave(uint32 icc,uint8 slaveAddress)
{
    gICCError_t state = ICC_PASS ;
    if((icc==ICC0)||(icc==ICC1)||(icc==ICC2)||(icc==ICC3))
    {
        HW_WRITE_BIT(icc+I2CMCR, 5, HIGH);
        HW_WRITE_BIT(icc+I2CSCSR, 0, HIGH);
        HW_WRITE_MASKED_REG(icc+I2CSOAR, slaveAddress, 0, 0x7F);
    }else
        state=ICC_MODULE_NOT_EXIST;
    return state;
}
gICCError_t slaveRecievedData(uint32 icc,uint8 *status)
{
    gICCError_t state = ICC_PASS;
    if ((icc == ICC0) || (icc == ICC1) || (icc == ICC2) || (icc == ICC3))
    {
        *status=HW_READ_BIT(icc+I2CSCSR, 0);
    }else
        state=ICC_MODULE_NOT_EXIST;
    return state;
}
gICCError_t slaveReadByte(uint32 icc,uint8 *data)
{
    gICCError_t state = ICC_PASS ;
    uint8 status;
    slaveRecievedData(icc, status);
    if((icc==ICC0)||(icc==ICC1)||(icc==ICC2)||(icc==ICC3))
    {
        while(status!=0);
        *data = HW_READ_MASKED_BYTE_REG(icc+I2CSDR, 0, 0xFF);
    }else
        state=ICC_MODULE_NOT_EXIST;
    return state;
}







    ___________________________________________________________________________
and in main iam using loopback mode to test i2c

    iam very sorry about formatting my first time to post here

    ___________________________________________________________________________________________________
/**
 * main.c
 */
#include <stdbool.h>
#include <stdint.h>
#include"App/app_gpio.h"
#include"HAL/timers.h"
#include"APP/app_uart.h"
#include"HAL/can.h"
#include"HAL/ICC.h"
int main(void)
{
    uint8 TXdata [2] ;
    uint8 RXdata [2] ;
    uint8 index ;
    const uint8 slave=0x3C;
    setSysClock(INTERNAL_16M, c20MHZ);
    gGPIOObj_t inPin ;
    gUARTCFG_t UARTobj;
    UARTobj.FIFOsEnable=FALSE;
    UARTobj.clockSource=SYSTEM_CLOCK;
    UARTobj.parityEnable=FALSE;
    UARTobj.stopBits=ONE_STOP_BIT;
    UARTobj.wordLength=EIGHT_BITS;
    UARTobj.integarDiv=130;
    UARTobj.fractionaldiv=13;
    UARTobj.uart=UART0_MODULE;
    inPin.base=BASE_F;
    inPin.dir=INPUT;
    inPin.pin_num=0;
    inPin.configPadObj.resType=PULL_UP_RES;
    inPin.configPadObj.lockFlag=FALSE;
    inPin.configPadObj.currentVal=CURRENT_2MA;
    initPort(&inPin,0b11101110);
    initUART(&UARTobj);
    //I2c Init
    initAppropriateICCPins(ICC1_MOD);
    initMaster(ICC1);
    setSCLclock(ICC1, STANDARD_MODE, 20);
    ICCenableLoopBack(ICC1);
    ICCInitSlave(ICC1, slave);
    setMasterSlaveAddress(ICC1, slave);
    selectOperation(ICC1, TRANSMIT);
    TXdata[0]='I';
    TXdata[1]='2';
    TXdata[2]='C';
    for (index = 0; index <= 2; index++)
    {
        RXdata[index] = 0;
    }
    for (index = 0; index <= 2; index++)
    {
        UARTprintf("Sending ... %c\n\r",TXdata[index]);
        writeByte(ICC1, TXdata[index], 1, 1, 1);
        slaveReadByte(ICC1, &RXdata[index]);
        UARTprintf("Recieved ... %c\n\r",RXdata[index]);
    }


	return 0;
}

  • 0 in reply to Mahmoud Morgan
    TI__Guru 72500 points
    OK, I am not sure why you choose to write your own drivers when you have access to free drivers written by the IC vendor that have been tested and proven.

    As you can imagine, we get many requests for help on this forum. To be as efficient as possible and help as many people as possible, we encourage everyone to use the TivaWare drivers. We do not take the time to debug the efforts of those who choose to not use the drivers provided. I hope you understand. You will find that very few (if any) of the experienced community members write their own drivers when appropriate TivaWare drivers exist. The source for each TivaWare driver is provided. If your goal is to understand the hardware registers and their use, please look at how the TivaWare drivers write to the hardware registers.