所谓的硬件I2C就是STM32芯片上有其相应的外设和驱动电路，通过配置相应的寄存器，就可以完成I2C的通信。本节实验我们介绍软件模拟I2C，软件I2C一般是通过GPIO引脚，按照I2C的时序要求来控制引脚电平状态以产生通讯时序。
$ M; c0 J5 h3 N$ m( V
' e; X+ U( J' X% ^! z2 [8 q1、I2C通信流程中包含信号如下：
9 |8 l/ s8 z, O6 u2 ~
开始信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。
( n' h: }' [. [7 f, M结束信号：SCL为高电平时，SDA由低电平向高电平跳变，结束传送数据。
应答信号：发送器每发送一个字节，就在第9个时钟脉冲期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号。
2、I2C总线时序图如下：

2 P& {% F9 K3 j# x! t4 k
9 ^3 A  \$ C; b" r" H: u. ^9 n$ V6 Y3、I2C通讯过程的基本结构如下所示：
: E- ~6 B9 a9 c% Y
; u& i" |6 j" E  T: ?/ ]# }% f0 X- D+ ~3 X1）主机写数据到从机

2）主机由从机中读数据

7 p! l1 Z3 `  N1 j

* n& s; _8 v8 x& C* Q3）I2C通讯复合格式
( m! d$ q6 j8 I" E$ @- l+ Y9 p6 B. A
; x! n7 e) }. a8 c9 q  _* @$ i

' s* O6 \3 q6 _3 r5 Z3 B+ [

' T7 I3 V- P& L1 _& H5 J4 N# s% J' B
, j" e) _! ^+ \其中 S 表示由主机的 I2C接口产生的传输起始信号(S)，这时连接到 I2C总线上的所有从机都会接收到这个信号。
& e9 S( ^  L; c4 T) Y6 r. x6 }8 Y
起始信号产生后，所有从机就等待主机广播从机地址信号(SLAVE_ADDRESS)。在 I2C总线上，每个设备的地址都是唯一的，当主机广播的地址与某个设备地址相同时，这个设备就被选中了，没被选中的设备将会忽略之后的数据信号。根据 I2C协议，这个从机地址可以是 7位或 10位。

在地址位之后，是传输方向的选择位，该位为 0时，表示后面的数据传输方向是由主机传输至从机，即主机向从机写数据。该位为 1时，则相反，即主机由从机读数据。

/ C( b/ R- A3 b& l从机接收到匹配的地址后，会返回一个应答(ACK)或非应答(NACK)信号，只有接收到应答信号后，主机才能继续发送或接收数据。
4 z& k6 r3 r$ g, |# R. g
! L& c7 v9 Z% H7 r3 [若配置的方向传输位为“写数据”方向，即第一幅图的情况，广播完地址，接收到应答信号后，主机开始正式向从机传输数据(DATA)，数据包的大小为 8位，主机每发送完一个字节数据，都要等待从机的应答信号(ACK)，重复这个过程，可以向从机传输 N 个数据，这个 N没有大小限制。当数据传输结束时，主机向从机发送一个停止传输信号(P)，表示不再传输数据。
6 t: v" X$ C/ E4 c& z% y% ~, |
若配置的方向传输位为“读数据”方向，即第二幅图的情况，广播完地址，接收到应答信号后，从机开始向主机返回数据(DATA)，数据包大小也为 8 位，从机每发送完一个数据，都会等待主机的应答信号(ACK)，重复这个过程，可以返回 N 个数据，这个 N 也没有大小限制。当主机希望停止接收数据时，就向从机返回一个非应答信号(NACK)，则从机自动停止数据传输。

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

) J' I' y1 I' f4）数据有效性时序图如下：
* R* Y& G' I% X' I

/ P( c) r+ K; ^4 t6 SI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。 即：数据在SCL的上升沿到来之前就需准备好。并在下降沿到来之前必须稳定。

' ]/ H1 d3 E* x- C1 I5）地址及数据方向

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

$ c) `4 }7 f5 _+ {# Q: Q2 A5 A9 }

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

bsp_soft_i2c.c程序如下：

1. #include "bsp_soft_i2c.h"   
   
2. #include <stdbool.h>
   
3. 
   
4. // 初始化IIC的IO口
   3 k8 t/ F5 R" R6 W, C
5. void I2C2_Soft_Init(void)
   ' R+ p- `9 n% j' ]0 L
6. {
   / m/ Z8 ]6 P% r% E, i! K* b& P5 Y
7.     GPIO_InitTypeDef GPIO_InitStructure;   // 定义GPIO结构体
   # O  F( d$ U! x0 l! _3 G
8.         
   . Z" N# W$ \0 B" Z
9.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);  // 打开GPIOB口时钟
   
10.         
    
11.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;  // 输出
    ; A: T: b6 V) n# K; M( f1 c! P
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; // 上拉
    9 P" B# h+ D5 d% u
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_3; // 50MHZ
    
16.     GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化GPIO
    5 i$ f# ]$ M; S+ m6 a$ _9 i* a
17.         
    
18.     I2C2_Stop();
    ! K% e$ W/ m8 J( _
19. }
    " j. b( d, W( [) j8 p# r" ^
20. 
    " ^2 M' y( g4 h% s/ B! G2 a6 D9 U
21. // 发送IIC起始信号
    
22. bool I2C2_Start(void)
    
23. {
    
24.     Pin_SCL_H; // 拉高时钟线
    
25.     Pin_SDA_H; // 拉高信号线
    
26.     I2C2_Delay1us();
    
27.     if(!Read_SDA_Pin)                return false;
    " E# Y  M/ I0 H# V2 }
28.     Pin_SDA_L;
    
29.     I2C2_Delay1us();
    / U1 l* f! M6 w
30.     Pin_SDA_L;
    - q3 `) j( a' T9 w
31.     I2C2_Delay1us();
    ( V6 W& R& H; A) g1 l+ G
32.     return true;
    ) J5 M8 [4 ~" [5 `, E, a2 M
33. }
    
34. 
    
35. // 发送IIC停止信号
    $ S$ k. C* N; b9 f& d9 E
36. bool I2C2_Stop(void)
    6 {9 k* x6 \/ k  l7 i: G
37. {
    3 z! U$ `: ?3 w1 G  D* H& H
38.     Pin_SCL_H;
    
39.     Pin_SDA_L;
    
40.     I2C2_Delay1us();
    
41.     if(Read_SDA_Pin)        return false;
    ! Q. S7 g$ e7 |* F0 [
42.     Pin_SDA_H;
    
43.     I2C2_Delay1us();
    . k* h: ^, g/ _. H4 h
44.     if(!Read_SDA_Pin) return false;
    - d- Z- C; K- `0 V& H6 r
45.     Pin_SDA_H;
    9 N, n: ~* U% K% M
46.     I2C2_Delay1us();        
    ) j; t+ a- s4 l* S3 t. {- Z
47.     return true;
    
48. }
    
49. 
    ! C! s% d+ U% g) I
50. // IIC发送ACK信号
    - S! ?. L1 T. ~: W9 o% l
51. void I2C2_Ack(void)
    
52. {
    5 v, h4 u: O5 B" i( e7 W) j
53.     Pin_SCL_L;
    
54.     I2C2_Delay1us();
    
55.     Pin_SDA_L;        
    3 ?* o% u5 `7 k. }+ Y# r: ?) [
56.     Pin_SCL_H;
    
57.     I2C2_Delay1us();
    # p, h* E8 t$ N, O0 M* |
58.     Pin_SCL_L;
    . q2 @  L$ V1 g& m: s5 [9 _2 L
59.     Pin_SDA_H;
    6 [7 K% ]+ k+ b* o+ E
60.     I2C2_Delay1us();
    
61. }
    # p% R( d5 O; v* [) N; {* Q* H
62. 
    3 x9 j( n0 Q2 I1 T- `" S
63. // IIC不发送ACK信号
    
64. void I2C2_NAck(void)
    
65. {
    
66.     Pin_SCL_L;
    
67.     I2C2_Delay1us();        
    & t" g$ A8 d5 d& [
68.     Pin_SDA_H;
    & Z5 A8 K" O9 S& j$ E
69.     Pin_SCL_H;
    
70.     I2C2_Delay1us();
      ]. K1 m/ E3 R! P
71.     Pin_SCL_L;
    0 z8 a" P. X# D' h
72.     I2C2_Delay1us();
    / C) Z7 X/ h/ B# `  J
73. }
    
74. 
    $ R# [5 [- r4 g) v. U3 `
75. // IIC等待ACK信号
    6 n  l% X* U" f* z. |6 H
76. uint8_t I2C2_Wait_Ack(void)
    
77. {
    
78.     Pin_SCL_L;
    ( G5 Z2 Y! \, j. d$ x
79.     I2C2_Delay1us();        
    5 K  g. p* _" ?( I/ T, m( E; M1 ?% y
80.     Pin_SDA_H;
    % g. |: R8 J6 z) Q
81.     Pin_SCL_H;
    
82.     I2C2_Delay1us();        
    
83.     if(Read_SDA_Pin)
    ) u" P3 r- m7 k, r; _
84.     {
    9 [0 F% V! W8 R# R% U# D
85.         Pin_SCL_L;
    
86.         I2C2_Delay1us();
    
87.         return false;
    - _2 c9 H+ v  r- n9 c( l& b
88.     }
    
89.     Pin_SCL_L;
    
90.     I2C2_Delay1us();
    4 a. l! U* a- e9 b
91.     return true;
    
92. }
    
93. 
    
94. // IIC发送一个字节
    
95. void I2C2_Send_Byte(uint8_t txd)
    - Y1 v) [1 _4 n6 t' W3 \
96. {
    + Y9 u% c. c9 ~& I$ [) K
97.     for(uint8_t i=0; i<8; i++)
    
98.     {
      G3 }( f$ D% f* k, W( V' U# ^! i
99.         Pin_SCL_L;
    / X& X, A- \( e, }
100.         I2C2_Delay1us();
     1 E* R$ @: {# p& m% j9 [+ D
101.         if(txd & 0x80)
     
102.             Pin_SDA_H;
     
103.         else
     
104.             Pin_SDA_L;
     : y$ r2 Z0 N& S, y' m
105.             txd <<= 1;
     
106.             Pin_SCL_H;
     3 t! Q! N# x8 D2 D3 t9 `! m
107.             I2C2_Delay1us();
     / X( C: U* s: W+ c, G- X
108.     }
     ) n2 B# P; @, W/ T0 T
109. }
     6 W! Y: w. j. T( p- ^3 l
110. 
     
111. // IIC读取一个字节
     
112. uint8_t        I2C2_Read_Byte(void)
     7 U" M* w6 z, b# v% R7 {8 S# f
113. {
     
114.     uint8_t rxd = 0;
     & C1 |2 a4 [9 d( {% w; ?5 t& g
115.     for(uint8_t i=0; i<8; i++)
     
116.     {
     ; I! h# n( [' D
117.         rxd <<= 1;
     * J  S4 T4 _, m: @9 k1 x) \; N" g
118.         Pin_SCL_L;
     / ^" q$ r3 a, w: P
119.         I2C2_Delay1us();
     
120.         Pin_SCL_H;        
     ( a, ?% \: h, q+ a" O
121.         I2C2_Delay1us();               
     * K6 k2 g* U1 X* W
122.         if(Read_SDA_Pin)
     
123.         {
     ! R5 W# f# q& F( S& H% m5 K$ T
124.             rxd |= 0x01;
     & B1 R9 q, C7 P, O2 K" }
125.         }
     
126.     }
     
127.     return rxd;
     3 L9 s  L% i) k
128. }
     
129. 
     
130. // 向从机指定地址写数据
     
131. bool I2C_Write_REG(uint8_t SlaveAddress, uint8_t REG_Address,uint8_t REG_data)
     " q& k& Z9 C2 n7 B# r
132. {
     ; A3 }5 A2 ^' p: M7 f1 [0 B
133.     if(!I2C2_Start())                return false;
     
134.     I2C2_Send_Byte(SlaveAddress);
     
135.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     # }( U. w4 Y7 |, G2 V
136.     I2C2_Send_Byte(REG_Address);
     2 J/ S* i/ P) ^
137.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
138.     I2C2_Send_Byte(REG_data);
     
139.     if(!I2C2_Wait_Ack()) { I2C2_Stop(); return false;        }
     , n9 r( `) e; Y9 `5 f1 P  D+ b
140.     if(!I2C2_Stop()) return false;
     
141.     return true;
     
142. }
     ) V# j! F- o  x% s% N, @
143. 
     
144. // 从设备中读取数据
     
145. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address)
     " |& c5 Q$ w* u6 y+ _2 l
146. {
     
147.     uint8_t data;
     + p, m, ^" J; r. u' O
148.     if(!I2C2_Start())        return false;
     
149.     I2C2_Send_Byte(SlaveAddress);
     2 ]/ u& z. b9 ]7 Z" n+ L9 V
150.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
151.     I2C2_Send_Byte(REG_Address);
     
152.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     ) B* n& B. ?2 ^/ J% {+ Z  u' w
153.     if(!I2C2_Start())        return false;
     ' z1 p- i& D9 T- g- A( y( M( a
154.     I2C2_Send_Byte(SlaveAddress + 1);
     
155.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
156.     data = I2C2_Read_Byte();
     # k" K0 }: M( j
157.     I2C2_NAck();
     
158.     if(!I2C2_Stop())        return false;        
     4 n+ `% ^1 |7 V2 P3 L6 G1 u
159.     return data;
     * e& S- V: W( k& ]
160. }
     : o3 s' ~1 h$ |/ z. o. v
161. 
     % V  b4 U9 Y2 h1 {' L& W. N
162. // 连续写N个字节
     
163. bool I2C2_Write_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     6 v* ^0 F: L9 X) S
164. {
     
165.     if(!I2C2_Start())return false;
     
166.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     
167.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     8 H8 r3 b7 R# S) S% T2 N
168.     I2C2_Send_Byte(REG_Address);   
     * G; g# }' N2 Z
169.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
170.     for(uint16_t i=0; i<len; i++)
     # ]: [- U! K  |; C  z5 P
171.     {
     
172.         I2C2_Send_Byte(buf<i>);
     
173.       </i>  if(i<len-1)
     
174.         {
     ) X6 `: T7 p5 g$ `2 O$ \* X8 Z) h
175.             if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     ' `$ V  E' N. Y! u! o1 J) I
176.         }
     6 D8 P* Q/ P" g; F
177.     }
     4 O7 y4 x3 J* S
