16.1 关于I2C
6 S2 s* ?0 s4 U16.1.1 I2C协议

I²C（Inter-Integrated Circuit），常读作“I方C”,它是一种多主从架构串行通信总线。在1980年由飞利浦公司设计，用于让主板、嵌入式系统或手机连接低速周边设备。如今在嵌入式领域是非常常见通信协议，常用于MPU/MCU与外部设备连接通信、数据传输。
% R) Q( L: o+ P5 j
I²C由两条线组成，一条双向串行数据线SDA，一条串行时钟线SCL。每个连接到总线的设备都有一个独立的地址，主机可以通过该地址来访问不同设备。因为I²C协议比较简单，常常用GPIO来模拟I²C时序，这种方法称为模拟I²C。如果使用MCU的I²C控制器，设置好I²C控制器, I²C控制器就自动实现协议时序，这种方式称为硬件I²C。因为I²C设备的速率比较低，通常两种方式都可以，模拟I²C方便移植，硬件I²C工作效率相对较高。
/ b  Y) r8 \/ C  ?! M) U: G7 F2 c' D
关于I²C协议，通过下面例子进行一个形象的比喻方便大家理解，如图 16.1.1 所示，老师（MCU）将球（数据）传给众多学生中的一个（众多外设设备中的一个）。
; r) h& N1 u2 Y0 h$ U

; B* H6 g" Q3 f) \5 `; ]/ v# C# c

图 16.1.1 I²C协议比喻

首先老师将球踢给某学生，即主机发送数据给从机，步骤如下：
4 X7 H% H( o  E4 c, [4 Q( a( u
1) 老师：开始了(start)；
/ i! R' t0 [# u! t
( i6 q* j  Y0 k+ Y; A2) 老师：A！我要发球给你！(地址/方向)；

1 n  K- P( A6 T6 D3) 学生A：到！(回应)；
) y/ u4 C2 T  Q( z9 h6 U1 h
4) 老师把球发出去（传输）；

" q, M5 X" S' A% `$ E0 [1 e5) A收到球之后，应该告诉老师一声（回应）；

$ K7 g; [( x. j7 c3 k6) 老师：结束（停止）；
3 \6 k  Z/ z: p7 }+ c


* |: [2 W# L% Y$ C4 D接着老师让学生把球传给自己，即从机发送数据给主机，步骤如下：
2 _  @3 A8 ?6 g' ^3 `
1) 老师：开始了(start)；

2) 老师：B！把球发给我！(地址/方向)；

3) 学生B：到！
0 G  x9 {+ f; m; x: ]" J! ~! s
4) B把球发给老师（传输）；
7 S0 A* l/ D- Q9 Z
5) 老师收到球之后，给B说一声，表示收到球了（回应）；
: f3 D  L; y, O1 B
6) 老师：结束（停止）。
: P2 ]6 E6 j9 R( M4 [7 n0 ^, ]


从上面的例子可知，都是老师（主机）主导传球，按照规范的流程（通信协议），以保证传球的准确性，收发球的流程总结如下：

① 老师说开始了，表示开始信号(start)；

② 老师提醒某个学生要发球，表示发送地址和方向(address/read/write)；
) x* z- m" k& v% a* x* j! ~3 F
③ 该学生回应老师(ack)；
/ K5 `0 f( k. o3 c# u
( I$ g/ J) Z/ f7 r④ 老师发球/接球，表示数据的传输；

9 i, G9 X; ]4 A0 w⑤ 收到球要回应：回应信号(ACK)；
+ B- B6 h8 e6 c' E2 m, M
⑥ 老师说结束，表示IIC传输结束(P)。


0 D- @% a: n# a
0 R! ~. v. v4 D4 p以上就是I²C的传输协议，如果是软件模拟I²C，需要依次实现每个步骤。因此，还需要知道每一步的具体细节，比如什么时候的数据有效，开始信号怎么表示。
  ^5 U* Z8 ]$ d" q# i. I3 b
1 q4 n& x% s, T0 s, h
1 |' I2 ^2 G: y, F
/ O5 n7 t) J5 n* F! }数据有效性

$ \; F; U" M0 Q# R* M* I, kI²C由两条线组成，一条双向串行数据线SDA，一条串行时钟线SCL。SDA线上的数据必须在时钟的高电平周期保持稳定，数据线的高或低电平状态只有在 SCL 线的时钟信号是低电平时才能改变。换言之，SCL为高电平时表示有效数据，SDA为高电平表示“1”，低电平表示“0”；SCL为低电平时表示无效数据，此时SDA会进行电平切换，为下次数据表示做准备。数据有效性示意图如图 16.1.2 所示。
8 F) M8 T! ?/ b6 m/ r4 k5 u6 ]

图 16.1.2 数据有效性

' v* t( ~$ h6 Z4 N, {
开始信号和结束信号

I²C起始信号（S）：当SCL高电平时，SDA由高电平向低电平转换；
/ I! w/ ^* P- b. I4 n5 [
I²C停止信号（P）：当SCL高电平时，SDA由低电平向高电平转换；

; k; x; D+ \: E

- M4 B5 D. E  d& }
# i8 h" Y/ l5 h6 B+ g

图 16.1.3 开始信号和结束信号

+ s9 U" G9 h0 d: y, i1 F

4 u( `# X5 t% i" g' e& ^应答信号                          

