CC3200的I2C

dontium

CC3200的I2C [复制链接]

CC3200的I2C
一、I2C功能
CC3200的I2C有四种模式：
主机发送；
主机接收；
从机发送；
从机接收。
它可以支持同时的主机和从机操作。
I2C支持的速度有两种：
标准模式 ------ 100Kbps
快速模式-------- 400Kbps

中断：
主机中断：发送或接收完成中断，
从机中断：发送给主机或从主机处接收完成中断，或检测到开始或停止条件中断。
使用DMA：
使用分离的通道进行发送或接收
使用FIFO的单个或突发传输。

CC3200的I2C寄存器：


二、TI例程对I2C的操作
1、PinMuxConfig（）函数。设置端口功能
其主要有：
     // Enable Peripheral Clocks
   MAP_PRCMPeripheralClkEnable(PRCM_I2CA0, PRCM_RUN_MODE_CLK);
    // Configure PIN_01 for I2C0 I2C_SCL
    MAP_PinTypeI2C(PIN_01, PIN_MODE_1);

    // Configure PIN_02 for I2C0 I2C_SDA
MAP_PinTypeI2C(PIN_02, PIN_MODE_1);

2、打开I2C模块

//! Enables and configures the I2C peripheral
int I2C_IF_Open(unsigned long ulMode)
{
    // Enable I2C Peripheral
    //MAP_HwSemaphoreLock(HWSEM_I2C, HWSEM_WAIT_FOR_EVER);
    PRCMPeripheralClkEnable(PRCM_I2CA0, PRCM_RUN_MODE_CLK);
    PRCMPeripheralReset(PRCM_I2CA0);

    // Configure I2C module in the specified mode
    switch(ulMode)
    {
        case I2C_MASTER_MODE_STD:       /* 100000 */
            I2CMasterInitExpClk(I2C_BASE,SYS_CLK,false);
            break;

        case I2C_MASTER_MODE_FST:       /* 400000 */
            I2CMasterInitExpClk(I2C_BASE,SYS_CLK,true);
            break;

        default:
            I2CMasterInitExpClk(I2C_BASE,SYS_CLK,true);
            break;
    }
    // Disables the multi-master mode
    //MAP_I2CMasterDisable(I2C_BASE);
   
    return SUCCESS;
}

3、I2C读写
int I2C_IF_Read(unsigned char ucDevAddr,
        unsigned char *pucData,
        unsigned char ucLen)
{
    unsigned long ulCmdID;

    RETERR_IF_TRUE(pucData == NULL);
    RETERR_IF_TRUE(ucLen == 0);

    // Set I2C codec slave address
    MAP_I2CMasterSlaveAddrSet(I2C_BASE, ucDevAddr, true);

    // Check if its a single receive or burst receive
    if(ucLen == 1)
    {
        // Configure for a single receive
        ulCmdID = I2C_MASTER_CMD_SINGLE_RECEIVE;
    }
    else
    {
        // Initiate a burst receive sequence
        ulCmdID = I2C_MASTER_CMD_BURST_RECEIVE_START;
    }
    // Initiate the transfer.
    RET_IF_ERR(I2CTransact(ulCmdID));

    // Decrement the count and increment the data pointer
    // to facilitate the next transfer
    ucLen--;

    // Loop until the completion of reception or error
    while(ucLen)
    {
        // Receive the byte over I2C
        *pucData = MAP_I2CMasterDataGet(I2C_BASE);

        // Decrement the count and increment the data pointer
        // to facilitate the next transfer
        ucLen--;
        pucData++;
        if(ucLen)
        {
            // Continue the reception
            RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_RECEIVE_CONT));
        }
        else
        {
            // Complete the last reception
            RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_RECEIVE_FINISH));
        }
    }

    // Receive the byte over I2C
    *pucData = MAP_I2CMasterDataGet(I2C_BASE);

    return SUCCESS;
}


int I2C_IF_Write(unsigned char ucDevAddr,
         unsigned char *pucData,
         unsigned char ucLen,
         unsigned char ucStop)
{
    RETERR_IF_TRUE(pucData == NULL);
    RETERR_IF_TRUE(ucLen == 0);

    // Set I2C codec slave address
    MAP_I2CMasterSlaveAddrSet(I2C_BASE, ucDevAddr, false);

    // Write the first byte to the controller.
    MAP_I2CMasterDataPut(I2C_BASE, *pucData);

    // Initiate the transfer.
    RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_SEND_START));

    // Decrement the count and increment the data pointer
    // to facilitate the next transfer
    ucLen--;
    pucData++;

    // Loop until the completion of transfer or error
    while(ucLen)
    {
        // Write the next byte of data
        MAP_I2CMasterDataPut(I2C_BASE, *pucData);

        // Transact over I2C to send byte
        RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_SEND_CONT));

        // Decrement the count and increment the data pointer
        // to facilitate the next transfer
        ucLen--;
        pucData++;
    }

    // If stop bit is to be sent, send it.
    if(ucStop == true)
    {
        RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_SEND_STOP));
    }
    return SUCCESS;
}

4、关闭I2C
int I2C_IF_Close()
{
    //
    // Power OFF the I2C peripheral
    //
    MAP_PRCMPeripheralClkDisable(PRCM_I2CA0, PRCM_RUN_MODE_CLK);

    return SUCCESS;
}

