1、I2C总线简介

I2C是两线式串行总线，用于连接微控制器及其外围设备。

I2C总线最主要的优点是其简单性和有效性。由于接口直接在组件之上，因此I2C总线占用的空间非常小，减少了电路板的空间和芯片管脚的数量，降低了互联成本。总线的长度可高达25英尺，并且能够以10Kbps的最大传输速率支持40个组件。I2C总线的另一个优点是，它支持多主控(multimastering)， 其中任何能够进行发送和接收的设备都可以成为主总线。一个主控能够控制信号的传输和时钟频率。当然，在任何时间点上只能有一个主控。

单片机的通讯模块常用的有UART、SPI、I2C、CAN等等，当然还有无线模块这里不讨论。UART大多用于单片机与PC的通信，CAN总线常用于单片机与单片机通信，而SPI和I2C则用于单片机和外围设备、外围设备和其它外围设备的通信，根据自己的需要来设计通讯方式。

0 }1 B( [+ g  s* k0 h# k

相比较SPI而言，I2C需要更少的接线，仅由数据线SDA和时钟SCL构成 。而SPI则需要四根引线，它们是SDI（数据输入），SDO（数据输出），SCLK（时钟），CS（片选）。但是常常因为I2C的通讯协议较为复杂，不容易在程序中实现而导致数据丢失、无应答、“死等”等问题。

下面我们就来通过I2C的时序来解析一下I2C的通讯。

, Z5 K% h8 I6 m

2、I2C总线的时序

I2C总线是由数据线SDA和时钟SCL构成的串行总线，可发送和接收数据。在CPU与被控IC之间、IC与IC之间进行双向传送，最高传送速率100kbps。各种被控制电路均并联在这条总线上，但就像电话机一样只有拨通各自的号码才能工作，所以每个电路和模块都有唯一的地址，在信息的传输过程中，I2C总线上并接的每一模块电路既是主控器（或被控器），又是发送器（或接收器），这取决于它所要完成的功能。CPU发出的控制信号分为地址码和控制量两部分，地址码用来选址，即接通需要控制的电路，确定控制的种类；控制量决定该调整的类别及需要调整的量。这样，各控制电路虽然挂在同一条总线上，却彼此独立，互不相关。

3 W% k; ^" \; @# K# _! L

I2C总线在传送数据过程中共有三种类型信号， 它们分别是：开始信号、结束信号和应答信号。

开始信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。

结束信号：SCL为高电平时，SDA由低电平向高电平跳变，结束传送数据。

应答信号：接收数据的IC在接收到8bit数据后，向发送数据的IC发出特定的低电平脉冲，表示已收到数据。CPU向受控单元发出一个信号后，等待受控单元发出一个应答信号，CPU接收到应答信号后，根据实际情况作出是否继续传递信号的判断。若未收到应答信号，由判断为受控单元出现故障。

I2C总线通信过程中出现的几种信号状态和时序分析如下：

（1）总线空闲状态

I2C总线总线的SDA和SCL两条信号线同时处于高电平时，规定为总线的空闲状态。此时各个器件的输出级场效应管均处在截止状态，即释放总线，由两条信号线各自的上拉电阻把电平拉高。

8 R+ T/ e7 U- e1 |

（2）启动信号

在时钟线SCL保持高电平期间，数据线SDA上的电平被拉低（即负跳变），定义为I2C总线总线的启动信号，它标志着一次数据传输的开始。

启动信号是一种电平跳变时序信号，而不是一个电平信号。启动信号是由主控器主动建立的，在建立该信号之前I2C总线必须处于空闲状态，如图所示。

2 v* b8 P8 w) P7 u5 O
5 s( V2 t3 Q# R+ y

（3）停止信号

在时钟线SCL保持高电平期间，数据线SDA被释放，使得SDA返回高电平（即正跳变），称为I2C总线的停止信号，它标志着一次数据传输的终止。

停止信号也是一种电平跳变时序信号，而不是一个电平信号，停止信号也是由主控器主动建立的，建立该信号之后，I2C总线将返回空闲状态。

（4）数据位传送

在I2C总线上传送的每一位数据都有一个时钟脉冲相对应（或同步控制），即在SCL串行时钟的配合下，在SDA上逐位地串行传送每一位数据。

进行数据传送时，在SCL呈现高电平期间，SDA上的电平必须保持稳定，低电平为数据0，高电平为数据1。

只有在SCL为低电平期间，才允许SDA上的电平改变状态。逻辑0的电平为低电压，而逻辑1的电平取决于器件本身的正电源电压VDD（当使用独立电源时），如图所示。

（5） 应答信号

I2C总线上的所有数据都是以8位字节传送的，发送器每发送一个字节，就在时钟脉冲9期间释放数据线，由接收器反馈一个应答信号。

应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。

对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。

如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号P，如图所示。

' ]) J( k3 A- o  v" m

（6）插入等待时间

如果被控器需要延迟下一个数据字节开始传送的时间，则可以通过把时钟线SCL电平拉低并且保持，使主控器进入等待状态。

一旦被控器释放时钟线，数据传输就得以继续下去，这样就使得被控器得到足够时间转移已经收到的数据字节，或者准备好即将发送的数据字节。

带有CPU的被控器在对收到的地址字节做出应答之后，需要一定的时间去执行中断服务子程序，来分析或比较地址码，其间就把SCL线钳位在低电平上，直到处理妥当后才释放SCL线，进而使主控器继续后续数据字节的发送，如图所示。

# b/ Z- \# _2 @+ b3 ]  R

（7）重启动信号

在主控器控制总线期间完成了一次数据通信（发送或接收）之后，如果想继续占用总线再进行一次数据通信（发送或接收），而又不释放总线，就需要利用重启动Sr信号时序。

重启动信号Sr既作为前一次数据传输的结束，又作为后一次数据传输的开始。利用重启动信号的优点是，在前后两次通信之间主控器不需要释放总线，这样就不会丢失总线的控制权，即不让其他主器件节点抢占总线。

（8）时钟同步

如果在某一I2C总线系统中存在两个主器件节点，分别记为主器件1和主器件2，其时钟输出端分别为CLK1和CLK0，它们都有控制总线的能力。

假设在某一期间两者相继向SCL线发出了波形不同的时钟脉冲序列CLK1和CLK2（时钟脉冲的高、低电平宽度都是依靠各自内部专用计数器定时产生的），在总线控制权还没有裁定之前这种现象是可能出现的。

鉴于I2C总线的“线与”特性，使得时钟线SCL上得到的时钟信号波形，既不像主器件1所期望的CLK1，也不像主器件2所期望的CLK2，而是两者进行逻辑与的结果。

CLKI和CLK2的合成波形作为共同的同步时钟信号，一旦总线控制权裁定给某一主器件，则总线时钟信号将会只由该主器件产生，如图所示。

# p- j9 I- H! e( d) M

（9）总线冲突和总线仲裁

假如在某I2C总线系统中存在两个主器件节点，分别记为主器件1和主器件2，其数据输出端分别为DATA1和DATA2，它们都有控制总线的能力，这就存在着发生总线冲突（即写冲突）的可能性。

假设在某一瞬间两者相继向总线发出了启动信号，鉴于：I2C总线的“线与”特性，使得在数据线SDA上得到的信号波形是DATA1和DATA2两者相与的结果，该结果略微超前送出低电平的主器件1，其DATA1的下降沿被当做SDA的下降沿。

在总线被启动后，主器件1企图发送数据“101……”，主器件2企图发送数据“100101……”。

两个主器件在每次发出一个数据位的同时都要对自己输出端的信号电平进行抽检，只要抽检的结果与它们自己预期的电平相符，就会继续占用总线，总线控制权也就得不到裁定结果。

主器件1的第3位期望发送“1”，也就是在第3个时钟周期内送出高电平。

在该时钟周期的高电平期间，主器件1进行例行抽检时，结果检测到一个不相匹配的电平“0”，这时主器件1只好决定放弃总线控制杈；因此，主器件2就成了总线的惟一主宰者，总线控制权也就最终得出了裁定结果，从而实现了总线仲裁的功能。

从以上总线仲裁的完成过程可以得出：仲裁过程主器件1和主器件2都不会丢失数据；各个主器件没有优先级别之分，总线控制权是随机裁定的，即使是抢先发送启动信号的主器件1最终也并没有得到控制杈。

系统实际上遵循的是“低电平优先”的仲裁原则，将总线判给在数据线上先发送低电平的主器件，而其他发送高电平的主器件将失去总线控制权，如图所示。

, w7 e: \( G, w8 _7 W

# M" }8 H+ l  q5 `（10）总线封锁状态。

在特殊情况下，如果需要禁止所有发生在I2C总线上的通信活动，封锁或关闭总线是一种可行途径，只要挂接于该总线上的任意一个器件将时钟线SCL锁定在低电平上即可。

* Y/ `& z0 P- a  H7 e4 J+ ^9 ?

# H( l- @, }& _! W

3、参考代码

子函数文件 iic.c

1. #include "myi2c.h"
   7 }) n& b. t" A. J
2. 
   
3. void I2C_GPIO_Config(void)
   7 X3 U2 L! |! [7 \9 a: J- p
4. {
   
5.   GPIO_InitTypeDef  GPIO_InitStructure;
   
6. 
   
7.   GPIO_InitStructure.GPIO_Pin =  SCL_PIN;
   4 d, V9 q" T4 g0 S0 x' H0 ^
8.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   , {8 q7 s. W5 U9 S0 `) `7 {* G
9.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
   & M; N  m- A( V" }( d+ y& }
10.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    ; t4 e0 ^% S. N2 N& d
11.   GPIO_InitStructure.GPIO_Pin =  SDA_PIN;
    ; Y, t- Q: C! ]; o' S
12.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
13.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
    
14.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    ! v1 D# j" C$ T; D1 H
15. }
    0 N! n, L7 G* V/ O/ j
16. 
    . }7 k  P( W- l$ y7 |9 B
17. void I2C_delay(void)
    
18. {
    - r. T1 Q. y" K  R0 Y9 {. m+ S
19.   
    , C7 j  j; J; y4 T$ b+ Z
20.    u8 i=10; //这里可以优化速度 ，经测试最低到5还能写入
    
21.    while(i)
    0 x. z5 [* `* A; }! G
22.    {
    / d, _" {+ X& M6 X$ r7 C
23.      i--;
    
24.    }
    + R: |" m; m" |( t! F1 I! v; a
25. }
    " J% {9 D8 y, w
26. void delay5ms(void)
    
27. {
    0 |% E4 j3 u7 K  q
28.   
    
29.    int i=5000;
    9 y; V* c& U/ p* A7 e( y
30.    while(i)
    
31.    {
    
32.      i--;
    - N8 R1 p3 H! l0 ^0 I8 }9 m! Z
33.    }
    , P9 L* ~/ L& a+ o$ G
34. }
    ' [2 a8 T7 r0 u
35. 
    
36. uint16_t I2C_Start(void)
    
37. {
    
38. SDA_H;
    
39. SCL_H;
    
40. I2C_delay();
    
41. if(!SDA_read)return FALSE; //SDA线为低电平则总线忙,退出
    
42. SDA_L;
    # W6 L6 l5 u( w; I! y, p$ D2 i
43. I2C_delay();
    
44. if(SDA_read) return FALSE; //SDA线为高电平则总线出错,退出
    & ]3 j3 ^  Q0 ]' H* z: S' h
