背景介绍
: m2 `( [% A6 l$ U0 ?2 x7 rI2C协议介绍
2 Z; y! I% y# W& |$ Q3 q' D; ]. \
I2C总线是由Philips公司开发的一种简单、双向二线制同步串行总线。它只需要两根线即可在连接于总线上的器件之间传送信息。
# U, k  b& u* l% p
I2C 总线在物理连接上非常简单，分别由SDA(串行数据线)和SCL(串行时钟线)及上拉电阻组成。通信原理是通过对SCL和SDA线高低电平时序的控制，来 产生I2C总线协议所需要的信号进行数据的传递。在总线空闲状态时，这两根线一般被上面所接的上拉电阻拉高，保持着高电平。

9 W3 F, z. r. G' B* |3 k7 f
/ M8 D7 C5 w9 g/ [6 U( R* u) O
5 U/ \8 A" t/ d- ]1 jI2C总线特征
8 Q5 v$ G9 h- Q$ X- e9 sI2C总线上的每一个设备都可以作为主设备或者从设备，而且每一个设备都会对应一个唯一的地址(可以从I2C器件的数据手册得知)，主从设备之间就通过这 个地址来确定与哪个器件进行通信，在通常的应用中，我们把CPU带I2C总线接口的模块作为主设备，把挂接在总线上的其他设备都作为从设备。

I2C总线上可挂接的设备数量受总线的最大电容400pF 限制，如果所挂接的是相同型号的器件，则还受器件地址位的限制。
) h; Q  ]4 S9 l3 C& G) u' W* A
5 a/ Q! [; E7 c" T* S0 i* P/ oI2C总线数据传输速率在标准模式下可达100kbit/s，快速模式下可达400kbit/s，高速模式下可达3.4Mbit/s。一般通过I2C总线接口可编程时钟来实现传输速率的调整，同时也跟所接的上拉电阻的阻值有关。

% o# Z, M% {4 v% S: s0 f. J1 a% rI2C总线上的主设备与从设备之间以字节(8位)为单位进行双向的数据传输。
/ ^7 J4 g+ }9 Y# g. N% R1 o
3 l" ^' x0 r4 ~2 fI2C总线协议
/ V0 r" p8 B/ o# q9 ?6 zI2C协议规定，总线上数据的传输必须以一个起始信号作为开始条件，以一个结束信号作为传输的停止条件。起始和结束信号总是由主设备产生。总线在空闲状态 时，SCL和SDA都保持着高电平，当SCL为高电平而SDA由高到低的跳变，表示产生一个起始条件；当SCL为高而SDA由低到高的跳变，表示产生一个 停止条件。在起始条件产生后，总线处于忙状态，由本次数据传输的主从设备独占，其他I2C器件无法访问总线；而在停止条件产生后，本次数据传输的主从设备 将释放总线，总线再次处于空闲状态。如图所示：

+ j7 j) }  T- l$ D1 W  g; z8 x
在了解起始条件和停止条件后，我们再来看看在这个过程中数据的传输是如何进行的。前面我们已经提到过，数据传输以字节为单位。主设备在SCL线上产生每个 时钟脉冲的过程中将在SDA线上传输一个数据位，当一个字节按数据位从高位到低位的顺序传输完后，紧接着从设备将拉低SDA线，回传给主设备一个应答位， 此时才认为一个字节真正的被传输完成。当然，并不是所有的字节传输都必须有一个应答位，比如：当从设备不能再接收主设备发送的数据时，从设备将回传一个否 定应答位。数据传输的过程如图所示：


( {" C2 }3 r1 {! a, J4 f# F
4 I: [* M/ D9 t; {: ]2 F在前面我们还提到过，I2C总线上的每一个设备都对应一个唯一的地址，主从设备之间的数据传输是建立在地址的基础上，也就是说，主设备在传输有效数据之前 要先指定从设备的地址，地址指定的过程和上面数据传输的过程一样，只不过大多数从设备的地址是7位的，然后协议规定再给地址添加一个最低位用来表示接下来 数据传输的方向，0表示主设备向从设备写数据，1表示主设备向从设备读数据。如图所示：
: r! @* j3 I5 _) f( d8 }



I2C总线操作
对I2C总线的操作实际就是主从设备之间的读写操作。大致可分为以下三种操作情况：
第一，主设备往从设备中写数据。数据传输格式如下：

- Y4 F( O$ G& C2 S7 r5 c9 W
9 c( T/ I, F8 N- J- G2 X% S
+ E( B) W. r& T4 O: L  Q9 a第二，主设备从从设备中读数据。数据传输格式如下：


! q3 R& u. W. \! C/ l2 _( Z
; W5 U: J+ J, g3 z0 w9 _7 b第三，主设备往从设备中写数据，然后重启起始条件，紧接着从从设备中读取数据；或者是主设备从从设备中读数据，然后重启起始条件，紧接着主设备往从设备中写数据。数据传输格式如下：

9 H5 e3 s' e. r# f
! ^  ]$ g$ r# i
第三种操作在单个主设备系统中，重复的开启起始条件机制要比用STOP终止传输后又再次开启总线更有效率。
, J2 F) `! I" U- ?! [
( t! \4 X( M6 a1 \4 o本套库的特点
; ]$ v2 M& |3 u0 T2 A1 S本套库的设计基于三个工程现实问题：
1.硬件I2C数量有限而且会影响代码的可移植性能；
2.I2C通常不会有很高的数据速度和使用频率；
* n6 v: K# |! N' \5 [- y; {3.不同的从机器件一般不会挂载在同一个总线上；

$ H5 j# l, }" D# b第一个问题决定了必要性。设计一套软件模拟I2C库函数可以使得I2C的使用不受数量的限制且可移植行更强。第二个问题决定了可行性。使用I2C总线的低速低频特性决定了使用软件直接操作单片机的GPIO模拟I2C协议不至于占用过多的单片机资源或者无法满足性能的要求。第三个问题决定了通用性。软件模拟的I2C库函数必须有一套机制可以通过分时复用的方式驱动多条总线。笔者编写的库函数较好的符合了上述三个特征，以下给出源码以供大家参考。

源码实现
注意，笔者的源码是基于STM32F407平台运行的，延时函数也是从它处调用。在移植本代码的时候应当注意与平台硬件相关部分(例如void I2C_Virtual_SetSDA_Out())以及延时函数(delay_us())的实现。

头文件
  ?- Z0 U- h, i! Q* r

1. #ifndef __I2C_H__
   3 T; c1 z4 i- o3 D! W+ w' t; G
2. #define __I2C_H__
   
3. 
   
4. #include "stm32f4xx.h"
   3 w5 W- t( [* X$ }7 F
5. #include "stm32f4xx_conf.h"
   
6. 
   
7. #ifdef I2C_VIRTUAL
   . N1 x9 Q3 M+ H" n
8. 
   
9. typedef struct
   
10. {
    
11.         char SclPort;
    $ g% c& G4 ~( [1 _( F; F
12.         uint8_t SclPin;
    
13.         char SdaPort;
    " M* K8 C" o* I+ f
14.         uint8_t SdaPin;
    
15. } I2CPort_Struct;
    " y, L. Q& K! B; }# p  p
16. 
    
17. typedef struct
    
18. {
    
19.         //I2C从机设备的端口
    
20.         I2CPort_Struct port;
    ) V  v- H) P5 O3 E0 g0 n
21.         /*
    
22.          * I2C设备的写地址 = I2C设备地址 << 1 + 0
    8 R9 `" |! t, h+ y$ O
23.          * I2C设备的读地址 = (I2C设备地址 << 1) + 1
    
24.          */
    
25.         //I2C从机设备地址（器件地址占7位，D7~D1）
    
26.         uint8_t address;
    
27.         //I2C从机设备读写状态（0：写，1：读）
    
28. //        uint8_t rwStatus;
    
29.         //I2C从机设备的状态（0：错误或不存在，1：正常）
    
30.         uint8_t devStatus;
    
31. } I2CDevice_Struct;
      I$ c  `! R. `% L' W% X
32. 
    4 x6 e. b& ]) J6 w
33. extern uint8_t I2C_Virtual_ack;
    + h4 }0 C9 E5 Y. k