178.     I2C2_Stop();
     & C& \' n2 n' V# z4 v
179.     return true;
     5 E! h! q. E. T* S& C  U) X
180. }
     1 L8 }$ [! i; A0 ]/ X% O
181. 
     " x* r6 z. q$ [/ c  ~$ N
182. // 连续读N个字节
     8 ~$ c0 ]+ K! t# P3 f; p
183. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     , ?, w. ^5 |" ~' f+ w
184. {
     
185.     if(!I2C2_Start())return false;
     4 K. h. W7 ]9 ?$ n9 |$ r
186.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     
187.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     * o7 k& Q$ O# i
188.     I2C2_Send_Byte(REG_Address);   
     
189.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     % d+ q6 l8 y5 j- ]1 I
190.     if(!I2C2_Start())return false;
       ?1 \# Z+ w0 j+ Z% N! a9 X+ N
191.     I2C2_Send_Byte(SlaveAddress | 1); // 读操作
     ' k* u: S5 \/ q5 V$ _' x
192.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
193.     for(uint16_t i=0; i<len; i++)
     ' F2 \  u9 Q. l* z7 j9 X% `
194.     {
     % u7 t* _% r, P0 T% E4 G0 c
195.         buf = I2C2_Read_Byte();
     
196.         if(i<len-1)
     9 `/ i( K# F6 z& F
197.         {
     
198.             I2C2_Ack();
     ; L- L- A$ y6 Q: H: f$ F
199.         }
     " a4 q0 X* A* |: a! z* a* d) `
200.     }
     
