所谓的硬件I2C就是STM32芯片上有其相应的外设和驱动电路，通过配置相应的寄存器，就可以完成I2C的通信。本节实验我们介绍软件模拟I2C，软件I2C一般是通过GPIO引脚，按照I2C的时序要求来控制引脚电平状态以产生通讯时序。
% i/ i! X8 C0 h$ N' m2 ]
% v3 L$ |+ W, g. \1、I2C通信流程中包含信号如下：

开始信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。
: L" ^7 b. t% l, S+ A8 x( |$ A3 b结束信号：SCL为高电平时，SDA由低电平向高电平跳变，结束传送数据。
应答信号：发送器每发送一个字节，就在第9个时钟脉冲期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号。
2、I2C总线时序图如下：
' V  R  U0 u7 ^- i
( c+ k. w; N6 E/ w5 t: ~* L6 @

3、I2C通讯过程的基本结构如下所示：

) [9 D; [. x$ m& w/ R7 ]1）主机写数据到从机

: [$ L4 t4 v9 D7 i" D$ ]

2 h' E2 }$ Y5 Y) W7 G- J2）主机由从机中读数据

8 O( g" P4 R9 K4 C

+ l( _4 l( X' m' w3）I2C通讯复合格式
" g& k( p! L2 W

( [3 E) f* p+ u9 f7 L* {
( R$ j' B& {; G2 v7 J

! v* x7 H. @. T6 ~- w( q7 _其中 S 表示由主机的 I2C接口产生的传输起始信号(S)，这时连接到 I2C总线上的所有从机都会接收到这个信号。

$ ]: P" R# C" k起始信号产生后，所有从机就等待主机广播从机地址信号(SLAVE_ADDRESS)。在 I2C总线上，每个设备的地址都是唯一的，当主机广播的地址与某个设备地址相同时，这个设备就被选中了，没被选中的设备将会忽略之后的数据信号。根据 I2C协议，这个从机地址可以是 7位或 10位。

在地址位之后，是传输方向的选择位，该位为 0时，表示后面的数据传输方向是由主机传输至从机，即主机向从机写数据。该位为 1时，则相反，即主机由从机读数据。
; T4 A% o* b* J0 I/ W
7 [( W* q/ m0 p* k! X从机接收到匹配的地址后，会返回一个应答(ACK)或非应答(NACK)信号，只有接收到应答信号后，主机才能继续发送或接收数据。

7 b" `6 ^% z+ K2 [若配置的方向传输位为“写数据”方向，即第一幅图的情况，广播完地址，接收到应答信号后，主机开始正式向从机传输数据(DATA)，数据包的大小为 8位，主机每发送完一个字节数据，都要等待从机的应答信号(ACK)，重复这个过程，可以向从机传输 N 个数据，这个 N没有大小限制。当数据传输结束时，主机向从机发送一个停止传输信号(P)，表示不再传输数据。

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

+ G* K/ K9 D! L; K除了基本的读写，I2C通讯更常用的是复合格式，即第三幅图的情况，该传输过程有两次起始信号(S)。一般在第一次传输中，主机通过 SLAVE_ADDRESS寻找到从设备后，发送一段“数据”，这段数据通常用于表示从设备内部的寄存器或存储器地址(注意区分它与 SLAVE_ADDRESS 的区别)；在第二次的传输中，对该地址的内容进行读或写。也就是说，第一次通讯是告诉从机读写地址，第二次则是读写的实际内容。
* w- _4 ]) x3 g' P: J" t
4）数据有效性时序图如下：
2 P* r8 [+ p1 l

$ u  T, @* w/ v+ ^I2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。 即：数据在SCL的上升沿到来之前就需准备好。并在下降沿到来之前必须稳定。
# ^% i( y+ ]. C7 b2 m
5）地址及数据方向
. k2 r) m/ e+ R2 w) t* H4 J) [
I2C 总线上的每个设备都有自己的独立地址，主机发起通讯时，通过 SDA 信号线发送设备地址(SLAVE_ADDRESS)来查找从机。I2C 协议规定设备地址可以是 7位或 10 位，实际中 7 位的地址应用比较广泛。紧跟设备地址的一个数据位用来表示数据传输方向，它是数据方向位(R/W)，第 8位或第 11 位。数据方向位为“1”时表示主机由从机读数据，该位为“0”时表示主机向从机写数据，如图：
) p; s; ^6 G9 P5 |7 O

1 o9 S5 H. ~3 k" @+ ?5 H
读数据方向时，主机会释放对 SDA信号线的控制，由从机控制 SDA 信号线，主机接收信号，写数据方向时，SDA由主机控制，从机接收信号。

bsp_soft_i2c.c程序如下：

- e) m5 l  B: s4 ]

1. #include "bsp_soft_i2c.h"   
   
2. #include <stdbool.h>
   
3. 
   
4. // 初始化IIC的IO口
   
5. void I2C2_Soft_Init(void)
   
6. {
   
7.     GPIO_InitTypeDef GPIO_InitStructure;   // 定义GPIO结构体
   . Z- W9 D2 m; @3 R" A
8.         
   : P3 E4 P. W1 E* ?
9.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);  // 打开GPIOB口时钟
   0 {- C* v& z8 s2 [3 {! M& n
10.         
    
11.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;  // 输出
    
12.     GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; // 开漏
    
13.     GPIO_InitStructure.GPIO_Pin = Pin_SCL | Pin_SDA ; // IIC对应IO口
    
14.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; // 上拉
    
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_3; // 50MHZ
    
16.     GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化GPIO
    
17.         
    
18.     I2C2_Stop();
    
19. }
    4 M2 L3 C4 m6 Z3 q6 o; d5 [) n* D) T, y
20. 
    9 w/ }3 O+ _7 z
21. // 发送IIC起始信号
    
22. bool I2C2_Start(void)
    ; X4 x$ |9 y- s6 x. a" J
23. {
    
24.     Pin_SCL_H; // 拉高时钟线
    3 L3 o" S# h, S9 Q$ A# i$ P
25.     Pin_SDA_H; // 拉高信号线
    $ x6 _: T0 l+ c2 k8 g9 l$ H
26.     I2C2_Delay1us();
    : u& M4 O: ~( b. e
27.     if(!Read_SDA_Pin)                return false;
    " ~1 @) G) k& r( }' G7 L1 w* w: c
28.     Pin_SDA_L;
    
29.     I2C2_Delay1us();
    
30.     Pin_SDA_L;
    5 }# M8 f7 R  E% b
31.     I2C2_Delay1us();
    6 o- ]1 ~+ u4 M' O, S, S- ~& k
32.     return true;
    
33. }
    
34. 
    
35. // 发送IIC停止信号
    
36. bool I2C2_Stop(void)
    
37. {
    
38.     Pin_SCL_H;
    
39.     Pin_SDA_L;
    . G, m# Z: o6 ]! ^8 @, M  h' Q. x
40.     I2C2_Delay1us();
    
41.     if(Read_SDA_Pin)        return false;
    , z1 {0 b! G' O: o& X
42.     Pin_SDA_H;
    
43.     I2C2_Delay1us();
    
44.     if(!Read_SDA_Pin) return false;
    
45.     Pin_SDA_H;
    
46.     I2C2_Delay1us();        
    ( g7 \8 C6 T/ q, [
47.     return true;
    % D9 P2 ~# @& m: p
48. }
    
49. 
    5 O/ D$ @" R( z9 _9 Q) U
50. // IIC发送ACK信号
    
51. void I2C2_Ack(void)
    , [; J% V9 p5 v3 A( Q7 J8 ^6 j
52. {
    ( U4 H& p. q6 r5 C; [/ W4 d7 n
53.     Pin_SCL_L;
    
54.     I2C2_Delay1us();
    
55.     Pin_SDA_L;        
    $ b8 u5 R( X# F/ ?5 _
56.     Pin_SCL_H;
    9 B* w0 Z8 f8 r( i: q6 U
57.     I2C2_Delay1us();
    
58.     Pin_SCL_L;
    ) X: u- n/ j/ V2 u
59.     Pin_SDA_H;
    " b3 o: Y. v! J0 ?- k& N
60.     I2C2_Delay1us();
    # |" k, T8 ]" T. l5 k& [
61. }
    / V' N+ C% c* t# B/ I* m2 e7 V1 o
62. 
    : o: K% \& g$ v7 G
63. // IIC不发送ACK信号
    
64. void I2C2_NAck(void)
    # g! O# T1 {+ t5 i
65. {
    7 m: ?5 c0 X6 K1 P" q+ n2 z
66.     Pin_SCL_L;
    ' N9 x4 y0 W4 o& r9 n3 A, P$ |
67.     I2C2_Delay1us();        
    
68.     Pin_SDA_H;
    7 E* W( p  c0 F- B* E: o7 y( F9 W
69.     Pin_SCL_H;
    5 |) z! }* v3 ?7 {$ F1 Z$ B" q
70.     I2C2_Delay1us();
    8 z7 n" H3 n) m3 {
71.     Pin_SCL_L;
    . e& d2 `( g4 m" I& t' u
72.     I2C2_Delay1us();
    
73. }
    
74. 
    
75. // IIC等待ACK信号
    
76. uint8_t I2C2_Wait_Ack(void)
    ! j. ?# L0 }1 w0 K0 T
77. {
    
78.     Pin_SCL_L;
    
79.     I2C2_Delay1us();        
    
80.     Pin_SDA_H;
    
81.     Pin_SCL_H;
    
82.     I2C2_Delay1us();        
    
83.     if(Read_SDA_Pin)
    2 Z& B9 v* u3 p9 R3 E6 R. b
84.     {
    
85.         Pin_SCL_L;
    , W; l- H, N" ?" b, b+ S
86.         I2C2_Delay1us();
      [) w0 K9 H# ^6 d8 h; e
87.         return false;
    
88.     }
    2 f( g, [; w8 h
89.     Pin_SCL_L;
    
90.     I2C2_Delay1us();
    
91.     return true;
    
92. }
    5 r0 d( B2 W6 ~& ]6 _7 g
93. 
    
94. // IIC发送一个字节
    " _& d; D; t$ G4 Y0 j
95. void I2C2_Send_Byte(uint8_t txd)
    
96. {
    
97.     for(uint8_t i=0; i<8; i++)
    0 m" h$ k) c1 b: ^( E* B- u
98.     {
    
99.         Pin_SCL_L;
    
100.         I2C2_Delay1us();
     $ g4 j7 q% t# V- P% G  K3 d
101.         if(txd & 0x80)
     
102.             Pin_SDA_H;
     
103.         else
     
104.             Pin_SDA_L;
     $ f' R& }0 J* s* R, k
105.             txd <<= 1;
     
106.             Pin_SCL_H;
     
107.             I2C2_Delay1us();
     
108.     }
     , b: R) m# z/ y! x: t; b- G
109. }
     , t3 x( E! B" o  @
110. 
     
111. // IIC读取一个字节
     4 q$ ^4 Z+ b, H/ H8 x5 ?: {/ `9 Y0 Q4 }
112. uint8_t        I2C2_Read_Byte(void)
     
113. {
     7 G! v- i: g6 k1 u7 k/ P. R' j
114.     uint8_t rxd = 0;
     
115.     for(uint8_t i=0; i<8; i++)
     
116.     {
     4 C; b% a4 h# ]
117.         rxd <<= 1;
     
118.         Pin_SCL_L;
     
119.         I2C2_Delay1us();
     
120.         Pin_SCL_H;        
     : R- y4 Z- z" W7 e% [, w
121.         I2C2_Delay1us();               
     
122.         if(Read_SDA_Pin)
     5 b* p( N  |9 e, ~+ T% a/ Y# J
123.         {
     
124.             rxd |= 0x01;
     
125.         }
     
126.     }
     9 g  W7 G' X, v8 c1 h
127.     return rxd;
     ! M' L+ n& K2 ?% U8 a! h0 ~
128. }
     & @" y0 I- V3 G: s8 l* q
129. 
     6 A9 W) s; _" W
130. // 向从机指定地址写数据
     ! ^- P1 m: i2 B* u( \
131. bool I2C_Write_REG(uint8_t SlaveAddress, uint8_t REG_Address,uint8_t REG_data)
     
132. {
     
133.     if(!I2C2_Start())                return false;
     # r$ X' d; z4 k/ ?  u
134.     I2C2_Send_Byte(SlaveAddress);
     2 `8 ], F% P: D1 B& R
135.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     " z! a( a" o- L
136.     I2C2_Send_Byte(REG_Address);
     ) x1 `$ v' ]2 i4 U7 D
137.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
138.     I2C2_Send_Byte(REG_data);
     
139.     if(!I2C2_Wait_Ack()) { I2C2_Stop(); return false;        }
     0 B* R  J% |8 L6 `5 O7 l
140.     if(!I2C2_Stop()) return false;
     ) M# L& d9 H% U7 X6 d: T
141.     return true;
     
142. }
     
143. 
     6 ^1 ?8 O  |' J' F
144. // 从设备中读取数据
     / t. k1 H1 `- j6 N( o
145. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address)
     ' I$ k2 R9 t' m8 ?
146. {
     ' n4 X+ }, I* z8 ~3 v
147.     uint8_t data;
     
148.     if(!I2C2_Start())        return false;
     " C; `# [! h1 x% i& x1 f/ c$ O# F8 g
149.     I2C2_Send_Byte(SlaveAddress);
     3 w1 B2 ?9 d4 h, x4 o9 x1 j: m
150.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     5 ?+ s" `# M) j& e6 I
151.     I2C2_Send_Byte(REG_Address);
     
152.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     ; b: N8 K; {) a- H+ y
153.     if(!I2C2_Start())        return false;
     ( z4 T! d% w$ ?) ?8 `/ m6 X
154.     I2C2_Send_Byte(SlaveAddress + 1);
     
155.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
156.     data = I2C2_Read_Byte();
     
157.     I2C2_NAck();
     ( @/ ^2 o' J6 A! i1 [
158.     if(!I2C2_Stop())        return false;        
     
159.     return data;
     5 A2 z- ]# _/ g7 l
160. }
     
161. 
     4 M4 b6 }$ l! x6 p- ?2 _
162. // 连续写N个字节
     
163. bool I2C2_Write_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     
164. {
     1 d# F1 N; X; s/ f5 o! A; Z& e
165.     if(!I2C2_Start())return false;
     
166.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     " e8 q9 h9 J/ v  a, v
167.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     $ w5 k( x/ Z6 W- I
168.     I2C2_Send_Byte(REG_Address);   
     
169.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
170.     for(uint16_t i=0; i<len; i++)
     
171.     {
     7 H5 ?" `1 |, k( B5 R( \3 N# Q5 @
172.         I2C2_Send_Byte(buf<i>);
     ! \0 I. e+ n$ H) I1 y  k
173.       </i>  if(i<len-1)
     9 ^8 S. A1 c5 v! B. L! I: F
174.         {
     : f6 ]! z3 b& g- C  v% K8 @) i- L
175.             if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
176.         }
     1 c  j) v, j$ V
177.     }
     
178.     I2C2_Stop();
     
179.     return true;
     
180. }
     
181. 
     
182. // 连续读N个字节
     
183. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     1 R/ M9 u1 r$ L) ~
184. {
     8 q- N! w8 P* D/ H( U0 I# Q% d
185.     if(!I2C2_Start())return false;
     ! w1 F: p$ W2 f' P3 M3 v2 Q
186.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     , s$ G8 L- Z+ [) h
187.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
       H# `$ L/ a. g5 b4 x9 @
188.     I2C2_Send_Byte(REG_Address);   
     ) f3 _  h3 T* z& C- o3 E
189.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
190.     if(!I2C2_Start())return false;
     
191.     I2C2_Send_Byte(SlaveAddress | 1); // 读操作
     ( T" Z3 Z1 p1 F, g, X1 H9 H
192.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
193.     for(uint16_t i=0; i<len; i++)
     0 x8 d: H6 V* X7 f& S  a
194.     {
     
195.         buf = I2C2_Read_Byte();
     ( k% j" [5 a/ P( x, G1 P3 J! G
196.         if(i<len-1)
     0 a6 L* ]# D" P% w, n7 y
197.         {
     & R  j  Z8 d4 c! x( P# f( z
198.             I2C2_Ack();
     ! W/ b( X1 `! M- |$ Q% R
199.         }
     
200.     }
     ! b, T. D0 o2 a: g6 G  `
201.     I2C2_NAck();
     
202.     I2C2_Stop();
     + \' ?) y: D# I9 [3 B
203.     return true;
     / F. a( G0 C- ~& t
204. }
     & t9 m8 J  ^( m* [8 Q& r5 t
205. 
     
206. // 检查设备地址
     
207. bool I2C2_CheckDevice(uint8_t SlaveAddress)
     3 u- j1 {0 n& d+ G, n' q6 Z4 {; q; E; l
208. {
     ) j( J) V8 [3 W+ W
209.     if(!I2C2_Start())        return false;
     
210.     I2C2_Send_Byte(SlaveAddress);
     $ ^+ u3 p! e# `! o( e
211.     if(!I2C2_Wait_Ack())
     2 A( Y* L- I1 n
212.     {
     1 |* s; z6 f7 D3 t2 c  J
213.         I2C2_Stop();
     
214.         return false;               
     
215.     }
     
216.     if(!I2C2_Stop())        return false;        
     % H0 ]$ l8 |  q* P! H' N2 a. ?
217.     return true;        
     8 H! y/ i9 P+ n8 p2 z: E$ Z5 D
218. }

复制代码

- Z# t4 F6 o) I; }bsp_soft_i2c.h程序如下：
3 L8 h# C2 z- p" c) I) T

1. #ifndef _BSP_SOFT_I2C_H_
   4 s8 A$ T; @9 R" ~! p/ \) }
2. #define _BSP_SOFT_I2C_H_
   
3. 
   
4. #include "stm32f0xx.h"
   
5. #include <stdbool.h>
   * x; F/ h% p" x
6. 
   4 Y# M1 P4 V4 Z# b7 W
7. // 定义内联延时函数        
     b  E( l3 e1 j% d
8. static inline void I2C2_Delay1us(void)
   , q! b9 f  U0 C7 y' i) b
9. {
   % f! b8 u  K9 |6 e3 v$ i
10.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    ! q: E$ f. g7 |: y7 o3 P( l0 X
11.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    * c  K' K8 q% G" k; O6 z
12.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    / S0 Z# A, L) R4 q
13.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    $ [* |9 m7 O$ u% l8 X. v
14.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    # b& `' v) a* l- T* k$ O' e
15.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();        
    
16. }        
    
17. 
    5 G; D$ O, N" q# P
18. 
    : @  E1 l3 u! m' r9 o% E5 C6 T9 u1 O
19. #define        I2C2_GPIOx  GPIOB
    1 ]: z3 Z# |' e- b: _2 P
20. #define Pin_SCL                GPIO_Pin_10
    ) ?0 M, N7 w" |$ Q3 W& A9 O& ^
21. #define Pin_SDA                GPIO_Pin_11
    : C& u/ o( T5 {! `, H; I3 z% y1 N
22. 
    
23. #define Pin_SCL_L                I2C2_GPIOx->ODR &= ~Pin_SCL
    + q2 J7 y9 C5 P6 t
24. #define Pin_SCL_H                I2C2_GPIOx->ODR |= Pin_SCL
    
25. 
    
26. #define Pin_SDA_L                I2C2_GPIOx->ODR &= ~Pin_SDA
    
27. #define Pin_SDA_H                I2C2_GPIOx->ODR |= Pin_SDA
      x, C. q- G' I  P" V
28. 
    ( R$ L& {* V7 u3 H+ D6 F( W1 ~% f
29. #define Read_SDA_Pin        I2C2_GPIOx->IDR & Pin_SDA
    
30. 
    ' F4 V2 [, f: a% |2 T! H' d7 ?
31. void I2C2_Soft_Init(void);                        
    
32. bool I2C2_Start(void);                                                
    
33. bool I2C2_Stop(void);                                          
    
34. void I2C2_Send_Byte(uint8_t txd);
    
35. uint8_t I2C2_Read_Byte(void);
    
36. uint8_t I2C2_Wait_Ack(void);                 
    
37. void I2C2_Ack(void);                                                        
    
38. void I2C2_NAck(void);                                                
    
39. 
    ! d% n, [4 q8 ?7 m$ m2 {
40. bool I2C2_Write_REG(uint8_t SlaveAddress,uint8_t REG_Address,uint8_t REG_data);
    
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);
    6 l0 l: y: I# R. P! s2 o  x
43. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len);
    ; m- k' ?, I3 S
44. bool I2C2_CheckDevice(uint8_t SlaveAddress);
    * _( T# U6 }+ H  R, [/ \9 O( D
45. #endif

复制代码

( r: s/ i" X. l6 ~. N