所谓的硬件I2C就是STM32芯片上有其相应的外设和驱动电路，通过配置相应的寄存器，就可以完成I2C的通信。本节实验我们介绍软件模拟I2C，软件I2C一般是通过GPIO引脚，按照I2C的时序要求来控制引脚电平状态以产生通讯时序。

1、I2C通信流程中包含信号如下：
/ v; ~, p2 R# o& [' T0 ^9 L
& S7 w! N3 [% u8 F# h) r4 M开始信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。
6 y  D$ M  u; D; O结束信号：SCL为高电平时，SDA由低电平向高电平跳变，结束传送数据。
应答信号：发送器每发送一个字节，就在第9个时钟脉冲期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节；应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。对于反馈有效应答位ACK的要求是，接收器在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。 如果接收器是主控器，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主控接收器发送一个停止信号。
2、I2C总线时序图如下：

$ o7 B. \0 B* P
  g  x6 ^9 Z1 f. a) e+ R3、I2C通讯过程的基本结构如下所示：
3 ~; _8 {% V: q0 ^( o+ B8 ]
1）主机写数据到从机

2）主机由从机中读数据
- }0 w( I1 q0 @: `# M, W: w
8 w$ i% E/ o6 d2 G9 [

3）I2C通讯复合格式
! ^! v9 Q+ T  x$ z: e- h
) j4 T3 M( s# C  B, e5 [6 `* _

" b! G  X3 l0 x  b, f1 U
" R: Z$ f; k; A* S$ i0 N4 p1 z9 R3 x# P

0 N; F* b3 |* ?* B
其中 S 表示由主机的 I2C接口产生的传输起始信号(S)，这时连接到 I2C总线上的所有从机都会接收到这个信号。

( }3 b; o' a& @0 p, q# V起始信号产生后，所有从机就等待主机广播从机地址信号(SLAVE_ADDRESS)。在 I2C总线上，每个设备的地址都是唯一的，当主机广播的地址与某个设备地址相同时，这个设备就被选中了，没被选中的设备将会忽略之后的数据信号。根据 I2C协议，这个从机地址可以是 7位或 10位。
3 ?. }+ q+ v% u, ^) |
在地址位之后，是传输方向的选择位，该位为 0时，表示后面的数据传输方向是由主机传输至从机，即主机向从机写数据。该位为 1时，则相反，即主机由从机读数据。

8 P( K# G* w) F/ K$ ~* M' {从机接收到匹配的地址后，会返回一个应答(ACK)或非应答(NACK)信号，只有接收到应答信号后，主机才能继续发送或接收数据。
- t* ]8 t3 i+ s1 _4 r: s
/ G4 }1 _9 O% A( z若配置的方向传输位为“写数据”方向，即第一幅图的情况，广播完地址，接收到应答信号后，主机开始正式向从机传输数据(DATA)，数据包的大小为 8位，主机每发送完一个字节数据，都要等待从机的应答信号(ACK)，重复这个过程，可以向从机传输 N 个数据，这个 N没有大小限制。当数据传输结束时，主机向从机发送一个停止传输信号(P)，表示不再传输数据。

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

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

- [* t# _) L& K1 N, ^4）数据有效性时序图如下：

$ B9 e# u( \# X  z  \

) T! k% D- ^2 R' }: _
+ v% i9 w$ x8 ?- u1 s& M* CI2C总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。 即：数据在SCL的上升沿到来之前就需准备好。并在下降沿到来之前必须稳定。
+ x" _$ g8 Q& ~7 v8 z+ G2 v6 o/ k3 V
/ U' N: e3 n# m; J+ i6 a" ]! }5）地址及数据方向
( M$ F2 E5 `5 F4 R1 _
I2C 总线上的每个设备都有自己的独立地址，主机发起通讯时，通过 SDA 信号线发送设备地址(SLAVE_ADDRESS)来查找从机。I2C 协议规定设备地址可以是 7位或 10 位，实际中 7 位的地址应用比较广泛。紧跟设备地址的一个数据位用来表示数据传输方向，它是数据方向位(R/W)，第 8位或第 11 位。数据方向位为“1”时表示主机由从机读数据，该位为“0”时表示主机向从机写数据，如图：

% r$ a9 E& J* n

  i* w. M" S# W( L, N* p
8 O% i/ O/ F6 C* J  n/ ]8 s: ^读数据方向时，主机会释放对 SDA信号线的控制，由从机控制 SDA 信号线，主机接收信号，写数据方向时，SDA由主机控制，从机接收信号。

bsp_soft_i2c.c程序如下：

1. #include "bsp_soft_i2c.h"   
   # J. H5 J) A" U9 _5 U4 Z8 y
2. #include <stdbool.h>
   
3. 
   
4. // 初始化IIC的IO口
   
5. void I2C2_Soft_Init(void)
   " s9 B7 W, H; \% S4 ~/ m
6. {
   
7.     GPIO_InitTypeDef GPIO_InitStructure;   // 定义GPIO结构体
   # c3 I4 x5 J+ O! `/ e
8.         
   8 D0 X! i' w# H% b0 x9 k/ V# b. J1 h+ R
9.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);  // 打开GPIOB口时钟
   7 b3 O8 @% f) q