I²C每次传输的8位数据，每次传输后需要从机反馈一个应答位，以确认从机是否正常接收了数据。当主机发送了8位数据后，会再产生一个时钟，此时主机放开SDA的控制，读取SDA电平，在上拉电阻的影响下，此时SDA默认为高，必须从机拉低，以确认收到数据。
3 t7 {8 O$ {1 N( J6 Z& e
. C. ]1 Q* [& j1 Z3 E& E

9 O/ Q! V1 @; _, m" m- U  Y
" n, C0 r- [3 e; c

图 16.1.4 数据传输格式和应答信号

' I1 X% }0 O3 h4 L3 D5 l# t# n! P. r( Q
7 g& z1 d  u+ `完整传输流程  
: E" a. B7 r" G8 B
I²C完整传输流程如下：
- v6 t4 W3 q( U6 [! {6 S/ G+ ~
2 i2 q1 @) ~2 d. X( O& p6 z( U① SDA和SCL开始都为高，然后主机将SDA拉低，表示开始信号；
2 Q0 S, {: X- s4 ^( P" j8 e
0 m' e4 C) v/ n! `" P5 l9 Z② 在接下来的8个时间周期里，主机控制SDA的高低，发送从机地址。其中第8位如果为0，表示接下来是写操作，即主机传输数据给从机；如果为1，表示接下来是读操作，即从机传输数据给主机；另外，数据传输是从最高位到最低位，因此传输方式为MSB（Most Significant Bit）。
- S" T8 V5 C0 v- i3 Y; b
0 C( J# ^) q7 k& t; A③ 总线中对应从机地址的设备，发出应答信号；

% ]0 ^9 a4 \$ H/ x- d3 Q/ K④ 在接下来的8个时间周期里，如果是写操作，则主机控制SDA的高低；如果是读操作，则从机控制SDA的高低；
$ j% C" u4 K/ i: l! G+ H
0 m" l" p0 u# R6 Z0 ?& s# n⑤ 每次传输完成，接收数据的设备，都发出应答信号；
! S5 y2 K  a$ C& }
& K' B  |! i" k- \⑥ 最后，在SCL为高时，主机由低拉高SDA，表示停止信号，整个传输结束；
9 A. @4 l4 o* T' G; ^# J5 Q
( s" \5 A9 \1 W8 A4 s) l. `
& ]$ z' S/ K# |/ m) |) A7 H

1 S) v. H; n) e- m& ?( W8 y$ ^! e

图 16.1.5 I2C传输时序

16.1.2 EEPROM介绍

EEPROM的全称是“电可擦除可编程只读存储器”，即Electrically Erasable Programmable Read-Only Memory。通常用于存放用户配置信息数据，比如在开发板首次运行时，需要屏幕校准，校准后的配置信息就可以保存在EEPROM里，开发板断电后配置信息不丢失，下次启动，开发板自动读取EEPROM的校准配置信息，就不需要重新校准。

+ {7 G! [2 t1 h; AEEPROM和Flash的本质上是一样的，Flash包括MCU内部的Flash和外部扩展的Flash，本开发板就有一个SPI接口的外部Flash（W25Q64），在后面SPI接口再讲解。从功能上，Flash通常存放运行代码，运行过程中不会修改，而EEPROM存放用户数据，可能会反复修改。从结构上，Flash按扇区操作，EEPROM通常按字节操作。两者区别这里不再过多赘述，读者理解EEPROM在嵌入式中扮演的角色即可。

% O$ `! o) j  V2 @1 a# W- W1 v
5 R- F% ?7 X$ `
结构组成
, Z( m, r& _- W" i5 Y
EEPROM类型众多，其中比较常见是AT24Cxx系列，从命名上看，AT24Cxx中xx的单位是K Bit，如AT24C08，其存储容量为8K Bit。本开发板上的EEPROM型号为AT24C02，其存储容量为2K Bit，2*1024=2048 Bit。
# \  V& A3 P9 z6 [9 K' q
对于AT24C01/02，每页大小为8 Byte，对于AT24C04/08/16，每页大小为16 Byte。如图 16.1.6 所示，AT24C02由32页（Page）组成，每一页由8个字节（Byte）组成，每个Byte由8位（Bit）组成，Bit为最小存储单位，存放1个0或1。

% }+ z. Z0 c$ q

% S2 X/ Y* L+ D  b0 ]
: V+ M- u, a/ s+ R; O" R! O

图 16.1.6 AT24C02结构示意图

& N! @! x/ @6 C# S
7 O  U# e9 ~* x7 ?- }
, l' m3 C; g0 m( u% }' ~设备地址  

" f) r, W) m$ S5 i3 N* `2 |I²C设备都会有一个设备地址，不同容量的AT24C02，设备地址定义会有所差异，由芯片数据手册《AT24Cxx.pdf》可知，如图 16.1.7 所示。

4 }6 J2 P/ [: P

图 16.1.7 AT24Cxx设备地址定义

0 a# V( U5 U7 hAT24C02的容量为2K，对应上图中的第一行，高四位固定为“1010”，中间三位由A2、A1、A0引脚的电平决定，比如A2~0引脚全接地，则值为“000”，最后的最低位为读写位，0代表写命令，1代表读命令。

A2、A1、A0引脚电平需要由原理图决定，假设全接电源地，则如果需要向AT24C02写数据，则发送地址“1010 0000”，如果需要向AT24C02读数据，则发送地址“1010 0001”。
7 R$ v+ C5 `3 @/ t
3 n$ A7 Z* Y9 D. t9 F3 l假设开发板有多个AT24C02挂在同一I²C总线上，通过这个规则，只需设计电路时，让A2、A1、A0引脚电平不同，即可区分两个AT24C02。

对于容量再大一点的AT24Cxx系列，比如AT24C04，器件地址由A2、A1引脚决定，数据空间有P0决定。比如对AT24C04的0~2K空间操作，则P0为0，对2K~4K空间操作，则P0为1。

9 A# q- A* `# n! Z: H4 Z# i
" X2 m: C$ b$ i6 I4 I
! q9 f  u6 n$ |7 N! e; z9 W: I写AT24Cxx  

AT24Cxx支持字节写模式和页写模式。字节写模式是一个地址一个数据的写；页写模式是连续写数据，一个地址多个数据的写，但是页写模式不能自动跨页，如果超出一页长度，超出的数据会覆盖原先写入的数据。
0 x9 Z, R- G, @2 f8 `5 Y
如图 16.1.8 所示，为AT24Cxx字节写模式的时序，在MCU发出开始信号（Start）后，发出8 Bit的设备地址信息（图中读写位为低电平，即写数据），待收到AT24Cxx应答信号后，再发出要写的数据地址，再次等待AT24Cxx应答，最后发出8 Bit数据写数据，待AT24Cxx应答后，发出停止信号（Stop），完成一次单字节写数据。

图 16.1.8 AT24Cxx字节写模式时序

; K+ z, A4 c' uAT24C02容量为2K，因此数据地址范围为0x00~0xFF，即0~255，每个数据地址每次写1Byte，即8bit，也就刚好256*8=2048Bit。对于1K容量的产品，数据地址范围为0x00~0x7F，最高位不会用到，因此图中数据地址的最高位为“*”，意思是对于1K容量的产品，该位无需关心。
' j' p. p. F/ S2 r) K
' q) A. [2 `  P% Q2 D1 Y

2 r0 K4 d& A* o- _/ W3 A

图 16.1.9 单字节写模流程图

图 16.1.10 为AT24Cxx的页写模式时序，与字节写模式的差异在于，不是只发送1Byte数据，而是任意多个。需要注意，该模式不能跨页写，遇到跨页时，需要重新发送完整的时序。
" U( s* u8 [/ _- X& A' X6 O/ v
. |6 i0 F  n/ `- L  d* }4 J; |6 t

9 m$ \3 S8 i& @) z

图 16.1.10 AT24Cxx页写模式时序

值得一提的是，《AT24Cxx.pdf》里提到每次写完之后，再到下次写之前，需要间隔5ms时间，以确保上次写操作在芯片内部完成，如图 16.1.11 所示。

& I. Y$ [1 N% V

1 p. o( O$ a( ]% Y1 P$ p7 J
/ c) M5 \( t/ x0 i" l

图 16.1.11 AT24Cxx写间隔

6 A. y  Q/ ?# L6 g0 v
读AT24Cxx

AT24Cxx支持当前地址读模式、随机地址读模式和顺序读模式。当前地址读模式就是在上一次读/写操作之后的最后位置，继续读出数据，比如上次读/写在地址n，接下来可以直接从n+1处读出数据；随机地址读模式是指定数据地址，然后读出数据；顺序读模式是连续读出多个数据。
( A) H+ |# M% _1 ^8 n( b" n" h! J5 P
在当前地址读模式下，无需发送数据地址，数据地址为上一次读/写操作之后的位置，时序如图 16.1.12 所示，注意在结尾，主机接收数据后，无需产生应答信号。

3 L4 a8 j# x/ @9 U$ `5 b8 Y, V3 ~0 p

. N$ B& H6 J3 ]7 C' U& Y

图 16.1.12 AT24Cxx当前地址读模式

在随机地址读模式下，需要先发送设备地址，待读的数据地址，接着再重新发出开始信号，设备地址，读出数据，时序如图 16.1.13 所示。

0 Q* Y# z) I+ S% D. u! K: u% V
, C* }# L$ q: n' o, |9 P