34. 
    1 N4 q, i+ f9 g1 I& N
35. void I2C_Virtual_ConfigPort(char SDA_Port, uint8_t SDA_Pin, char SCL_Port, uint8_t SCL_Pin);
    
36. void I2C_Virtual_SwitchBus(char SDA_Port, uint8_t SDA_Pin, char SCL_Port, uint8_t SCL_Pin);
    ; I3 l% c3 S9 v# x1 V
37. void I2C_Virtual_SetSDA_Out(void);
    2 z2 h( N# V& F' t
38. void I2C_Virtual_SetSDA_In(void);
    : X) x( o$ h/ i3 ~2 L3 L6 B
39. void I2C_Virtual_Init(void);
    9 g: g9 r; x) S, i$ B
40. void I2C_Virtual_Start(void);
    5 m  q5 d% M) `! ]. U- {3 J
41. void I2C_Virtual_Stop(void);
    
42. uint8_t I2C_Virtual_SendByte(uint8_t c);
    # i$ {+ x1 e" X. G. I/ O
43. uint8_t I2C_Virtual_RcvByte(void);
    - h# d/ f4 m2 h- _; L) C- n2 X8 T2 g
44. void I2C_Virtual_Ack(void);
    ; s! w# C- ]7 W
45. void I2C_Virtual_NoAck(void);
    
46. void I2C_Virtual_WaitAck(uint16_t time);
    
47. 
    5 V, H! c# A! S  R, N% y2 H/ m
48. #endif
    
49. #endif
    7 D0 _  Z: ~$ T% N( l2 h) ^

复制代码

源文件
STM32F407平台
  U  N7 Z7 }* ?' K/ _

1. #include "i2c_virtual.h"
   # w! [" z0 c/ p' W
2. 
   8 g4 ~' z; f/ P3 k* @
3. #ifdef I2C_VIRTUAL
   6 L( j0 F' K; w2 V
4. 
   5 k6 ]4 q! Q* S7 V; m) q
5. static uint16_t I2C_Virtual_SDA_Pin;
   + n1 R1 P. z2 F8 p% U6 ^2 Q4 H
6. static GPIO_TypeDef *I2C_Virtual_SDA_Port;
   
7. static unsigned long *I2C_Virtual_SDA_OUT_Addr;
   
8. static unsigned long *I2C_Virtual_SDA_IN_Addr;
     ^0 k( c* ]3 d
9. static unsigned long *I2C_Virtual_SCL_OUT_Addr;
   
10. 
    7 q3 {- C7 v; c$ m; N  A
11. uint8_t I2C_Virtual_ack;        //应答标志位
    
12. 
    1 N0 T3 I. ]! g8 b
13. /**
    1 |+ _+ W7 M+ v9 H5 X: U4 k9 d
14. * @brief 配置模拟I2C的引脚端口。
    
15. *                 主要实现了MCU的GPIO端口配置，SDA需要配置为开漏输出，SCL需要配置为推挽输出。
    3 u) f+ {8 {- S4 u5 n
16. *                 此函数实现与硬件平台相关。
    
17. * @param SDA_Port: 'A'~'G'
    
18. * @param SDA_Pin: 0~15
    
19. * @param SCL_Port: 'A'~'G'
    
20. * @param SCL_Pin: 0~15
    
21. */
    
22. void I2C_Virtual_ConfigPort(char SDA_Port, uint8_t SDA_Pin, char SCL_Port, uint8_t SCL_Pin)
    2 h3 n# c  d- c' Q4 c
23. {
    
24.         uint16_t I2C_Virtual_SDA_Pin;
    2 K& H. h$ S& E2 }! Y) m& y2 R
25.         uint16_t I2C_Virtual_SCL_Pin;
    
26.         GPIO_TypeDef *I2C_Virtual_SDA_Port;
    
27.         GPIO_TypeDef *I2C_Virtual_SCL_Port;
    % j. V# {3 t! G+ `1 R
28.         GPIO_InitTypeDef GPIO_InitStructure;
    
29. 
    
30.         switch (SDA_Port)
    7 Y3 L# D' f  k  l5 n2 b
31.         {
    
32.         case 'A':
      c# G( O& }9 o/ d) F
33.                 I2C_Virtual_SDA_Port = GPIOA;
    0 g- n( g% D- j# F* @4 K2 f
34.                 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);
    
35.                 break;
    
36.         case 'B':
    6 m! z' E- j% N9 U
37.                 I2C_Virtual_SDA_Port = GPIOB;
      H: G* j5 X+ D# j) X& W# ?
38.                 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE);
    
39.                 break;
    . p0 c$ ~7 l, L  Q5 A  ~1 ]9 L' `
40.         case 'C':
    " e. `' E$ D+ z' y" o
