所谓的硬件I2C就是STM32芯片上有其相应的外设和驱动电路，通过配置相应的寄存器，就可以完成I2C的通信。本节实验我们介绍软件模拟I2C，软件I2C一般是通过GPIO引脚，按照I2C的时序要求来控制引脚电平状态以产生通讯时序。
/ |! P7 x* R* t9 E
& T" y* R- x7 p7 O6 P6 O/ i) R1、I2C通信流程中包含信号如下：
5 P; T& x7 U/ p! i( `1 N! b
, l  d* O$ G6 Z4 a' f7 ~6 v3 H7 J5 D开始信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。
结束信号：SCL为高电平时，SDA由低电平向高电平跳变，结束传送数据。
应答信号：发送器每发送一个字节，就在第9个时钟脉冲期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号。
& Z! {( Y' Z" d/ b* `2、I2C总线时序图如下：
) `  Q: c) @3 Q# I
: W  O4 o; o& i0 \# Q

: @! F+ ^4 f! q, d0 a
' B" b5 Q& Z) _3、I2C通讯过程的基本结构如下所示：

) k2 c: F4 t% c7 @1）主机写数据到从机
; x4 Y. [1 T/ ?/ c4 d9 ~6 {, L
0 {9 H9 N! a) f$ l5 Z9 G

8 f8 h# ~* p2 ]6 c; J* t
2）主机由从机中读数据

4 r$ a; l) W4 g/ y/ p; M5 z
% m8 u1 @- t, c$ u6 t; r3）I2C通讯复合格式

  D4 X& }2 N" \% [6 F% f' e

( N" Z9 j$ f8 F其中 S 表示由主机的 I2C接口产生的传输起始信号(S)，这时连接到 I2C总线上的所有从机都会接收到这个信号。
3 E4 C+ v# |( Y: X$ x3 f" _
起始信号产生后，所有从机就等待主机广播从机地址信号(SLAVE_ADDRESS)。在 I2C总线上，每个设备的地址都是唯一的，当主机广播的地址与某个设备地址相同时，这个设备就被选中了，没被选中的设备将会忽略之后的数据信号。根据 I2C协议，这个从机地址可以是 7位或 10位。
' `& _: Y( Z* p& w' M, _5 Q
: ?" g& L  e8 g5 M% b7 y) _在地址位之后，是传输方向的选择位，该位为 0时，表示后面的数据传输方向是由主机传输至从机，即主机向从机写数据。该位为 1时，则相反，即主机由从机读数据。
1 S' s. U- _4 e1 U% U& N
" @7 P+ a% b1 V' H# {0 X从机接收到匹配的地址后，会返回一个应答(ACK)或非应答(NACK)信号，只有接收到应答信号后，主机才能继续发送或接收数据。

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

/ c+ i; }# E1 F2 |2 d9 G若配置的方向传输位为“读数据”方向，即第二幅图的情况，广播完地址，接收到应答信号后，从机开始向主机返回数据(DATA)，数据包大小也为 8 位，从机每发送完一个数据，都会等待主机的应答信号(ACK)，重复这个过程，可以返回 N 个数据，这个 N 也没有大小限制。当主机希望停止接收数据时，就向从机返回一个非应答信号(NACK)，则从机自动停止数据传输。
- c5 l! V( @6 ~# `: r
除了基本的读写，I2C通讯更常用的是复合格式，即第三幅图的情况，该传输过程有两次起始信号(S)。一般在第一次传输中，主机通过 SLAVE_ADDRESS寻找到从设备后，发送一段“数据”，这段数据通常用于表示从设备内部的寄存器或存储器地址(注意区分它与 SLAVE_ADDRESS 的区别)；在第二次的传输中，对该地址的内容进行读或写。也就是说，第一次通讯是告诉从机读写地址，第二次则是读写的实际内容。

4）数据有效性时序图如下：

$ J2 ~4 e2 x" S4 u9 g6 z* X

7 P& F; j7 e/ n+ F
) Q0 \. e/ B7 |- p3 T: P. w' sI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。 即：数据在SCL的上升沿到来之前就需准备好。并在下降沿到来之前必须稳定。
! y, ^. j1 w8 t: X8 {2 X2 \% s' z
( K8 ]$ [$ ~7 E9 ]5）地址及数据方向

( o3 z! m. S2 O0 O6 RI2C 总线上的每个设备都有自己的独立地址，主机发起通讯时，通过 SDA 信号线发送设备地址(SLAVE_ADDRESS)来查找从机。I2C 协议规定设备地址可以是 7位或 10 位，实际中 7 位的地址应用比较广泛。紧跟设备地址的一个数据位用来表示数据传输方向，它是数据方向位(R/W)，第 8位或第 11 位。数据方向位为“1”时表示主机由从机读数据，该位为“0”时表示主机向从机写数据，如图：

读数据方向时，主机会释放对 SDA信号线的控制，由从机控制 SDA 信号线，主机接收信号，写数据方向时，SDA由主机控制，从机接收信号。

bsp_soft_i2c.c程序如下：
5 \# r6 Q! ]2 ?  ?! C& M' e" h
5 |( W; G% f% O2 s' g& v

1. #include "bsp_soft_i2c.h"   
   & c' G) j# a1 s, C' e5 @& N4 |
2. #include <stdbool.h>
   
3. 
   2 T5 m- _3 F, L4 P" g5 D3 ~
4. // 初始化IIC的IO口
   
5. void I2C2_Soft_Init(void)
   8 K2 v5 R; [% p
6. {
     C9 B2 a& V6 }
7.     GPIO_InitTypeDef GPIO_InitStructure;   // 定义GPIO结构体
   
8.         
   ' \( ~4 e# R8 X1 g
9.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);  // 打开GPIOB口时钟
   
10.         
    
11.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;  // 输出
    6 M0 `# l6 x, [# f) }
12.     GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; // 开漏
    0 s7 o" U, F. d) p+ F( `( b6 q# v9 Q
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
    $ e8 W; \/ g8 p/ `, f$ f, H
17.         
    + P% K' r. [& k' q
18.     I2C2_Stop();
    ' [+ x$ }/ a* d5 T) L
19. }
    
20. 
    
21. // 发送IIC起始信号
    
22. bool I2C2_Start(void)
    5 z5 t% e. x0 I2 ^
23. {
    + L2 I' v3 b  s5 P0 e. o
24.     Pin_SCL_H; // 拉高时钟线
    
25.     Pin_SDA_H; // 拉高信号线
    
26.     I2C2_Delay1us();
    
27.     if(!Read_SDA_Pin)                return false;
    
28.     Pin_SDA_L;
    7 w5 |/ H+ I: o
29.     I2C2_Delay1us();
    6 [8 b+ @0 P1 N" D7 i
30.     Pin_SDA_L;
    
31.     I2C2_Delay1us();
    
32.     return true;
    & F- D( X% v  K3 S4 g* D& _
33. }
    
34. 
    5 _( H" T3 O$ r6 G8 x
35. // 发送IIC停止信号
    
36. bool I2C2_Stop(void)
    
37. {
    
38.     Pin_SCL_H;
    ( I. i8 |7 G6 m, a" [5 v: C) ?
39.     Pin_SDA_L;
    
40.     I2C2_Delay1us();
    . e/ y! s" `: J& L( ^4 t" H
41.     if(Read_SDA_Pin)        return false;
    ' X, u' i& V% M  n
42.     Pin_SDA_H;
    
43.     I2C2_Delay1us();
    
44.     if(!Read_SDA_Pin) return false;
    
45.     Pin_SDA_H;
    2 b* u% U5 m, j$ _7 f5 ^& m, a
46.     I2C2_Delay1us();        
    
47.     return true;
    
48. }
    
49. 
    
50. // IIC发送ACK信号
    
51. void I2C2_Ack(void)
    
52. {
    
53.     Pin_SCL_L;
    
54.     I2C2_Delay1us();
    ' j0 G+ q' a; p
55.     Pin_SDA_L;        
      q( i: o$ k: ^9 g) p$ O# y
56.     Pin_SCL_H;
    , P+ u/ h/ ?5 d
57.     I2C2_Delay1us();
    4 K5 F* Y. l4 l2 n
58.     Pin_SCL_L;
      f* m% y. q" M- M; J
59.     Pin_SDA_H;
    
60.     I2C2_Delay1us();
    
61. }
    
62. 
    
63. // IIC不发送ACK信号
    : o4 N% h' S4 D& r  `
64. void I2C2_NAck(void)
    ; \3 e) H9 j" Z8 c. s
65. {
    
66.     Pin_SCL_L;
    - P( H) @- Y) G3 `+ U
67.     I2C2_Delay1us();        
    
68.     Pin_SDA_H;
    
69.     Pin_SCL_H;
      @+ L# j- i! o% f6 H" d. T
70.     I2C2_Delay1us();
    7 m; u  U) o8 l7 S' {
71.     Pin_SCL_L;
    
72.     I2C2_Delay1us();
    ) Q4 P( B4 m4 M" @1 j( J( _2 o
73. }
    
74. 
    
75. // IIC等待ACK信号
    & L1 V, D* z$ |: n
76. uint8_t I2C2_Wait_Ack(void)
    
77. {
    
78.     Pin_SCL_L;
    
79.     I2C2_Delay1us();        
    
80.     Pin_SDA_H;
    6 c; E" v! D% T7 S  C8 |
81.     Pin_SCL_H;
    
82.     I2C2_Delay1us();        
    
83.     if(Read_SDA_Pin)
    
84.     {
    ; w7 i: p' h9 \& L! E1 E
85.         Pin_SCL_L;
    
86.         I2C2_Delay1us();
    7 R  c, o& ?' ?, w/ c- M
87.         return false;
    ; u( k8 \- U1 k, G& c4 ?* }! |
88.     }
    3 ?: B% p" a. t. E# _$ I% E
89.     Pin_SCL_L;
    & k1 ?* t1 F. m: O9 I% o
90.     I2C2_Delay1us();
    * k5 m0 b) C- o0 B
91.     return true;
    & T6 j$ p- N' x5 F0 U! J  k* I; V
92. }
    
93. 
    $ |' c* ?- E9 l: K$ B; l
94. // IIC发送一个字节
    ) h7 T* h" D! [2 }( d/ L' ?8 ]7 Z
95. void I2C2_Send_Byte(uint8_t txd)
    
96. {
    6 M. y* e3 V2 K( W  `! o! ~! y$ e
97.     for(uint8_t i=0; i<8; i++)
    
98.     {
    % m$ e" J4 X& l7 S/ Z. J
99.         Pin_SCL_L;
    8 E& |* f' E# A. u7 v9 o
100.         I2C2_Delay1us();
     
101.         if(txd & 0x80)
     2 o$ R) G% ~8 _& g; _! p( L5 E
102.             Pin_SDA_H;
     . A! i4 ^* p4 q, o  o* _
103.         else
     
104.             Pin_SDA_L;
     , ?) t- N9 A3 d, L. g* n; t" P
105.             txd <<= 1;
     : j" h5 `; w) j( a1 t' T' s7 j
106.             Pin_SCL_H;
     ! |3 T2 e9 w. C1 z
107.             I2C2_Delay1us();
     
108.     }
     * o* d: ?% j' I  w
109. }
     9 y$ J5 K8 P; f- ]! I- P" W