201.     I2C2_NAck();
     1 `" W3 J3 c( j5 M  a/ w% v, t& U( O
202.     I2C2_Stop();
     0 p) L+ k9 V+ T4 L
203.     return true;
     - j5 q/ F5 C: q& \  n
204. }
     ' S+ e3 x7 v" n1 u5 ^
205. 
     + E6 r, {( d, J2 {( n
206. // 检查设备地址
     
207. bool I2C2_CheckDevice(uint8_t SlaveAddress)
     
208. {
     
209.     if(!I2C2_Start())        return false;
     
210.     I2C2_Send_Byte(SlaveAddress);
     . ?7 C0 ^1 f  J1 \9 v/ h
211.     if(!I2C2_Wait_Ack())
     
212.     {
     
213.         I2C2_Stop();
     ( @9 v/ e' g5 ?9 r
214.         return false;               
     3 x$ u# L5 {) x% @& ?  {# b
215.     }
     * r' D$ v+ `# Z7 X% p6 a; U
216.     if(!I2C2_Stop())        return false;        
     * g( B& \" e9 f/ T5 t( E
217.     return true;        
     
218. }

复制代码

bsp_soft_i2c.h程序如下：

1. #ifndef _BSP_SOFT_I2C_H_
   
2. #define _BSP_SOFT_I2C_H_
   