10.         
    ( d$ M% v/ g) A. _4 ]" B
11.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;  // 输出
    # r* H* e" ~( ~  s
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
    . G" I/ T8 C! q" W* v& I/ M
16.     GPIO_Init(GPIOB, &GPIO_InitStructure); // 初始化GPIO
    
17.         
    . R0 g, B) I( Q* B& ~% R
18.     I2C2_Stop();
    
19. }
    
20. 
    ' i$ [5 E: I# D6 ^( m9 H
21. // 发送IIC起始信号
    
22. bool I2C2_Start(void)
    
23. {
    
24.     Pin_SCL_H; // 拉高时钟线
    . n3 O; B* D' _; D/ v1 a
25.     Pin_SDA_H; // 拉高信号线
    
26.     I2C2_Delay1us();
    
27.     if(!Read_SDA_Pin)                return false;
    * ]" e: K5 L; a/ t8 V! ~; g7 w2 \! n
28.     Pin_SDA_L;
    # `- R4 u  V) Y9 V; m2 v4 u! s+ _
29.     I2C2_Delay1us();
    % `4 P' |" C! U; j
30.     Pin_SDA_L;
    6 }* U, T- z/ q. w3 u
31.     I2C2_Delay1us();
    + N3 l- X( q* V4 K/ H- }9 H
32.     return true;
    , ?2 u' ?2 O0 v( r2 i3 R
33. }
    
34. 
    
35. // 发送IIC停止信号
    4 f8 j0 Q8 f5 i+ S  n
36. bool I2C2_Stop(void)
    
37. {
    0 h- [  E$ {! C8 V/ P
38.     Pin_SCL_H;
    
39.     Pin_SDA_L;
    
40.     I2C2_Delay1us();
    ; Q! J% d# R+ E. l: a
41.     if(Read_SDA_Pin)        return false;
    / m( S4 X( ~- ?& y2 w
42.     Pin_SDA_H;
    9 O8 F8 E3 ^6 i/ M# q7 T
43.     I2C2_Delay1us();
    
44.     if(!Read_SDA_Pin) return false;
    
45.     Pin_SDA_H;
    3 S# |% ~: K$ M# C  B+ {
46.     I2C2_Delay1us();        
    2 j" [6 n$ x) T
47.     return true;
    5 \% {/ e3 g: P' F. H$ r
48. }
    ) v) t  U2 S# c+ }+ O) V
49. 
    
50. // IIC发送ACK信号
    
51. void I2C2_Ack(void)
    / B6 `, |) D; w7 x0 V8 Z
52. {
    
53.     Pin_SCL_L;
    
54.     I2C2_Delay1us();
    
55.     Pin_SDA_L;        
    ' w( f& g8 A4 C6 \$ N
56.     Pin_SCL_H;
    
57.     I2C2_Delay1us();
    
58.     Pin_SCL_L;
    * n8 e/ L% k6 ^' u- q. t, C( O6 K! u
59.     Pin_SDA_H;
    - W$ f  E# E7 J5 {/ l; c
60.     I2C2_Delay1us();
    " `! e/ g, g6 P
61. }
      K& N; _0 u& k# W
62. 
    
63. // IIC不发送ACK信号
    1 u3 W4 z, o# d% A+ K
64. void I2C2_NAck(void)
    
