所谓的硬件I2C就是STM32芯片上有其相应的外设和驱动电路，通过配置相应的寄存器，就可以完成I2C的通信。本节实验我们介绍软件模拟I2C，软件I2C一般是通过GPIO引脚，按照I2C的时序要求来控制引脚电平状态以产生通讯时序。
* `; D3 P" l7 o' B5 x
3 G) ]/ J" O: Q" I, Q( O( A3 H1、I2C通信流程中包含信号如下：

8 _/ a( _1 X8 w7 a开始信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。
结束信号：SCL为高电平时，SDA由低电平向高电平跳变，结束传送数据。
) M3 B& Q; U7 X7 P$ \: p4 o应答信号：发送器每发送一个字节，就在第9个时钟脉冲期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号。
; z- e1 H# g  H% ?2、I2C总线时序图如下：

% e9 C) M8 A6 [, p; C( `

# w/ c; H- b3 m
3、I2C通讯过程的基本结构如下所示：

: }2 G0 p8 U. Y# t1）主机写数据到从机
- E/ p$ J) y9 \! R7 n$ O0 X

( Z4 g$ e7 u' @' m# N  N
* k; o( H0 L) t' U5 |/ @) g2）主机由从机中读数据

" ?9 M) U+ x% K% F1 y! \/ c2 P

4 V6 g9 `3 I' n) }# b: p. X2 Q
" \4 N- R6 u) {; l5 C3）I2C通讯复合格式
3 D3 A  G& w. `+ M# K' S* L
" r8 W; Q6 B. b) d+ x3 C* O

2 V# N( p( c& M3 o' {# ?$ p0 q

8 U+ E* c* {. k$ j/ @& ^; l
其中 S 表示由主机的 I2C接口产生的传输起始信号(S)，这时连接到 I2C总线上的所有从机都会接收到这个信号。

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

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

+ t7 a2 {  X/ o0 ^; _从机接收到匹配的地址后，会返回一个应答(ACK)或非应答(NACK)信号，只有接收到应答信号后，主机才能继续发送或接收数据。
, T9 l# C3 z" ]: W2 B
若配置的方向传输位为“写数据”方向，即第一幅图的情况，广播完地址，接收到应答信号后，主机开始正式向从机传输数据(DATA)，数据包的大小为 8位，主机每发送完一个字节数据，都要等待从机的应答信号(ACK)，重复这个过程，可以向从机传输 N 个数据，这个 N没有大小限制。当数据传输结束时，主机向从机发送一个停止传输信号(P)，表示不再传输数据。

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

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

! X, h0 O) l$ N9 ^7 z2 F: \

& O  B, R, x9 a( {4 X
' C9 F( G7 q3 [5 g3 G2 VI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。 即：数据在SCL的上升沿到来之前就需准备好。并在下降沿到来之前必须稳定。

0 \- M9 H0 L& V( S" z; g5）地址及数据方向

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

/ o7 O; `5 Z9 ]" w
/ U7 ~" Y$ O8 S, l, a2 h读数据方向时，主机会释放对 SDA信号线的控制，由从机控制 SDA 信号线，主机接收信号，写数据方向时，SDA由主机控制，从机接收信号。

bsp_soft_i2c.c程序如下：

/ U" p6 w8 u/ ^/ n% Y/ u

1. #include "bsp_soft_i2c.h"   
   
2. #include <stdbool.h>
   
3. 
   * C2 e( Q3 n8 m# p5 E
4. // 初始化IIC的IO口
   
5. void I2C2_Soft_Init(void)
   
6. {
   6 `& @! v4 V/ O0 X
7.     GPIO_InitTypeDef GPIO_InitStructure;   // 定义GPIO结构体
   ) `7 C$ g1 y  p. {' M) c
8.         
   " }, g, b/ F% U- ^) y; E) e, _5 S
9.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);  // 打开GPIOB口时钟
   , p; a, Q4 f$ w# a* {
10.         
    
11.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;  // 输出
    . t  Y% ^  N# h2 I% q6 M* U% d8 t
12.     GPIO_InitStructure.GPIO_OType = GPIO_OType_OD; // 开漏
    
13.     GPIO_InitStructure.GPIO_Pin = Pin_SCL | Pin_SDA ; // IIC对应IO口
    ( u  o# E( C) o
14.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; // 上拉
    - z2 b) k" y  M  N1 a- g7 J
15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_3; // 50MHZ
    $ k/ J+ w! W8 h5 ^& E
16.     GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化GPIO
    # i) D5 j+ c1 M+ N; C2 ]: V' j
17.         
    
18.     I2C2_Stop();
    
19. }
    
20. 
    4 P* }! }5 j+ |$ ~. T
21. // 发送IIC起始信号
    
22. bool I2C2_Start(void)
    " v/ v% A$ ?0 l3 ]
23. {
    
24.     Pin_SCL_H; // 拉高时钟线
    
25.     Pin_SDA_H; // 拉高信号线
    + d: N0 K0 Y; Z" _, A
26.     I2C2_Delay1us();
    
27.     if(!Read_SDA_Pin)                return false;
    . G% f' h/ n3 Z; ]
28.     Pin_SDA_L;
    
29.     I2C2_Delay1us();
    
30.     Pin_SDA_L;
    
31.     I2C2_Delay1us();
    ' x" I4 c2 g: q$ L
32.     return true;
    4 b2 }4 a4 `8 c7 l
33. }
    
34. 
    1 k1 R; O* E% ~% H, g0 h) Z
35. // 发送IIC停止信号
    ! v8 b! [3 i  @
36. bool I2C2_Stop(void)
    4 j! U) n) s2 s$ h3 i, d, i
37. {
    5 l* a6 q/ p' i' Z# h
38.     Pin_SCL_H;
    8 n# M# _' u) P  D
39.     Pin_SDA_L;
    
40.     I2C2_Delay1us();
    " }% }0 D4 o( V7 d, [9 V
41.     if(Read_SDA_Pin)        return false;
    
42.     Pin_SDA_H;
    3 O4 i% f7 f4 C# _' Y# Z, @
43.     I2C2_Delay1us();
    
44.     if(!Read_SDA_Pin) return false;
    
45.     Pin_SDA_H;
    7 y+ f' S, |$ R: w2 \9 U
46.     I2C2_Delay1us();        
    
47.     return true;
    
48. }
      L3 V5 u$ u0 W. Z$ x
49. 
    ' Q- G! ^5 \& i$ J# u$ @7 \
50. // IIC发送ACK信号
    
51. void I2C2_Ack(void)
    
52. {
    
53.     Pin_SCL_L;
    
54.     I2C2_Delay1us();
    
55.     Pin_SDA_L;        
    2 P4 }4 w' [* C& N, |
56.     Pin_SCL_H;
    ) Q* ^$ I# Q$ b& ^2 Q+ u