110. 
     
111. // IIC读取一个字节
     
112. uint8_t        I2C2_Read_Byte(void)
     
113. {
     + |( B, g1 M1 C: ]
114.     uint8_t rxd = 0;
     
115.     for(uint8_t i=0; i<8; i++)
     
116.     {
     ! e, J& A8 e6 y0 X0 S
117.         rxd <<= 1;
     
118.         Pin_SCL_L;
     + B, }( ^, S1 G* `! E
119.         I2C2_Delay1us();
     
120.         Pin_SCL_H;        
     
121.         I2C2_Delay1us();               
     
122.         if(Read_SDA_Pin)
     . x& w+ v- l' S. J1 e+ Y; O2 |
123.         {
     & K3 N" V% s+ g+ b, Q# y# q. Z
124.             rxd |= 0x01;
     $ N/ u  [0 @6 E. _0 a
125.         }
     
126.     }
     
127.     return rxd;
     4 E( y9 _8 }; a' j% a$ T# P
128. }
     , F+ S5 c0 f# P9 d1 b2 h4 O
129. 
     
130. // 向从机指定地址写数据
     ) z; C- R  S  A/ t6 a/ p1 g( c: z
131. bool I2C_Write_REG(uint8_t SlaveAddress, uint8_t REG_Address,uint8_t REG_data)
     
132. {
     $ O7 U/ H7 q, x: H# B% y
133.     if(!I2C2_Start())                return false;
     
134.     I2C2_Send_Byte(SlaveAddress);
     4 ?9 q. U" Q; K+ P& x" a  B; }0 d
135.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     # W' P& t9 B: I# S- C" W1 A
136.     I2C2_Send_Byte(REG_Address);
     
137.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     1 R; q4 y  @% \! E# C) S" X& {
138.     I2C2_Send_Byte(REG_data);
     / e9 W7 Q1 [3 V( a; s
139.     if(!I2C2_Wait_Ack()) { I2C2_Stop(); return false;        }
     
140.     if(!I2C2_Stop()) return false;
     0 r7 H# L$ j' G' X
141.     return true;
     ; ?, A1 l" E6 `  @+ B5 }
142. }
     