41.                 I2C_Virtual_SDA_Port = GPIOC;
    & u! F! e6 [! F9 V" T$ ?7 E. E. d
42.                 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC,ENABLE);
    % u3 M0 [0 ~' e6 c. j7 y! Y6 S
43.                 break;
    * M! Z; g  z/ J8 Q/ @+ P
44.         case 'D':
    
45.                 I2C_Virtual_SDA_Port = GPIOD;
    
46.                 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD,ENABLE);
      ^. |, Q+ \7 t4 B- }/ h  A. l% _. k* h" O
47.                 break;
    1 S6 ?; c' Z; e6 x" O
48.         case 'E':
    
49.                 I2C_Virtual_SDA_Port = GPIOE;
    
50.                 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE,ENABLE);
    
51.                 break;
    
52.         case 'F':
    # |  o4 L9 C, s
53.                 I2C_Virtual_SDA_Port = GPIOF;
    
54.                 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF,ENABLE);
    
55.                 break;
    . V1 z* b3 p0 K) n1 q+ i. X
56.         case 'G':
    
57.                 I2C_Virtual_SDA_Port = GPIOG;
    ' T: d& h' z2 X
58.                 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG,ENABLE);
    
59.                 break;
    8 V( {- C/ ?+ s: }: {% l' @0 `
60.         default:
    / A3 p% u( K! ^& j
61.                 break;
    
62.         }
    
63. 
    4 o0 e7 j  V( Q. g& V: o
64.         I2C_Virtual_SDA_Pin = (uint16_t) (0x0001 << SDA_Pin);
    
65. 
    ' T6 w  f9 m; J  x
66.         switch (SCL_Port)
    
67.         {
    3 x: }3 l  \3 m9 H$ k& z
68.         case 'A':
    8 m- ~; J. B; C* W
69.                         I2C_Virtual_SCL_Port = GPIOA;
    
70.                         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);
    
71.                         break;
    9 I/ W- Y4 c$ C, D+ f8 J. N; J+ ~$ V
72.                 case 'B':
    
73.                         I2C_Virtual_SCL_Port = GPIOB;
    " l. B4 z! X$ n' T( L; N0 ~
74.                         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE);
    
75.                         break;
    7 p7 j- D3 \4 E- p
76.                 case 'C':
    
77.                         I2C_Virtual_SCL_Port = GPIOC;
    ; ?. Z. a( w' p: f; s. Q
78.                         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC,ENABLE);
    ! p/ ?+ P' W' }3 t* o2 w, ^
79.                         break;
    2 K: c1 O  d( y7 o" W" `5 j  X
80.                 case 'D':
    
81.                         I2C_Virtual_SCL_Port = GPIOD;
    
82.                         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD,ENABLE);
    
83.                         break;
    , V  {( F) m5 u6 g
84.                 case 'E':
    
85.                         I2C_Virtual_SCL_Port = GPIOE;
    . D4 z. |5 {" X* R
86.                         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE,ENABLE);
    
87.                         break;
    7 T2 Q6 i- |5 p; s# B3 z
88.                 case 'F':
    
89.                         I2C_Virtual_SCL_Port = GPIOF;
    3 E* ~6 L$ |4 O3 I; I
90.                         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF,ENABLE);
    % w# V) {" T* Q% \" j; D
91.                         break;
    
92.                 case 'G':
    ! `3 a' J! K7 `! c) W% y
93.                         I2C_Virtual_SCL_Port = GPIOG;
    , m" M7 p7 Q9 r; U, c" U3 n: @
94.                         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG,ENABLE);
    
95.                         break;
    3 [% q  V5 V) a2 T7 P* ?
96.                 default:
    
97.                         break;
    
98.         }
    
99. 
    
100.         I2C_Virtual_SCL_Pin = (uint16_t) (0x0001 << SCL_Pin);
     
101. 
     9 H' v/ P1 g1 x8 e) ^
102.         GPIO_InitStructure.GPIO_Pin = I2C_Virtual_SDA_Pin;
     ) a9 |% N( T, g+ W% \
103.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
     
104.         GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
     ; l5 d/ g% F) l/ |
105.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
     
106.         GPIO_Init(I2C_Virtual_SDA_Port, &GPIO_InitStructure);
     & b" @) K+ `, I0 I
107. 
     
108.         GPIO_InitStructure.GPIO_Pin = I2C_Virtual_SCL_Pin;
     9 t5 k7 R% o0 j4 o6 ?8 f2 y
109.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
     
110.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
     $ K) c9 o8 T. Y& L. o+ b# {& _4 }& Y
111.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
     
112.         GPIO_Init(I2C_Virtual_SCL_Port, &GPIO_InitStructure);
     
113. }
     
114. 
     0 E6 b+ H+ S* `3 Z$ Q) h3 e) r: q# t
115. /**
     7 y( C# r% s' `0 \/ Z
116. * @brief 使本套库函数可以支持多个独立的软件模拟I2C总线。
     
117. *                 通过切换I2C总线引脚，以分别控制不同的芯片。
     & W4 @4 X; u8 O2 [# |
118. *                 一般在配置模拟I2C的引脚端口之后，需要调用此函数设置总线。
     2 R7 |6 i) O; o: O8 Q1 f3 |7 R
119. * @param SDA_Port: 'A'~'G'
     
120. * @param SDA_Pin: 0~15
     
121. * @param SCL_Port: 'A'~'G'
     
122. * @param SCL_Pin: 0~15
     - F3 j  A/ p% |6 z
123. */
     
124. void I2C_Virtual_SwitchBus(char SDA_Port, uint8_t SDA_Pin, char SCL_Port, uint8_t SCL_Pin)
     . t& U' T3 p% F4 Z. r* e
125. {
     1 x  z2 c$ [  t% s/ z2 F+ i
126. 
     
127.         switch (SDA_Port)
     
128.         {
     - I2 `& }4 f7 v$ a2 r
129.         case 'A':
       q2 J' l6 ]  T' S/ k" K
130.                 I2C_Virtual_SDA_Port = GPIOA;
     2 P" B0 _8 T6 V5 c" b% S. `
131.                 I2C_Virtual_SDA_OUT_Addr = GPIOA_OUT_ADDR(SDA_Pin);
     5 W" x" N" g3 `
132.                 I2C_Virtual_SDA_IN_Addr = GPIOA_IN_ADDR(SDA_Pin);
     
133.                 break;
     * z* ~) ]- L1 F+ A$ R. b% z1 u1 y# o
134.         case 'B':
     ' Q' P! j1 W0 b: S
135.                 I2C_Virtual_SDA_Port = GPIOB;
     
136.                 I2C_Virtual_SDA_OUT_Addr = GPIOB_OUT_ADDR(SDA_Pin);
     ) p+ o' G' P! w
