NUC 240 smbus I2C_WAIT_READY(i2c) 無限等待

我在網站上找到關於 SMBUS 的相關的程式, 因此複製下來放在 NUC 240 環境下執行, 卻都在當在指令 I2C_WAIT_READY(i2c) 無法繼續執行, 卻不知為何?
不知是否可以幫幫忙解決問題,  感恩不盡.

我的設備位置是 0x16,  功能編號位址為 0x03,  傳回資料位元組 2 byte,  程式碼如下:

1. #include <stdio.h>
   
2. #include "NUC230_240.h"
   
3. 
   
4. #define PLLCON_SETTING      SYSCLK_PLLCON_50MHz_XTAL
   
5. #define PLL_CLOCK           50000000
   
6. 
   
7. volatile uint8_t g_u8DeviceAddr;
   
8. volatile uint8_t g_au8TxData[3];
   
9. volatile uint8_t g_u8RxData;
   
10. volatile uint8_t g_u8DataLen;
    
11. volatile uint8_t g_u8EndFlag = 0;
    
12. 
    
13. typedef void (*I2C_FUNC)(uint32_t u32Status);
    
14. 
    
15. static I2C_FUNC s_I2C0HandlerFn = NULL;
    
16. 
    
17. void I2C0_IRQHandler(void)
    
18. {
    
19.     uint32_t u32Status;
    
20. 
    
21.     u32Status = I2C_GET_STATUS(I2C0);
    
22.     if(I2C_GET_TIMEOUT_FLAG(I2C0)) {
    
23.         /* Clear I2C0 Timeout Flag */
    
24.         I2C_ClearTimeoutFlag(I2C0);
    
25.     } else {
    
26.         if(s_I2C0HandlerFn != NULL)
    
27.             s_I2C0HandlerFn(u32Status);
    
28.     }
    
29. }
    
30. 
    
31. void I2C_MasterRx(uint32_t u32Status)
    
32. {
    
33.     if(u32Status == 0x08) {   
    
34.         I2C_SET_DATA(I2C0, (g_u8DeviceAddr << 1));
    
35.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    
36.     } else if(u32Status == 0x18) {  
    
37.         I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
    
38.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    
39.     } else if(u32Status == 0x20) {
    
40.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_STO_SI);
    
41.     } else if(u32Status == 0x28) {
    
42.         if(g_u8DataLen != 2) {
    
43.             I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
    
44.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    
45.         } else {
    
46.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_SI);
    
47.         }
    
48.     } else if(u32Status == 0x10) {  
    
49.         I2C_SET_DATA(I2C0, ((g_u8DeviceAddr << 1) | 0x01));
    
50.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    
51.     } else if(u32Status == 0x40) {  
    
52.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    
53.     } else if(u32Status == 0x58) {
    
54.         g_u8RxData = (unsigned char) I2C_GET_DATA(I2C0);
    
55.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
    
56.         g_u8EndFlag = 1;
    
57.     } else {
    
58.         printf("Status 0x%x is NOT processed\n", u32Status);
    
59.     }
    
60. }
    
61. 
    
62. void I2C_MasterTx(uint32_t u32Status)
    
63. {
    
64.     if(u32Status == 0x08) {
    
65.         I2C_SET_DATA(I2C0, g_u8DeviceAddr << 1);  
    
66.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    
67.     } else if(u32Status == 0x18) {
    
68.         I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
    
69.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    
70.     } else if(u32Status == 0x20) {
    
71.         I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_STO_SI);
    
72.     } else if(u32Status == 0x28) {  
    
73.         if(g_u8DataLen != 3) {
    
74.             I2C_SET_DATA(I2C0, g_au8TxData[g_u8DataLen++]);
    
75.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);
    
76.         } else {
    
77.             I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);
    
78.             g_u8EndFlag = 1;
    
79.         }
    
80.     } else {
    
81.         /* TO DO */
    
82.         printf("Status 0x%x is NOT processed\n", u32Status);
    
83.     }
    
84. }
    
85. 
    
86. void SYS_Init(void)
    
87. {
    
88.      /* Enable Internal RC 22.1184MHz clock */
    
89.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);
    
90. 
    
91.     /* Waiting for Internal RC clock ready */
    
92.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);
    
93. 
    
94.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
    
95.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));
    
96. 
    
97.     /* Enable external XTAL 12MHz clock */
    
98.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);
    
99. 
    
100.     /* Waiting for external XTAL clock ready */
     
101.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);
     
102. 
     
