所谓的硬件I2C就是STM32芯片上有其相应的外设和驱动电路，通过配置相应的寄存器，就可以完成I2C的通信。本节实验我们介绍软件模拟I2C，软件I2C一般是通过GPIO引脚，按照I2C的时序要求来控制引脚电平状态以产生通讯时序。
- v' E9 L2 q9 G% V, D( d
1、I2C通信流程中包含信号如下：
& v7 r' `( Y, `8 R- q
8 M$ D5 G  w, f4 Z开始信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。
% d! i! a9 T: {结束信号：SCL为高电平时，SDA由低电平向高电平跳变，结束传送数据。
应答信号：发送器每发送一个字节，就在第9个时钟脉冲期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号。
6 U8 Q) F4 R) q' }- X2、I2C总线时序图如下：
& e; K7 C& U" @, F
7 a/ U. g0 a8 V

  R. x" V6 m5 \9 u* \5 d9 e- l/ [9 F
9 O: w6 F4 \! u% _- Z8 y4 `. \% b3、I2C通讯过程的基本结构如下所示：

3 A- u( X" D8 R- v6 d- f1）主机写数据到从机

' \# q4 m" z0 J, ~. t

2）主机由从机中读数据
# \  @6 a2 l1 t
# Q) S( Y+ u; |8 N' I- C2 u7 L

3）I2C通讯复合格式
) z5 o8 y: w+ P+ {9 d- A0 m- s, q: e9 `

. Q) C% \# ~( r6 v
, `8 b/ i5 d; K, Q+ i: J: Q/ H

其中 S 表示由主机的 I2C接口产生的传输起始信号(S)，这时连接到 I2C总线上的所有从机都会接收到这个信号。
3 F" {& B; f7 w' n0 W; j
起始信号产生后，所有从机就等待主机广播从机地址信号(SLAVE_ADDRESS)。在 I2C总线上，每个设备的地址都是唯一的，当主机广播的地址与某个设备地址相同时，这个设备就被选中了，没被选中的设备将会忽略之后的数据信号。根据 I2C协议，这个从机地址可以是 7位或 10位。

1 R' q$ F7 `0 L- E. \在地址位之后，是传输方向的选择位，该位为 0时，表示后面的数据传输方向是由主机传输至从机，即主机向从机写数据。该位为 1时，则相反，即主机由从机读数据。

+ @" k9 Y4 t2 k4 i5 }* k从机接收到匹配的地址后，会返回一个应答(ACK)或非应答(NACK)信号，只有接收到应答信号后，主机才能继续发送或接收数据。
. U2 O& |0 M; H6 z0 c) F
若配置的方向传输位为“写数据”方向，即第一幅图的情况，广播完地址，接收到应答信号后，主机开始正式向从机传输数据(DATA)，数据包的大小为 8位，主机每发送完一个字节数据，都要等待从机的应答信号(ACK)，重复这个过程，可以向从机传输 N 个数据，这个 N没有大小限制。当数据传输结束时，主机向从机发送一个停止传输信号(P)，表示不再传输数据。