图 16.1.13 AT24Cxx随机地址读模式

在顺序读模式下，需要先从当前地址读模式或随机地址读模式启动，随后便可连续读多个数据，时序如图 16.1.14 所示
' b+ N' {& v+ f2 H0 Z

% L( K2 N! J: n8 X: o

图 16.1.14 AT24Cxx顺序读模式

& P) i2 J2 Z0 w; k: k, ?

* Q- `, U$ ~2 a
16.2 硬件设计
) U) k; J% i6 q; C6 F/ N; S如图 16.2.1 为开发板EEPROM部分的原理图，U6为AT24C02芯片，它的A0、A1、A2都接地，因此该设备地址为“1010 000X”，当读该设备时，X为1，写该设备时，X为0。
& F0 U* j* H( e* I
U4的7脚为写保护引脚（Write Protect，WP），当该引脚为高，则禁止写AT24C02，这里直接拉低WP，任何时候都可直接写AT24C02。

此外，I2C的两个脚SCL和SDA都进行了上拉处理，从而保证I2C总线空闲时，两根线都必须为高电平。如果没有上拉，在主机发送完数据后，放开SDA，此时SDA的电平状态不确定，可能为高，也可能为低，无法确定是从机拉低给出应答信号。
: W# H" M& i0 g  Z8 ]0 ~' d3 }
( O- ?+ n/ o$ a  `6 B0 g结合原理图可知，PB6作为了I2C1的SCL，PB7作为了I2C1的SDA。
! ~$ E; k6 r9 r* L2 _5 E+ I
2 Q; B( R3 I1 M" h

图 16.2.1 EEPROM模块原理图

" j* g! y# I* B. ^. |& S
16.3 软件设计
: J) ?) _$ P2 t" l! D16.3.1 软件设计思路

3 H% U# Q/ H: K2 A) G6 Z4 ~3 L6 P实验目的：本实验通过GPIO模拟I2C总线时序，对EEPROM设备AT24C02进行读写操作。