3. 
   ! ?) s  m" D7 ~5 h$ a
4. #include "stm32f0xx.h"
   
5. #include <stdbool.h>
   - k6 a( ^/ y9 O# J+ k4 ~. Y( @# }
6. 
   4 U8 t- d2 M/ W; v& K7 q7 u
7. // 定义内联延时函数        
   
8. static inline void I2C2_Delay1us(void)
   5 t% E9 a0 Y. x! {: A
9. {
   
10.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    2 G- g" I9 U3 x+ ?, I
11.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
12.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    : N, Z. i) \/ l; M, l
13.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    ! |0 ]1 t5 [* s! m0 H; Y1 O
14.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
15.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();        
    5 I2 o; V7 L% v: h% |& ^  s7 x% V
16. }        
    
17. 
    
18. 
    
19. #define        I2C2_GPIOx  GPIOB
    
20. #define Pin_SCL                GPIO_Pin_10
    7 l+ K0 L# d& ?2 w1 D
21. #define Pin_SDA                GPIO_Pin_11
    / T- Q# p1 Z3 ~
22. 
    " j1 x9 o7 a6 Q0 N, r7 C
23. #define Pin_SCL_L                I2C2_GPIOx->ODR &= ~Pin_SCL
    2 X0 h2 U7 n: [  D* x
24. #define Pin_SCL_H                I2C2_GPIOx->ODR |= Pin_SCL
    
25. 
    3 C( C) v* ]9 \5 a5 F" g4 G% O
26. #define Pin_SDA_L                I2C2_GPIOx->ODR &= ~Pin_SDA
    
27. #define Pin_SDA_H                I2C2_GPIOx->ODR |= Pin_SDA
    
28. 
    9 N9 B: @! e* P
29. #define Read_SDA_Pin        I2C2_GPIOx->IDR & Pin_SDA
    9 p# b; G( a. |* d: r( P
30. 
    
31. void I2C2_Soft_Init(void);                        
    3 X9 h- i. h2 y- G; G/ }
32. bool I2C2_Start(void);                                                
    % w1 _* \9 M% Z7 T; G
33. bool I2C2_Stop(void);                                          
    6 g2 Y" ?& @5 Q" R* U9 o! i8 K4 `# D
34. void I2C2_Send_Byte(uint8_t txd);
    
35. uint8_t I2C2_Read_Byte(void);
    ; n( `$ k0 A: `1 H+ P
36. uint8_t I2C2_Wait_Ack(void);                 
    
37. void I2C2_Ack(void);                                                        
    
38. void I2C2_NAck(void);                                                
    
39. 
    3 o' ]4 I7 E# X+ \3 G4 F4 b
40. bool I2C2_Write_REG(uint8_t SlaveAddress,uint8_t REG_Address,uint8_t REG_data);
    5 E6 j* t: Q  I0 K! k  L& r
41. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address);
    0 `4 O# r  @6 P
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);
    , Y/ ^) l) o7 `' x: }
44. bool I2C2_CheckDevice(uint8_t SlaveAddress);
    
45. #endif

复制代码

+ b3 S0 `4 J0 q  x5 D

+ L' c( o( h; |3 G