45. SDA_L;
    
46. I2C_delay();
    
47. return TRUE;
    
48. }
    8 S9 }- G, P6 c$ f
49. 
    & h; @; }, K" [+ @0 B! ~
50. void I2C_Stop(void)
    
51. {
    
52. SCL_L;
    
53. I2C_delay();
    
54. SDA_L;
    2 c' B# M2 F5 |: P: F- h1 m
55. I2C_delay();
    7 t! s# b3 p4 g/ \
56. SCL_H;
      g9 K8 o( ?" ^1 g/ \
57. I2C_delay();
      {: c# E" q" ?# m: I% U' r6 P# A
58. SDA_H;
    8 W9 O$ F' b& P6 F  I
59. I2C_delay();
    # w, Z/ g( a$ V  d% a+ O
60. }
    " }1 v# ?0 {- U8 M( j' O
61. 
    
62. void I2C_Ack(void)
    
63. {
    * P; Y( o5 B* @
64. SCL_L;
    
65. I2C_delay();
    
66. SDA_L;
    - D$ [7 y8 ~  d! q0 V5 g
67. I2C_delay();
    
68. SCL_H;
    3 k/ u, f9 ?6 U* J8 T4 B
69. I2C_delay();
    
70. SCL_L;
    
71. I2C_delay();
    
72. }  
    1 J% _- c2 N( l  f' a* H. \
73. 
    
74. void I2C_NoAck(void)
    
75. {
    
76. SCL_L;
    
77. I2C_delay();
    
78. SDA_H;
    
79. I2C_delay();
    
80. SCL_H;
    
81. I2C_delay();
    
82. SCL_L;
    
83. I2C_delay();
    
84. }
    # b1 c+ _) a* |+ Y
85. 
    4 q$ C0 k3 ]$ w+ ?8 a4 k: _
86. uint16_t I2C_WaitAck(void)   //返回为:=1有ACK,=0无ACK
    4 z5 Q6 {) o- |# X* Q# ]' o( Y
87. {
    & J" G, W/ {  c+ a- P( M/ Q
88. SCL_L;
    - Y- Q" h, v4 B3 p5 p. l) K( V
89. I2C_delay();
    
90. SDA_H;   
    
91. I2C_delay();
    
92. SCL_H;
    
93. I2C_delay();
    1 F# j2 `: J" Z, L8 G
94. if(SDA_read)
    & ]( E8 s7 g( p. d2 F
95. {
    : t; [1 j/ G+ l  l* d
96.       SCL_L;
    
97.    I2C_delay();
    
98.       return FALSE;
    
99. }
    6 U* {- `) i4 [; K
100. SCL_L;
     
101. I2C_delay();
     # u' O; B) ]3 V( B& e
102. return TRUE;
     ( ~: V9 h  Y+ g
103. }
     1 C+ d: B1 G0 [$ t
104. 
     
105. void I2C_SendByte(unsigned char SendByte) //数据从高位到低位//
     ; H1 S. O1 }0 B& m$ j
106. {
     
107.     u8 i=8;
     
108.     while(i--)
     & f* A! i3 u: e" s- S& u* x
109.     {
     ; W' S  a2 Y6 ?9 k; X1 ]
110.         SCL_L;
     $ Q8 V2 Z( s+ G) u4 Q
111.         I2C_delay();
     , f( j+ e5 \1 C7 y
112.       if(SendByte&0x80)
     
113.         SDA_H;
     $ I* ?( k0 ?7 ?; O2 N
114.       else
     0 i: _% P8 I# C) p+ ?, a
115.         SDA_L;  
     : k4 A( }1 n" y, s  L# ~
116.         SendByte<<=1;
     - f& ^1 f+ c9 G% y" c6 \" O
117.         I2C_delay();
     
118.   SCL_H;
     5 ?& d6 _0 c; W8 \
119.         I2C_delay();
     
120.     }
     5 A7 f; h# C: \0 w
121.     SCL_L;
     
122. }
     
123. 
     
124. unsigned char I2C_RadeByte(void)  //数据从高位到低位//
     8 p! h4 X  ~& d8 m/ T, Q
125. {
     
126.     u8 i=8;
     ' D* H  |) f* y: D# H0 E, e; q' ]
127.     u8 ReceiveByte=0;
     4 e: p! t4 _2 Q$ F$ d' C' B; J: [  n
128.     SDA_H;   
     
129.     while(i--)
     3 G: ^  W5 n9 \+ k, ^$ d8 J* l. K0 T1 S
130.     {
     + {: ^8 \" F  |# [3 k5 _8 H
131.       ReceiveByte<<=1;     
     & M0 h8 Z" o- X2 _8 m
132.       SCL_L;
     ! _5 ]3 b+ B- t6 B  n) ^) L$ ?6 \
133.       I2C_delay();
     / ?/ H) R# B# Z! \4 C& y
134.    SCL_H;
     , m" v: t& |* q9 Y( ^$ o; Y1 i( [
135.       I2C_delay();
     
136.       if(SDA_read)
     - I; {4 c) `2 D( ]3 N2 F. x3 b
137.       {
     ) a) L/ Q6 t6 m8 y/ f
138.         ReceiveByte|=0x01;
     
139.       }
     1 s1 N! f# E% J6 x* s. J; F
140.     }
     
141.     SCL_L;
     2 [0 N* u9 I$ @
142.     return ReceiveByte;
     
143. }
     
144. //ZRX         
     + h7 I, V0 U0 L
145. //单字节写入*******************************************
     
146. uint16_t Single_Write(unsigned char SlaveAddress,unsigned char REG_Address,unsigned char REG_data)       //void
     
147. {
     + G" s/ ?$ e3 U; r. R8 S8 T
148.    if(!I2C_Start())return FALSE;
     
149.     I2C_SendByte(SlaveAddress);   //发送设备地址+写信号//I2C_SendByte(((REG_Address & 0x0700) >>7) | SlaveAddress & 0xFFFE);//设置高起始地址+器件地址
     7 A9 o" h( c' D( J
150.     if(!I2C_WaitAck()){I2C_Stop(); return FALSE;}
     
151.     I2C_SendByte(REG_Address );   //设置低起始地址     
     
152.     I2C_WaitAck();
     ' K9 Q1 S' J( l  f: R% i0 W7 _$ r
153.     I2C_SendByte(REG_data);
     % w7 I1 m$ g: a4 J/ F
154.     I2C_WaitAck();  
     
155.     I2C_Stop();
     
156.     delay5ms();
     2 \+ \4 J; _6 r8 e) q5 b# k8 }
157.     return TRUE;
     
158. }
     
159. //单字节读取*****************************************
     
160. unsigned char Single_Read(unsigned char SlaveAddress,unsigned char REG_Address)
     ; P2 g. f! V( u- t
161. {   unsigned char REG_data;      
     
162. if(!I2C_Start())return FALSE;
     % ~) V5 N$ d' w* z8 i
163.     I2C_SendByte(SlaveAddress); //I2C_SendByte(((REG_Address & 0x0700) >>7) | REG_Address & 0xFFFE);//设置高起始地址+器件地址
     / k( _: q; P  c6 c6 F! B
164.     if(!I2C_WaitAck()){I2C_Stop();return FALSE;}
     
165.     I2C_SendByte((u8) REG_Address);   //设置低起始地址     
     & I) I1 P" ?/ b5 z8 ~1 A8 t5 w+ e
166.     I2C_WaitAck();
     
167.     I2C_Start();
     
168.     I2C_SendByte(SlaveAddress+1);
     
169.     I2C_WaitAck();
     
170. REG_data= I2C_RadeByte();
     
171.     I2C_NoAck();
     " P# d+ g* I$ N* x- y+ O: m, k
172.     I2C_Stop();
     
173.     //return TRUE;
     
174. return REG_data;
     
175. }

复制代码

7 k% F7 C' j8 `: K* P头文件 iic.h
6 e4 |) g1 P; i; U+ C" M

1. #ifndef __MYI2C_H__
   , f+ C2 u$ \# ~& t
2. #define __MYI2C_H__
   
3. #include "stm32f10x.h"
   
4. #define FALSE 0
   
5. #define TRUE  1
   
6. 
   
7. #define SCL_PIN GPIO_Pin_6
   ; G  z6 O; N3 O9 E' ?8 y
8. #define SDA_PIN GPIO_Pin_7
   - w6 I* I6 |) C/ o5 Z
9. 
   3 r# @3 `; f/ i5 G; \# S5 d, t3 h
10. #define SCL_H         GPIOB->BSRR = SCL_PIN
    
11. #define SCL_L         GPIOB->BRR  = SCL_PIN
    
12. 
    : e0 w) e+ Y& W* r& M
13. #define SDA_H         GPIOB->BSRR = SDA_PIN
    
14. #define SDA_L         GPIOB->BRR  = SDA_PIN
    5 p" Y& e' f$ y5 Y# ?; _; r& s' s
15. 
    
16. #define SCL_read      GPIOB->IDR  & SCL_PIN
    - [3 C) N# ?4 T- d
17. #define SDA_read      GPIOB->IDR  & SDA_PIN
    ( C. ^8 _/ w0 `, o
18. 
    + R9 N2 y- a( Y/ q3 _; [
19. void I2C_GPIO_Config(void);
    
20. void I2C_delay(void);
    2 B: j' I! x6 Y' k3 o* u" K
21. void delay5ms(void);
    ; F2 d! z+ L/ ]& N. Q0 Z3 U
22. uint16_t I2C_Start(void);
    3 U) l9 D, e3 q# \# f' T
23. void I2C_Stop(void);
    9 c5 l! \+ ?: b* x" I( H
24. void I2C_Ack(void);
    
25. void I2C_NoAck(void);
    # R# m& Y; A4 t, c
26. uint16_t I2C_WaitAck(void);
    ) E' V3 c6 o7 H/ U: e
27. void I2C_SendByte(unsigned char SendByte);
    
28. unsigned char I2C_RadeByte(void);
    * i9 D8 L4 G8 A# O: l" ^
29. uint16_t Single_Write(unsigned char SlaveAddress,unsigned char REG_Address,unsigned char REG_data);
    & _( X2 c( x$ Q7 M  ~3 _
30. unsigned char Single_Read(unsigned char SlaveAddress,unsigned char REG_Address);
    
31. 
    4 x4 t' Z. m/ J
32. 
    
33. #endif // __MYI2C_H__

复制代码

/ Y# Y* W% h9 S1 I& |' z7 D

, R* Y8 ^3 k2 F
这样写才行
# Q, }, G# i- R. g1 V6 R; S#define  I2C_Direction_Transmitter      ((uint8_t)0x00)
2 ^( V. K( Q7 d- P$ I$ J5 [) d$ K
8 i/ q4 I! L, a0 yuint16_t Single_Write(unsigned char SlaveAddress,unsigned char REG_Address,unsigned char REG_data)       //void
{
4 G1 D0 n2 v: @+ E   if(!I2C_Start())return FALSE;
/ N; |5 h2 A1 l( a  H7 h4 E    I2C_SendByte(SlaveAddress<<1|I2C_Direction_Transmitter);  
    if(!I2C_WaitAck()){I2C_Stop(); return FALSE;}
; f3 c  u! \! {" g6 p  J- _! L    I2C_SendByte(REG_Address );   //ÉèÖõÍÆðʼµØÖ·     
3 j2 r. n$ z# g    I2C_WaitAck();
0 J# ^/ m3 h( G2 [7 O* e    I2C_SendByte(REG_data);
/ i1 P( g4 j/ f7 t5 B( W    I2C_WaitAck();  
    I2C_Stop();
) j$ L+ J( `; V  y+ G9 a, R    delay5ms();
    return TRUE;
}
#define  I2C_Direction_Receiver         ((uint8_t)0x01)
, ?& f: w% R  G" @. \: Lu8 Single_Read(unsigned char SlaveAddress,unsigned char REG_Address)
{   
        unsigned char REG_data;      
        if(!I2C_Start())
        return FALSE;
    I2C_SendByte(SlaveAddress<<1|I2C_Direction_Transmitter);
    if(!I2C_WaitAck())
     {
           I2C_Stop();
          return FALSE;
         }
- U! J$ Z& A( j. @( f. h6 H  \    I2C_SendByte((u8) REG_Address);
; G  r( X+ w( {    I2C_WaitAck();
    I2C_Start();
5 o! _, f- u$ {" ^9 L3 \6 f" y' Z    I2C_SendByte(SlaveAddress<<1|I2C_Direction_Receiver);
    I2C_WaitAck();
    REG_data= I2C_RadeByte();
  ?/ _7 L, {/ b  w- u% r* x    I2C_NoAck();
    I2C_Stop();
    //return TRUE;
; T6 j4 J' a3 [+ h. p$ Q) q    return  REG_data;
}
! y* D0 I3 F: L# ~9 u

有硬件IIC了，还用模拟方式？

用模拟方式非常好的1种，你用多了就很喜欢。

samhong 发表于 2017-6-20 18:53
% f' ~  V% f2 Z6 X用模拟方式非常好的1种，你用多了就很喜欢。

还是模拟好，不受限制

我自己也写了一个模拟的，可以支持任意IO口，而且支持多个Ｉ２C通道

谢谢楼主分享

代码里有个错误

路过！~学习学习！~

MrJiu 发表于 2017-6-21 09:34
我自己也写了一个模拟的，可以支持任意IO口，而且支持多个Ｉ２C通道

老大  新手 求个代码   我IIC 上面4个传感器  不会搞啊  求代码 896072073@qq.com

我认为我不行，但这些很行的，用行话说叫不作为！
仿真的IIC到处都能抄，分享还能拿积分，EASY！

这个不错，收藏学习