5 Q. {/ [9 m% U7 \4 n3 u1) 引脚初始化：GPIO端口时钟使能、GPIO引脚设置为输入/输出模式（PB6、PB7）；
+ m" i" q5 o% \/ A- m
2) 封装I2C每个环节的时序函数：起始信号、响应信号、读写数据、停止信号；
/ Y- M! W- l7 E: l0 E( D. G" b: m
* e, a: {9 U. P3) 使用I2C协议函数，实现对AT24C02的读写；
& E) F1 _, d, X9 t$ T( z
( K4 p* E: u4 e" \4 m; s4) 主函数，每按一次按键，写一次AT24C02，接着读出来验证是否和写的数据一致；

1 {: u+ S. n% j, c' `9 p本实验配套代码位于“5_程序源码\8_通信—模拟I2C\”。

: |) q2 r% r! w5 ~$ q+ u  K2 _

16.3.2 软件设计讲解

1) GPIO选择与接口定义

首先定义SCL和SDA引脚，引脚的高低电平宏定义，如代码段 16.3.1 所示。

5 e6 L" o5 |# b+ {( N  k代码段 16.3.1 模拟I2C引脚相关定义（driver_i2c.h）
# t3 l( y8 L  U
' A, X9 x% Y! A0 d5 l$ d( x

1. /************************* I2C 硬件相关定义 *************************/
   
2. 
   
3. #define ACK                 (0)
   + F! \, y* l$ {
4. 
   
5. #define NACK                (1)
   
6. 
   0 L4 q' g4 Y. @4 t" |
7. 
   
8. 
   1 c% m1 R% v1 Q# {
9. #define SCL_PIN             GPIO_PIN_6
   / C$ G0 i, x% l8 [0 k* x
10. 
    
11. #define SCL_PORT            GPIOB
    
12. 
    . E7 M6 o/ V* a+ R/ i
13. #define SCL_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    $ S% |) \4 }; D4 d# E
14. 
    & J2 D/ U( J, u, S. `  W
15. 
    ' O9 e' W: s9 I. ?2 b7 c
16. 
    
17. #define SDA_PIN             GPIO_PIN_7
    
18. 
    
19. #define SDA_PORT            GPIOB
    ; @+ N: w* p, v2 t" [
20. 
    6 X! x" ?6 ^$ c
21. #define SDA_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    
22. 
    
23. 
    2 V- L$ X. Z1 j+ c5 `9 |% r) D
24. 
    
25. #define SCL_H()             HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_SET)
    0 `( K* S# n+ o6 k7 h# H5 F" J; [8 s
26. 
    : o( [# y' I4 F$ {! g" ?7 I
27. #define SCL_L()             HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_RESET)
    
28. 
    
29. #define SCL_INPUT()         HAL_GPIO_ReadPin(SCL_PORT, SCL_PIN)
    
30. 
    
31. 
    
32. 
    5 H) _- h5 r( [
33. #define SDA_H()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_SET)
    
34. 
    * X5 r5 Z5 q) i+ ?, z% Z3 M1 n5 S0 V
35. #define SDA_L()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_RESET)
    
36. 
    ) o- w6 u7 G8 p! }3 h3 J
37. #define SDA_INPUT()         HAL_GPIO_ReadPin(SDA_PORT, SDA_PIN)

复制代码

; I! k, z5 ?; s接着将两个GPIO引脚初始化，使能引脚时钟，先默认设置为输出模式。SCL引脚为时钟信号，始终为输出模式，SDA引脚为数据引脚，可能输出或者输入，因此还需要编写函数实现输入、输出的切换，如代码段 16.3.2 所示。
8 C+ i# ^# U7 U& h
代码段 16.3.2 I2C引脚初始化（driver_i2c.c）

1. /*
   ( v- t0 s! E) z6 ^  Q
2. *  函数名：void I2C_Init(void)
   + {+ S- x* C" u; Q2 S8 L& ^
3. *  输入参数：
   
4. *  输出参数：无
   0 t( B8 [5 I4 F( s  [* s& x
5. *  返回值：无
   
6. *  函数作用：初始化模拟I2C的引脚为输出状态且SCL/SDA都初始为高电平
   : ~2 i9 L! ^- H
7. */
     z8 Y7 w- z5 l9 a. }; P! D
8. void I2C_Init(void)
   
9. {
   
10.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    4 K5 m" n) H$ {& I7 s
11. 
    
12.     SCL_PIN_CLK_EN();
    " i' a. q5 G7 R! }
13.     SDA_PIN_CLK_EN();
    % @9 {5 B# y8 H% }- E
14. 
    
15.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    
16.     GPIO_InitStruct.Pull      = GPIO_NOPULL;
      k. b* E8 q' ]( v7 n: L
17.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
18. 
    
19.     GPIO_InitStruct.Pin       = SCL_PIN;
    , v/ f7 s4 [4 R5 u$ l) K7 T
20.     HAL_GPIO_Init(SCL_PORT, &GPIO_InitStruct);
    $ f+ ?  T% Y% \4 P5 R" k
21. 
    7 a' d- a: b( V3 V1 j) a* Q
22.     GPIO_InitStruct.Pin       = SDA_PIN;
    6 r7 C9 r& W; J5 T
23.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    - z! J( |- l. K1 C/ \
24. 
    2 U+ [+ x+ L" {$ R0 W4 u
25.     SCL_H();
    
26.     SDA_H();
    " g* p. H/ j% @" E  x( G
27. }
    
28. 
    
29. /*
    / h% N2 H# U5 o% H& u
30. *  函数名：static void I2C_SDA_OUT(void)
    
31. *  输入参数：
    6 ?; _3 a, Z* ]. j8 d9 N" L
32. *  输出参数：无
    / c, x: J5 m; c: v' H
33. *  返回值：无
    5 j7 [3 E+ C  H0 U0 g$ P1 n. l1 R
34. *  函数作用：配置SDA引脚为输出
    6 O7 x! m1 M# {" d. [" c
35. */
    1 e2 i$ V0 f% v4 i; a5 R
36. static void I2C_SDA_OUT(void)
    * v$ f& B. D4 r6 R: I! y9 `
37. {
    9 h( T* |; h; F; H$ h, J; x: {
38.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    2 o" {, O, c( O3 K
39. 
    1 T7 H8 F. g: q# A' }
40.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    ' B; K: m' P! u9 S
41.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    3 @6 K& F3 _0 q* a6 H2 r
42.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    ( |7 Y$ b  n' c6 J
43. 
    ) U0 m( A' X/ C; ?' N5 J
44.     GPIO_InitStruct.Pin       = SDA_PIN;
    & U2 n3 U- d7 q: G+ f
45.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    
46. }
    
47. 
    
48. /*
    
49. *  函数名：static void I2C_SDA_IN(void)
    : s& b0 }& n/ P$ F0 b" U
50. *  输入参数：
    $ T3 D( m2 J5 ]/ m0 {( x- Q
51. *  输出参数：无
    ' u: M# v- [0 P: K4 N
52. *  返回值：无
    ! h) o! H" ]: W* @/ a* a2 d
53. *  函数作用：配置SDA引脚为输入
    ( _8 C7 g6 }. |' j
54. */
    
55. static void I2C_SDA_IN(void)
    
56. {
    
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
58. 
    6 b. |" I( n2 C3 O" D, e: U
59.     GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
    $ K" O; u6 \+ Y0 p! {7 a
60.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    1 }+ r" v1 X/ P
61. 
    / o, X+ `* N: S) T5 P
62.     GPIO_InitStruct.Pin       = SDA_PIN;
    
63.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    1 k- v8 f* S9 k3 M4 r% h
64. }

复制代码

" ]" `+ N/ e$ E1 L3 L2) I2C时序函数

" a9 W8 L) O) b8 K/ j7 g0 u+ O开始信号/结束信号
* Q$ O0 Y$ E* U
) V  ^( C5 h$ C  f( J9 P. Q参考前面图 16.1.3 所示的开始信号和结束信号编写程序。对于开始信号，首先将SDA和SCL都拉高，随后SDA拉低，再SCL拉低。对于结束信号，首先拉低SDA，拉高SCL，再拉低SDA，代码如代码段 16.3.3 所示。
& L' ~8 ^8 A0 {% J& a* e
代码段 16.3.3 I2C开始信号和结束信号（driver_i2c.c）
. I# x9 f1 R: ^/ F# |9 X' p
+ P/ D7 q3 O% ?7 }" u3 m

1. /*
   
2. *  函数名：void I2C_Start(void)
   
3. *  输入参数：
   
4. *  输出参数：无
   
5. *  返回值：无
   
6. *  函数作用：I2C开始信号
   
7. */
   
8. void I2C_Start(void)
   
9. {
   
10.     I2C_SDA_OUT();
    4 M% j# J0 W8 ]6 h; a: D0 O0 K: j) v( G' K
11. 
    1 h- c0 O1 n/ E- N
12.     SCL_H();
    
13.     I2C_Delay();
    
14. 
    ( V; N! m1 I# |/ R
15.     SDA_H();
    
16.     I2C_Delay();
    # u3 [: A  c! o7 `) m
17. 
    ) J/ w7 e$ e4 @. O9 B
18.     SDA_L();
    2 l0 E  n/ Q* b$ z: I! n7 s: W& u
19.     I2C_Delay();
    
20. 
    ; a. f. n; l4 e% V" }* w8 ~
21.     SCL_L();
    1 z: B8 O) U( s. x% |
22.     I2C_Delay();
    
23. }
    # \7 V; Y: Y- ]" z, v% H
24. 
    6 Q6 U6 c0 O0 l) P* k
25. /*
    2 q9 Q* w5 U" x2 u! Q$ w0 y* X
26. *  函数名：void I2C_Stop(void)
    
27. *  输入参数：
    ; D& Q2 R3 D# [! \
28. *  输出参数：无
    
29. *  返回值：无
    1 `# Q1 m( _3 ~( m- b1 y
30. *  函数作用：I2C停止信号
    
31. */
    
32. void I2C_Stop(void)
    
33. {
    & N3 |; b1 f* ~9 b) M  ~7 m
34.     I2C_SDA_OUT();
    
35. 
    / Z  G# q# P9 n
36.     SDA_L();
    
37.     I2C_Delay();
    
38. 
    
39.     SCL_H();
    
40.     I2C_Delay();
    6 G' r+ B0 g$ ~
41. 
    9 C& Y0 i6 K' |% Z+ W
42.     SDA_H();
    
43.     I2C_Delay();
    
44. }

复制代码

0 N& u9 G8 {3 \4 N2 i应答信号/非应答信号/等待应答信号
* g& K8 \, v' C1 ]
! B3 [+ Y  R6 j6 W1 z1 v参考前面图 16.1.4 所示，编译应答信号，如代码段 16.3.4 所示。

4 k& }4 u7 `- f代码段 16.3.4 应答/非应答/等待应答信号（driver_i2c.c）
& C: Z  X" D4 ^4 ?; X
" [# v0 @' l- c& s; N) h

1. /*
   
2. *  函数名：void I2C_ACK(void)
   
3. *  输入参数：
   ; m4 Y( q" J! d5 e
4. *  输出参数：无
   4 y3 B- T4 y5 ]! n+ H
5. *  返回值：无
   % _( D4 ~' f$ [9 X& i
6. *  函数作用：I2C发出应答信号
   
7. */
   
8. void I2C_ACK(void)
     f+ ]$ X1 r9 Y  o/ `. }7 y- U
9. {
   
10.     I2C_SDA_OUT();
    " H* ^! G' x& d4 o% X
11. 
    9 X; E, p# Y" Q5 h; ~6 |
12.     SCL_L();
    
13.     I2C_Delay();
    . e1 S# I! G: r7 ]% d
14. 
    + Z! ^2 N4 N* O+ {: u* t6 e
15.     SDA_L();
    ) @4 O8 M* ]) G3 L& X% g( ~% _
16.     I2C_Delay();
    
17. 
    
18.     SCL_H();
    
19.     I2C_Delay();
    
20. 
    + {1 R8 Y- u. l# G$ U  H
21.     SCL_L();
    
22.     I2C_Delay();
    & N. w3 W) u% {
23. }
    
24. 
    
25. /*
    
26. *  函数名：void I2C_NACK(void)
    ( V2 R' U8 D1 B. R, u
27. *  输入参数：
    
28. *  输出参数：无
    $ s# P5 y+ c! C7 I
29. *  返回值：无
    ; D9 F5 I& T$ C+ k9 c: Z! y
30. *  函数作用：I2C发出非应答信号
    
31. */
    & n$ ~2 C7 Y$ F$ X: _
32. void I2C_NACK(void)
    
33. {
    
34.     I2C_SDA_OUT();
    
35. 
    
36.     SCL_L();
    
37.     I2C_Delay();
    
38. 
    
39.     SDA_H();
    , D" Z$ S- m) y) D) f. e
40.     I2C_Delay();
    ; g0 ], L2 C  p# K& E
41. 
    9 U' X8 [  r1 I6 i" K( Y
42.     SCL_H();
    
43.     I2C_Delay();
    / X9 Z/ w. t" ^, j+ |# m8 j4 l6 W
44. 
    
45.     SCL_L();
    
46.     I2C_Delay();
    1 U" p! c6 b; G% Z" g
47. }
    ) E) p5 `+ Y* P: G/ [0 ]7 K0 A
48. 
    
49. /*
    : h+ p( J7 r8 _, a7 h
50. *  函数名：uint8_t I2C_GetACK(void)
    ! k. o9 t. p6 E2 S  f5 U
51. *  输入参数：
    
52. *  输出参数：无
    
53. *  返回值：1无应答，0有应答
    & |1 h7 p2 i. P% i: w/ T+ a6 [
54. *  函数作用：I2C等待从机的应答信号
    
55. */
    
56. uint8_t I2C_GetACK(void)
    
57. {
    % ~2 m  j" g  i& O+ s
58.     uint8_t time = 0;
    
59.     I2C_SDA_IN();
    - h3 B" h' [/ F! O6 i$ j, R
60. 
    
61.     SCL_L();
    
62.     I2C_Delay();
    " T9 [4 w. I( W0 ^* S+ o
63. 
    * h, D( o8 s! G( |6 {- n
64.     SDA_H();
    
65.     I2C_Delay();
    
66. 
    
67.     SCL_H();
    
68.     I2C_Delay();
    
69. 
    
70.     while(SDA_INPUT())
    ' f" Z7 Y5 H/ l5 J
71.     {
    0 A* P0 a3 C% P4 t
72.         time++;
    
73.         if(time>250)
    
74.         {
    5 {, i! h2 g  _
75.             SCL_L();
    
76.             return 1;
    1 @& R( D$ B' _' @7 ?) I
77.         }
    
78.     }
    % m  V2 f% g  `  ]9 i; S6 t