, M8 {" J/ u  ~7 o若配置的方向传输位为“读数据”方向，即第二幅图的情况，广播完地址，接收到应答信号后，从机开始向主机返回数据(DATA)，数据包大小也为 8 位，从机每发送完一个数据，都会等待主机的应答信号(ACK)，重复这个过程，可以返回 N 个数据，这个 N 也没有大小限制。当主机希望停止接收数据时，就向从机返回一个非应答信号(NACK)，则从机自动停止数据传输。

除了基本的读写，I2C通讯更常用的是复合格式，即第三幅图的情况，该传输过程有两次起始信号(S)。一般在第一次传输中，主机通过 SLAVE_ADDRESS寻找到从设备后，发送一段“数据”，这段数据通常用于表示从设备内部的寄存器或存储器地址(注意区分它与 SLAVE_ADDRESS 的区别)；在第二次的传输中，对该地址的内容进行读或写。也就是说，第一次通讯是告诉从机读写地址，第二次则是读写的实际内容。

4）数据有效性时序图如下：
& s, X" F2 d- ^
/ `: \3 q/ v5 n- Z

1 w' E+ |, w, Q8 W. r) L& pI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。 即：数据在SCL的上升沿到来之前就需准备好。并在下降沿到来之前必须稳定。
+ Q$ H8 j8 R) U
! j9 g2 y5 T# M5）地址及数据方向

I2C 总线上的每个设备都有自己的独立地址，主机发起通讯时，通过 SDA 信号线发送设备地址(SLAVE_ADDRESS)来查找从机。I2C 协议规定设备地址可以是 7位或 10 位，实际中 7 位的地址应用比较广泛。紧跟设备地址的一个数据位用来表示数据传输方向，它是数据方向位(R/W)，第 8位或第 11 位。数据方向位为“1”时表示主机由从机读数据，该位为“0”时表示主机向从机写数据，如图：
% P- V2 ?/ l" h, @  ^( q* y
: a- u: B$ {1 Y8 [

9 n( \% E4 _5 {7 v
读数据方向时，主机会释放对 SDA信号线的控制，由从机控制 SDA 信号线，主机接收信号，写数据方向时，SDA由主机控制，从机接收信号。
' i. }! z' ^- d
bsp_soft_i2c.c程序如下：

$ k+ [9 e0 Y7 C7 y. o1 j/ N

1. #include "bsp_soft_i2c.h"   
   
2. #include <stdbool.h>
   
3. 
   
4. // 初始化IIC的IO口
   
5. void I2C2_Soft_Init(void)
   . o3 H: u. k+ U; d
6. {
   # J" \7 f- j% d$ L
7.     GPIO_InitTypeDef GPIO_InitStructure;   // 定义GPIO结构体
   
8.         
   
9.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);  // 打开GPIOB口时钟
   6 u! \4 E! N# J! E' @
10.         
    7 X, x1 Q% }+ o$ K2 U; C7 O
11.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;  // 输出
    : @& i' y2 p. n+ M1 r
12.     GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; // 开漏
    
13.     GPIO_InitStructure.GPIO_Pin = Pin_SCL | Pin_SDA ; // IIC对应IO口
    6 d: V% v1 \8 H5 Y; J$ X
14.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; // 上拉
    , u& F' U2 d9 u* l( w  k2 Z, _
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_3; // 50MHZ
    
16.     GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化GPIO
    % F/ G* C( @  I2 @! P
17.         
    
18.     I2C2_Stop();
    
19. }
    
20. 
    
21. // 发送IIC起始信号
    + S% D* Y+ \+ _0 \1 N7 p; l) p
22. bool I2C2_Start(void)
    
23. {
    / E4 @+ m! |2 V3 g; R7 q4 B* I% a( j
24.     Pin_SCL_H; // 拉高时钟线
    
25.     Pin_SDA_H; // 拉高信号线
    
26.     I2C2_Delay1us();
    
27.     if(!Read_SDA_Pin)                return false;
    , b: C& |( C, [; U; I0 _9 i& g$ Y
28.     Pin_SDA_L;
    
29.     I2C2_Delay1us();
    . s6 \6 Q# ~; L
30.     Pin_SDA_L;
    
31.     I2C2_Delay1us();
    
32.     return true;
    
33. }
    ; |% i3 ]3 D, N2 t) G
34. 
      O9 ]5 U$ F" o, e& k. h( M- @
35. // 发送IIC停止信号
    
36. bool I2C2_Stop(void)
    
37. {
    
38.     Pin_SCL_H;
    ) T+ t- H$ Q" ?; C4 O# }
39.     Pin_SDA_L;
    & b1 w# q' X' V* l4 _3 U' ]! A
40.     I2C2_Delay1us();
    4 }" v6 o0 E& q3 V/ I
41.     if(Read_SDA_Pin)        return false;
    
42.     Pin_SDA_H;
    ( P& y- K/ y1 W# a
43.     I2C2_Delay1us();
    
44.     if(!Read_SDA_Pin) return false;
    
45.     Pin_SDA_H;
    
46.     I2C2_Delay1us();        
    9 J, b; j9 p: o& `+ M; ?
47.     return true;
    
48. }
    8 A. |4 f4 a- G8 Z
49. 
    3 C* A' B4 g+ M2 N
50. // IIC发送ACK信号
    - N6 p! s3 O8 I; D' i
51. void I2C2_Ack(void)
    " j. K" q4 X8 M
52. {
    ) }# E1 H# t' S% f6 X& Y/ P! k7 q
53.     Pin_SCL_L;
    ' C2 w1 v" V8 ?" D5 H4 j, p
54.     I2C2_Delay1us();
    ! r3 h) k& ?+ o' l. S; ]