strong161

这样是不是代码好看点

1. 1、PinMuxConfig（）函数。设置端口功能、PinMuxConfig（）函数。设置端口功能
2. 其主要有：
3. // Enable Peripheral Clocks
4. MAP_PRCMPeripheralClkEnable(PRCM_I2CA0, PRCM_RUN_MODE_CLK);
5. // Configure PIN_01 for I2C0 I2C_SCL
6. MAP_PinTypeI2C(PIN_01, PIN_MODE_1);
8. // Configure PIN_02 for I2C0 I2C_SDA
9. MAP_PinTypeI2C(PIN_02, PIN_MODE_1);
11. 2、打开I2C模块
13. //! Enables and configures the I2C peripheral
14. int I2C_IF_Open(unsigned long ulMode)
15. {
16. // Enable I2C Peripheral
17. //MAP_HwSemaphoreLock(HWSEM_I2C, HWSEM_WAIT_FOR_EVER);
18. PRCMPeripheralClkEnable(PRCM_I2CA0, PRCM_RUN_MODE_CLK);
19. PRCMPeripheralReset(PRCM_I2CA0);
21. // Configure I2C module in the specified mode
22. switch(ulMode)
23. {
24. case I2C_MASTER_MODE_STD: /* 100000 */
25. I2CMasterInitExpClk(I2C_BASE,SYS_CLK,false);
26. break;
28. case I2C_MASTER_MODE_FST: /* 400000 */
29. I2CMasterInitExpClk(I2C_BASE,SYS_CLK,true);
30. break;
32. default:
33. I2CMasterInitExpClk(I2C_BASE,SYS_CLK,true);
34. break;
35. }
36. // Disables the multi-master mode
37. //MAP_I2CMasterDisable(I2C_BASE);
39. return SUCCESS;
40. }
42. 3、I2C读写
43. int I2C_IF_Read(unsigned char ucDevAddr,
44. unsigned char *pucData,
45. unsigned char ucLen)
46. {
47. unsigned long ulCmdID;
49. RETERR_IF_TRUE(pucData == NULL);
50. RETERR_IF_TRUE(ucLen == 0);
52. // Set I2C codec slave address
53. MAP_I2CMasterSlaveAddrSet(I2C_BASE, ucDevAddr, true);
55. // Check if its a single receive or burst receive
56. if(ucLen == 1)
57. {
58. // Configure for a single receive
59. ulCmdID = I2C_MASTER_CMD_SINGLE_RECEIVE;
60. }
61. else
62. {
63. // Initiate a burst receive sequence
64. ulCmdID = I2C_MASTER_CMD_BURST_RECEIVE_START;
65. }
66. // Initiate the transfer.
67. RET_IF_ERR(I2CTransact(ulCmdID));
69. // Decrement the count and increment the data pointer
70. // to facilitate the next transfer
71. ucLen--;
73. // Loop until the completion of reception or error
74. while(ucLen)
75. {
76. // Receive the byte over I2C
77. *pucData = MAP_I2CMasterDataGet(I2C_BASE);
79. // Decrement the count and increment the data pointer
80. // to facilitate the next transfer
81. ucLen--;
82. pucData++;
83. if(ucLen)
84. {
85. // Continue the reception
86. RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_RECEIVE_CONT));
87. }
88. else
89. {
90. // Complete the last reception
91. RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_RECEIVE_FINISH));
92. }
93. }
95. // Receive the byte over I2C
96. *pucData = MAP_I2CMasterDataGet(I2C_BASE);
98. return SUCCESS;
99. }
102. int I2C_IF_Write(unsigned char ucDevAddr,
103. unsigned char *pucData,
104. unsigned char ucLen,
105. unsigned char ucStop)
106. {
107. RETERR_IF_TRUE(pucData == NULL);
108. RETERR_IF_TRUE(ucLen == 0);
110. // Set I2C codec slave address
111. MAP_I2CMasterSlaveAddrSet(I2C_BASE, ucDevAddr, false);
113. // Write the first byte to the controller.
114. MAP_I2CMasterDataPut(I2C_BASE, *pucData);
116. // Initiate the transfer.
117. RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_SEND_START));
119. // Decrement the count and increment the data pointer
120. // to facilitate the next transfer
121. ucLen--;
122. pucData++;
124. // Loop until the completion of transfer or error
125. while(ucLen)
126. {
127. // Write the next byte of data
128. MAP_I2CMasterDataPut(I2C_BASE, *pucData);
130. // Transact over I2C to send byte
131. RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_SEND_CONT));
133. // Decrement the count and increment the data pointer
134. // to facilitate the next transfer
135. ucLen--;
136. pucData++;
137. }
139. // If stop bit is to be sent, send it.
140. if(ucStop == true)
141. {
142. RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_SEND_STOP));
143. }
144. return SUCCESS;
145. }
147. 4、关闭I2C
148. int I2C_IF_Close()
149. {
150. //
151. // Power OFF the I2C peripheral
152. //
153. MAP_PRCMPeripheralClkDisable(PRCM_I2CA0, PRCM_RUN_MODE_CLK);
155. return SUCCESS;
156. }

复制代码