79.     SCL_L();
    
80. 
    - X$ |" Y( h% w/ w8 l8 W
81.     return 0;
    
82. }

复制代码

& Y+ v( |& s8 F. }! w. n; R8~23行：应答信号，在一个SDA时钟周期里，将SCL拉低；
/ F: t! k/ F; P2 O8 p/ o0 p( B7 g) R
$ l* z9 W, |7 s& a32~47行：非应答信号，在一个SDA时钟周期里，将SCL拉高；
5 e7 E% C# j, N# v$ j$ `
1 \( I- s: |! [' g( q56~82行：等待应答信号，拉高SDA后放开SDA，读取SDA是否被拉低，如果拉低返回0，否则返回1；
" A6 J+ N( ?: N8 O


发送/接收函数
8 t( \2 N% e6 f
最后还剩发送/接收函数，如代码段 16.3.5 所示。对于发送函数，控制SDA产生8个时钟周期，每个时钟周期里控制SDA高低电平发送1位数据。对于接收函数，控制SDA产生8个时钟周期，每个时钟周期里读取SDA高低电平接收1位数据。

+ _9 X3 D5 F% C+ C. b) n1 q0 a代码段 16.3.5 发送/接收函数（driver_i2c.c）

1. /*
   7 ?5 Q; f+ L% {; a% f
2. *  函数名：void I2C_SendByte(uint8_t data)
   
3. *  输入参数：data->发送的数据
   
4. *  输出参数：无
   
5. *  返回值：无
   9 s% e6 y: d& y) z- G; l9 F: z
6. *  函数作用：I2C发送一个字节
   6 I* c' A: H$ w! ~( A% W" [
7. */
   
8. void I2C_SendByte(uint8_t data)
   
9. {
   
10.     uint8_t cnt = 0;
    
11. 
    
12.     I2C_SDA_OUT();
    : [* a7 }, R9 A
13. 
    9 q" Z9 r0 @' t3 E6 C
14.     for(cnt=0; cnt<8; cnt++)
    
15.     {
    
16.         SCL_L();
    
17.         I2C_Delay();
    8 `0 C1 Q# a1 X- a+ b& u/ U
18. 
    + H) k0 Q) e( x# y! ?7 ]. J
19.         if(data & 0x80)
    
20.         {
    - [/ ?- S: g( g9 }2 g, t* W6 b# J
21.             SDA_H();
    ' m  N/ G( A8 D/ H* r+ F5 R3 D: T
22.         }
    " r2 c% L7 E6 S' M8 A
23.         else
    
24.         {
    
25.             SDA_L();
    
26.         }
    . V2 x, U5 k5 `
27.         data = data<<1;
    " X& l$ @# l- I
28.         SCL_H();
    
29.         I2C_Delay();
    
30.     }
    1 d$ w& L! I5 V2 j6 \
31. 
    
32.     SCL_L();
    
33.     I2C_Delay();
    7 D: V2 Z. {0 d
34.     I2C_GetACK();
    
35. }
    
36. 
    
37. /*
    
38. *  函数名：uint8_t I2C_ReadByte(uint8_t ack)
    
39. *  输入参数：ack->发送的应答标志，1应答，0非应答
    
40. *  输出参数：无
    
41. *  返回值：返回读到的字节
    . z! E' v' T9 H& Y+ F
42. *  函数作用：I2C读出一个字节
    ' d7 E$ e% \+ O: C; F7 v( a( O
43. */
    
44. uint8_t I2C_ReadByte(uint8_t ack)
    / F, ^  _8 w! u+ q; U
45. {
    
46.     uint8_t cnt;
    
47.     uint8_t data = 0xFF;
    8 `( I$ E  h$ l2 y* Q3 B) _8 O
48. 
    & f% ?2 B9 S* B/ Y0 N
49.     SCL_L();
    
50.     I2C_Delay();
    
51. 
    $ \7 t( m( |5 r2 R( n% ^; D7 Z
52.     for(cnt=0; cnt<8; cnt++)
    6 w; Q3 z1 T( Q) O. T
53.     {
    
54.         SCL_H();                 //SCL高(读取数据)
    - l$ `7 D* M9 I, n! H
55.         I2C_Delay();
    
56. 
    # x. u+ s$ k5 v
57.         data <<= 1;
    
58.         if(SDA_INPUT())
    4 o, j8 ]+ I8 v/ k. d' T$ F
59.         {
    7 z7 H$ g9 V( n5 i) ~
60.             data |= 0x01;        //SDA高(数据为1)
    
61.         }
    : F9 |. W  D+ m5 Q8 ]
62.         SCL_L();
    
63.         I2C_Delay();
    
64.     }
    
65.     //发送应答信号，为低代表应答，高代表非应答
    + |" ~) ~2 H0 d; p: E$ ?
66.     if(ack == 0)
    3 i# T% G5 }$ ?- j- b
67.     {
    6 T- X( r  Z  ]$ g& `; ^
68.         I2C_ACK();
    * q9 @/ Z, A, u5 V- b2 B7 e- r2 h
69.     }
    
70.     else
    
71.     {
    % Z' y( l5 M; s% U2 N5 T/ @
72.         I2C_NACK();
    
73.     }
    $ B: t* C7 K0 f+ ~& s3 U" s
74.     return data;                 //返回数据
    
75. }

复制代码

14~31行：循环8次，每次循环：
; z* J" s3 {9 G, B6 t# ~2 i
$ b1 M/ l6 V2 ]/ x4 u" U- r16行：先拉低SCL；

19~26行：将输入的数据data与0x08且运算，得到最高位的值，从而控制SDA输出对应的高、低电平;

27行：将data左移一位，得到次高位；
7 V5 O5 f% _( R( r, X, F
2 ~2 _- A5 m2 E# X. F9 l2 o4 @2 @29行：拉高SCL，让SDA处于稳定期，从设备即可获取SDA的值；

, ?' J1 q# Q2 S35行：等待从设备的应答信号；
( e- @3 N) f* W
/ Z" w: E; b$ B) G1 s$ P; s! v53~65行：循环8次，每次循环：
* q* o* R( o+ o3 ^6 U! D
55行：先拉高SCL，此时认为从设备控制SDA电平，处于稳定期；

7 x8 B, Y7 L2 X! G; o58行：将data左移1位，以确保收到数据按最高位在前存放；
7 d3 R& D& V5 K6 l, c& c7 {8 t
/ |. P, A6 {8 C59~62行：读取SDA电平，如果为高，保存到data当前最低位，否则data最低位默认为0；
9 e$ M  z: U8 s7 H5 g/ w! G
. e6 \6 P1 `& s# v3 E" G63行：SCL拉低，此时从设备继续控制SDA电平变化

0 e- w- V: P; i66~74行：根据传入的参数，决定是否发送应答信号；



0 z7 u4 I% P7 @& R. ^$ O整个I2C协议函数中，经常用到“ I2C_Delay()”来实现SCL时钟周期。对于AT24Cxx，由其芯片手册可知，时钟脉冲宽度（Clock Pulse Width）需要大于5us，也就是SCL如果刚变为高电平，需要等待至少5us才能变为低电平，因此定义“ I2C_Delay()”为5us以上即可。

2 K; m1 v) j- x- ?

1. #define I2C_Delay()     us_timer_delay(5)  // Clock Pulse Width >5us

复制代码

( f( \6 g- G/ ]: E& ^+ g, X这里的“us_timer_delay()”可以由定时器提供，也可以使用循环提供，前者精度更高，效果更好。定时器的介绍在后面章节，本章不作分析，延时函数的两者方式如代码段 16.3.6 所示。

代码段 16.3.6 延时函数的实现（driver_timer.c）

1. #if 0
   - E3 B8 o% f& H/ a. A- o+ e' r% \
2. /*
   
3. *  函数名：void us_timer_delay(uint16_t t)
   / V; H0 D3 x3 k; ^
4. *  输入参数：t-延时时间us
   
5. *  输出参数：无
   * n$ a( K) w" Z* P$ ~
6. *  返回值：无
   3 R# C" ~: S& A' E( T9 a
7. *  函数作用：定时器实现的延时函数，延时时间为t us，为了缩短时间，函数体使用寄存器操作，用户可对照手册查看每个寄存器每一位的意义
   6 u& g2 v4 T) `1 [& k, |* A
8. */
   8 V, o2 c7 ?' x! d& T  d
9. void us_timer_delay(uint16_t t)
   3 z2 t7 t4 ?0 E& L0 I
10. {
    2 ~7 F0 A+ L0 C# C) I, X7 [
11.     uint16_t counter = 0;
    ) {# d* H/ W: m
12.     __HAL_TIM_SET_AUTORELOAD(&htim, t);
    
13.     __HAL_TIM_SET_COUNTER(&htim, counter);
    $ T+ U9 g% L7 m; i! l8 }$ s
14.     HAL_TIM_Base_Start(&htim);
    4 @7 f7 @  y1 i+ y
15.     while(counter != t)
    ( X; C& P; @: c# s, K) F7 Z* j
16.     {
    
17.         counter = __HAL_TIM_GET_COUNTER(&htim);
    1 C+ X# U3 m% W' h
18.     }
    
19.     HAL_TIM_Base_Stop(&htim);
    6 y2 p3 g5 q# i& {8 {. z
20. }
    
21. #else
    
22. /*
    4 C* ?# a* Y7 s2 R" d' o9 k
23. *  函数名：void us_timer_delay(uint16_t t)
    
24. *  输入参数：t-延时时间us
    
25. *  输出参数：无
    , E& \  |& _2 u! C4 r
26. *  返回值：无
    , n  U7 F* }# j! a
27. *  函数作用：延时粗略实现的延时函数，延时时间为t us
    # B0 |; Q& Z, h% k* e! b" _* {8 h
28. */
    
29. void us_timer_delay(uint16_t t)
    
30. {
    * ~) U% O1 o: N& R# U
31.     uint16_t counter = 0;
    
32. 
    
33.     while(t--)
    8 F; c1 t9 k. q- k* }  K
34.     {
    ) J" x& j+ g% a/ F' h) H& {
35.         counter=10;
    
36. 
    ' F; G( n- L7 x  U9 |& ?
37.         while(counter--) ;
    + Z" ?% A4 `1 B
38.     }
    . k2 {. ]  r0 C+ N& o