55.     Pin_SDA_L;        
    
56.     Pin_SCL_H;
    
57.     I2C2_Delay1us();
    ; V8 Y, q) Y' R3 Z% L! t
58.     Pin_SCL_L;
    
59.     Pin_SDA_H;
    + Q( F0 z, X1 ~& q
60.     I2C2_Delay1us();
    
61. }
    
62. 
    
63. // IIC不发送ACK信号
    
64. void I2C2_NAck(void)
    
65. {
    
66.     Pin_SCL_L;
    
67.     I2C2_Delay1us();        
    
68.     Pin_SDA_H;
    
69.     Pin_SCL_H;
    
70.     I2C2_Delay1us();
    - S, _  k" z* t( X
71.     Pin_SCL_L;
    & R; ]6 M& D7 B' t( o$ F7 e
72.     I2C2_Delay1us();
      N0 R$ u0 t8 }  K* |# E
73. }
    " F" r  q+ f6 M+ V3 H6 m
74. 
    
75. // IIC等待ACK信号
    2 C: a/ ?3 j, I$ v) x( R2 t; t
76. uint8_t I2C2_Wait_Ack(void)
    
77. {
    - T1 ^* |7 @+ X
78.     Pin_SCL_L;
    
79.     I2C2_Delay1us();        
    
80.     Pin_SDA_H;
    ! X  g0 d; X9 m6 C; b5 D! D. @
81.     Pin_SCL_H;
    
82.     I2C2_Delay1us();        
    
83.     if(Read_SDA_Pin)
      |/ c9 Q( s: W- ]% z
84.     {
      H& i" H  ]1 K* l, X5 z
85.         Pin_SCL_L;
    1 U2 `; o" Q  a5 e
86.         I2C2_Delay1us();
    % B& [7 N- `$ U) {
87.         return false;
    
88.     }
    ; [( M4 f* C0 Z& H0 _/ r
89.     Pin_SCL_L;
    1 r' D( f- K; ~, a9 B+ e# t9 o& f) L: u
90.     I2C2_Delay1us();
    
91.     return true;
    
92. }
    
93. 
    ! |( t- C0 m* x! x
94. // IIC发送一个字节
    
95. void I2C2_Send_Byte(uint8_t txd)
    * y; {6 B" U& b$ N
96. {
    0 V" [& V# p5 l: Y) x" _1 b1 H- v
97.     for(uint8_t i=0; i<8; i++)
    
98.     {
    8 g5 }3 ?4 Y- ~- c  o
99.         Pin_SCL_L;
    1 N% x  s2 S; z0 C! B
100.         I2C2_Delay1us();
     
101.         if(txd & 0x80)
     
102.             Pin_SDA_H;
     
103.         else
     9 q, x: y( _6 \+ h
104.             Pin_SDA_L;
     
105.             txd <<= 1;
     
106.             Pin_SCL_H;
     : ]) j* a- L' V' q7 N
107.             I2C2_Delay1us();
     * `  V( o" l! ], W5 u! }
108.     }
     1 o' B+ I6 p  v; d" J
109. }
     
110. 
     
111. // IIC读取一个字节
     1 I/ b3 l  u% g
112. uint8_t        I2C2_Read_Byte(void)
     ; S1 O1 @$ ^$ H2 q4 G/ r2 c" A1 R
113. {
     
114.     uint8_t rxd = 0;
     + }3 \! ^- q4 p- Q! J) l
115.     for(uint8_t i=0; i<8; i++)
     8 v" L9 |& t7 D6 J
116.     {
     + O/ ^) l3 t- m4 C
117.         rxd <<= 1;
     
118.         Pin_SCL_L;
     
119.         I2C2_Delay1us();
     " f3 q2 W- p  S2 E  s
120.         Pin_SCL_H;        
     1 @1 G' f: V( n% O
121.         I2C2_Delay1us();               
     
122.         if(Read_SDA_Pin)
     
123.         {
     + W$ y( O1 S4 y
124.             rxd |= 0x01;
     & ]* L8 J0 J8 P1 D' \% ?" `
125.         }
     , b3 e* z/ n1 l; g6 Q/ p9 L) X" N
126.     }
     
127.     return rxd;
     ) H7 q: |% P; N6 [4 r" ^! S
128. }
     4 C& u5 m% ^; l' k/ }) [' G
129. 
     $ j- ~7 F$ u2 Q. Z* }, k  G
