21ic电子技术开发论坛 › 单片机与嵌入式系统 › Microchip › I2C的IO的标准模拟时序
返回列表 发新帖我要提问

[PIC®/AVR®/dsPIC®产品] I2C的IO的标准模拟时序

[复制链接]
1258|3
 楼主| mintspring 发表于 2023-11-16 09:21 | 显示全部楼层 |阅读模式
I2c, IO, 时序, 模拟
i2c.h
复制
  1. #ifndef __FILE_I2CBASIC_H
    

  2. #define __FILE_I2CBASIC_H
    


  3. 

  4. // Send the I2C start command to the target device
    

  5. void I2CSendStart( void );
    

  6. // Send the I2C stop command to the target device
    

  7. void I2CSendStop( void );
    

  8. // Send a clock pulse and check SDA for an ACK
    

  9. // Target will send an ACK as a 1
    

  10. // If SDA is 0 there is no ACK what means NACK
    

  11. unsigned char I2CCheckACK( void );
    

  12. // Send a NACK
    

  13. void I2CSendNACK( void );
    

  14. // Send a ACK
    

  15. void I2CSendACK( void );
    

  16. // Send a byte to the target
    

  17. void I2CSendByte(unsigned char SendByte);
    

  18. // Receive a byte from the target
    

  19. unsigned char I2CGetByte( void );
    

  20. // ClkSyncByte, do the garbage collection if bus fault
    

  21. void I2CClkSyncByte(void);
    


  22. 

  23. #endif


回复

收藏 举报

相关帖子
 楼主| mintspring 发表于 2023-11-16 09:22 | 显示全部楼层