65. {
    $ ^1 `5 ^! u1 `. k0 k9 z( o7 n8 a
66.     Pin_SCL_L;
    ! j9 X$ u  A5 N1 C+ A% {: A! p. E# Q
67.     I2C2_Delay1us();        
    3 h( P; ^2 N! ~: q9 u
68.     Pin_SDA_H;
    
69.     Pin_SCL_H;
    ! M2 R! y1 E# ]4 ~$ Y' ^
70.     I2C2_Delay1us();
    
71.     Pin_SCL_L;
      q3 B( B* F# g' F
72.     I2C2_Delay1us();
    
73. }
    / d. k" C7 t% [% x* R3 i
74. 
    ( j  Y3 p: o6 P5 F* M
75. // IIC等待ACK信号
    # ]  o) e' V7 ]( ^
76. uint8_t I2C2_Wait_Ack(void)
    ( [* z) Y/ E: d1 I$ P9 K
77. {
    & V5 ^; L  q# G& x) U1 T
78.     Pin_SCL_L;
    9 w: L* \0 w% s; o* s8 [$ o( f" z6 t
79.     I2C2_Delay1us();        
    
80.     Pin_SDA_H;
    : q( F- x5 @+ G
81.     Pin_SCL_H;
    
82.     I2C2_Delay1us();        
    
83.     if(Read_SDA_Pin)
    
84.     {
    / K: p* R5 S- V0 M! A
85.         Pin_SCL_L;
    
86.         I2C2_Delay1us();
    
87.         return false;
    4 }( B+ N4 w# s& R5 g" P- K1 R+ i
88.     }
    , a8 r- s: f' D, k
89.     Pin_SCL_L;
    
90.     I2C2_Delay1us();
    
91.     return true;
    ! t) a' ^+ K1 |
92. }
    
93. 
    
94. // IIC发送一个字节
    3 p2 H* t0 b6 ]( |/ Y
95. void I2C2_Send_Byte(uint8_t txd)
    * W( E! E: n$ V8 E( S, L7 X
96. {
    
97.     for(uint8_t i=0; i<8; i++)
    8 w& c/ r4 ]7 R" h. Q& ?" h
98.     {
    
99.         Pin_SCL_L;
    ' v# I8 D7 l! o# G$ F
100.         I2C2_Delay1us();
     
101.         if(txd & 0x80)
     
102.             Pin_SDA_H;
     ! A! u: L! y7 u! d, k
103.         else
     / z. q/ X+ m& O7 P4 v- D. w1 N
104.             Pin_SDA_L;
     2 b' W. \/ T$ L
105.             txd <<= 1;
     
106.             Pin_SCL_H;
     / {  k. J2 k- C! C  ^% V
107.             I2C2_Delay1us();
     
108.     }
     & _7 D2 T6 {' ^" R1 A+ J
109. }
     
110. 
     6 a6 r$ V0 h7 z6 O
111. // IIC读取一个字节
       v& ]/ Q! d, w, z' ^
112. uint8_t        I2C2_Read_Byte(void)
     5 t! E' ?4 h" u) a( F" M+ P- ^
113. {
     
114.     uint8_t rxd = 0;
     
115.     for(uint8_t i=0; i<8; i++)
     
116.     {
     : ^& x/ ?8 j2 x; U1 U* n
117.         rxd <<= 1;
     
118.         Pin_SCL_L;
     
119.         I2C2_Delay1us();
     
120.         Pin_SCL_H;        
     # y% \7 W' e+ W7 |
121.         I2C2_Delay1us();               
     
122.         if(Read_SDA_Pin)
     ; S8 Z* r7 |2 _; z' F. a
123.         {
     % M  j1 v' z) a0 h
124.             rxd |= 0x01;
     - v4 `- s, |4 W
125.         }
     0 ^. W: V  ^  I+ g6 }( K$ t5 @
126.     }
     
127.     return rxd;
     
128. }
     
129. 
     & T" e3 [3 `7 y  P2 q! [+ O( y
130. // 向从机指定地址写数据
     * z% ^+ J( F0 b4 ?7 X5 G7 e3 r3 U
131. bool I2C_Write_REG(uint8_t SlaveAddress, uint8_t REG_Address,uint8_t REG_data)
     4 J: `+ ?5 S3 A+ C. p
132. {
     
133.     if(!I2C2_Start())                return false;
     6 j9 ]# u3 g9 U, A* O
134.     I2C2_Send_Byte(SlaveAddress);
     ! j. x& V: P! M6 s! H4 s
135.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     % P$ C; L: d" k6 \/ x+ k8 b
136.     I2C2_Send_Byte(REG_Address);
     0 j3 e* b! C$ S
137.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
138.     I2C2_Send_Byte(REG_data);
     2 W4 ~' y! \$ l) ^' J$ ]* L. @: ]
139.     if(!I2C2_Wait_Ack()) { I2C2_Stop(); return false;        }
     ) M  A& ~% o& [/ S9 g0 U6 m
140.     if(!I2C2_Stop()) return false;
     
141.     return true;
     
142. }
     
143. 
       [6 A5 g6 T8 s. [
144. // 从设备中读取数据
     
145. uint8_t I2C2_Read_REG(uint8_t SlaveAddress,uint8_t REG_Address)
     . O9 B7 M- n" R/ T0 q) D$ \
146. {
     % r1 d' a0 |2 Q
147.     uint8_t data;
     6 F# j0 P  P/ J$ i$ f! }6 ^& m% F  R
148.     if(!I2C2_Start())        return false;
     
149.     I2C2_Send_Byte(SlaveAddress);
     7 J6 Q7 \8 N  E8 y+ V" Z
150.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     5 Z" v/ X  r4 z# a6 o/ O1 z- ~
151.     I2C2_Send_Byte(REG_Address);
     
152.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     
153.     if(!I2C2_Start())        return false;
     : C7 R% A  i7 s, p! y2 ^
154.     I2C2_Send_Byte(SlaveAddress + 1);
     
155.     if(!I2C2_Wait_Ack()) { I2C2_Stop();        return false;        }
     & @  H+ p* E$ q. [( a
156.     data = I2C2_Read_Byte();
     ' O+ S$ u, I6 Q/ _, w! K
157.     I2C2_NAck();
     
158.     if(!I2C2_Stop())        return false;        
     
159.     return data;
     4 Z" L# C& T; M7 Z0 P1 `. O
160. }
     
161. 
     : A$ K- E: D# F  N3 P+ F# a4 T! g
162. // 连续写N个字节
     
163. bool I2C2_Write_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     % X2 M: n6 V9 U9 l
164. {
     . E- f% @' d5 h; z* a
165.     if(!I2C2_Start())return false;
     
166.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     
167.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     7 E6 b3 \& ^6 s( s
168.     I2C2_Send_Byte(REG_Address);   
     . w4 B$ E- B+ X# {' Y  r( C% y
169.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
170.     for(uint16_t i=0; i<len; i++)
     
171.     {
     
172.         I2C2_Send_Byte(buf<i>);
     - S8 q3 T- R' x- e
173.       </i>  if(i<len-1)
     * J) {9 S, d0 E, h4 `, M# S' u
174.         {
     $ ~: T- q2 W6 x; ]' r6 P
175.             if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     0 x) D& m0 m  f8 W- H3 O
176.         }
     
177.     }
     5 p) s+ N3 I: b
178.     I2C2_Stop();
     4 Q! B/ A8 W3 i1 D2 b$ y
179.     return true;
     ) I8 g9 n% K* {/ F" e# T
180. }
     ) o& K1 J6 e0 ]* B- l
181. 
     
182. // 连续读N个字节
     . X) B9 Q& b9 M# z
183. bool I2C2_Read_NByte(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t* buf, uint8_t len)
     9 k9 F( O5 J- ~' V6 w9 m
184. {
     9 R2 M  C: Q7 l- Q; g8 ?3 M+ T8 ]/ o
185.     if(!I2C2_Start())return false;
     
186.     I2C2_Send_Byte(SlaveAddress);  //发送设备地址+写信号
     5 ?" H; @* _' r
187.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     3 Z! A' v9 j' A* }
188.     I2C2_Send_Byte(REG_Address);   
       x8 W$ ~' y. U; D+ n3 C+ U
189.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
       \( y* G; x3 v& _2 H9 x9 ~7 g4 r
190.     if(!I2C2_Start())return false;
     
191.     I2C2_Send_Byte(SlaveAddress | 1); // 读操作
     
192.     if(!I2C2_Wait_Ack()){I2C2_Stop(); return false;}
     
193.     for(uint16_t i=0; i<len; i++)
     $ o# k4 }/ @7 K8 y6 k
194.     {
     
195.         buf = I2C2_Read_Byte();
     6 P4 N4 t$ M4 ~% v; i1 V
196.         if(i<len-1)
     7 s* _' f: U+ t' ^
197.         {
     
198.             I2C2_Ack();
       T  s( U- i2 n6 b* Q9 J8 L( g& ~
199.         }
     
200.     }
     & o$ j8 f! I* W
201.     I2C2_NAck();
     / G& R8 Z, I" W6 C$ Y9 e9 f
202.     I2C2_Stop();
     
203.     return true;
     
204. }
     . t. }/ q& Y  z" c1 O
205. 
     ' @! }% U7 A! z* d5 r
206. // 检查设备地址
     ; r* q) m0 @, O* k9 s# O, p
207. bool I2C2_CheckDevice(uint8_t SlaveAddress)
     
208. {
     
209.     if(!I2C2_Start())        return false;
     0 E1 k1 ~" p( C: H* D
210.     I2C2_Send_Byte(SlaveAddress);
     
211.     if(!I2C2_Wait_Ack())
     
212.     {
     1 g# _1 V+ j% N; v0 A8 {
213.         I2C2_Stop();
     
214.         return false;               
     4 G# I: ~4 p; o7 e9 w" f+ x
215.     }
     4 f' V* _! _" c- T# s3 s
216.     if(!I2C2_Stop())        return false;        
     $ b" {8 B! n, s8 P- ]
217.     return true;        
     
218. }

复制代码

; A  m. U- P* T" Y: B/ s2 Lbsp_soft_i2c.h程序如下：

" J+ v1 a) E) v9 }0 @8 l

1. #ifndef _BSP_SOFT_I2C_H_
   1 p5 O% F( t5 h; ]- c- i
2. #define _BSP_SOFT_I2C_H_
   
3. 
   / ]' ]; G2 M6 w* b) ?, f
4. #include "stm32f0xx.h"
   
5. #include <stdbool.h>
   6 X% n- y4 _# k1 T
6. 
   
7. // 定义内联延时函数        
   9 B5 b* j& P4 d, `* d- B7 }# d
8. static inline void I2C2_Delay1us(void)
   8 _8 A; P1 d$ d: i9 e3 }! O
9. {
   3 e) E, X" B# q' |1 t  V9 A" u
10.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    % H: f4 L1 B+ r# I4 M
11.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    * l( B/ A3 J* E/ W
12.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    5 A& k% c  n! P% P4 G: h
13.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    : x2 n8 o) \0 F
14.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();
    ' y) j' D$ g8 R% O; A" Z3 t
15.         __nop();__nop();__nop();__nop();__nop();__nop();__nop();__nop();        
    
16. }        
    ' G& I0 s! _; A4 S
17. 
    
18. 
    
19. #define        I2C2_GPIOx  GPIOB
    
20. #define Pin_SCL                GPIO_Pin_10
    
21. #define Pin_SDA                GPIO_Pin_11
    
22. 
    / X& M" X2 X5 x% P8 j4 K1 v
23. #define Pin_SCL_L                I2C2_GPIOx->ODR &= ~Pin_SCL
    # ?( e2 c, X1 w- r4 i% d! v9 n
24. #define Pin_SCL_H                I2C2_GPIOx->ODR |= Pin_SCL
    8 W! n; ~6 U/ m% b. J
25. 
    
26. #define Pin_SDA_L                I2C2_GPIOx->ODR &= ~Pin_SDA
    : y2 a6 a! H+ S( L
27. #define Pin_SDA_H                I2C2_GPIOx->ODR |= Pin_SDA
    ' M! A. A. j8 g- s4 [- T) x
28. 
    
29. #define Read_SDA_Pin        I2C2_GPIOx->IDR & Pin_SDA
    / n- z$ R# r1 j( J
30. 
    
31. void I2C2_Soft_Init(void);                        
    
32. bool I2C2_Start(void);                                                
    ' ]! Z7 S/ ]4 s* }. e
33. bool I2C2_Stop(void);                                          
    
34. void I2C2_Send_Byte(uint8_t txd);
    
35. uint8_t I2C2_Read_Byte(void);
    9 t, j' b9 c- Q: H7 Z$ o; d: q' }
36. uint8_t I2C2_Wait_Ack(void);                 
    ! t/ s/ r0 x% w5 W1 D6 l$ S. i
37. void I2C2_Ack(void);                                                        
    
38. void I2C2_NAck(void);                                                
    3 L+ f" A( ?$ n+ ?5 Y
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);
    
44. bool I2C2_CheckDevice(uint8_t SlaveAddress);
    ( {# ^& w9 h5 T0 _" u8 N+ O
45. #endif

复制代码

2 Q3 Y  M% l) {