57.     I2C2_Delay1us();
    ! p3 u9 [: m% Q$ `; P" F$ X
58.     Pin_SCL_L;
    ! q3 a3 i, n" j; g+ W* B
59.     Pin_SDA_H;
    
60.     I2C2_Delay1us();
    3 u1 M4 W8 a" a8 P
61. }
    ! _# u( {. _! d5 ]4 j6 O/ l' D. F
62. 
    
63. // IIC不发送ACK信号
    
64. void I2C2_NAck(void)
    6 y/ Y( o* y2 |' \
65. {
    % ^: ^1 K, w& A' h9 B
66.     Pin_SCL_L;
    & \& Q& m% n+ W, z) ^
67.     I2C2_Delay1us();        
    % o1 r$ z+ ]) Y' O8 @+ {
68.     Pin_SDA_H;
    ' v, x! W1 N4 n1 \! j/ W
69.     Pin_SCL_H;
    
70.     I2C2_Delay1us();
    
71.     Pin_SCL_L;
    
72.     I2C2_Delay1us();
    : Y' P) b% l3 b
73. }
    
74. 
      X; C; g6 H, ~
75. // IIC等待ACK信号
    3 r5 A2 ~! H! W2 `
76. uint8_t I2C2_Wait_Ack(void)
    
77. {
    ( f  ]3 K6 _. [9 t) k
78.     Pin_SCL_L;
    
79.     I2C2_Delay1us();        
    
80.     Pin_SDA_H;
    0 O  e* X& l& D  d) @  C' e% ^
81.     Pin_SCL_H;
    
82.     I2C2_Delay1us();        
    
83.     if(Read_SDA_Pin)
    
84.     {
    
85.         Pin_SCL_L;
    4 f, `0 b7 i+ Q* _$ H( Q
86.         I2C2_Delay1us();
    7 V. M5 V, @* R( T9 h% p8 U
87.         return false;
    $ J6 c& a/ R: M
88.     }
    5 g$ r2 X6 G. _1 a' X" t
89.     Pin_SCL_L;
    
90.     I2C2_Delay1us();
    
91.     return true;
    5 @3 C6 N( U. G) D9 p7 d+ m
92. }
    
93. 
    
94. // IIC发送一个字节
    
95. void I2C2_Send_Byte(uint8_t txd)
    
96. {
    
97.     for(uint8_t i=0; i<8; i++)
    
98.     {
    
99.         Pin_SCL_L;
    
100.         I2C2_Delay1us();
     . G* S4 a: |8 Z! i$ b
101.         if(txd & 0x80)
     - f# s7 t& T  }: L
102.             Pin_SDA_H;
     
103.         else
     
104.             Pin_SDA_L;
     4 i/ ]5 \+ V, v# H0 n0 F- R
105.             txd <<= 1;
     4 m: E* s* \" f5 X- l
106.             Pin_SCL_H;
     ( @. ]. I6 }2 u2 X; A$ z
107.             I2C2_Delay1us();
     
108.     }
     
109. }
     ! t) @% W8 y0 I$ S6 A
110. 
     8 K" D! j* \( v* R
111. // IIC读取一个字节
     
112. uint8_t        I2C2_Read_Byte(void)
     
113. {
     
114.     uint8_t rxd = 0;
     
115.     for(uint8_t i=0; i<8; i++)
     ' @" Q* h$ M  K  ?2 s! t; G
116.     {
     
117.         rxd <<= 1;
     8 R# D0 c+ n7 y7 T
118.         Pin_SCL_L;
     ( V6 z5 E- v4 d
119.         I2C2_Delay1us();
     
120.         Pin_SCL_H;        
       ?3 v; z' X+ c* I! E
121.         I2C2_Delay1us();               
     0 h: _3 e$ }* P6 R3 K
122.         if(Read_SDA_Pin)
     
123.         {
     ; F' j4 c  ?) F  G
124.             rxd |= 0x01;
     
125.         }
     
126.     }
     
127.     return rxd;
     
128. }
     
129. 
     
130. // 向从机指定地址写数据
     8 R3 F1 D/ a" M9 C7 C. f: N
131. bool I2C_Write_REG(uint8_t SlaveAddress, uint8_t REG_Address,uint8_t REG_data)
     
132. {
     6 i: n9 m) L3 x: w
133.     if(!I2C2_Start())                return false;
     
134.     I2C2_Send_Byte(SlaveAddress);
     ' `# z# ^. S# h+ ^
135.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     % }0 |$ y2 t6 C, N% u3 b
136.     I2C2_Send_Byte(REG_Address);
     
137.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
138.     I2C2_Send_Byte(REG_data);
     ' y4 F3 I# Q5 G8 e: l
139.     if(!I2C2_Wait_Ack()) { I2C2_Stop(); return false;        }
     
140.     if(!I2C2_Stop()) return false;
     
141.     return true;
     * r2 ~$ D4 j0 j0 d" j7 ]3 m
142. }
     