39. }
    
40. #endif

复制代码

" Y% A& {. r) y4 M' J/ _! v
3) AT24C02读写函数

( {# {" I5 Z% S3 p" b  r编写好I2C协议函数后，参考AT24C02手册编写读写数据函数，如代码段 16.3.7 所示。

* @/ G, {$ P. ]1 c2 x% U( K代码段 16.3.7 读写AT24C02一字节数据（driver_eeprom.c）

0 z% C# ?8 z- W1 c2 F& D

1. /*
   $ \) L0 J8 y" r5 G9 @
2. *  函数名：uint8_t EEPROM_WriteByte(uint16_t addr, uint8_t data)
   
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   0 m4 _3 f7 s& O
4. *            data -> 要写的数据
   ' ]5 y" d( ~4 y1 O& u- I* b
5. *  输出参数：无
   % M  q( Z( n& Q; F1 o
6. *  返回值：无
   
7. *  函数作用：EEPROM写一个字节
   9 l1 w5 O& O( t  u/ E1 {; f
8. */
   
9. void EEPROM_WriteByte(uint16_t addr, uint8_t data)
   5 h3 g) l! q! K8 l7 {
10. {
    
11.     /* 1. Start */
    
12.     I2C_Start();
    
13. 
    " ^; j  v* k2 l8 z5 T: K$ I
14.     /* 2. Write Device Address */
    
15.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    0 a5 J9 `: Y/ R! m8 M/ {+ c
16. 
    
17.     /* 3. Data Address */
    0 Q/ `: j9 |2 g3 d7 r
18.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    9 C& R, v* A  ?0 u% B% A
19.     {
    
20.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    6 F' J! O% j! f6 o+ [
21.     }
    
22.     else
    
23.     {
    4 [) W2 f6 [. f: M9 D
24.         I2C_SendByte( (uint8_t)(addr>>8) );
    
25.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
26.     }
    / j  o9 h/ J/ F
27. 
    $ D& }1 ?( d* ^
28.     /* 4. Write a byte */
    
29.     I2C_SendByte(data);
    
30. 
    " j  W1 O1 q6 ^. M$ j( V' \2 H) o
31.     /* 5. Stop */
    - ]- k$ \# a1 W# l! u
32.     I2C_Stop();
    ( x8 a: r; Z$ |; z/ G' x, N
33. }
    & B! V1 Z+ g0 u. e/ N8 e
34. 
    0 n) w) ?4 `3 T) i' p/ W8 L! [
35. /*
    ( N4 Y# g$ O+ R# A9 |) Y9 i
36. *  函数名：uint8_t EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    
37. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    8 \9 ^& j4 b* c6 ]: h) \& F
38. *            data -> 要读的数据指针
    
39. *  输出参数：无
    
40. *  返回值：无
    6 }+ e9 u+ m8 `6 I+ r
41. *  函数作用：EEPROM读一个字节
    
42. */
    : A& l' a: R& t# b/ m' {
43. void EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    ' X# ]- _6 E! ?0 |' ]  D# `
44. {
    : a& S: C& E1 g- U" }7 m+ Z
45.     /* 1. Start */
    
46.     I2C_Start();
    
47. 
    ) Y1 y, G4 l  y3 D6 g
48.     /* 2. Write Device Address */
    
49.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    0 X) z" I" r& u. B' r3 q) R
50. 
    % I1 p4 M: o! T
51.     /* 3. Data Address */
    " h8 n: V8 C3 r" Y  k! O3 {- L1 e
52.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    . X- T" C, I8 x( Y$ ?
53.     {
    % p. D5 |" u, X& @( ^1 m* A
54.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
55.     }
    3 B" m' H* C( C0 v
56.     else
    
57.     {
    
58.         I2C_SendByte( (uint8_t)(addr>>8) );
    2 ~' D. Q" h6 v0 }; I1 ]) \: N
59.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    6 t; f, n* l3 C2 O' G) [6 q) A( k
60.     }
    0 G! b1 W: }6 M& o$ o
61. 
    ' R. g7 D3 b# x, v( }
62.     /* 4. Start Again */
    1 f& e+ f. g0 x. J
63.     I2C_Start();
    # _- r+ `5 Z3 E0 Z, N6 u3 `; \
64. 
    " _% n* V4 e& \6 j
65.     /* 5. Write Device Address Read */
    
66.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_RD );
    
