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;
}

这样是不是代码好看点

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);
   
7. 
   
8. // Configure PIN_02 for I2C0 I2C_SDA
   
9. MAP_PinTypeI2C(PIN_02, PIN_MODE_1);
   
10. 
    
11. 2、打开I2C模块
    
12. 
    
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);
    
20. 
    
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;
    
27. 
    
28. case I2C_MASTER_MODE_FST: /* 400000 */
    
29. I2CMasterInitExpClk(I2C_BASE,SYS_CLK,true);
    
30. break;
    
31. 
    
32. default:
    
33. I2CMasterInitExpClk(I2C_BASE,SYS_CLK,true);
    
34. break;
    
35. }
    
36. // Disables the multi-master mode
    
37. //MAP_I2CMasterDisable(I2C_BASE);
    
38. 
    
39. return SUCCESS;
    
40. }
    
41. 
    
42. 3、I2C读写
    
43. int I2C_IF_Read(unsigned char ucDevAddr,
    
44. unsigned char *pucData,
    
45. unsigned char ucLen)
    
46. {
    
47. unsigned long ulCmdID;
    
48. 
    
49. RETERR_IF_TRUE(pucData == NULL);
    
50. RETERR_IF_TRUE(ucLen == 0);
    
51. 
    
52. // Set I2C codec slave address
    
53. MAP_I2CMasterSlaveAddrSet(I2C_BASE, ucDevAddr, true);
    
54. 
    
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));
    
68. 
    
69. // Decrement the count and increment the data pointer
    
70. // to facilitate the next transfer
    
71. ucLen--;
    
72. 
    
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);
    
78. 
    
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. }
    
94. 
    
95. // Receive the byte over I2C
    
96. *pucData = MAP_I2CMasterDataGet(I2C_BASE);
    
97. 
    
98. return SUCCESS;
    
99. }
    
100. 
     
101. 
     
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);
     
109. 
     
110. // Set I2C codec slave address
     
111. MAP_I2CMasterSlaveAddrSet(I2C_BASE, ucDevAddr, false);
     
112. 
     
113. // Write the first byte to the controller.
     
114. MAP_I2CMasterDataPut(I2C_BASE, *pucData);
     
115. 
     
116. // Initiate the transfer.
     
117. RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_SEND_START));
     
118. 
     
119. // Decrement the count and increment the data pointer
     
120. // to facilitate the next transfer
     
121. ucLen--;
     
122. pucData++;
     
123. 
     
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);
     
129. 
     
130. // Transact over I2C to send byte
     
131. RET_IF_ERR(I2CTransact(I2C_MASTER_CMD_BURST_SEND_CONT));
     
132. 
     
133. // Decrement the count and increment the data pointer
     
134. // to facilitate the next transfer
     
135. ucLen--;
     
136. pucData++;
     
137. }
     
138. 
     
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. }
     
146. 
     
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);
     
154. 
     
155. return SUCCESS;
     
156. }
     

复制代码