复制
  1. /********************************************************************/
    

  2. /* Function    : I2C Basic Funktions                           FILE */
    

  3. /*------------------------------------------------------------------*/
    

  4. /* Description : This File has the basic functions needed for       */
    

  5. /*               I2C comunication and is optimized to meet the      */
    

  6. /*               requirements of 100KHz I2C running on normal       */
    

  7. /*               8051 Core [url=home.php?mod=space&uid=72445]@[/url] 24MHz                                  */
    

  8. /*------------------------------------------------------------------*/
    

  9. /* Author      : Michael Schmitt                                    */
    

  10. /*------------------------------------------------------------------*/
    

  11. /* Input       : none                                               */
    

  12. /*------------------------------------------------------------------*/
    

  13. /* Returnvalue : none                                               */
    

  14. /*------------------------------------------------------------------*/
    

  15. /* History     : 00/03    V1.0 Initial Version                      */
    

  16. /*                                                                  */
    

  17. /********************************************************************/
    

  18. #ifndef __FILE_I2CBASIC_C
    

  19. #define __FILE_I2CBASIC_C
    


  20. 

  21. //#define I2C_DEBUG_MODE
    


  22. 

  23. void I2CDelay( void )
    

  24. {
    

  25.     NOP;
    

  26.     NOP;
    

  27.     NOP;
    

  28.     NOP;
    

  29.     NOP;
    

  30.     NOP;
    

  31. }
    


  32. 

  33. // Send the I2C start command to the target device
    

  34. // "safety start" for 100kHz devices (24MHz)
    

  35. void I2CSendStart( void )
    

  36. {
    

  37. #ifdef I2C_DEBUG_MODE
    

  38.     printf("\n\r<Start>");
    

  39. #endif
    

  40.     // Start Condition SDA 1->0 while SCL is 1
    

  41.     I2CDelay();
    

  42.     I2CSDA = 1;
    

  43.     I2CDelay();
    

  44.     I2CSCL = 1;
    

  45.     I2CDelay();
    

  46.     I2CSDA = 0;
    

  47.     I2CDelay();
    

  48.     I2CSCL = 0;
    

  49.     I2CDelay();
    

  50. }
    


  51. 


  52. 

  53. // Send the I2C stop command to the target device
    

  54. // "safety stop" for 100kHz devices (24MHz)
    

  55. void I2CSendStop( void )
    

  56. {
    

  57. #ifdef I2C_DEBUG_MODE
    

  58. printf("<Stopp>");
    

  59. #endif
    

  60.     // Stop Condition SDA 0->1 while SCL is 1
    

  61.     I2CDelay();
    

  62.     I2CSDA = 0;
    

  63.     I2CDelay();
    

  64.     I2CSCL = 1;
    

  65.     I2CDelay();
    

  66.     I2CSDA = 1;
    

  67.     I2CDelay();
    

  68. }
    


  69. 


  70. 

  71. // Send a clock pulse and check SDA for an ACK
    

  72. // Target will send an ACK as a 1
    

  73. // If SDA is 0 there is no ACK what means NACK
    

  74. unsigned char I2CCheckACK( void )
    

  75. {
    

  76.     unsigned char return_value;
    

  77.     I2CSDA = 1;
    

  78.         NOP;
    

  79.         NOP;
    

  80.         NOP;
    

  81.         NOP;
    

  82. //    I2CDelay();
    

  83.     I2CSCL = 1;
    

  84. //      NOP;
    

  85. //      NOP;
    

  86. //      NOP;
    

  87. //      NOP;
    

  88. //      NOP;
    

  89.         NOP;
    

  90.         NOP;
    

  91.         NOP;
    

  92.         NOP;
    

  93.         NOP;
    

  94. //    I2CDelay();
    

  95.     return_value = !I2CSDA;   // invert
    

  96. #ifdef I2C_DEBUG_MODE
    

  97.     if( return_value == 1 )
    

  98.     {
    

  99.         printf("<?ACK>");
    

  100.     }
    

  101.     else
    

  102.     {
    

  103.         printf("<?NACK>");
    

  104.     }
    

  105. #endif
    

  106.     I2CSCL = 0;
    

  107.     return( return_value ); // 1=ACK 0=NACK
    

  108. }
    


  109. 

  110. // Send a NACK
    

  111. void I2CSendNACK( void )
    

  112. {
    

  113. #ifdef I2C_DEBUG_MODE
    

  114. printf("<!NACK>");
    

  115. #endif
    

  116.     // NACK by Master sending a single 1
    

  117.     I2CSDA = 1;
    

  118.         NOP;
    

  119.         NOP;
    

  120.         NOP;
    

  121.         NOP;
    

  122.         NOP;
    

  123.         NOP;
    

  124.         NOP;
    

  125.         NOP;
    

  126.         NOP;
    

  127.         NOP;
    

  128. //    I2CDelay();
    

  129.     I2CSCL = 1;
    

  130.         NOP;
    

  131.         NOP;
    

  132.         NOP;
    

  133.         NOP;
    

  134.         NOP;
    

  135.         NOP;
    

  136.         NOP;
    

  137.         NOP;
    

  138.         NOP;
    

  139.         NOP;
    

  140. //    I2CDelay();
    

  141.     I2CSCL = 0;
    

  142.         NOP;
    

  143.         NOP;
    

  144.         NOP;
    

  145.         NOP;
    

  146.         NOP;
    

  147.         NOP;
    

  148.         NOP;
    

  149.         NOP;
    

  150.         NOP;
    

  151.         NOP;
    

  152. //    I2CDelay();
    

  153.     I2CSDA = 0;
    

  154. }
    


  155. 

  156. // Send a ACK
    

  157. void I2CSendACK( void )
    

  158. {
    

  159. #ifdef I2C_DEBUG_MODE
    

  160.     printf("<!ACK>");
    

  161. #endif
    

  162.     // ACK by Master sending a single 0
    

  163.         I2CSDA = 0;
    

  164.         NOP;
    

  165.         NOP;
    

  166.         NOP;
    

  167.         NOP;
    

  168.         NOP;
    

  169.         NOP;
    

  170.         NOP;
    

  171.         NOP;
    

  172.         NOP;
    

  173.         NOP;
    

  174. //    I2CDelay();
    

  175.     I2CSCL = 1;
    

  176.         NOP;
    

  177.         NOP;
    

  178.         NOP;
    

  179.         NOP;
    

  180.         NOP;
    

  181.         NOP;
    

  182.         NOP;
    

  183.         NOP;
    

  184.         NOP;
    

  185.         NOP;
    

  186. //    I2CDelay();
    

  187.     I2CSCL = 0; // Cmd executin lasts 1usec so clk 100KHz
    

  188. //      NOP;
    

  189. //      NOP;
    

  190. //      NOP;
    

  191. //      NOP;
    

  192. //      NOP;
    

  193. //      NOP;
    

  194. //      NOP;
    

  195. //      NOP;
    

  196. //      NOP;
    

  197. //      NOP;
    

  198. //    I2CDelay();
    

  199. //  I2CSDA = 0;
    

  200. }
    


  201. 

  202. // Send a byte to the target
    

  203. void I2CSendByte(unsigned char SendByte)
    

  204. {
    

  205.     register unsigned char i;
    

  206. #ifdef I2C_DEBUG_MODE
    

  207. printf("<S:%02X>",(unsigned int)SendByte);
    

  208. #endif
    

  209.     for (i=0; i<8; i++)
    

  210.     {
    

  211. //      I2CDelay();
    

  212.         if ( SendByte & 0x80)
    

  213.         {
    

  214.             I2CSDA = 1;        // MSB first -> LSB last
    

  215.         }
    

  216.         else
    

  217.         {
    

  218.             I2CSDA = 0;
    

  219.         }
    

  220. //      NOP;
    

  221. //      NOP;
    

  222. //      NOP;
    

  223. //      NOP;
    

  224.         I2CSCL = 1;
    

  225.         /* doing the shift during clocking, otherwise the pulse width would be to short */
    

  226.         NOP;
    

  227.         NOP;
    

  228.         NOP;
    

  229.         NOP;
    

  230.         NOP;
    

  231.         NOP;
    

  232.         NOP;
    

  233.         SendByte = SendByte << 1;
    

  234. //      I2CDelay();
    

  235.         I2CSCL = 0;
    

  236. //      I2CDelay();
    

  237.     }
    

  238. }
    


  239. 

  240. // Receive a byte from the target
    

  241. unsigned char I2CGetByte( void )
    

  242. {
    

  243.     register unsigned char i, res;
    


  244. 

  245.     I2CSDA = 1; /* release SDA-Line */
    

  246. //      NOP;
    

  247. //      NOP;
    

  248. //      NOP;
    

  249. //      NOP;
    

  250. //  I2CDelay();
    

  251.     res = 0;
    

  252.     for (i=0;i<8;i++)     // each bit at a time, MSB first
    

  253.     {
    

  254.         NOP;
    

  255.         NOP;
    

  256.         NOP;
    

  257.         NOP;
    

  258.         NOP;
    

  259.         I2CSCL = 1;
    

  260.         res = res << 1;
    

  261. //      I2CDelay();
    

  262. //      NOP;
    

  263. //      NOP;
    

  264. //      NOP;
    

  265. //      NOP;
    

  266. //      NOP;
    

  267.         if (I2CSDA) res++;
    

  268. //      I2CDelay();
    

  269. //      NOP;
    

  270. //      NOP;
    

  271. //      NOP;
    

  272. //      NOP;
    

  273. //      NOP;
    

  274.         I2CSCL = 0;
    

  275. //      I2CDelay();
    

  276.         NOP;
    

  277.         NOP;
    

  278.         NOP;
    

  279.         NOP;
    

  280.         NOP;
    

  281.     }
    

  282. #ifdef I2C_DEBUG_MODE
    

  283. printf("<G:%02X>",(unsigned int)res);
    

  284. #endif
    

  285.     return(res);
    

  286. }
    


  287. 

  288. // ClkSyncByte fclk=100kHz
    

  289. void I2CClkSyncByte(void)
    

  290. {
    

  291.     register unsigned char i;
    

  292. #ifdef I2C_DEBUG_MODE
    

  293. printf("<SYNC>");
    

  294. #endif
    

  295.     for (i=0; i<8; i++)
    

  296.     {
    

  297.         NOP;
    

  298.         NOP;
    

  299.         NOP;
    

  300.         NOP;
    

  301.         NOP;
    

  302. //      I2CDelay();
    

  303.         I2CSCL = 1;
    

  304.         NOP;
    

  305.         NOP;
    

  306.         NOP;
    

  307.         NOP;
    

  308.         NOP;
    

  309.         NOP;
    

  310.         NOP;
    

  311.         NOP;
    

  312.         NOP;
    

  313.         NOP;
    

  314. //      I2CDelay();
    

  315.         I2CSCL = 0;
    

  316.         NOP;
    

  317.         NOP;
    

  318.         NOP;
    

  319.         NOP;
    

  320.         NOP;
    

  321. //      I2CDelay();
    

  322.     }
    

  323. }
    


  324. 

  325. #endif
回复

收藏 举报

 楼主| mintspring 发表于 2023-11-16 09:23 | 显示全部楼层
在这个基础上根据自己情况替换成相应的操作即可。
回复

收藏 举报

Jacquetry 发表于 2023-11-20 10:36 来自手机 | 显示全部楼层
模拟方式就是适合移植啊
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

mintspring

303

主题

4972

帖子

24

粉丝
快速回复 在线客服 返回列表 返回顶部