67. 
    
68.     /* 6.Read a byte */
    
69.     *pdata = I2C_ReadByte(NACK);
    
70. 
    % r, A3 t! V1 `
71.     /* 7. Stop */
    ' a5 _1 x: \0 ?) P6 q
72.     I2C_Stop();
    5 s( Q( B- R% E+ x+ M
73. }

复制代码

参加前面图 16.2.1 和图 16.1.13 所示的介绍时序，编写AT24C02一字节读写程序。
" G( l: D1 b: G. y3 R6 i, o
9~33行：写AT24C02一字节数据；
: N8 k0 ]  X5 Z  a4 E7 M# C
9 ]( a2 ~$ o" i: e  |12行：发送I2C开始信号；

* I1 ~6 n: A* w; ?1 ]1 x15行：发送AT24C02的设备地址，最后一位表示写操作；
! i0 o! h  K* y
18~26行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；
* Q2 x! [) v% O0 x
29行：发送数据；
! h; `- i4 ]5 A9 Q6 O8 d5 V6 O7 a
; v+ V% K( C' T! F: c% w* ]/ y/ f32行：发送I2C停止信号；
- w7 P; _; O+ x5 F7 C
7 c( @/ P) a7 }# U43~73行：读AT24C02一字节数据；
3 z6 x8 Z! m# `# v
46行：发送I2C开始信号；
8 m% _4 Z. o+ w# S0 G, d
49行：发送AT24C02的设备地址，最后一位表示写操作（接下来要写数据地址）；