137.                 I2C_Virtual_SDA_IN_Addr = GPIOB_IN_ADDR(SDA_Pin);
     
138.                 break;
     
139.         case 'C':
     " S% B7 g2 v/ W7 Q0 E3 ~' _! W4 ^
140.                 I2C_Virtual_SDA_Port = GPIOC;
     
141.                 I2C_Virtual_SDA_OUT_Addr = GPIOC_OUT_ADDR(SDA_Pin);
     ; \' l8 k$ U4 P
142.                 I2C_Virtual_SDA_IN_Addr = GPIOC_IN_ADDR(SDA_Pin);
     
143.                 break;
     
144.         case 'D':
     
145.                 I2C_Virtual_SDA_Port = GPIOD;
     
146.                 I2C_Virtual_SDA_OUT_Addr = GPIOD_OUT_ADDR(SDA_Pin);
     % T' D4 ~* M5 f$ ]( z% {
147.                 I2C_Virtual_SDA_IN_Addr = GPIOD_IN_ADDR(SDA_Pin);
     
148.                 break;
     
149.         case 'E':
     9 n4 ~2 ?1 u! b% }4 L
150.                 I2C_Virtual_SDA_Port = GPIOE;
     
151.                 I2C_Virtual_SDA_OUT_Addr = GPIOE_OUT_ADDR(SDA_Pin);
     
152.                 I2C_Virtual_SDA_IN_Addr = GPIOE_IN_ADDR(SDA_Pin);
     
153.                 break;
     / [6 w4 S2 R. ?0 z) P
154.         case 'F':
     2 r4 ~: Y8 b% M7 Y
155.                 I2C_Virtual_SDA_Port = GPIOF;
     
156.                 I2C_Virtual_SDA_OUT_Addr = GPIOF_OUT_ADDR(SDA_Pin);
     
157.                 I2C_Virtual_SDA_IN_Addr = GPIOF_IN_ADDR(SDA_Pin);
     
158.                 break;
     & T2 j/ r% e/ B' V) H8 _
159.         case 'G':
     
160.                 I2C_Virtual_SDA_Port = GPIOG;
     
161.                 I2C_Virtual_SDA_OUT_Addr = GPIOG_OUT_ADDR(SDA_Pin);
     
162.                 I2C_Virtual_SDA_IN_Addr = GPIOG_IN_ADDR(SDA_Pin);
     
163.                 break;
     
164.         default:
     
165.                 break;
     
166.         }
     " h+ g8 `/ x- ]
167. 
     : y$ d5 o+ r0 ]9 k/ q5 U* w6 d) O
168.         I2C_Virtual_SDA_Pin = (uint16_t) (0x0001 << SDA_Pin);
     
169. 
     7 P+ k, k1 g# R+ C
170.         switch (SCL_Port)
     # L$ f+ M7 C8 _  |* n9 k' s* c
