开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
I2C.c
资源名称：SDK_M5661.rar　[点击查看]
上传用户：hjhsjcl
上传日期：2020-09-25
资源大小：11378k
文件大小：10k
源码类别：

压缩解压

开发平台：

C++ Builder

I2C.c：源码内容
  1. /*==========================================================================
  2. Copyright (c) 2004 ALi Corporation. All Rights Reserved
  4. Target File: FM
  5. Applying Source File : FmM5181.c
  7. content: 
  9. History: 
  10.  Created by David Chiu 2004/4/27
  11.  Modified by Dennis Shih 2006/01/16
  12. ==========================================================================*/
  13. #define _I2C_H_
  15. #include "TypeDef.h"
  16. #include "Const.h"
  17. #include "Reg5661.h"
  19. #if(FM_MODULE==2)
  20. #include "I2C.h"
  21. #include <intrins.h>
  22. #endif
  24. /*
  25. #include "Common.h"
  26. #include "UiFm.h"
  28. #include "I2C.h"
  29. #include "FmChipDrv.h"
  31. #if(_C_MODE_)
  32. #include "IconDefine.h"
  33. #include "OLED.h"
  34. #else
  35. #include "Lcd.h"
  36. #endif
  37. */
  38. /*--------------------------------------------------------------------------
  39. Desciption:
  40. Initial setting of I2C Module
  41. Arguments:
  42. void
  43. Global arguments:
  44. void
  45. Returns:
  46. void
  47. --------------------------------------------------------------------------*/
  48. #if(FM_MODULE==2)
  49. //////////////////////////////////////////////////////
  50. #define i2c_delay2()
  51. {
  52. _nop_();
  53. _nop_();
  54. }
  55. #define i2c_delay4()
  56. {
  57. _nop_();
  58. _nop_();
  59. }
  60. #define i2c_delay()
  61. {
  62. _nop_();
  63. _nop_();
  64. }
  66. /*
  67. void i2c_delay (void) // 400Khz, NEED TO DEBUG
  68. {
  69. // BYTE i;
  70. // for(i=0;i<1;i++)
  71. // {
  72. _nop_();
  73. _nop_();
  74. // _nop_();
  75. // }
  76. }
  77. */
  79. void i2c_start (BYTE device) i2c_large_test
  80. //void i2c_start (BYTE device)  large
  81. {
  82. #if ((_PM_FM_)|(_PM_INIT_))
  83. if (device==I2C_LCD)
  84. #endif
  85. {
  86. I2C_LCD_SDA_OUT();  
  87. I2C_LCD_SCL_OUT();
  88. I2C_LCD_SDA_1();
  89. I2C_LCD_SCL_1(); i2c_delay4();
  90. I2C_LCD_SDA_0(); i2c_delay();
  91. I2C_LCD_SCL_0(); i2c_delay();
  92. }
  93. #if ((_PM_FM_)|(_PM_INIT_))
  94. else
  95. {
  96. I2C_FM_SDA_OUT();    i2c_delay4();
  97. I2C_FM_SCL_OUT();
  98. I2C_FM_SDA_1();
  99. I2C_FM_SCL_1(); i2c_delay4();
  100. I2C_FM_SDA_0(); i2c_delay();
  101. I2C_FM_SCL_0(); i2c_delay();
  102. }
  103. #endif
  104. }
  107. void i2c_stop (BYTE device) i2c_large_test
  108. {
  109. #if ((_PM_FM_)|(_PM_INIT_))
  110. if (device==I2C_LCD)
  111. #endif
  112. {
  113. I2C_LCD_SDA_OUT();
  114. I2C_LCD_SCL_OUT();
  115. I2C_LCD_SDA_0(); i2c_delay();
  116. I2C_LCD_SCL_1(); i2c_delay4();
  117. I2C_LCD_SDA_1(); i2c_delay();
  118. I2C_LCD_SCL_0(); i2c_delay();
  119. }
  120. #if ((_PM_FM_)|(_PM_INIT_))
  121. else
  122. {
  123. I2C_FM_SDA_OUT();
  124. I2C_FM_SCL_OUT();
  125. I2C_FM_SDA_0(); i2c_delay();
  126. I2C_FM_SCL_1(); i2c_delay4();
  127. I2C_FM_SDA_1(); i2c_delay();
  128. I2C_FM_SCL_0(); i2c_delay();
  129. }
  130. #endif
  131. }
  133. #if(0)
  134. void init_i2c (BYTE device) i2c_large_test //main()初始化中调用
  135. {
  136. #if ((_PM_FM_)|(_PM_INIT_))
  137. if (device==I2C_LCD)
  138. #endif
  139. {
  140. I2C_LCD_SDA_OUT();
  141. I2C_LCD_SCL_OUT();
  142. I2C_LCD_SCL_0();
  143. }
  144. #if ((_PM_FM_)|(_PM_INIT_))
  145. else
  146. {
  147. I2C_FM_SDA_OUT();
  148. I2C_FM_SCL_OUT();
  149. I2C_FM_SCL_0();
  150. }
  151. #endif
  152. i2c_stop(device);
  153. }
  154. #endif
  156. void i2c_clock (BYTE device) i2c_large_test
  157. {
  158. // BYTE sample;
  159. #if ((_PM_FM_)|(_PM_INIT_))
  160. if (device==I2C_LCD)
  161. #endif
  162. {
  163. I2C_LCD_SCL_OUT();
  164. I2C_LCD_SCL_1(); i2c_delay4();
  165. // I2C_LCD_SDA_IN();
  166. // sample=I2C_LCD_SDA_RD;
  167. // I2C_LCD_SDA_OUT();
  168. I2C_LCD_SCL_0(); i2c_delay();
  169. }
  170. #if ((_PM_FM_)|(_PM_INIT_))
  171. else
  172. {
  173. I2C_FM_SCL_OUT();
  174. I2C_FM_SCL_1(); i2c_delay4();
  175. // I2C_FM_SDA_IN();
  176. // sample=I2C_FM_SDA_RD;
  177. // I2C_FM_SDA_OUT();
  178. I2C_FM_SCL_0(); i2c_delay();
  179. }
  180. #endif
  181. // if (sample==0) return (0);
  182. // else return (1);
  183. // return (0); 
  184. }
  187. BYTE i2c_rd_ack (BYTE device) i2c_large_test
  188. {
  189. BYTE sample;
  190. #if ((_PM_FM_)|(_PM_INIT_))
  191. if (device==I2C_LCD)
  192. #endif
  193. {
  194. I2C_LCD_SCL_OUT();
  195. I2C_LCD_SCL_1(); i2c_delay4();
  196. I2C_LCD_SDA_IN();
  197. sample=I2C_LCD_SDA_RD;
  198. I2C_LCD_SDA_OUT();
  199. I2C_LCD_SCL_0(); i2c_delay();
  200. }
  201. #if ((_PM_FM_)|(_PM_INIT_))
  202. else
  203. {
  204. I2C_FM_SCL_OUT();
  205. I2C_FM_SCL_1(); i2c_delay4();
  206. I2C_FM_SDA_IN();     i2c_delay4();
  207. sample=I2C_FM_SDA_RD; 
  208. I2C_FM_SDA_OUT();
  209. I2C_FM_SCL_0(); i2c_delay();
  210. }
  211. #endif
  212. if (sample==0) return (0);
  213. else return (1);
  214. // return (0);
  215. }
  218. BYTE i2c_rd_data (BYTE device) i2c_large_test
  219. {
  220. BYTE sample;
  221. #if ((_PM_FM_)|(_PM_INIT_))
  222. if (device==I2C_LCD)
  223. #endif
  224. {
  225. I2C_LCD_SCL_OUT();
  226. I2C_LCD_SCL_1(); i2c_delay4();
  227. // I2C_LCD_SDA_IN();
  228. sample=I2C_LCD_SDA_RD;
  229. // I2C_LCD_SDA_OUT();
  230. I2C_LCD_SCL_0(); i2c_delay();
  231. }
  232. #if ((_PM_FM_)|(_PM_INIT_))
  233. else
  234. {
  235. I2C_FM_SCL_OUT();
  236. I2C_FM_SCL_1(); i2c_delay4();
  237. // I2C_FM_SDA_IN();
  238. sample=I2C_FM_SDA_RD;  i2c_delay4();
  239. // I2C_FM_SDA_OUT();
  240. I2C_FM_SCL_0(); i2c_delay();
  241. }
  242. #endif
  243. if (sample==0) return (0);
  244. else return (1);
  245. // return (0);
  246. }
  249. BYTE i2c_send (BYTE device, BYTE i_data) i2c_large_test
  250. {
  251.  BYTE i;
  252.  for (i=0;i<8;i++)
  253.      {
  254. if (i_data&0x80) 
  255. {
  256.       #if ((_PM_FM_)|(_PM_INIT_))
  257. if (device==I2C_LCD)
  258.           #endif
  259. {I2C_LCD_SDA_1();}
  260.           #if ((_PM_FM_)|(_PM_INIT_))
  261. else
  262. {I2C_FM_SDA_1();} 
  263.           #endif
  264. }
  265. else 
  266. {
  267.       #if ((_PM_FM_)|(_PM_INIT_))
  268. if (device==I2C_LCD)
  269.       #endif
  270. {I2C_LCD_SDA_0();}
  271.       #if ((_PM_FM_)|(_PM_INIT_))
  272. else  
  273. {I2C_FM_SDA_0();} 
  274.           #endif
  275. }
  276. i_data=i_data<<1;
  277. i2c_clock(device);
  278.      }
  279.  #if ((_PM_FM_)|(_PM_INIT_))     
  280.  if (device==I2C_LCD)
  281.  #endif
  282. {I2C_LCD_SDA_1();}
  283.  #if ((_PM_FM_)|(_PM_INIT_))  
  284.  else  
  285. {I2C_FM_SDA_1();} 
  286.  #endif
  287.  #if ((_PM_FM_)|(_PM_INIT_))
  288.  if (device==I2C_LCD)
  289.  #endif
  290. {I2C_LCD_SDA_IN();}  //请求ACK
  291.  #if ((_PM_FM_)|(_PM_INIT_))   
  292.  else  
  293. {I2C_FM_SDA_IN();} 
  294.  #endif
  295.  return (!i2c_rd_ack(device));
  296. }
  299. BYTE i2c_receive (BYTE device) i2c_large_test
  300. {
  301. BYTE i,i_data=0;
  302. #if ((_PM_FM_)|(_PM_INIT_))
  303. if (device==I2C_LCD)
  304. #endif
  305. {I2C_LCD_SDA_IN();}
  306. #if ((_PM_FM_)|(_PM_INIT_))  
  307. else  
  308. {I2C_FM_SDA_IN();}
  309. #endif  
  310. for (i=0;i<8;i++)
  311.     {
  312. i_data*=2;
  313. if (i2c_rd_data(device)) i_data++;
  314.     }
  315. #if ((_PM_FM_)|(_PM_INIT_))    
  316. if (device==I2C_LCD)
  317. #endif
  318. {I2C_LCD_SDA_OUT();}
  319. #if ((_PM_FM_)|(_PM_INIT_))  
  320. else  
  321. {I2C_FM_SDA_OUT();}
  322. #endif 
  323. return(i_data);
  324. } 
  327. void i2c_ack (BYTE device) i2c_large_test
  328. {
  329. #if ((_PM_FM_)|(_PM_INIT_))
  330. if (device==I2C_LCD)
  331. #endif 
  332. {I2C_LCD_SDA_0();}
  333. #if ((_PM_FM_)|(_PM_INIT_))
  334. else  
  335. {I2C_FM_SDA_0();} 
  336. #endif 
  337. i2c_clock(device);
  338. #if ((_PM_FM_)|(_PM_INIT_))
  339. if (device==I2C_LCD)
  340. #endif 
  341. {I2C_LCD_SDA_1();}
  342. #if ((_PM_FM_)|(_PM_INIT_))
  343. else  
  344. {I2C_FM_SDA_1();} 
  345. #endif 
  346. }
  349. void i2c_nack (BYTE device) i2c_large_test
  350. {
  351. #if ((_PM_FM_)|(_PM_INIT_))
  352. if (device==I2C_LCD)
  353. #endif 
  354. {I2C_LCD_SDA_1();}
  355. #if ((_PM_FM_)|(_PM_INIT_))
  356. else  
  357. {I2C_FM_SDA_1();} 
  358. #endif 
  359. i2c_clock(device);
  360. #if ((_PM_FM_)|(_PM_INIT_))
  361. if (device==I2C_LCD)
  362. #endif 
  363. {I2C_LCD_SDA_0();}
  364. #if ((_PM_FM_)|(_PM_INIT_))
  365. else  
  366. {I2C_FM_SDA_0();} 
  367. #endif 
  368. }
  371. BYTE i2c_address(BYTE device, BYTE addr) i2c_large_test
  372. {
  373. i2c_start(device);
  374. if (i2c_send(device, addr))
  375. return (1);
  376. else
  377. return (0);
  378. }
  381. BYTE i2c_wr(BYTE device, BYTE sla_addr, BYTE length, BYTE * buff) i2c_large_test
  382. {
  383. BYTE i;
  384. if (i2c_address(device, sla_addr))
  385. {
  386. for (i=0;i<length;i++)
  387. {
  388. if (i2c_send(device, *buff))
  389. {
  390. buff++;
  391. // i2c_feeddog();
  392. }
  393. else
  394. {
  395. i2c_stop(device);
  396. return(0);
  397. }
  398. }
  399. i2c_stop(device);
  400. return(1);
  401. }
  402. else
  403. {
  404. i2c_stop(device);
  405. return (0);
  406. }
  407. }
  410. BYTE i2c_rd(BYTE device, BYTE sla_addr, BYTE length, BYTE * buff) i2c_large_test
  411. {
  412. BYTE i;
  413. if (i2c_address(device, sla_addr|0x01))
  414. {
  415. for(i=0;i<length;i++)
  416. {
  417. *(buff++)=i2c_receive(device);
  418. if (i==(length-1)) 
  419.    {
  420. i2c_nack(device);
  421. i2c_stop(device);
  422.    }
  423. else i2c_ack(device);
  424. // i2c_feeddog();
  425. }
  426. return(1);
  427. }
  428. else
  429. {
  430. i2c_stop(device);
  431. return (0);
  432. }
  433. }
  434. #if(0)
  435. BYTE i2c_rd1(BYTE device, BYTE sla_addr, BYTE length, BYTE * buff) i2c_large_test
  436. {
  437. BYTE i;
  438. sla_addr=12;
  439. if (i2c_address(device, sla_addr|0x01))
  440. {
  441. //for(i=0;i<length;i++)
  442. for(i=0;i<2;i++)
  443. {
  444. *(buff++)=i2c_receive(device);
  445. if (i==(length-1)) 
  446.    {
  447. i2c_nack(device);
  448. i2c_stop(device);
  449.    }
  450. else i2c_ack(device);
  451. // i2c_feeddog();
  452. }
  453. return(1);
  454. }
  455. else
  456. {
  457. i2c_stop(device);
  458. return (0);
  459. }
  460. }
  461. #endif
  462. #if (_PEDOMETER_Mode_)
  463. void I2cInit(void)
  464. {
  465. obSYSSOFTRSTCTRL2 |= 0x04; // Disable I2C soft reset
  466. obCLKI2CMCTRL = 0xD0; // Enable I2C Clock 12MHz
  467. // obCLKI2CMCTRL =0xD8; //Dennis Shih 2006/01/26
  468. // obCLKI2CMDIVF=0x00; //Dennis Shih 2006/01/26
  470. obMODSEL2 |= 0x08; // I2C Mode Select
  471. obREADYENH |= 0x08; // I2C I/O Ready
  472. }
  473. bit I2cWaitBusy(void)
  474. {
  475. #define I2C_TIME_OUT 0xFF
  477. BYTE bRetry=I2C_TIME_OUT;
  479. while(obI2CSERSTS&0x80)
  480. {
  481. // bRetry--;
  482. // if(bRetry==0)
  483. // return FALSE;
  485. }
  486. return TRUE;
  487. }
  488. #endif 
  490. #else //#if(FM_MODULE==2)
  492. #if (_PM_FM_|_PM_MPTEST_|_PEDOMETER_Mode_)
  493. void I2cInit(void)
  494. {
  495. obSYSSOFTRSTCTRL2 |= 0x04; // Disable I2C soft reset
  496. obCLKI2CMCTRL = 0xD0; // Enable I2C Clock 12MHz
  497. // obCLKI2CMCTRL =0xD8; //Dennis Shih 2006/01/26
  498. // obCLKI2CMDIVF=0x00; //Dennis Shih 2006/01/26
  500. obMODSEL2 |= 0x08; // I2C Mode Select
  501. obREADYENH |= 0x08; // I2C I/O Ready
  502. }
  504. #endif //(_PM_FM_|_PM_MPTEST_)
  506. #if (_PM_FM_|_PM_MPTEST_|_PEDOMETER_Mode_)
  507. bit I2cWaitBusy(void)
  508. {
  509. #define I2C_TIME_OUT 0xFF
  511. BYTE bRetry=I2C_TIME_OUT;
  513. while(obI2CSERSTS&0x80)
  514. {
  515. // bRetry--;
  516. // if(bRetry==0)
  517. // return FALSE;
  519. }
  520. return TRUE;
  521. }
  522. #endif //(_PM_FM_|_PM_MPTEST_)
  523. #endif