143. 
     
144. // 从设备中读取数据
     
145. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address)
     
146. {
     ' a  [  w8 q( e/ l. o
147.     uint8_t data;
     
148.     if(!I2C2_Start())        return false;
     
149.     I2C2_Send_Byte(SlaveAddress);
     1 x/ k1 J7 d% g
150.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     0 E" e3 \  M, z1 ]( ^2 T, p* Q6 i
151.     I2C2_Send_Byte(REG_Address);
     
152.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     5 O) _% D) J- J! [" \+ i8 }0 x$ u
153.     if(!I2C2_Start())        return false;
     & f% A7 d7 d3 r% Q* m6 e; Y
154.     I2C2_Send_Byte(SlaveAddress + 1);
     + U' g3 f6 |/ J0 N
155.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     ' Z2 ^( w1 U6 R
156.     data = I2C2_Read_Byte();
     * N7 Z+ t7 j& Y: u2 }, Q8 H
157.     I2C2_NAck();
     - j7 W" q; H) c
158.     if(!I2C2_Stop())        return false;        
     4 X8 P$ }9 l. V
159.     return data;
     8 z( o1 x; M' m* a
160. }
     3 I! z$ F% ^9 K: M- v* s5 w* f
161. 
     
162. // 连续写N个字节
     
163. bool I2C2_Write_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     
164. {
     5 B" Q! R' p7 y( v) G2 g; ]% Z
165.     if(!I2C2_Start())return false;
     ' j3 o6 v2 u$ c' S/ R0 g: q
166.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     $ z& c+ X* t8 Y
167.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
168.     I2C2_Send_Byte(REG_Address);   
     + S8 a( B: w1 k3 j% [* g( e; Y- b
169.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     # m) \& i/ Z- V7 q( @+ Z
170.     for(uint16_t i=0; i<len; i++)
     
171.     {
     7 o/ _6 ~  J+ q
172.         I2C2_Send_Byte(buf<i>);
     
173.       </i>  if(i<len-1)
     - X6 R2 x- A2 H" F
174.         {
     , r, o3 \: c9 D* s9 g
175.             if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     9 u" q. N4 ^" h
176.         }
     5 ]5 b  H9 ^& @2 O( G- g8 s
177.     }
     2 h9 j4 q6 q2 c. ^1 a! t
178.     I2C2_Stop();
     / b- a. {5 U" m  o9 E4 u
179.     return true;
     
180. }
     
181. 
     $ t1 Z/ I& A3 @1 W0 @1 Q- e( Q
182. // 连续读N个字节
     
183. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     
184. {
     
185.     if(!I2C2_Start())return false;
     & Z1 s/ j9 U4 Q
186.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     
187.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
188.     I2C2_Send_Byte(REG_Address);   
     
189.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
190.     if(!I2C2_Start())return false;
     7 r& a7 G( I; |7 R: ?; C# d
191.     I2C2_Send_Byte(SlaveAddress | 1); // 读操作
     1 i0 H7 d, d* l" d
192.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     / K/ G3 g2 z- q- J7 E$ M% ?
193.     for(uint16_t i=0; i<len; i++)
     
194.     {
     
195.         buf = I2C2_Read_Byte();
     5 ?* K8 F; ^# z' U; e
196.         if(i<len-1)
     
197.         {
     
198.             I2C2_Ack();
     
199.         }
     $ Z3 ?& u$ ~$ }: n5 ~0 t2 {3 D
200.     }
     ( X$ k: {+ ^' H: z0 B0 Q
201.     I2C2_NAck();
     * @/ W4 j) x) K7 L/ w, z1 V5 ~
202.     I2C2_Stop();
     
203.     return true;
     ' k  X: F* u1 E. S; Y
204. }
     0 A  b2 `( J# N/ W$ M- X
205. 
     # C* y8 z) z9 |& t2 d) U4 o
206. // 检查设备地址
     . u7 v/ \/ Q9 ?( _; v0 y- C+ O9 K
207. bool I2C2_CheckDevice(uint8_t SlaveAddress)
     8 W( Q- h% g" K, W. H, P
208. {
     6 Q5 c& k7 Z- y/ a  C! T
209.     if(!I2C2_Start())        return false;
     
210.     I2C2_Send_Byte(SlaveAddress);
     
211.     if(!I2C2_Wait_Ack())
     4 f1 b) D& |% H' h' u
212.     {
     
213.         I2C2_Stop();
     0 k, T8 X3 }& n; E) Z* r
214.         return false;               
     # P+ i# v: j% |2 I
215.     }
     # B) S! Y" ~8 d8 `1 G7 u, I" d
216.     if(!I2C2_Stop())        return false;        
     / g/ V# m6 s+ J9 U# P0 q- J
217.     return true;        
     
218. }

复制代码

% b. N  J% Y# K. l5 f1 Ibsp_soft_i2c.h程序如下：

1. #ifndef _BSP_SOFT_I2C_H_
   ( B' Q0 O2 v. _# U( k8 l! L$ C
2. #define _BSP_SOFT_I2C_H_
   # R; A3 k# Y( P9 F
3. 
   * D* }) W) k8 g/ d! |7 y
4. #include "stm32f0xx.h"
   
5. #include <stdbool.h>
   
6. 
   & n! O* A& J+ p7 ^$ ?6 O
7. // 定义内联延时函数        
   3 }( z6 \$ ~1 S3 E& C; u
8. static inline void I2C2_Delay1us(void)
   
9. {
   # A# f# ]- ^. E& z
10.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    9 X. T8 D2 V7 C
11.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
12.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
13.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
14.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
15.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();        
    
16. }        
    
17. 
    / ~0 u1 u9 d) V$ y
18. 
    % J3 t2 G% |2 ^$ x8 t4 ]
19. #define        I2C2_GPIOx  GPIOB
    
20. #define Pin_SCL                GPIO_Pin_10
    
21. #define Pin_SDA                GPIO_Pin_11
    
22. 
    8 T- t' _% ?* w7 ~- K. ]
23. #define Pin_SCL_L                I2C2_GPIOx->ODR &= ~Pin_SCL
    7 A" h7 f# Z8 i4 z+ ^6 X
24. #define Pin_SCL_H                I2C2_GPIOx->ODR |= Pin_SCL
    + C. M+ C9 S  Z/ d4 m
25. 
    2 W& P, S; f. {( @# z3 O5 N/ {
26. #define Pin_SDA_L                I2C2_GPIOx->ODR &= ~Pin_SDA
    
27. #define Pin_SDA_H                I2C2_GPIOx->ODR |= Pin_SDA
    
28. 
    5 i* {# I8 @* W, V
29. #define Read_SDA_Pin        I2C2_GPIOx->IDR & Pin_SDA
    
30. 
    $ k$ ~& e6 ~2 t  V# S
31. void I2C2_Soft_Init(void);                        
    
32. bool I2C2_Start(void);                                                
    
33. bool I2C2_Stop(void);                                          
    # ~. e+ u' m# b5 c/ _+ D
34. void I2C2_Send_Byte(uint8_t txd);
    3 }  a7 \: Q2 V
35. uint8_t I2C2_Read_Byte(void);
    ! t) h0 O# z3 g
36. uint8_t I2C2_Wait_Ack(void);                 
    * B$ V4 }; J! {
37. void I2C2_Ack(void);                                                        
    & Z9 o1 b! Z7 w3 ]- X, j% ~5 G
38. void I2C2_NAck(void);                                                
    
39. 
    
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);
    
43. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len);
    0 e- m& {# `/ r- ]1 R# q* v* {5 z
44. bool I2C2_CheckDevice(uint8_t SlaveAddress);
    
45. #endif

复制代码

$ w: i9 T, @+ d2 u( ~5 t& l9 X. n