143. 
     1 o0 }: J, G& Q. K8 q2 I) E
144. // 从设备中读取数据
     - x4 h5 ]  r2 O# l0 m0 z6 p+ D
145. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address)
     ' V' C, x) g/ Q. N, e$ S
146. {
     , V, y" z; e$ r8 j7 t5 }! r
147.     uint8_t data;
     
148.     if(!I2C2_Start())        return false;
     
149.     I2C2_Send_Byte(SlaveAddress);
     
150.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     6 B3 z5 P8 P7 ~
151.     I2C2_Send_Byte(REG_Address);
     / J- i' @: ?5 U: H
152.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     9 N. h/ u1 j# A& E4 ?" L0 W+ i
153.     if(!I2C2_Start())        return false;
     ; i, C7 X8 t" ~6 i% I, z6 H' E
154.     I2C2_Send_Byte(SlaveAddress + 1);
     7 _4 m$ q1 Y' O( S5 P5 Y" E- t# [
155.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
156.     data = I2C2_Read_Byte();
     % V' M2 `: ^6 G2 D# i; S
157.     I2C2_NAck();
     
158.     if(!I2C2_Stop())        return false;        
     * P) F8 p0 O: x# I8 [0 U4 N/ W
159.     return data;
     $ v0 e) W2 \' n! v