130. // 向从机指定地址写数据
     
131. bool I2C_Write_REG(uint8_t SlaveAddress, uint8_t REG_Address,uint8_t REG_data)
     
132. {
     # o1 d( [$ m) L% c. ~
133.     if(!I2C2_Start())                return false;
     
134.     I2C2_Send_Byte(SlaveAddress);
     
135.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
136.     I2C2_Send_Byte(REG_Address);
     4 W% z+ ]6 j8 d6 H$ T$ U
137.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
       r) O" r. c7 f2 K6 v: j; _
138.     I2C2_Send_Byte(REG_data);
     
139.     if(!I2C2_Wait_Ack()) { I2C2_Stop(); return false;        }
     1 U" U8 C2 }6 l3 K3 R& ^
140.     if(!I2C2_Stop()) return false;
     
141.     return true;
     9 p, o" J+ j% B+ j: P3 Q, v, f" |
142. }
     5 M* X2 z% x$ p( [, U2 J' o4 u5 ~: _- L
143. 
     
144. // 从设备中读取数据
       ]& H! A% k3 F4 F4 O
145. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address)
     ) _: A. w) L& D" ^' P
146. {
     
147.     uint8_t data;
     
148.     if(!I2C2_Start())        return false;
     
149.     I2C2_Send_Byte(SlaveAddress);
     
150.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     $ x: ^$ Z9 j/ y: W$ e& _9 d6 b; A
151.     I2C2_Send_Byte(REG_Address);
     6 E8 a. D! n8 T& M8 |" [0 r' D
152.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     / f  D$ W8 d- ]3 c  E
153.     if(!I2C2_Start())        return false;
     
154.     I2C2_Send_Byte(SlaveAddress + 1);
     
155.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
156.     data = I2C2_Read_Byte();
     
157.     I2C2_NAck();
     
158.     if(!I2C2_Stop())        return false;        
     0 N, k& t* `# h9 z9 Y
159.     return data;
     
160. }
     . r' o5 o8 O& ~; b) y9 Z
161. 
     
162. // 连续写N个字节
     
163. bool I2C2_Write_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     
164. {
     ' R$ U& ]) M5 n! \* S& P! \# i
165.     if(!I2C2_Start())return false;
     7 F( t/ \) D5 _! H. U2 B( V7 s
166.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     " m, N) R5 z/ z$ `& J) m
167.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
168.     I2C2_Send_Byte(REG_Address);   
     
169.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     / E# S# V5 I+ ~1 R8 K" e3 _5 K) s
170.     for(uint16_t i=0; i<len; i++)
     1 E8 x, b5 `+ Q5 I
171.     {
     7 [) Z4 Z# s; l" V& `
172.         I2C2_Send_Byte(buf<i>);
     
173.       </i>  if(i<len-1)
     
174.         {
     * O2 h% B9 B9 _) B/ q& e% |- c
175.             if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
176.         }
     
177.     }
     