103.     /* Set core clock as PLL_CLOCK from PLL */
     
104.     CLK_SetCoreClock(PLL_CLOCK);
     
105. 
     
106.     /* Enable UART module clock */
     
107.     CLK_EnableModuleClock(UART0_MODULE);
     
108. 
     
109.     /* Enable I2C0 module clock */
     
110.     CLK_EnableModuleClock(I2C0_MODULE);
     
111. 
     
112.     /* Select UART module clock source */
     
113.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));
     
114. 
     
115.      /* Set GPB multi-function pins for UART0 RXD and TXD */
     
116.     SYS->GPB_MFP = SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;
     
117. 
     
118.     /* Set GPA multi-function pins for I2C0 SDA and SCL */
     
119.     SYS->GPA_MFP = SYS_GPA_MFP_PA8_I2C0_SDA | SYS_GPA_MFP_PA9_I2C0_SCL;
     
120. }
     
121. 
     
122. void UART0_Init()
     
123. {
     
124.     /* Reset IP */
     
125.     SYS_ResetModule(UART0_RST);
     
126. 
     
127.     /* Configure UART0 and set UART0 Baudrate */
     
128.     UART_Open(UART0, 115200);
     
129. }
     
130. 
     
131. void I2C0_Close(void)
     
132. {
     
133.     /* Disable I2C0 interrupt and clear corresponding NVIC bit */
     
134.     I2C_DisableInt(I2C0);
     
135.     NVIC_DisableIRQ(I2C0_IRQn);
     
136. 
     
137.     /* Disable I2C0 and close I2C0 clock */
     
138.     I2C_Close(I2C0);
     
139.     CLK_DisableModuleClock(I2C0_MODULE);
     
140. 
     
141. }
     
142. 
     
143. void I2C0_Init(void)
     
144. {
     
145.     /* Open I2C module and set bus clock */
     
146.     I2C_Open(I2C0, 80000); //BaudRate 80k, 100000 => 100K
     
147. 
     
148.     /* Get I2C0 Bus Clock */
     
149.     printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));
     
150. 
     
151.     /* Set I2C 4 Slave Addresses */
     
152.     I2C_SetSlaveAddr(I2C0, 0, 0x1ˊ6, 0);   /* Slave Address : 0x15 */
     
153. 
     
154.     /* Enable I2C interrupt */
     
155.     I2C_EnableInt(I2C0);
     
156.     NVIC_EnableIRQ(I2C0_IRQn);
     
157. }
     
158. 
     
159. uint8_t I2C_WriteByteTwoRegs(I2C_T *i2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr, const uint8_t data)
     
160. { uint8_t u8Xfering = 1, u8Err = 0, u8Addr = 1, u8Ctrl = 0;
     
161.   uint32_t u32txLen = 0;
     
162. 
     
163.   I2C_START(i2c);
     
164.         
     
165.         while(u8Xfering && (u8Err == 0))
     
166.         {
     
167.                 I2C_WAIT_READY(i2c);
     
168.                
     
169.                 switch(I2C_GET_STATUS(i2c))
     
170.     {
     
171.        case 0x08:
     
172.           I2C_SET_DATA(i2c, (u8SlaveAddr << 1 | 0x00));
     
173.           u8Ctrl = I2C_I2CON_SI;
     
174.           break;
     
175.        case 0x18:  
     
176.           I2C_SET_DATA(i2c, (uint8_t)(u16DataAddr & 0xFF00) >> 8);
     
177.           break;
     
178.        case 0x20:
     
179.        case 0x30:     
     
180.           u8Ctrl = I2C_I2CON_STO_SI;      
     
181.           u8Err = 1;               
     
182.           break;
     
183.        case 0x28:
     
184.           if(u8Addr)
     
185.           {
     
186.              I2C_SET_DATA(i2c, (uint8_t)(u16DataAddr & 0xFF));
     
187.              u8Addr = 0;
     
188.           }
     
189.           else if((u32txLen < 1) && (u8Addr == 0))
     
190.           {
     
191.              I2C_SET_DATA(i2c, data);
     
192.              u32txLen++;
     
193.           }
     
194.           else
     
195.           {
     
196.              u8Ctrl = I2C_I2CON_STO_SI;
     
197.              u8Xfering = 0;
     
198.           }
     
199.           break;
     
200.        case 0x38:  
     
201.        default:  
     
202.              u8Ctrl = I2C_I2CON_STO_SI;                  
     
203.              u8Err = 1;
     
204.              break;                                       
     
205.                  }
     
206.                  I2C_SET_CONTROL_REG(i2c, u8Ctrl);
     
207.          }
     
208.          return (u8Err | u8Xfering);  
     
209. }
     