52~60行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；

: M  U6 z+ s8 t! x63行：再次发送I2C开始信号；

; A3 z* e$ e" n, U5 c! B- D3 O66行：发送AT24C02的设备地址，最后一位表示读操作；

69行：读取AT24C02数据，且无需ACK；
+ I$ c4 Z' s# d
72行：发送I2C停止信号；

: ^9 m# M5 j5 d) ~* D实现了对AT24C02单字节的读写，还需要实现多字节的读写。多字节读写可以通过AT24Cxx的页写模式和顺序读模式，实现多个数据的连续读写。在页写模式时，需要程序上设置，不能跨页写，这里简单处理，直接多次调用前面的单次读写即可，如代码段 16.3.8 所示。
! F" ~8 s7 s9 \  W# [; `2 E8 `" l
代码段 16.3.8 读写AT24C02多字节数据（driver_eeprom.c）

1 S) X% w8 i3 i$ e' g* q

1. /*
   
2. *  函数名：void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
   
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   ' c( M0 ~1 s/ d
4. *            data -> 要写的数据指针
   
5. *            sz   -> 要写的字节个数
   ' I7 @0 J+ l$ ^9 [
6. *  输出参数：无
   
7. *  返回值：无
   
8. *  函数作用：EEPROM写N个字节
   # B3 m4 i7 [" e9 ]4 u
9. */
   
10. void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
11. {
    
12.     uint16_t i = 0;
    . d8 o  ^& }* U; |3 g# W
13. 
    
14.     for(i=0; i<sz; i++)
    ' W1 L" r( K* A! |9 t* A6 T
15.     {
    
16.         EEPROM_WriteByte(addr, pdata<i>);
    
17.         addr++;
    
18.         HAL_Delay(10); // Write Cycle Time 5ms
    
19.     }
    
20. }
    
21. 
    
22. /*
    5 V8 a( J1 F& M6 ~0 H+ c, N
23. *  函数名：void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    # A; j3 a* _+ C! k2 r
24. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    
25. *            data -> 要读的数据指针
    : V4 Q% ]; k) x1 Q3 M$ G
26. *            sz   -> 要读的字节个数
    
27. *  输出参数：无
    
28. *  返回值：无
      R9 z, S, y# |
29. *  函数作用：EEPROM读N个字节
    
30. */
    
31. void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    7 X% @/ }2 ?7 U: D6 ^
32. {
    , M) A7 C1 `! Q8 M$ a6 N" ~3 W
33.     uint16_t i = 0;
    - l: A# E, l0 P0 b
34. 
    4 u! N! d9 A+ V5 n, y
35.     for(i=0; i<sz; i++)
    
36.     {
    
37.         EEPROM_ReadByte(addr, &pdata<i>);
    : m$ M( f2 Y/ R: k
38.         addr++;
    
39.     }
    8 C" z9 P/ Q) P- U9 O- ^% u
40. }</i></i>

复制代码

: A+ `5 v7 d8 E. {$ _需要注意的是，AT24Cxx每次写操作后，有一个写间隔，需要间隔5ms以上，因此在写多个字节时，每次写完都需要延时5ms以上。
9 \9 j! c* `6 o3 y/ k. a

, a! T& I& M$ B! o2 Q
4) 主函数控制逻辑

在主函数里，每按一下按键，调用“EEPROM_Write_Nbytes()”对AT24C02写一串数据，再调用“EEPROM_Read_Nbytes()”读出该数据，如代码段 16.3.9 所示。

代码段 16.3.9 主函数控制逻辑（main.c）
  G3 M/ W1 ]. H3 x# r6 I; u4 ?5 \
6 @; g# `% m& Z& m$ k" s6 ?

1. // 初始化I2C
   
2.    I2C_Init();
   - U! }8 r" p! k
3. 
   
4.    while(1)
   / i$ x" D: S/ w( k3 o- N
5.    {
   1 `& S0 J4 w- D. G1 x( M9 _0 g! l2 a
6.        if(key_flag) // 按键按下
   
7.        {
   
8.            key_flag = 0;
   
9. 
   $ X) H/ R/ W/ A- R
10.            printf("\n\r");
    
11.            printf("Start write and read eeprom.\n\r");
    7 G* a7 @1 _" `( K
12. 
    
13.            // 读写一串字符，并打印
    4 P: e8 ]9 @- ~
14.            EEPROM_Write_NBytes(0, tx_buffer, sizeof(tx_buffer)); // 写数据
    
15.            HAL_Delay(1);
    5 v! `: B& X5 j3 f! G5 `! B- A7 ^
16. 
    
17.            EEPROM_Read_NBytes(0, rx_buffer, sizeof(tx_buffer));  // 读数据
    1 B) `( U0 |1 Y/ v( j
18.            HAL_Delay(1);
    ' @* g2 f6 b2 r- W! \" `& T
19. 
    9 v  s3 N0 d& ~9 _
20.            printf("EEPROM Write: %s\n\r", tx_buffer);
    
21.            printf("EEPROM Read : %s\n\r", rx_buffer);
    
22. 
    
23.            memset((uint8_t*)rx_buffer, 0, sizeof(rx_buffer));   // 清空接收的数据
    
24.        }
    
25. }
    

复制代码

$ s+ D# I! b. h4 }: `% M- @16.4 实验效果
本实验对应配套资料的“5_程序源码\8_通信—模拟I2C\”。打开工程后，编译，下载，按下按键KEY，即可看到串口如图 16.4.1 所示。

8 e' [" Z( a; ?5 T
' e# G/ Q/ E) T# _. D+ w, v2 O

图 16.4.1 模拟I2C读写AT24C02数据

3 Y2 e% h/ O+ n; N作者：攻城狮子黄
8 y6 x) e8 w# J! `, q( C4 n
* C* R% m9 A5 o
" J! `$ |- @9 p3 L