160. }
     ( \9 Y* q# m, h% |- P
161. 
     7 q3 o6 D7 ]% ^* ~8 A( B) B- [( e8 n
162. // 连续写N个字节
     
163. bool I2C2_Write_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     , S; K) L/ L8 W3 A1 l! l$ n) L
164. {
     " y" M) N( s. p1 C2 P4 @& c4 P1 W
165.     if(!I2C2_Start())return false;
     
166.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     
167.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     7 Q! U" e; d" p' r* s) S
168.     I2C2_Send_Byte(REG_Address);   
     
169.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     % n8 J, {5 `- N- T9 I- R
170.     for(uint16_t i=0; i<len; i++)
     
171.     {
       E' m9 a" o& y' ?
172.         I2C2_Send_Byte(buf<i>);
     ; P0 h9 ~1 q/ E% O5 V
173.       </i>  if(i<len-1)
     
174.         {
     0 C+ c- r% c3 [  g! K
175.             if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
176.         }
     ; I$ x, |+ T: R, G, f$ C* y
177.     }
     
178.     I2C2_Stop();
     
179.     return true;
     3 a$ }# C0 t) h- N$ H" {  G
180. }
     0 n& D! s9 N1 }0 e. e
181. 
     ' P& d7 u7 K. F: a. L
182. // 连续读N个字节
     7 f9 ?2 S0 p) e
183. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     , V2 F4 L  S0 T
184. {
     
185.     if(!I2C2_Start())return false;
     
186.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     4 `1 e9 o, O. X7 l" m
187.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
188.     I2C2_Send_Byte(REG_Address);   
     / r8 y0 e! V1 E! O9 j
189.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
190.     if(!I2C2_Start())return false;
     $ f& O! A  h' a/ X4 m, u
191.     I2C2_Send_Byte(SlaveAddress | 1); // 读操作
     * F% e7 ~$ X: p( i
192.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
193.     for(uint16_t i=0; i<len; i++)
     ' V0 ^$ f* a8 ^+ i2 _5 U$ F
194.     {
     # \. E0 k% q' r: Y! R4 \
195.         buf = I2C2_Read_Byte();
     5 k: C. p8 {" Q0 G& ^
196.         if(i<len-1)
     
197.         {
     2 C/ e9 s  s5 h( R1 k" F
198.             I2C2_Ack();
     8 m) D# d! A) D8 B& P
199.         }
     ; j: H3 K, R+ S2 x8 l! c
200.     }
     + Y- J( U3 O5 G; E
201.     I2C2_NAck();
     3 M4 l5 g7 c7 j4 q; f( B, M, t( ^
202.     I2C2_Stop();
     & @1 k/ ?# t) Z. D
203.     return true;
     
204. }
     
205. 
     4 A/ T4 f+ b+ l% q( |
206. // 检查设备地址
     
207. bool I2C2_CheckDevice(uint8_t SlaveAddress)
     6 {* J/ R8 P8 {: v0 n5 {; p8 u
208. {
     ) P# c: A+ _$ h" m# A$ x
209.     if(!I2C2_Start())        return false;
     
210.     I2C2_Send_Byte(SlaveAddress);
     ) e4 W- `/ \! |+ Y: p) c
211.     if(!I2C2_Wait_Ack())
     ! ]! T8 C  y4 E0 c+ b/ d) Q# t8 D; v
212.     {
     0 o) H. b& M7 z/ c8 `
213.         I2C2_Stop();
     
214.         return false;               
     ; \( r* l% Z! D- ~
215.     }
     4 }  h9 ]0 a* L* \4 `3 l
216.     if(!I2C2_Stop())        return false;        
     
217.     return true;        
     3 r6 ~* ~# c! k' q7 I* Y
218. }

复制代码

$ N$ W! K/ e! u1 i( gbsp_soft_i2c.h程序如下：
7 e- v3 a( x" ~% b! |

1. #ifndef _BSP_SOFT_I2C_H_
   
2. #define _BSP_SOFT_I2C_H_
   
3. 
   0 u# W8 ^" k+ z# I7 r$ y. h
4. #include "stm32f0xx.h"
   ) i  s. ^4 |+ [2 w4 |
5. #include <stdbool.h>
   
6. 
   ( b' i( @* r3 h8 x" a
7. // 定义内联延时函数        
   6 I$ W/ J" z: \2 w" L. ]
8. static inline void I2C2_Delay1us(void)
   
9. {
   
10.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    / n; {6 q3 Z8 i. E9 c" ]
11.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    . A; Q+ g3 e: V0 K0 I
12.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    / D* e- P; D8 r3 z/ Q
13.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    0 c6 F$ A+ D' G& o* Q) j
14.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    
15.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();        
      |( b1 m3 u) t' T
16. }        
    6 f' I% B7 T# \$ O$ }
17. 
    ) B) \4 B) ^  Y& [% q4 {
18. 
    ) x/ n8 e+ j) `* j9 X, @% B
19. #define        I2C2_GPIOx  GPIOB
    
20. #define Pin_SCL                GPIO_Pin_10
    1 F, ~1 }3 m- E" ?0 U0 f+ H5 f6 x& Q
21. #define Pin_SDA                GPIO_Pin_11
      l  V: Z- F* A% n3 t. \; }
22. 
    
23. #define Pin_SCL_L                I2C2_GPIOx->ODR &= ~Pin_SCL
    * G, m. o. b2 E/ o/ S' ?
24. #define Pin_SCL_H                I2C2_GPIOx->ODR |= Pin_SCL
    
25. 
    
26. #define Pin_SDA_L                I2C2_GPIOx->ODR &= ~Pin_SDA
    1 e# g' a* ^% B  z7 F
27. #define Pin_SDA_H                I2C2_GPIOx->ODR |= Pin_SDA
    
28. 
    
29. #define Read_SDA_Pin        I2C2_GPIOx->IDR & Pin_SDA
    6 {; s4 N, G2 i" b
30. 
    
31. void I2C2_Soft_Init(void);                        
    
32. bool I2C2_Start(void);                                                
    
33. bool I2C2_Stop(void);                                          
    " m/ ?/ Z! @6 Z9 c5 O! P
34. void I2C2_Send_Byte(uint8_t txd);
    % d4 ?/ S9 U- I1 s5 `
35. uint8_t I2C2_Read_Byte(void);
    ' \. m" T( m9 @+ a! s0 p
36. uint8_t I2C2_Wait_Ack(void);                 
    
37. void I2C2_Ack(void);                                                        
    7 O0 y! \& a/ M: \! E& n5 h; X9 L
38. void I2C2_NAck(void);                                                
    1 d& w2 K/ ?9 M4 a8 p
39. 
    
40. bool I2C2_Write_REG(uint8_t SlaveAddress,uint8_t REG_Address,uint8_t REG_data);
    2 t. z4 r/ A, j% }' @" F0 z
41. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address);
    8 m( B5 @$ h+ B2 N3 N4 ~
42. bool I2C2_Write_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len);
    4 L8 l; n$ Y& [9 f" v% ?: t- f7 j
43. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len);
    - J- M1 L! u& P( u3 D3 J& {
44. bool I2C2_CheckDevice(uint8_t SlaveAddress);
    8 m, z# _& a$ C2 b8 P
45. #endif

复制代码

; @% Z% `/ x' g- c% J
' X, L4 U" e: g/ c
- j3 j6 R; g: l0 N+ L