210. 
     
211. uint8_t I2C_ReadByteTwoRegs(I2C_T *i2c, uint8_t u8SlaveAddr, uint16_t u16DataAddr)
     
212. {
     
213.   uint8_t u8Xfering = 1, u8Err = 0, rdata = 0, u8Addr = 1, u8Ctrl = 0;
     
214. 
     
215.   I2C_START(i2c);
     
216.   while(u8Xfering && (u8Err == 0))
     
217.   {
     
218.     switch(I2C_GET_STATUS(i2c))
     
219.           {
     
220.       case 0x08:
     
221.          I2C_SET_DATA(i2c, (u8SlaveAddr << 1 | 0x00));
     
222.          u8Ctrl = I2C_I2CON_SI; //I2C_CTL_SI;
     
223.          break;
     
224.       case 0x18:  
     
225.          I2C_SET_DATA(i2c, (uint8_t)(u16DataAddr & 0xFF00) >> 8);
     
226.          break;
     
227.       case 0x20:   
     
228.       case 0x30:   
     
229.          u8Ctrl = I2C_I2CON_STO_SI;            
     
230.          u8Err = 1;               
     
231.          break;
     
232.       case 0x28:
     
233.          if(u8Addr)
     
234.          {
     
235.            I2C_SET_DATA(i2c, (uint8_t)(u16DataAddr & 0xFF));  
     
236.            u8Addr = 0;
     
237.          }
     
238.          else            
     
239.            u8Ctrl = I2C_I2CON_STA_SI;
     
240.            break;
     
241.       case 0x10:           
     
242.          I2C_SET_DATA(i2c, ((u8SlaveAddr << 1) | 0x01));
     
243.          u8Ctrl = I2C_I2CON_SI;
     
244.          break;
     
245.       case 0x40:  
     
246.          u8Ctrl = I2C_I2CON_SI;
     
247.          break;
     
248.       case 0x48:
     
249.          u8Ctrl = I2C_I2CON_STO_SI;
     
250.          u8Err = 1;               
     
251.          break;            
     
252.       case 0x58:
     
253.          rdata = (unsigned char) I2C_GET_DATA(i2c);
     
254.          u8Ctrl = I2C_I2CON_STO_SI; //I2C_CTL_STO_SI;
     
255.          u8Xfering = 0;
     
256.          break;
     
257.       case 0x38:
     
258.       default:  
     
259.          u8Ctrl = I2C_I2CON_STO_SI; //I2C_CTL_STO_SI;
     
260.          u8Err = 1;
     
261.          break; // Arbitration Lost
     
262.            }
     
263.           I2C_SET_CONTROL_REG(i2c, u8Ctrl);  
     
264.   }
     
265.   if(u8Err) rdata = 0;  
     
266. 
     
267.   return rdata;  
     
268. }
     
269. 
     
270. volatile uint8_t g_u8DeviceAddr;
     
271. volatile uint32_t ret_code;
     
272. volatile uint16_t u16DataAddr;
     
273. 
     
274. int32_t main(void)
     
275. {
     
276.     /* Unlock protected registers */
     
277.     SYS_UnlockReg();
     
278. 
     
279.     /* Init System, IP clock and multi-function I/O */
     
280.     SYS_Init();
     
281. 
     
282.     /* Lock protected registers */
     
283.     SYS_LockReg();
     
284. 
     
285.     /* Init UART0 for printf */
     
286.     UART0_Init();
     
287. 
     
288. 
     
289.     printf("I2C0_SDA(PD.4), I2C0_SCL(PD.5)\n");
     
290. 
     
291.     I2C0_Init();
     
292.         
     
293. ret_code = I2C_WriteByteTwoRegs(I2C0, 0x16, 0x03, 0x2);
     
294. 
     
295. CLK_SysTickDelay(20000);
     
296. 
     
297. g_u8DeviceAddr = 0x16;
     
298. 
     
299. u16DataAddr = 0x0003;
     
300. 
     
301. ret_code = I2C_ReadByteTwoRegs(I2C0, g_u8DeviceAddr, u16DataAddr);
     
302. 
     
303.     while(1);        
     
304. }

复制代码

请给出I2C_WAIT_READY函数程序代码实现部分

#define I2C_WAIT_READY(i2c)     while(!((i2c)->I2CON & I2C_I2CON_SI_Msk))