171.         {
     % j! M6 L: A9 g9 G
172.         case 'A':
     $ t; _: f4 o. A1 A9 _
173.                 I2C_Virtual_SCL_OUT_Addr = GPIOA_OUT_ADDR(SCL_Pin);
     7 r) g& w2 D7 n! \/ r& h. [
174.                 break;
     " {$ C5 m) F* @; I4 m, h2 h8 r6 X
175.         case 'B':
     : `4 `/ i, I, H. t
176.                 I2C_Virtual_SCL_OUT_Addr = GPIOB_OUT_ADDR(SCL_Pin);
     : t* V% g% D0 B' F% O4 ]5 R- b+ Z
177.                 break;
     
178.         case 'C':
     
179.                 I2C_Virtual_SCL_OUT_Addr = GPIOC_OUT_ADDR(SCL_Pin);
     
180.                 break;
     
181.         case 'D':
     
182.                 I2C_Virtual_SCL_OUT_Addr = GPIOD_OUT_ADDR(SCL_Pin);
     
183.                 break;
     
184.         case 'E':
     
185.                 I2C_Virtual_SCL_OUT_Addr = GPIOE_OUT_ADDR(SCL_Pin);
     
186.                 break;
     ; ]+ \% ^* E  G( `7 B( R
187.         case 'F':
     
188.                 I2C_Virtual_SCL_OUT_Addr = GPIOF_OUT_ADDR(SCL_Pin);
     ( D4 p6 V0 T: V6 T2 H6 t( J4 L5 f2 v
189.                 break;
     ( w) j# f/ f- ], D! E, B8 i
190.         case 'G':
     
191.                 I2C_Virtual_SCL_OUT_Addr = GPIOG_OUT_ADDR(SCL_Pin);
     
192.                 break;
     
193.         default:
     3 T5 c4 E# w7 |( V
194.                 break;
     ( x; Y; {  N0 d4 l
195.         }
     " O  `! l( f+ E. I% X
196. }
     8 ?7 G3 D4 K( d4 l* _7 {3 k( J
197. 
     " R. V$ A1 e- U" T9 u& A# J
198. 
     
199. 
       u" g6 o+ f, }5 K7 _7 ~
200. /**
     / P4 s% p0 s2 G& N  b: G
201. * @brief Switch data bus input/output state.
     * ~( p: R9 O9 U
202. */
     : J$ s" v( V6 W, N' l
203. void I2C_Virtual_SetSDA_Out(void)
     
204. {
     ; |" c5 {+ M. Z0 r( ?
205.         GPIO_InitTypeDef GPIO_InitStructure;
     
206. 
     9 g' m$ \  M8 [8 d+ k0 R7 U) ?' Z. Q
207.         GPIO_InitStructure.GPIO_Pin = I2C_Virtual_SDA_Pin;
     
208.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
     
209.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     % j" Q6 R& q' ^% F) Q
210.         GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
     + N6 ]* i1 k5 c
211.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
     
212. 
     
213.         GPIO_Init(I2C_Virtual_SDA_Port, &GPIO_InitStructure);
     7 L1 u4 A- Y# r# |
214. }
     1 f5 D/ u0 C! Z! |2 m3 S7 x
215. 
     
216. 
     
217. 
     
218. /**
     6 K& i2 C+ c* i
219. * @brief Switch data bus input/output state.
     0 [4 E* Z& R2 P% q3 G( d# ?
220. */
     ( X( s' ~( H& Z" d. B
221. void I2C_Virtual_SetSDA_In(void)
     
222. {
     " B# S  C- n. q1 ^  |
223.         GPIO_InitTypeDef GPIO_InitStructure;
     ! m% P8 X( x( R/ p, s2 T$ [& p
224. 
     
225.         GPIO_InitStructure.GPIO_Pin = I2C_Virtual_SDA_Pin;
     
226.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
     
227.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     9 \* h. l" }7 r8 ^% J/ b( G4 M
228.         GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
     " M( G/ s' @( C; o
229.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
     
230. 
     
231.         GPIO_Init(I2C_Virtual_SDA_Port, &GPIO_InitStructure);
     / Y6 t& d, g. A) D5 V7 V+ y
232. }
     ' N' X+ [8 b$ _
233. 
     
234. 
     
235. /**
     * P* M7 G2 b0 n5 K6 ?. m! b
236. * @brief Initialization of the virtual I2C.
     " L' J# z* q( r; w
237. */
     % h' @0 K8 V6 Q
238. void I2C_Virtual_Init(void)
     
239. {
     $ x: f. p+ L# _; e
240.         *I2C_Virtual_SCL_OUT_Addr = 1;
     
241.         
     
242.         I2C_Virtual_SetSDA_Out();
     7 [  W$ v0 U; [3 z4 c1 ]! a. c( v9 A
243.         *I2C_Virtual_SDA_OUT_Addr = 1;
     3 F0 y, ]+ m" r& n
244. }
     
245. 
     
246. 
       J, V* c( {+ c9 L/ d
247. 
     + _$ t+ D/ T; @6 f7 n
248. /**
     
249. * @brief Start I2C.
     
250. */
     
251. void I2C_Virtual_Start()
     
252. {
     
253.         *I2C_Virtual_SDA_OUT_Addr = 1;                        //发送起始条件的数据信号
     
254.         delay_us(1);
     5 |: \) [! |; j6 H' W8 J
255. 
     
256.         *I2C_Virtual_SCL_OUT_Addr = 1;
     
257.         delay_us(10);                                                                                //起始条件建立时间大于4.7us,延时
     
258. 
     
259.         *I2C_Virtual_SDA_OUT_Addr = 0;                //发送起始信号
     
260.         delay_us(10);                                                                                //起始条件锁定时间大于4μ
     
261. 
     : U6 [0 K" O# U$ ?6 W
262.         *I2C_Virtual_SCL_OUT_Addr = 0;                        //钳住I2C总线，准备发送或接收数据
     
263.         delay_us(2);
     8 j/ C. b  U6 m0 Q* v+ I' P& X
264. }
       {5 Y' ]  a. z% i; v3 v
265. 
     
266. 
     
267. 
     ' P- T# e) R0 ]* q
268. /**
     # v, q* s6 O# U% n2 J: j4 D
269. * @brief Stop I2C.
     
270. */
     
271. void I2C_Virtual_Stop()
     & H' l0 z( \1 |* K# M
272. {
     
273.         *I2C_Virtual_SCL_OUT_Addr = 0;
     " ]$ {# K9 w1 S7 N
274.         delay_us(2);
     2 b9 ]5 N  |, Y2 h8 K
275. 
     
276.         *I2C_Virtual_SDA_OUT_Addr = 0;        //发送结束条件的数据信号
     
277.         delay_us(1);
     + u" \2 L  P9 G6 X) a
278. 
     " v6 f- _8 V, u* r2 U
279.         *I2C_Virtual_SCL_OUT_Addr = 1;                //发送结束条件的时钟信号
     ; v3 m8 u3 ?& ?3 U
280.         delay_us(10);                                                                        //结束条件建立时间大于4μ
     1 A/ f% e- S5 d+ r( L. b
281. 
     
282.         *I2C_Virtual_SDA_OUT_Addr = 1;                //发送I2C总线结束信号
     9 K6 O  m6 P$ V# e) {- ?7 N
283.         delay_us(10);
     . C' q' V9 k7 ^8 A  z
284. }
     
285. 
     . M# p  P% U& }2 K+ `
286. 
     , t$ t  g0 }& d! Z5 m
287. 
     
288. /**
     
289. * @brief 主机字节数据发送函数
     - c' y  Y8 m9 Y5 _1 k; O) E
290. *                 将数据c发送出去,可以是地址,也可以是数据,发完后等待应答,
     
291. *                 并对此状态位进行操作.(不应答或非应答都使ack=0 假)
     3 n" b, c, K' f8 S: I" k; w
292. *                 发送数据正常，ack=1; ack=0表示被控器无应答或损坏。
     
293. * @retval 应答位
     ; V- y5 D$ O  F! v' a, c9 [7 {
294. *                 @arg 0:有应答
     
295. *                 @arg 1:无应答
     
296. */
     
297. uint8_t I2C_Virtual_SendByte(uint8_t c)
     4 Q" t- }- c- S$ V
298. {
     
299.         for (uint8_t BitCnt = 0; BitCnt < 8; BitCnt++)        //要传送的数据长度为8位
     
300.         {
     . R' O* }" |. H, y* \
301.                 if ((c << BitCnt) & 0x80)        //判断发送位
     
302.                         *I2C_Virtual_SDA_OUT_Addr = 1;
     8 L% W  K, Z) Y& F
303.                 else
     - t) N' n& I6 J8 l  a9 u) Y; W
304.                         *I2C_Virtual_SDA_OUT_Addr = 0;
     
305. 
     
306.                 delay_us(1);
     
307. 
     ! k' [5 y7 W! i0 Z
308.                 *I2C_Virtual_SCL_OUT_Addr = 1;        //置时钟线为高，通知被控器开始接收数据位
     
309.                 delay_us(10);        //保证时钟高电平周期大于4μ
     
310. 
     
311.                 *I2C_Virtual_SCL_OUT_Addr = 0;
     3 \6 R* d8 M; F" a2 S2 S
312.         }
     
313. 
     
314.         I2C_Virtual_WaitAck(1000);
     $ L+ {% r4 @' l) e& `0 h
315.         
     
316.         return I2C_Virtual_ack;
     
317. }
     
318. 
     / y# ?  L4 b0 c
319. 
     
320. 
     1 }5 X$ Y% g. J, U* K: e+ ~( k
321. /**
     * |7 e" I9 F- ?# f1 Z: V
322. * @brief 主机字节数据接收函数
     ) E% ?9 Z+ F9 F3 M4 i
323. *                 用来接收从器件传来的数据,并判断总线错误(不发应答信号)，
     * G7 B. I* [# b7 @# \* X3 t
324. *                 发完后请用应答函数。
     / x9 U) t1 `! _. `$ v- O
325. */
     ( J) O2 j3 P$ _. a' S
326. uint8_t I2C_Virtual_RcvByte()
     ! w- h& Y- d+ S! U3 x1 Z
327. {
     1 H* C5 e  U- v( B% M0 R
328.         uint8_t retc;
     
329.         uint8_t BitCnt;
     . \# Y" x+ C6 C
330. 
     3 O9 R. H. H% L3 V  ?8 U0 J7 ~
331.         retc = 0;
     / x% \1 l8 R- ?( I1 f
332. 
     
333.         *I2C_Virtual_SDA_OUT_Addr = 1;        //置数据线为输入方式
     & f4 C4 j% @6 b! W2 t* x
334. 
     
335.         for (BitCnt = 0; BitCnt < 8; BitCnt++)
     
336.         {
     
337.                 delay_us(1);
     . n5 P6 x0 h$ N4 ^$ y, u
338.                 *I2C_Virtual_SCL_OUT_Addr = 0;        //置时钟线为低，准备接收数据位
     6 T/ v9 i) E  u: b" N
339.                 delay_us(10);        //时钟低电平周期大于4.7us
     
340.                 *I2C_Virtual_SCL_OUT_Addr = 1;        //置时钟线为高使数据线上数据有效
     * R, a. V5 r/ T* n
341.                 //delay1us();
     
342.                 retc = retc << 1;
       Y. b1 A$ _  ]! @
343.                 I2C_Virtual_SetSDA_In();
     
344. 
     . Z2 j- e$ Y7 `# \+ i0 Y1 H
345.                 if (*I2C_Virtual_SDA_IN_Addr == 1)
     : U) U/ U% I! E
346.                         retc = retc + 1;        //读数据位,接收的数据位放入retc中
     
347. 
     
348.                 I2C_Virtual_SetSDA_Out();
     7 G$ ~3 m" _, x; W
349.                 delay_us(1);
     8 C" [. v" t  B6 \9 z& Z+ a
350.         }
     0 |& l5 `9 i  P# ^$ y
351. 
     ; `. |7 j. j: p) m1 D2 k! A5 q
352.         *I2C_Virtual_SCL_OUT_Addr = 0;
     0 R* ]5 V& ]+ t% X. ]! S7 v
353.         delay_us(2);
     
354. 
     
355.         return (retc);
     8 w' ]: ^0 P' X9 k
356. }
     
357. 
     
358. 
     
359. 
     6 O2 Y' ?; c6 W; H3 p1 V! c
360. /**
     0 [( [& S* y% d$ J/ t% ~
361. * @brief 主机应答函数
     . u# L/ z0 s3 S; a% |; b1 s( E
362. */
     1 i( \/ I. t8 U+ l; t" N
363. void I2C_Virtual_Ack(void)
     6 @$ w( G" s! k
364. {
     % o- v. p2 y: g# c1 O1 w" }
365.         *I2C_Virtual_SDA_OUT_Addr = 0;
     ( h, p0 V4 z, ?, n. L
366.         delay_us(2);
     0 }3 b7 l. m8 {# g2 L
367. 
     8 @$ a& z2 M/ G! ~1 N$ x
368.         *I2C_Virtual_SCL_OUT_Addr = 1;
     
369.         delay_us(10);        //时钟低电平周期大于4μ
     
370. 
     
371.         *I2C_Virtual_SCL_OUT_Addr = 0;          //清时钟线，钳住I2C总线以便继续接收
     ' A  t! m+ c9 O1 i/ M5 R
372.         delay_us(2);
     
373. }
     & k! s$ I5 \: E  v$ M$ F
374. 
     # R; C" A% s5 l* [
375. 
     2 g8 y* n5 F3 W+ |8 W
376. 
     
377. /**
     ) e; e# l/ ], x+ T
378. * @brief 主机不应答函数
     ( l4 [0 w: h5 v5 o+ }9 F
379. */
     ) Q' ?. J6 X2 k( l3 ]& W
380. void I2C_Virtual_NoAck(void)
     
381. {
     % _) ?1 L. U  E( b
382.         *I2C_Virtual_SDA_OUT_Addr = 1;
     0 f4 j8 f! X& d( |5 N
383.         delay_us(1);
     
384. 
     
385.         *I2C_Virtual_SCL_OUT_Addr = 1;
     
386.         delay_us(10);        //时钟低电平周期大于4μ
     0 |0 e2 A( o8 X
387. 
     
388.         *I2C_Virtual_SCL_OUT_Addr = 0;            //清时钟线，钳住I2C总线以便继续接收
     
389.         delay_us(2);
     6 B1 n" l* J$ z+ m* g0 A1 g5 d
390. }
     + j1 N9 M" _9 z
391. 
     - j& q2 |5 C! G- t
392. 
     
393. /**
     
394. * @brief 主机等待应答函数
     
395. * @param time: wait for timeout
     
396. */
     % E0 s' F" r5 ?
397. void I2C_Virtual_WaitAck(uint16_t time)
     / _2 m2 [" U; z9 p7 D
398. {
     
399.         uint16_t timeout = 0;
     
400. 
     % w- d, H  E, q9 ?  d% t
401.         *I2C_Virtual_SDA_OUT_Addr = 1;        //8位发送完后释放数据线，准备接收应答位
     
402.         I2C_Virtual_SetSDA_In();
     
403. 
     
404.         *I2C_Virtual_SCL_OUT_Addr = 1;
     
405. 
     
406.         delay_us(1);
     0 I& e" A. P' l4 U; z% x
407. 
     ( y) r4 o- h" ~3 s4 X0 o0 F6 j
408.         while(*I2C_Virtual_SDA_IN_Addr != 0)
     
409.         {
     0 |8 l: z' m8 i% j
410.                 if(timeout++>time)
     
411.                 {
     " h' P( ?9 C& W2 z/ N/ }6 B
412.                         I2C_Virtual_ack = 0;
     + ?3 O4 H, g/ Z& n5 a  U1 ^  j
413.                         
     
414.                         I2C_Virtual_SetSDA_Out();
     ' q* [1 c; g0 |) A
415.                         I2C_Virtual_Stop();
     
416. 
     
417.                         return;
     & V/ F: P; C8 N# ^/ c7 H, I
418.                 }
     . w6 e% l$ P4 a" ?! [
419.         }
     
420. 
     
421.         I2C_Virtual_ack = 1;
     
422. 
     5 ~5 c* V0 q7 O- n" ]
423.         I2C_Virtual_SetSDA_Out();
     
424.         *I2C_Virtual_SCL_OUT_Addr = 0;
     
425. 
     
426.         delay_us(2);
     , @! E3 j8 H4 c
427. }
     
428. 
     
429. #endif
     

复制代码

* b3 I# M  K( L% |# K, KSTM32F103平台
平台的不同影响了void I2C_Virtual_ConfigPort(char SDA_Port, uint8_t SDA_Pin, char SCL_Port, uint8_t SCL_Pin), void I2C_Virtual_SetSDA_Out(void),void I2C_Virtual_SetSDA_In(void)这三个与底层硬件相关的函数。

) P- J2 h0 ]  h" Y0 z8 H

1. /**
   
2. * @brief 配置模拟I2C的引脚端口。
   # [  |5 j/ t. z" w3 i( A
3. *                 主要实现了MCU的GPIO端口配置，SDA需要配置为开漏输出，SCL需要配置为推挽输出。
   
4. *                 此函数实现与硬件平台相关。
   . F! _/ b7 E) N( X
5. * @param SDA_Port: 'A'~'G'
   
6. * @param SDA_Pin: 0~15
   : M) W' Y+ X4 v8 p$ N* @- _
7. * @param SCL_Port: 'A'~'G'
   
8. * @param SCL_Pin: 0~15
   8 t$ a4 y) U  }1 j: R
9. */
   
10. void I2C_Virtual_ConfigPort(char SDA_Port, uint8_t SDA_Pin, char SCL_Port, uint8_t SCL_Pin)
    
11. {
    
12.         uint16_t I2C_Virtual_SDA_Pin;
    
13.         uint16_t I2C_Virtual_SCL_Pin;
    
14.         GPIO_TypeDef *I2C_Virtual_SDA_Port;
    
15.         GPIO_TypeDef *I2C_Virtual_SCL_Port;
    1 x- T* a$ W2 b
16.         GPIO_InitTypeDef GPIO_InitStructure;
    
17. 
    
18.         switch (SDA_Port)
    
19.         {
    ( w0 t' d2 e% c! S2 [) }
20.         case 'A':
    9 m: |2 v! X) Q1 {/ U0 V
21.                 I2C_Virtual_SDA_Port = GPIOA;
    * m5 ?- [/ G# }. d7 `
22.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    % b0 A! P/ W) [$ i$ |9 O* h% y8 T
23.                 break;
    & t2 y* C; N$ A/ y; ~
24.         case 'B':
    . \$ G/ \* P, q6 m6 l# V
25.                 I2C_Virtual_SDA_Port = GPIOB;
    ; Y, A, q& S0 `, t! @
26.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    * n) }% m" P. Z6 s
27.                 break;
    ; o& @; ?; m; M  y. ?  M5 ]) N
28.         case 'C':
    
29.                 I2C_Virtual_SDA_Port = GPIOC;
    
30.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
    1 O' g& o! x- c! h. ?
31.                 break;
    9 i) a4 @- d- V2 `1 Q$ q
32.         case 'D':
    " D" j3 f" f7 Y( x7 [
33.                 I2C_Virtual_SDA_Port = GPIOD;
      F+ G1 [( S7 r! d
34.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
    5 k3 E& d) w! h5 {8 Z/ ?
35.                 break;
    
36.         case 'E':
    
37.                 I2C_Virtual_SDA_Port = GPIOE;
    2 X9 }+ i- ^9 R
38.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    0 W' _' p. T9 f8 F6 i0 X- A% l
39.                 break;
    
40.         case 'F':
    
41.                 I2C_Virtual_SDA_Port = GPIOF;
    + R" n! f8 \4 _; ~
42.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF,ENABLE);
    7 e( |9 e6 o, w1 c
43.                 break;
    ) p- n# p7 k  a- w; g
44.         case 'G':
    
45.                 I2C_Virtual_SDA_Port = GPIOG;
    
46.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG,ENABLE);
    
47.                 break;
    
48.         default:
    
49.                 break;
    
50.         }
    
51. 
    3 y- u* a- i+ t7 q0 o+ d8 Y
52.         I2C_Virtual_SDA_Pin = (uint16_t) (0x0001 << SDA_Pin);
    : U1 D; _8 I& h0 r& w# _: n% s0 F7 A
53. 
    / }. O( ?5 e1 C4 I
54.         switch (SCL_Port)
    : ]+ d/ r, }* f8 v
55.         {
    
56.         case 'A':
    
57.                 I2C_Virtual_SCL_Port = GPIOA;
    $ C7 F4 B5 g, u# v
58.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    % j) T* _  d+ T5 P% n# ^
59.                 break;
    
60.         case 'B':
    
61.                 I2C_Virtual_SCL_Port = GPIOB;
    
62.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    
63.                 break;
    3 U/ g8 y* `% s1 P( Y/ n
64.         case 'C':
    , q+ s0 W) \5 z! z
65.                 I2C_Virtual_SCL_Port = GPIOC;
    6 W' J: p# W* w$ n: F5 w0 {
66.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
    " ?9 |5 z0 {& E# F& j5 d$ |
67.                 break;
    
68.         case 'D':
    
69.                 I2C_Virtual_SCL_Port = GPIOD;
    
70.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
    ; d! A8 d1 d+ w8 N( Y5 U/ K
71.                 break;
    , y1 d, D" f: Q' V* I7 e3 }, K8 I
72.         case 'E':
    
73.                 I2C_Virtual_SCL_Port = GPIOE;
    ( G' P  ^& f" ^# P- ]7 ~( ]
74.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    
75.                 break;
    
76.         case 'F':
    1 A: C+ Y  o# o# ?
77.                 I2C_Virtual_SCL_Port = GPIOF;
    
78.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF,ENABLE);
    
79.                 break;
    * @/ o% m% O9 A4 ~# D) o
80.         case 'G':
    
81.                 I2C_Virtual_SCL_Port = GPIOG;
    
82.                 RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOG,ENABLE);
    7 x" o3 S, M  l. Z0 k) u
83.                 break;
    
84.         default:
    
85.                 break;
    
86.         }
    
87. 
    1 R/ A4 I1 _+ i, t$ t
88.         I2C_Virtual_SCL_Pin = (uint16_t) (0x0001 << SCL_Pin);
    2 z5 d$ ^# o5 n7 H8 u7 Q4 O* p
89. 
      x/ W0 G$ P3 J1 k
90.         GPIO_InitStructure.GPIO_Pin = I2C_Virtual_SDA_Pin;
    
91.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
    
92.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
93.         GPIO_Init(I2C_Virtual_SDA_Port, &GPIO_InitStructure);
    
94. 
    ) S, Z# A! g+ K1 R- D
95.         GPIO_InitStructure.GPIO_Pin = I2C_Virtual_SCL_Pin;
    
96.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
97.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
98.         GPIO_Init(I2C_Virtual_SCL_Port, &GPIO_InitStructure);
    
99. }
    9 {6 ]4 s" m8 j5 D, X
100. 
     
101. 
     - u: u! X- @. \1 P- }$ ?" N
102. 
     ( j; _2 w+ k8 l$ b9 M5 {1 u$ M
103. /**
     
104. * @brief Switch data bus input/output state.
     5 r+ A  e0 M1 B  Y, \
105. */
     7 L8 k* x/ i6 C( ?" I! _+ G
106. void I2C_Virtual_SetSDA_Out(void)
     6 o: l6 l( p$ x  e' G0 P! E
107. {
     
108.         GPIO_InitTypeDef GPIO_InitStructure;
     
109. 
     
110.         GPIO_InitStructure.GPIO_Pin = I2C_Virtual_SDA_Pin;
     
111.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     
112.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
     % E  }1 Y: L/ V9 n5 Y( i" n  d3 m
113. 
     : B, l# O- ]. }8 d
114.         GPIO_Init(I2C_Virtual_SDA_Port, &GPIO_InitStructure);
     
115. }
     * }; k0 u# w) J. O5 r- E
116. 
     
117. 
     ' n3 h0 K$ Q/ W9 a4 V& Q
118. 
     
119. /**
     ; o$ n/ j  g$ _: i* o: g
120. * @brief Switch data bus input/output state.
     5 Y0 B+ N2 G9 q# ~1 j
121. */
     
122. void I2C_Virtual_SetSDA_In(void)
     
123. {
     ; d/ x' N# _$ N4 ]5 w
124.         GPIO_InitTypeDef GPIO_InitStructure;
     
125. 
     . w" c3 u: Q  \+ x
126.         GPIO_InitStructure.GPIO_Pin = I2C_Virtual_SDA_Pin;
     # c$ T9 z" K. h$ Y
127.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
     8 S& Q6 r. Y2 T3 E8 {, P
128.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     . V' C+ y/ y, s+ y- b5 n2 Q7 g2 w
129. 
     " [  u+ M; e) ~8 K  _3 {
130.         GPIO_Init(I2C_Virtual_SDA_Port, &GPIO_InitStructure);
     2 ?- Y1 r' b1 }" _
131. }

复制代码

应用指南
) `8 t% k, n9 G; x3 C$ d/ e$ K: U软件模拟I2C属于底层驱动类型的库，一般情况下不会直接使用，而是为各种芯片的库函数提供底层接口。本章节从框架结构上对软件模拟I2C库驱动多个不同总线上的芯片做一个简要说明。
2 Q0 E. D" k  S2 U( Z" J
首先应完成GPIO的初始化配置，SDA功能的GPIO配置为开漏输出（总线要上拉）、SCL功能的GPIO配置为推挽或者开漏输出。此处以STM32F103单片机为例：

1. /**
   
2. * ADS1115 - SDA: PB0, SCL: PB1
   
3. */
   
4. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
   + X- I; t/ d( V3 `; m$ S
5. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   + d. V( k6 x0 `* _" z
6. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   
7. GPIO_Init(GPIOE, &GPIO_InitStructure);
   + b4 U" a+ A% l$ X- R
8. 
   
9. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
   
10. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
11. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
    
12. GPIO_Init(GPIOE, &GPIO_InitStructure);
    
13. 
    - U! s0 _7 ]! \* a# V
14. /**
    
15. * ADS1115 - SDA: PB2, SCL: PB3
    , n4 o& j- T; b( u
16. */
    ! R  V0 T* G+ q
17. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    
18. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    * Q+ E, q* E# q$ V! @4 r. A
19. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    : ?# N' N5 N! E# Q  k. I8 U- P
20. GPIO_Init(GPIOE, &GPIO_InitStructure);
    ; M5 u( |9 L+ p' A' m% a8 k  x
21. 
    3 E- @( D1 r% q
22. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    7 p& W& b/ O/ X/ ]: k
23. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
24. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
    8 E3 Y* f$ `: Y$ a
25. GPIO_Init(GPIOE, &GPIO_InitStructure);
      q% d( m5 }2 H: \" T" i9 b

复制代码

8 \  p: E  Q6 D9 P本库函数中内置了void I2C_Virtual_ConfigPort(char SDA_Port, uint8_t SDA_Pin, char SCL_Port, uint8_t SCL_Pin)函数，可以直接完成GPIO端口的初始化工作。应当注意的是，此函数的实现与硬件平台密切相关，因此在移植的时候需要注意。
  Y7 t- i6 A. P0 u
. @0 a8 n# b8 R1 k" s宏定义挂载设备的总线引脚，字符A, B, …,G表示端口号，数字0~15表示引脚号。

1. #define ADS1115_SCL_PORT        'A'
   8 S% R$ V5 J  ^$ q9 d. w5 C
2. #define ADS1115_SCL_PIN                6
   
3. 
   
4. #define ADS1115_SDA_PORT        'A'
   
5. #define ADS1115_SDA_PIN                5

复制代码

: V2 ]! f+ P1 y' u9 e- v设置Device1的I2C总线。

1. I2C_Virtual_SwitchBus(ADS1115_SDA_PORT, ADS1115_SDA_PIN, ADS1115_SCL_PORT, ADS1115_SCL_PIN);

复制代码

执行Device1的相关操作。
1 D2 Z# ^8 Q) n3 C/ e  ?在Device1的库函数的I2C通讯部分，应该调用本库的各种I2C通讯接口，例如void I2C_Virtual_Start(),void I2C_Virtual_Stop(),uint8_t I2C_Virtual_SendByte(uint8_t c)。

1. ADS1115_Config();
   
2. ADS1115_ReadData();

复制代码

3 U. g+ z. S/ o( r, J8 `) H切换Device2的I2C总线
+ N: |8 \& w- q1 x9 c' x

1. I2C_Virtual_SwitchBus(sts31Dev.SdaPort, sts31Dev.SdaPin, sts31Dev.SclPort, sts31Dev.SclPin);

复制代码

执行Device2的相关操作
# i6 m& m' o' d1 ]9 N) U4 i

1. STS31_Config();
   
2. STS31_ReadData();

复制代码

6 q, ]: \- j' }5 a; M/ [1 [


& P7 l- p- ^' b$ Z# Q