178.     I2C2_Stop();
     - V: u- \8 Q! x( ?( ~& ?2 I
179.     return true;
     
180. }
     " t5 ~* E5 b, r1 z& x1 c
181. 
     
182. // 连续读N个字节
     
183. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     # W! x: U7 `3 p- q8 h9 I& y
184. {
     - d* R( {: U  p4 i$ I( U! G5 @
185.     if(!I2C2_Start())return false;
     $ a# J1 L. D1 N  D% N" v) A% X! K1 c
186.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     
187.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     . a2 K# x" e& Q( N- W
188.     I2C2_Send_Byte(REG_Address);   
     5 C# Z" ?& |7 m0 Y9 Y
189.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     + r+ ?, X) G  Q( C
190.     if(!I2C2_Start())return false;
     
191.     I2C2_Send_Byte(SlaveAddress | 1); // 读操作
     - p: d8 D1 K( P0 M8 x! k# ]: P
192.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
193.     for(uint16_t i=0; i<len; i++)
     . p8 y# V2 `9 t2 ]
194.     {
       d! O9 \, m) T' N2 \6 R
195.         buf = I2C2_Read_Byte();
     * a! }5 B% P  I: `. ?4 J, c
196.         if(i<len-1)
     " L, o) W$ z$ T; l
197.         {
     
198.             I2C2_Ack();
     
199.         }
     - ]" O. |. D5 D; _7 E
200.     }
     
201.     I2C2_NAck();
     6 q. @, x/ ?3 j; w& a
202.     I2C2_Stop();
     - {2 \) p$ {( E  A! g
203.     return true;
     3 t4 L: C) y9 T3 O- Z& |
204. }
     
205. 
     * n. F: D, X8 [( U; t
206. // 检查设备地址
     9 b: H1 B% D+ Z# ?
207. bool I2C2_CheckDevice(uint8_t SlaveAddress)
     ; b# O  J  E7 H: p7 {
208. {
     ( a1 T' a; c5 z( O7 M! e5 E* a
209.     if(!I2C2_Start())        return false;
     
210.     I2C2_Send_Byte(SlaveAddress);
     5 x& z8 O/ X# S
211.     if(!I2C2_Wait_Ack())
     
212.     {
     " [6 O, d0 S  D, l
213.         I2C2_Stop();
     
214.         return false;               
     2 P% {$ L  b0 `9 E
215.     }
     # |2 }: h0 P9 F/ f
216.     if(!I2C2_Stop())        return false;        
     
217.     return true;        
     
218. }

复制代码

bsp_soft_i2c.h程序如下：

1 f, c: L& A4 }; _/ _; j

1. #ifndef _BSP_SOFT_I2C_H_
   
2. #define _BSP_SOFT_I2C_H_
   
3. 
   ' Z; t/ N! g+ ~  F- e
4. #include "stm32f0xx.h"
     Y  v: n9 p8 o8 o
5. #include <stdbool.h>
   ! w5 O3 F, {* e! O
6. 
   
7. // 定义内联延时函数        
   " \9 G/ O! O4 C
8. static inline void I2C2_Delay1us(void)
   0 Z2 N  L2 k1 J
9. {
   
10.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    , a2 Y; E  N+ F/ Z' H
11.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
12.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    # j4 u3 _4 ^; H
13.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    8 H2 v3 |8 ]/ o
14.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    9 j% {- q" F9 Y: K8 p
15.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();        
    
16. }        
    $ E% A6 N0 v0 ]7 M* i
17. 
    
18. 
    
19. #define        I2C2_GPIOx  GPIOB
    
20. #define Pin_SCL                GPIO_Pin_10
    1 K( i  ]4 Z- W" [4 @; S, e
21. #define Pin_SDA                GPIO_Pin_11
    
22. 
    
23. #define Pin_SCL_L                I2C2_GPIOx->ODR &= ~Pin_SCL
    
24. #define Pin_SCL_H                I2C2_GPIOx->ODR |= Pin_SCL
    4 C* h+ e1 T, v
25. 
    
26. #define Pin_SDA_L                I2C2_GPIOx->ODR &= ~Pin_SDA
    ' o- ~6 }$ c  m8 j2 L: R  {
27. #define Pin_SDA_H                I2C2_GPIOx->ODR |= Pin_SDA
    
28. 
    * W, A7 X2 C1 o% Z% h2 M# W
29. #define Read_SDA_Pin        I2C2_GPIOx->IDR & Pin_SDA
    3 Q  J  }; X, y/ ~( B
30. 
    : B$ v! w" W# D7 _
31. void I2C2_Soft_Init(void);                        
    ' \' `+ g& M, F- {
32. bool I2C2_Start(void);                                                
    
33. bool I2C2_Stop(void);                                          
    
34. void I2C2_Send_Byte(uint8_t txd);
    9 U  p& T% C7 R
35. uint8_t I2C2_Read_Byte(void);
    5 v& U7 z" C: j! |1 x2 O' u: z
36. uint8_t I2C2_Wait_Ack(void);                 
    # B$ a6 j/ j. N2 T
37. void I2C2_Ack(void);                                                        
    
38. void I2C2_NAck(void);                                                
    $ q2 _7 }* l) U9 b1 s# v9 I7 ^
39. 
    
40. bool I2C2_Write_REG(uint8_t SlaveAddress,uint8_t REG_Address,uint8_t REG_data);
    % }' l* S) T& J: J' J
41. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address);
    
42. bool I2C2_Write_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len);
    . H/ s& m& c* B5 t0 j4 E
43. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len);
    1 E1 E; X; E1 b- |
44. bool I2C2_CheckDevice(uint8_t SlaveAddress);
    
45. #endif

复制代码

) M7 M3 Z9 A* F, G
: K& m; q' J% a7 o% e( H' v( Y
7 U' r$ [6 W8 O  Q: C