16.1 关于I2C
0 O% r$ p6 o4 J! A16.1.1 I2C协议
6 I; `% g+ ]! ?, `: a
I²C（Inter-Integrated Circuit），常读作“I方C”,它是一种多主从架构串行通信总线。在1980年由飞利浦公司设计，用于让主板、嵌入式系统或手机连接低速周边设备。如今在嵌入式领域是非常常见通信协议，常用于MPU/MCU与外部设备连接通信、数据传输。

/ w  {% B9 ?$ |1 o8 T) W6 yI²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工作效率相对较高。

1 a( t) j, X8 |; C2 M* k关于I²C协议，通过下面例子进行一个形象的比喻方便大家理解，如图 16.1.1 所示，老师（MCU）将球（数据）传给众多学生中的一个（众多外设设备中的一个）。

# [: F" {, R- r6 ?) k
$ K) i* V7 b- ?/ y! U

图 16.1.1 I²C协议比喻

0 O3 N% d* e3 F. l0 _( H首先老师将球踢给某学生，即主机发送数据给从机，步骤如下：

+ l' X, u% L* b8 e) w3 b$ E1) 老师：开始了(start)；

2) 老师：A！我要发球给你！(地址/方向)；
( [" p% c9 m/ ~0 _: ]( j: |
3) 学生A：到！(回应)；

: F, Q4 H; \0 E* X3 M4) 老师把球发出去（传输）；
0 r6 |" D9 t7 ~6 ?$ M
/ s- L/ e: n8 a$ t' E. Q: k5) A收到球之后，应该告诉老师一声（回应）；

, C/ I& u3 |0 u2 s! i6) 老师：结束（停止）；

) I9 t4 K( _/ T, c: C
7 V2 G. N0 h5 w
接着老师让学生把球传给自己，即从机发送数据给主机，步骤如下：

/ a* k& q/ \  ?4 j- P1) 老师：开始了(start)；
' j; u) ?5 n9 T3 e4 V6 M! q
2) 老师：B！把球发给我！(地址/方向)；
6 I* b8 `; e+ `7 ~
- Y/ o9 o, ^2 _5 M6 Q3) 学生B：到！
  t9 y# u3 a: U# i
4) B把球发给老师（传输）；
1 k, p3 R4 K9 {& p" Q
( o5 ?$ M5 ]6 P. d' ?* ~5) 老师收到球之后，给B说一声，表示收到球了（回应）；

6) 老师：结束（停止）。



. @" _/ i( M3 T/ q4 j+ e; T% ?" u. i从上面的例子可知，都是老师（主机）主导传球，按照规范的流程（通信协议），以保证传球的准确性，收发球的流程总结如下：

. {5 g: ]& F5 E" B① 老师说开始了，表示开始信号(start)；

) E* n" o. n+ X0 a4 d% o9 |② 老师提醒某个学生要发球，表示发送地址和方向(address/read/write)；

# H' h! R5 ]4 h* D/ q3 r9 l③ 该学生回应老师(ack)；

④ 老师发球/接球，表示数据的传输；
. `; p6 X( B5 Q; ?7 H0 [
1 e8 m" y- z9 u# m' y4 k+ \⑤ 收到球要回应：回应信号(ACK)；
! p. M. h0 n* Z6 q
+ D/ V( n5 Y0 ]0 {0 V& f: I: [⑥ 老师说结束，表示IIC传输结束(P)。

8 J( X$ ^1 h" `6 ~) o9 s
2 K  e& q! \- C0 V- E
4 X+ V0 t! P, s( h( k- I( u以上就是I²C的传输协议，如果是软件模拟I²C，需要依次实现每个步骤。因此，还需要知道每一步的具体细节，比如什么时候的数据有效，开始信号怎么表示。
/ H7 P3 C3 S3 D: z! D5 d. J+ t


数据有效性

8 l$ m% s/ {. G2 j& P9 Q9 rI²C由两条线组成，一条双向串行数据线SDA，一条串行时钟线SCL。SDA线上的数据必须在时钟的高电平周期保持稳定，数据线的高或低电平状态只有在 SCL 线的时钟信号是低电平时才能改变。换言之，SCL为高电平时表示有效数据，SDA为高电平表示“1”，低电平表示“0”；SCL为低电平时表示无效数据，此时SDA会进行电平切换，为下次数据表示做准备。数据有效性示意图如图 16.1.2 所示。

% ?6 M" {/ c" X% X

3 k' X4 Y3 A, y6 }4 Z# G/ g7 q
9 U% \+ F; s% F: p$ q3 l% `

图 16.1.2 数据有效性

$ y5 b! S! x9 R+ d" r; K% Z1 D开始信号和结束信号
& `3 m1 j1 l" [7 g$ G! h+ F
# {7 @$ s  ^1 m2 W4 e0 w$ v1 AI²C起始信号（S）：当SCL高电平时，SDA由高电平向低电平转换；

I²C停止信号（P）：当SCL高电平时，SDA由低电平向高电平转换；
1 m- Y3 V3 U# ?2 c, k

) A0 d; b0 x7 D# U. j& }; ]

图 16.1.3 开始信号和结束信号

- S/ G6 M0 u9 v1 G& O3 }3 z) W
! Z3 Y, D6 Q/ Z+ A7 y" D应答信号                          
' p( o, a+ g  i8 ^9 v0 o, v
) @) L7 b6 T4 ~1 v3 [3 UI²C每次传输的8位数据，每次传输后需要从机反馈一个应答位，以确认从机是否正常接收了数据。当主机发送了8位数据后，会再产生一个时钟，此时主机放开SDA的控制，读取SDA电平，在上拉电阻的影响下，此时SDA默认为高，必须从机拉低，以确认收到数据。

2 e- d6 Q6 }/ k$ j

* H. d8 s9 x" b6 z3 G8 [- p
5 B' u/ _( @9 h" E

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

/ s9 n8 s/ b0 P0 y& k. h
- V+ m/ j3 U7 P; l! Y0 Z
9 c  O; X7 G/ @- I完整传输流程  

I²C完整传输流程如下：
& V7 [% S; v/ R0 C; V+ w
① SDA和SCL开始都为高，然后主机将SDA拉低，表示开始信号；

/ c4 s; T- D$ w& {② 在接下来的8个时间周期里，主机控制SDA的高低，发送从机地址。其中第8位如果为0，表示接下来是写操作，即主机传输数据给从机；如果为1，表示接下来是读操作，即从机传输数据给主机；另外，数据传输是从最高位到最低位，因此传输方式为MSB（Most Significant Bit）。

. I& i7 I  C/ F& t5 n③ 总线中对应从机地址的设备，发出应答信号；

④ 在接下来的8个时间周期里，如果是写操作，则主机控制SDA的高低；如果是读操作，则从机控制SDA的高低；
  f; s% L7 @/ x8 E: }6 i. t
⑤ 每次传输完成，接收数据的设备，都发出应答信号；

⑥ 最后，在SCL为高时，主机由低拉高SDA，表示停止信号，整个传输结束；

& r1 Q. i1 Z- d
( B! z+ M+ J& h8 d; @

2 R5 n; @- v$ c# F0 y% q
! f+ G8 Z0 c) E9 T

图 16.1.5 I2C传输时序

16.1.2 EEPROM介绍

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

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


' u; J" h6 p' ~% o
结构组成

4 k6 S& w- n1 n# KEEPROM类型众多，其中比较常见是AT24Cxx系列，从命名上看，AT24Cxx中xx的单位是K Bit，如AT24C08，其存储容量为8K Bit。本开发板上的EEPROM型号为AT24C02，其存储容量为2K Bit，2*1024=2048 Bit。
% `! _, Q4 c. O6 p" w$ W
对于AT24C01/02，每页大小为8 Byte，对于AT24C04/08/16，每页大小为16 Byte。如图 16.1.6 所示，AT24C02由32页（Page）组成，每一页由8个字节（Byte）组成，每个Byte由8位（Bit）组成，Bit为最小存储单位，存放1个0或1。
: f% |0 R1 h- y
) J; h7 t( Q& o, K4 o

5 q/ y, G# y5 g- _+ o5 }
* K% A5 Y# h. [5 }9 F. K

图 16.1.6 AT24C02结构示意图

3 O% B' X2 |3 Q8 j3 R4 ]

设备地址  

, h% w' [8 ^$ _1 j& CI²C设备都会有一个设备地址，不同容量的AT24C02，设备地址定义会有所差异，由芯片数据手册《AT24Cxx.pdf》可知，如图 16.1.7 所示。
" H( |# T2 t2 i# M" ?3 y- f# `6 n

9 y/ [+ f6 N; b- {" B3 r

图 16.1.7 AT24Cxx设备地址定义

AT24C02的容量为2K，对应上图中的第一行，高四位固定为“1010”，中间三位由A2、A1、A0引脚的电平决定，比如A2~0引脚全接地，则值为“000”，最后的最低位为读写位，0代表写命令，1代表读命令。
" A1 Y9 X7 ]+ i. Q  I% W+ B* {5 k
4 v- J. M) d! ~9 x6 d  f/ mA2、A1、A0引脚电平需要由原理图决定，假设全接电源地，则如果需要向AT24C02写数据，则发送地址“1010 0000”，如果需要向AT24C02读数据，则发送地址“1010 0001”。

假设开发板有多个AT24C02挂在同一I²C总线上，通过这个规则，只需设计电路时，让A2、A1、A0引脚电平不同，即可区分两个AT24C02。

对于容量再大一点的AT24Cxx系列，比如AT24C04，器件地址由A2、A1引脚决定，数据空间有P0决定。比如对AT24C04的0~2K空间操作，则P0为0，对2K~4K空间操作，则P0为1。
2 P% m+ [  R, Z' v8 P
1 G  \+ D4 q2 s3 W0 n' Z( Q

写AT24Cxx  
4 u* ~2 o- f% `, b3 Y
( O( D: b6 N1 h) y6 xAT24Cxx支持字节写模式和页写模式。字节写模式是一个地址一个数据的写；页写模式是连续写数据，一个地址多个数据的写，但是页写模式不能自动跨页，如果超出一页长度，超出的数据会覆盖原先写入的数据。

如图 16.1.8 所示，为AT24Cxx字节写模式的时序，在MCU发出开始信号（Start）后，发出8 Bit的设备地址信息（图中读写位为低电平，即写数据），待收到AT24Cxx应答信号后，再发出要写的数据地址，再次等待AT24Cxx应答，最后发出8 Bit数据写数据，待AT24Cxx应答后，发出停止信号（Stop），完成一次单字节写数据。

* n; P( O( g% `# u- M5 X. b( D5 U- S

+ D; h& z. T* i1 ~

图 16.1.8 AT24Cxx字节写模式时序

+ b2 s1 r0 W/ m9 cAT24C02容量为2K，因此数据地址范围为0x00~0xFF，即0~255，每个数据地址每次写1Byte，即8bit，也就刚好256*8=2048Bit。对于1K容量的产品，数据地址范围为0x00~0x7F，最高位不会用到，因此图中数据地址的最高位为“*”，意思是对于1K容量的产品，该位无需关心。

图 16.1.9 单字节写模流程图

图 16.1.10 为AT24Cxx的页写模式时序，与字节写模式的差异在于，不是只发送1Byte数据，而是任意多个。需要注意，该模式不能跨页写，遇到跨页时，需要重新发送完整的时序。
9 x; `3 ~; n% Y7 H  S3 ^5 Y
% E1 v( m% _8 u" x2 ]

/ V# k+ D$ R8 Z! K( {

图 16.1.10 AT24Cxx页写模式时序

值得一提的是，《AT24Cxx.pdf》里提到每次写完之后，再到下次写之前，需要间隔5ms时间，以确保上次写操作在芯片内部完成，如图 16.1.11 所示。
; T5 p& P' {3 v' D# v; o, {

图 16.1.11 AT24Cxx写间隔

" [7 `, z4 R. K6 R
读AT24Cxx
: P5 U8 M" S0 i: W9 w" |
AT24Cxx支持当前地址读模式、随机地址读模式和顺序读模式。当前地址读模式就是在上一次读/写操作之后的最后位置，继续读出数据，比如上次读/写在地址n，接下来可以直接从n+1处读出数据；随机地址读模式是指定数据地址，然后读出数据；顺序读模式是连续读出多个数据。
9 q. X6 p1 u. _1 V& r2 j
/ G9 K, M" ?& N  E& y: t% f在当前地址读模式下，无需发送数据地址，数据地址为上一次读/写操作之后的位置，时序如图 16.1.12 所示，注意在结尾，主机接收数据后，无需产生应答信号。

: X& ?. d  O" w9 y

图 16.1.12 AT24Cxx当前地址读模式

' n6 T5 R7 A7 n  w. j5 z+ w- F$ h在随机地址读模式下，需要先发送设备地址，待读的数据地址，接着再重新发出开始信号，设备地址，读出数据，时序如图 16.1.13 所示。
! ^4 D4 u: d! E' ^3 a7 R" O
& g" l1 s) ], c! Q* ]; Y  v  U

图 16.1.13 AT24Cxx随机地址读模式

在顺序读模式下，需要先从当前地址读模式或随机地址读模式启动，随后便可连续读多个数据，时序如图 16.1.14 所示

" K* g9 L1 E% n

图 16.1.14 AT24Cxx顺序读模式

5 D) C0 Q1 N$ E. I
' O5 j) s# b5 d
16.2 硬件设计
如图 16.2.1 为开发板EEPROM部分的原理图，U6为AT24C02芯片，它的A0、A1、A2都接地，因此该设备地址为“1010 000X”，当读该设备时，X为1，写该设备时，X为0。

; X2 e8 p" _# l; b) D2 m* N+ E9 `3 RU4的7脚为写保护引脚（Write Protect，WP），当该引脚为高，则禁止写AT24C02，这里直接拉低WP，任何时候都可直接写AT24C02。
: Y: {; X6 D# n) p8 \
7 m& o- W, o$ x. P- ?此外，I2C的两个脚SCL和SDA都进行了上拉处理，从而保证I2C总线空闲时，两根线都必须为高电平。如果没有上拉，在主机发送完数据后，放开SDA，此时SDA的电平状态不确定，可能为高，也可能为低，无法确定是从机拉低给出应答信号。

结合原理图可知，PB6作为了I2C1的SCL，PB7作为了I2C1的SDA。

, A  l2 Z: t4 a$ D0 c: \2 Z8 u
2 {) F/ r0 t# _( [

图 16.2.1 EEPROM模块原理图

2 w, J. K$ Q, v$ m0 G
/ g$ d& d9 a# k3 t1 K3 l" i! Z7 {+ n  u
16.3 软件设计
8 d( g* s  r' f7 r# P16.3.1 软件设计思路

实验目的：本实验通过GPIO模拟I2C总线时序，对EEPROM设备AT24C02进行读写操作。

" h" d9 R) E; W6 o" \1) 引脚初始化：GPIO端口时钟使能、GPIO引脚设置为输入/输出模式（PB6、PB7）；
7 v+ J9 \! V7 ?6 E1 V9 @
  Y! }  g/ g) h; f2 c" [( ?2) 封装I2C每个环节的时序函数：起始信号、响应信号、读写数据、停止信号；
5 X7 [3 o' ]5 |. r3 t  v1 S
3) 使用I2C协议函数，实现对AT24C02的读写；

4) 主函数，每按一次按键，写一次AT24C02，接着读出来验证是否和写的数据一致；
. {0 [5 P6 @3 s% m
本实验配套代码位于“5_程序源码\8_通信—模拟I2C\”。

. E. T, x4 u2 R7 _* k* J3 ^3 n& k

16.3.2 软件设计讲解

1) GPIO选择与接口定义

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

" c& J; n% f1 S# C' _3 Z, W/ V) g代码段 16.3.1 模拟I2C引脚相关定义（driver_i2c.h）
; x0 i% G9 q' {* b

1. /************************* I2C 硬件相关定义 *************************/
   
2. 
   * h, T- [6 h8 u# q) _- L' U( c
3. #define ACK                 (0)
   
4. 
   9 _4 j: Q. m- c! i; v3 j+ O! O+ X
5. #define NACK                (1)
   
6. 
   
7. 
   ' `6 C$ V1 d& C2 ?# J* l* \
8. 
   / ]; S  h* p. n: y. _
9. #define SCL_PIN             GPIO_PIN_6
   5 Y) q' L- n, J1 F( o
10. 
    " D+ v$ M' I& _9 Y
11. #define SCL_PORT            GPIOB
    1 U5 m8 q% X% R: j. K
12. 
    
13. #define SCL_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    * R( e4 n* U8 _6 y
14. 
    
15. 
    2 G, i) E' S( {1 e
16. 
    
17. #define SDA_PIN             GPIO_PIN_7
    
18. 
    
19. #define SDA_PORT            GPIOB
    
20. 
    4 ]6 v. R; y* d/ k- B* P
21. #define SDA_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    
22. 
    
23. 
    
24. 
    * D0 Y* \) L( }
25. #define SCL_H()             HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_SET)
    
26. 
    
27. #define SCL_L()             HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_RESET)
    7 f8 i4 N/ P/ B# K
28. 
    3 n, g5 D5 y2 s) q$ c
29. #define SCL_INPUT()         HAL_GPIO_ReadPin(SCL_PORT, SCL_PIN)
    
30. 
    
31. 
    
32. 
    
33. #define SDA_H()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_SET)
    
34. 
    
35. #define SDA_L()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_RESET)
    
36. 
    - e# w  U: D$ G8 ^$ R) `! I& o: Y- }& \
37. #define SDA_INPUT()         HAL_GPIO_ReadPin(SDA_PORT, SDA_PIN)

复制代码

- Z2 ^% v8 G- @# {% R接着将两个GPIO引脚初始化，使能引脚时钟，先默认设置为输出模式。SCL引脚为时钟信号，始终为输出模式，SDA引脚为数据引脚，可能输出或者输入，因此还需要编写函数实现输入、输出的切换，如代码段 16.3.2 所示。

代码段 16.3.2 I2C引脚初始化（driver_i2c.c）

9 j, Z% ^) ~# r( V+ f0 W8 _) V4 K

1. /*
   
2. *  函数名：void I2C_Init(void)
   
3. *  输入参数：
   ! P7 @4 D8 ~/ M
4. *  输出参数：无
   
5. *  返回值：无
   
6. *  函数作用：初始化模拟I2C的引脚为输出状态且SCL/SDA都初始为高电平
   
7. */
   ) v% d! `* n2 q  A
8. void I2C_Init(void)
   
9. {
   
10.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    0 [% x- J4 W. ]) `
11. 
    
12.     SCL_PIN_CLK_EN();
    0 H2 }) ]3 S8 |
13.     SDA_PIN_CLK_EN();
    
14. 
    ! D; M- b+ _5 g% ^0 p; Y
15.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    $ l  R" p# Q1 ^* g9 r# F
16.     GPIO_InitStruct.Pull      = GPIO_NOPULL;
    5 R+ t" x6 |+ }! ^( C
17.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
18. 
    
19.     GPIO_InitStruct.Pin       = SCL_PIN;
    " {  _9 o- W3 p+ z5 J( b
20.     HAL_GPIO_Init(SCL_PORT, &GPIO_InitStruct);
    8 B$ c9 N( K3 v% ~  D
21. 
    . B  r. d. ]% |3 J7 Y& ~4 V
22.     GPIO_InitStruct.Pin       = SDA_PIN;
    ) f! V, d7 S2 g" t; b' ]
23.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    0 y1 \# \" h  \: B# e' l2 r$ K
24. 
    
25.     SCL_H();
    3 W$ ?1 ?5 }3 L# M" j
26.     SDA_H();
    # G; f( e9 U% `: a5 n9 s
27. }
    + O% q8 j8 j6 B! r! T
28. 
    
29. /*
    
30. *  函数名：static void I2C_SDA_OUT(void)
    8 K$ H8 v% }( k, H6 i
31. *  输入参数：
    6 v* S5 @! w9 L: U3 |3 @$ B
32. *  输出参数：无
    . i: P$ g1 Y" z* h- I
33. *  返回值：无
    
34. *  函数作用：配置SDA引脚为输出
    ! g1 d$ u5 v( d& B) W: P
35. */
    % W8 |6 A4 u2 j  q5 Z
36. static void I2C_SDA_OUT(void)
    
37. {
    0 Z/ a5 ~1 _$ D, P" Q
38.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    0 J& a+ g9 A( y; ?6 }- Y
39. 
    0 h: y+ d' S% o2 [& Q% H
40.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    
41.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
42.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
43. 
    ; }9 M0 q& P+ O8 m* t6 Q4 ~
44.     GPIO_InitStruct.Pin       = SDA_PIN;
    
45.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    
46. }
    4 `0 l1 P) ?4 `1 q! c- R
47. 
    * s8 T7 ]9 z5 T& `8 o! ~  t* i
48. /*
    
49. *  函数名：static void I2C_SDA_IN(void)
    ' w$ F1 T' z0 {  M! M) e5 Z8 A
50. *  输入参数：
    
51. *  输出参数：无
    / b, B1 ~. J& ^. r5 N1 l' e
52. *  返回值：无
    8 l: J& l2 B& F% o; U, k
53. *  函数作用：配置SDA引脚为输入
    
54. */
    
55. static void I2C_SDA_IN(void)
    1 _1 W- ~0 j# O# Y
56. {
    - S( ]" R" ?/ Z5 L" @
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
58. 
    
59.     GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
    " S3 L4 j& q7 J
60.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
61. 
    
62.     GPIO_InitStruct.Pin       = SDA_PIN;
    ' T) ]4 L6 ?( P3 l
63.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    4 ~% b2 R" B& q2 W( ~& f0 s/ i
64. }

复制代码

' N' N9 R4 {% S5 C7 x
2) I2C时序函数
' k% `8 @* H& _9 F/ ^6 V( L
开始信号/结束信号
' g4 m  |& x7 H" Z/ D. |
参考前面图 16.1.3 所示的开始信号和结束信号编写程序。对于开始信号，首先将SDA和SCL都拉高，随后SDA拉低，再SCL拉低。对于结束信号，首先拉低SDA，拉高SCL，再拉低SDA，代码如代码段 16.3.3 所示。
% i# B6 O9 t9 A+ @
代码段 16.3.3 I2C开始信号和结束信号（driver_i2c.c）

0 H* P! A4 s% P9 J# q$ p. C

1. /*
   
2. *  函数名：void I2C_Start(void)
   
3. *  输入参数：
   ! j# T# T1 z6 S1 R
4. *  输出参数：无
   
5. *  返回值：无
   ' T5 K9 I5 Q4 n  }( s7 c0 Q. l2 [
6. *  函数作用：I2C开始信号
   
7. */
   
8. void I2C_Start(void)
   ; k5 K, m% y( A/ J3 J! E
9. {
   / w$ k, U. y7 e! N
10.     I2C_SDA_OUT();
    ( f7 |( N# p/ I" R9 n" S
11. 
    0 H: f- Z9 d! B" @: J
12.     SCL_H();
    
13.     I2C_Delay();
    
14. 
    
15.     SDA_H();
    
16.     I2C_Delay();
    ! Q) @6 b4 @  f3 \! U1 l
17. 
    
18.     SDA_L();
    # r; B3 q5 w  T! ~
19.     I2C_Delay();
    ! H) a+ `$ M! Q' I
20. 
    3 o0 Z6 E4 P( k" g( i
21.     SCL_L();
    
22.     I2C_Delay();
    7 ?$ Z' n9 t5 g; G) O
23. }
    8 i6 c5 F# Y0 T/ F, M
24. 
    / D% w7 B% \0 Z* g* P8 H
25. /*
    
26. *  函数名：void I2C_Stop(void)
      Q6 M# I  I9 A
27. *  输入参数：
    
28. *  输出参数：无
    : S/ Y1 R8 s, v. i2 v
29. *  返回值：无
    
30. *  函数作用：I2C停止信号
    
31. */
    ) O' w. G& B. s" V, g  J, w
32. void I2C_Stop(void)
    0 v7 d# N2 o7 x5 l
33. {
    . c* K$ t& J1 R& \
34.     I2C_SDA_OUT();
    
35. 
    
36.     SDA_L();
    3 k  q0 @( c. t* l$ m* K$ T9 _- N
37.     I2C_Delay();
    + G$ ?2 J4 O' W
38. 
    
39.     SCL_H();
    4 n6 K3 ?* [+ N7 _$ E6 g
40.     I2C_Delay();
    
41. 
    
42.     SDA_H();
    1 o( S, W% K9 h7 }* z) ~; X
43.     I2C_Delay();
    . G  ~3 c" F1 }- }% l
44. }

复制代码

: \5 c; F/ R4 ~; Z8 F  W5 d, @: H$ P应答信号/非应答信号/等待应答信号

% n, ^0 X2 H, V1 Y参考前面图 16.1.4 所示，编译应答信号，如代码段 16.3.4 所示。
9 q8 \/ `. ~* n1 J
( M- Q: z4 T! h0 E) I: D( a代码段 16.3.4 应答/非应答/等待应答信号（driver_i2c.c）
4 N, X- J; I) L

1. /*
   
2. *  函数名：void I2C_ACK(void)
   
3. *  输入参数：
   . G. k# J/ p3 X3 @
4. *  输出参数：无
   8 D/ d4 Z: R4 X# c  {8 N+ b
5. *  返回值：无
   
6. *  函数作用：I2C发出应答信号
   
7. */
   0 ?  X/ t  H5 x) ^$ [
8. void I2C_ACK(void)
   : W4 I4 y* N5 z/ W4 ]) t
9. {
   : M/ i$ x9 V9 Z; A: g* e
10.     I2C_SDA_OUT();
    
11. 
    $ v* ~- C5 C: {  N! t+ d2 O
12.     SCL_L();
    
13.     I2C_Delay();
    4 j" S4 o/ V# Y# H0 X' i
14. 
    . r/ E) D! {" s" k1 ^! b! L
15.     SDA_L();
    
16.     I2C_Delay();
    - J5 J# P$ W' I+ s: t" X
17. 
    1 o- R6 ]$ S% C% K
18.     SCL_H();
    
19.     I2C_Delay();
    
20. 
    
21.     SCL_L();
    
22.     I2C_Delay();
    1 N1 r; h7 t% I0 v3 Q/ C
23. }
      k8 X" ~- R' x  o6 J' M+ s
24. 
    
25. /*
    / f5 k  [% H6 @/ d0 N" a
26. *  函数名：void I2C_NACK(void)
    ' c# g8 G: n8 U, H# J) U
27. *  输入参数：
    ) U; Y3 B! F8 X: B3 k+ g
28. *  输出参数：无
    % d' m0 s8 a# x+ P
29. *  返回值：无
    # G5 T; h+ H8 @  G+ R' B
30. *  函数作用：I2C发出非应答信号
    
31. */
    1 R4 q2 A, z) s. J
32. void I2C_NACK(void)
    
33. {
    $ C3 T; l) a1 i+ E8 F; a9 `" H
34.     I2C_SDA_OUT();
    $ j/ g0 M; u' r, Y$ C" J0 [9 f% o
35. 
    
36.     SCL_L();
    . V% {0 w8 n6 j: I+ J* q7 t
37.     I2C_Delay();
    ! D+ q3 B. n3 Z
38. 
    
39.     SDA_H();
    ; w8 _! m+ N8 d  ~8 E3 ?9 J! C
40.     I2C_Delay();
    
41. 
    
42.     SCL_H();
    + g& Q4 l1 r- m
43.     I2C_Delay();
    * A4 U' M4 U9 J9 z/ `+ k3 ~; J1 A5 ~
44. 
    % G$ i8 d2 ^0 L) U2 d( v
45.     SCL_L();
    ' d7 N# @$ B* {* u
46.     I2C_Delay();
    
47. }
    - q5 T! O  D+ F4 q/ A
48. 
    
49. /*
    
50. *  函数名：uint8_t I2C_GetACK(void)
      K6 Y- K( v, J) I! D* l( l
51. *  输入参数：
    
52. *  输出参数：无
    
53. *  返回值：1无应答，0有应答
    3 Y) ?5 a4 h  h
54. *  函数作用：I2C等待从机的应答信号
    
55. */
    
56. uint8_t I2C_GetACK(void)
    0 D. p7 C! ?" \0 R( q5 m; c
57. {
    
58.     uint8_t time = 0;
    7 \: b0 y$ D8 @( ?. m: ?
59.     I2C_SDA_IN();
    
60. 
    
61.     SCL_L();
    : {# b- N/ D. _5 J
62.     I2C_Delay();
    
63. 
    
64.     SDA_H();
    & D, E3 s; m% x: Y2 m
65.     I2C_Delay();
    
66. 
    - a# H0 _. m& ]6 ~; C* e
67.     SCL_H();
    9 h5 G5 F. u8 c) f% d: n) h
68.     I2C_Delay();
    . p) j& A1 O; m; g2 U0 ^
69. 
    ( q3 u5 K! C! i3 `! j+ A; z+ y2 c
70.     while(SDA_INPUT())
    
71.     {
    
72.         time++;
    
73.         if(time>250)
    
74.         {
    
75.             SCL_L();
    ( I3 I" b/ }5 l5 D& v
76.             return 1;
    ' V) u# l' j5 f6 V' \$ b' B
77.         }
    
78.     }
    % N* Q, k, g  f" E! U8 I
79.     SCL_L();
    0 g: O8 w7 R+ g) L; N% n5 o- R8 U" a
80. 
    + P4 V) B' A" P8 c
81.     return 0;
    ( S; G0 h- o! P6 R/ e% K7 y6 a% ^
82. }

复制代码

8~23行：应答信号，在一个SDA时钟周期里，将SCL拉低；

- ~5 [. ?) t# a8 K! X! L5 Q( ^32~47行：非应答信号，在一个SDA时钟周期里，将SCL拉高；
3 ^' J; y. [# d
56~82行：等待应答信号，拉高SDA后放开SDA，读取SDA是否被拉低，如果拉低返回0，否则返回1；
9 f: U$ r9 B6 s4 V, }' G2 o2 T
7 V* t4 l6 O, j5 k$ D: a# n

9 ~0 v0 T; K4 k! W0 x' H发送/接收函数
) m2 o, K" l3 e4 L+ c  B
) S8 F  t; n$ R* l; z2 f* \最后还剩发送/接收函数，如代码段 16.3.5 所示。对于发送函数，控制SDA产生8个时钟周期，每个时钟周期里控制SDA高低电平发送1位数据。对于接收函数，控制SDA产生8个时钟周期，每个时钟周期里读取SDA高低电平接收1位数据。

' h. d2 R2 @+ |/ p" r代码段 16.3.5 发送/接收函数（driver_i2c.c）


% y! L4 m( Y0 k5 }' j. j
3 @, c+ }0 ]2 C, s, b

1. /*
   
2. *  函数名：void I2C_SendByte(uint8_t data)
   + i# g% q; |% z7 _: x
3. *  输入参数：data->发送的数据
   3 @0 a' b6 p, ^8 O
4. *  输出参数：无
   1 W  \  X( a  t* l
5. *  返回值：无
   # I" X- C, h! _- _! ?2 a  O
6. *  函数作用：I2C发送一个字节
   
7. */
   4 I8 Y- A% d5 J5 D
8. void I2C_SendByte(uint8_t data)
   
9. {
   & {' C# b8 R. P1 F5 {; L6 c7 P, h
10.     uint8_t cnt = 0;
    2 _0 L. F6 L5 u0 A+ C, G3 z$ F- f
11. 
    
12.     I2C_SDA_OUT();
    
13. 
    + e& r: e  K2 i" e4 Z& s, s( z
14.     for(cnt=0; cnt<8; cnt++)
    8 S- Z' N6 V. ?7 s
15.     {
    
16.         SCL_L();
    
17.         I2C_Delay();
    6 ~; V* p& g3 k0 A" S$ A1 n
18. 
    
19.         if(data & 0x80)
    
20.         {
    
21.             SDA_H();
    0 Y3 j3 I. {3 {
22.         }
    
23.         else
    
24.         {
    
25.             SDA_L();
    " {+ \: O. D1 j! S
26.         }
    1 t$ P/ r$ q8 W1 s' h7 q% R3 j
27.         data = data<<1;
    
28.         SCL_H();
    
29.         I2C_Delay();
    7 ~# B  o" j5 N9 U% a; p( m$ m5 h
30.     }
    
31. 
    0 `; p6 V$ u# A/ C! @) \
32.     SCL_L();
    1 ?" V2 F# z* J) P$ ~" l) ~
33.     I2C_Delay();
    
34.     I2C_GetACK();
    * n  t4 I1 e; m- `( g! u, |
35. }
    - a% [9 G6 }/ d8 n3 u) \& \& |
36. 
      O* H7 l: u7 J; f% V7 B" D
37. /*
    
38. *  函数名：uint8_t I2C_ReadByte(uint8_t ack)
    1 L  Y# z5 K2 c" K: B: O
39. *  输入参数：ack->发送的应答标志，1应答，0非应答
    / B, A  W0 X* Q9 X0 b$ N$ |
40. *  输出参数：无
    " ]3 c% J& Y- q3 ]7 ]# y. k
41. *  返回值：返回读到的字节
    
42. *  函数作用：I2C读出一个字节
    
43. */
    / P9 k: I" p  H: g0 m" r; J
44. uint8_t I2C_ReadByte(uint8_t ack)
    
45. {
    6 H$ ?$ N5 c3 E! v' k
46.     uint8_t cnt;
    4 _. U5 G' z$ i6 u" y
47.     uint8_t data = 0xFF;
    % O/ ?. m8 w' m, X# i
48. 
    + b) {3 P+ k( h3 q
49.     SCL_L();
    # e" Y+ R5 x+ o
50.     I2C_Delay();
    
51. 
    8 i' X7 q& b% r; `
52.     for(cnt=0; cnt<8; cnt++)
    
53.     {
    
54.         SCL_H();                 //SCL高(读取数据)
    
55.         I2C_Delay();
    
56. 
    . Y) h8 g; s; X+ J. o
57.         data <<= 1;
    
58.         if(SDA_INPUT())
    0 z7 t1 u6 |! P1 `6 Z) H% t
59.         {
    , ?# N3 ~9 I# z% N0 e& q- L% _6 h  _
60.             data |= 0x01;        //SDA高(数据为1)
    
61.         }
    % w* T1 z7 _& M0 D* q( m- e; _8 w
62.         SCL_L();
    
63.         I2C_Delay();
    / E: g9 `8 v1 q% q; s7 O: `( i
64.     }
    # o+ i( ~/ H. p- P
65.     //发送应答信号，为低代表应答，高代表非应答
    9 b4 z# F0 ~2 a- S7 }
66.     if(ack == 0)
    $ T- {/ m9 l3 m, y5 |+ t$ w
67.     {
    
68.         I2C_ACK();
    
69.     }
    / Z& N( H; V; M- j+ ], v
70.     else
    ; b- _2 u; ]# y. F9 t
71.     {
    
72.         I2C_NACK();
    
73.     }
    
74.     return data;                 //返回数据
    3 W; w' d5 a9 V6 S* u1 R9 o0 v
75. }

复制代码

14~31行：循环8次，每次循环：

16行：先拉低SCL；
. e  T4 s$ q; y1 q# z
19~26行：将输入的数据data与0x08且运算，得到最高位的值，从而控制SDA输出对应的高、低电平;

27行：将data左移一位，得到次高位；
5 I) g' z2 r+ K
* ^( B6 |1 V3 I* G+ B+ e9 h29行：拉高SCL，让SDA处于稳定期，从设备即可获取SDA的值；
5 Y% X- L# ~2 h1 |* W' X
35行：等待从设备的应答信号；

53~65行：循环8次，每次循环：
( K% C3 P* ^$ _! U( K2 r/ D
% |+ S1 J  |0 s7 x+ |9 Z/ I) L55行：先拉高SCL，此时认为从设备控制SDA电平，处于稳定期；

58行：将data左移1位，以确保收到数据按最高位在前存放；

59~62行：读取SDA电平，如果为高，保存到data当前最低位，否则data最低位默认为0；
" `3 e! i8 b7 R% W
63行：SCL拉低，此时从设备继续控制SDA电平变化

66~74行：根据传入的参数，决定是否发送应答信号；


" H: E* E$ ]6 m' M
1 {- A0 u/ y( Y  n5 e6 F9 s4 D整个I2C协议函数中，经常用到“ I2C_Delay()”来实现SCL时钟周期。对于AT24Cxx，由其芯片手册可知，时钟脉冲宽度（Clock Pulse Width）需要大于5us，也就是SCL如果刚变为高电平，需要等待至少5us才能变为低电平，因此定义“ I2C_Delay()”为5us以上即可。
$ k. N# s/ Y/ }: T

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

复制代码

4 e* j! f5 |7 G5 D7 R6 I$ l这里的“us_timer_delay()”可以由定时器提供，也可以使用循环提供，前者精度更高，效果更好。定时器的介绍在后面章节，本章不作分析，延时函数的两者方式如代码段 16.3.6 所示。
) U5 Q: w' E/ i) {" ~0 G8 r5 k
代码段 16.3.6 延时函数的实现（driver_timer.c）

1. #if 0
   
2. /*
   
3. *  函数名：void us_timer_delay(uint16_t t)
   
4. *  输入参数：t-延时时间us
   
5. *  输出参数：无
   9 x, s& Z* W" t' L
6. *  返回值：无
   , @4 K' u3 {5 G$ B0 x5 X6 g
7. *  函数作用：定时器实现的延时函数，延时时间为t us，为了缩短时间，函数体使用寄存器操作，用户可对照手册查看每个寄存器每一位的意义
   . B- A8 [, N% c! Z! s8 }' u
8. */
   / o1 k7 @$ s6 C, _& @5 w
9. void us_timer_delay(uint16_t t)
   
10. {
    
11.     uint16_t counter = 0;
    
12.     __HAL_TIM_SET_AUTORELOAD(&htim, t);
    
13.     __HAL_TIM_SET_COUNTER(&htim, counter);
    / Z/ q" L# r% v- h2 f
14.     HAL_TIM_Base_Start(&htim);
    
15.     while(counter != t)
    + g* O" q# ]3 L2 e
16.     {
      A$ c- v$ v8 G
17.         counter = __HAL_TIM_GET_COUNTER(&htim);
    
18.     }
    5 j: E$ K8 x9 _& Q6 b( d
19.     HAL_TIM_Base_Stop(&htim);
    
20. }
    
21. #else
    / i2 ]( T, S8 B4 M2 \6 C! L
22. /*
    3 a9 p7 s4 j' Y& G) ?6 X' x- m
23. *  函数名：void us_timer_delay(uint16_t t)
    ) `8 w7 x- F8 U2 |5 C
24. *  输入参数：t-延时时间us
    
25. *  输出参数：无
    
26. *  返回值：无
    6 m$ I4 i2 P% S; t: u
27. *  函数作用：延时粗略实现的延时函数，延时时间为t us
    0 v$ A1 d! H1 o* a6 d4 @0 ]
28. */
    8 R8 E9 v* r7 ]; }7 E! G' u
29. void us_timer_delay(uint16_t t)
    
30. {
    4 m' h# N7 W  t# y8 d
31.     uint16_t counter = 0;
    
32. 
    + t& R( c9 O) N& ]$ t5 I
33.     while(t--)
    # ~' r, p' ?6 Z  V3 ^# Z
34.     {
    8 l1 H& p. t/ N( S0 ?/ l
35.         counter=10;
    
36. 
    
37.         while(counter--) ;
    
38.     }
    9 D; T/ U8 O$ ^& O& n8 i$ P5 D# D% f
39. }
    ! }) C$ b. z& U" \% A
40. #endif

复制代码

3) AT24C02读写函数
$ T* D6 U7 b- I9 {" Y
$ L* O$ ^# I  n编写好I2C协议函数后，参考AT24C02手册编写读写数据函数，如代码段 16.3.7 所示。

代码段 16.3.7 读写AT24C02一字节数据（driver_eeprom.c）

1. /*
   
2. *  函数名：uint8_t EEPROM_WriteByte(uint16_t addr, uint8_t data)
   4 C8 e8 b$ d4 V# X$ B; x5 D0 Y, i
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   ) l5 X# x6 Y! y8 y) G8 Z- R5 b
4. *            data -> 要写的数据
   
5. *  输出参数：无
     [* t3 K/ h! d9 T$ p5 D
6. *  返回值：无
   
7. *  函数作用：EEPROM写一个字节
   
8. */
   
9. void EEPROM_WriteByte(uint16_t addr, uint8_t data)
   * b& w: b: w% X3 ^2 ?
10. {
    - E/ Q0 f( i/ K  Q
11.     /* 1. Start */
    
12.     I2C_Start();
    ) o8 h- G# X& g
13. 
    
14.     /* 2. Write Device Address */
    
15.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    
16. 
    : o/ [* V2 b7 e' }& n
17.     /* 3. Data Address */
    ; P- h" _1 N3 A% x3 O
18.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    % W+ _/ S. u2 j! k% m. K2 O7 \
19.     {
    
20.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
21.     }
    
22.     else
    5 e# U1 D) s3 l3 Y( J
23.     {
    
24.         I2C_SendByte( (uint8_t)(addr>>8) );
    
25.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
26.     }
    ' O9 h5 S. E% g; k( [! H
27. 
    % C; p$ I  j0 d% X  I
28.     /* 4. Write a byte */
    
29.     I2C_SendByte(data);
    . U* u( h0 b9 w" u6 g, K! S$ ]
30. 
    ! v3 C( @+ R* [- `+ D. S
31.     /* 5. Stop */
    . J: E1 O% F2 d
32.     I2C_Stop();
    
33. }
    1 _. q8 g" W" {2 H
34. 
    
35. /*
    2 i6 N! b; s. J; U
36. *  函数名：uint8_t EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    
37. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    
38. *            data -> 要读的数据指针
    
39. *  输出参数：无
    8 u8 b/ K+ d" @2 m6 F
40. *  返回值：无
    5 X, j* w4 m1 F( J5 x+ G
41. *  函数作用：EEPROM读一个字节
      e' F# Y1 `8 w4 k, g; R6 ]
42. */
    
43. void EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    
44. {
    ( N3 O& N5 O0 P7 u' z) K) l
45.     /* 1. Start */
    ( b3 u/ c5 T0 \
46.     I2C_Start();
    
47. 
    
48.     /* 2. Write Device Address */
      p' a, a; `& }$ @' K
49.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    
50. 
    
51.     /* 3. Data Address */
    
52.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    9 a8 A6 F$ y' ]$ |* ~) A
53.     {
    7 @& J  l8 H+ z/ e# o" @7 x
54.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
      H# f7 w0 W# [8 r* ~- O/ ~' U
55.     }
    
56.     else
    ) P3 G: m: @1 a
57.     {
    + i# p2 H6 ?* v
58.         I2C_SendByte( (uint8_t)(addr>>8) );
    
59.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    $ q  o- \/ b# I2 @$ G  _. i
60.     }
    5 x' |% N- t5 q+ R! c: \6 D: G. Y
61. 
    
62.     /* 4. Start Again */
    5 q; L2 k% n$ }6 |9 N
63.     I2C_Start();
      ?, a; \4 \% A# z
64. 
    + E$ b5 U# _+ ?  K+ \0 N- J
65.     /* 5. Write Device Address Read */
    
66.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_RD );
    7 z. l* |9 O6 y7 i/ d* g' I
67. 
    & x5 e/ B; j& C, r; _" L
68.     /* 6.Read a byte */
    
69.     *pdata = I2C_ReadByte(NACK);
      r4 Y& d# w; h0 C- L8 [4 a& l
70. 
    
71.     /* 7. Stop */
    
72.     I2C_Stop();
    $ f( r/ I7 b  f7 ?! ?$ p- v7 h
73. }

复制代码

4 O5 Q0 |& v/ c1 i参加前面图 16.2.1 和图 16.1.13 所示的介绍时序，编写AT24C02一字节读写程序。
, ]1 |& M& S2 C/ f0 f! a
9~33行：写AT24C02一字节数据；
$ f: M5 y  }( M
12行：发送I2C开始信号；
0 R7 b% \" B' H  U
$ U" e9 z- q& z15行：发送AT24C02的设备地址，最后一位表示写操作；

$ G# z) e' |# u( o- V18~26行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；

" l4 F7 B6 \# ^! }! S$ u29行：发送数据；
6 E- }+ h) X  O' n
32行：发送I2C停止信号；
6 E) V3 Z$ M" O$ Z3 s
9 Y4 A% u1 s7 y7 J' F, l% d) J! J43~73行：读AT24C02一字节数据；
  u- D7 J( q% V" ^7 K3 a
0 e* m/ A, O9 n: a( j46行：发送I2C开始信号；

49行：发送AT24C02的设备地址，最后一位表示写操作（接下来要写数据地址）；

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

% V, w! p2 @2 Q" y0 ]. u4 Q( q63行：再次发送I2C开始信号；
2 @% o5 r, Y6 M+ V% o
: z) S, p; G8 y3 ~  z0 h5 G9 m! y' b66行：发送AT24C02的设备地址，最后一位表示读操作；
  C" l4 i  [  Y4 Y; f1 a
* }6 T2 ^+ C) j/ j; s  B69行：读取AT24C02数据，且无需ACK；

72行：发送I2C停止信号；
6 k% M4 ~  I6 b1 Z2 Q( l1 [: a
) k6 ]/ B7 o' X1 o, E$ ~实现了对AT24C02单字节的读写，还需要实现多字节的读写。多字节读写可以通过AT24Cxx的页写模式和顺序读模式，实现多个数据的连续读写。在页写模式时，需要程序上设置，不能跨页写，这里简单处理，直接多次调用前面的单次读写即可，如代码段 16.3.8 所示。

3 u- A" u0 ^1 y1 m代码段 16.3.8 读写AT24C02多字节数据（driver_eeprom.c）

1. /*
   1 @) R- D$ @) R
2. *  函数名：void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
   ! @9 d/ N8 Q  F+ F0 M  C
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   
4. *            data -> 要写的数据指针
   2 x, }: m$ U5 @8 [* V6 S
5. *            sz   -> 要写的字节个数
   1 s; q" e5 C$ L; _4 }1 q& P# o
6. *  输出参数：无
   
7. *  返回值：无
   & ?8 {( S0 A. ~/ G" k) ]
8. *  函数作用：EEPROM写N个字节
   4 h- b. |0 X! b
9. */
   7 f* d$ Z7 \5 V# r& r  Q" A
10. void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    2 c" V9 A' b: ]% w6 U# ]# [6 G
11. {
    
12.     uint16_t i = 0;
    
13. 
    + b" S+ S6 D+ x; m
14.     for(i=0; i<sz; i++)
    
15.     {
    
16.         EEPROM_WriteByte(addr, pdata<i>);
    
17.         addr++;
    
18.         HAL_Delay(10); // Write Cycle Time 5ms
    0 n, C) L$ W7 e& u* q! @
19.     }
      R! g5 @4 C8 S+ r* Q3 |
20. }
    
21. 
    
22. /*
    
23. *  函数名：void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
24. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    
25. *            data -> 要读的数据指针
    
26. *            sz   -> 要读的字节个数
    4 n* A4 b. V! f5 P6 B9 J, z# n
27. *  输出参数：无
    
28. *  返回值：无
    2 D' y2 |$ K5 L  T! r
29. *  函数作用：EEPROM读N个字节
    ) ~: b& c( P+ L- z: R! l
30. */
    
31. void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    ) F" B7 p* L% S" B! L, F: E) E9 Q$ F
32. {
    
33.     uint16_t i = 0;
    1 D+ N7 ], v  X+ y! W% t
34. 
    
35.     for(i=0; i<sz; i++)
    
36.     {
    / p! A! \2 c, S, K7 d6 z# o; f3 G
37.         EEPROM_ReadByte(addr, &pdata<i>);
    
38.         addr++;
    $ V- X/ _' o7 a% ?' c" u' T# \
39.     }
    9 r- q: K6 |) K8 X6 ^# ]+ Z
40. }</i></i>

复制代码

- E/ t' R3 g" E" a" h3 c1 r需要注意的是，AT24Cxx每次写操作后，有一个写间隔，需要间隔5ms以上，因此在写多个字节时，每次写完都需要延时5ms以上。



0 L* T) R2 a/ L; F/ {4) 主函数控制逻辑

- N$ k; M9 _- b# K5 p! A" G* s在主函数里，每按一下按键，调用“EEPROM_Write_Nbytes()”对AT24C02写一串数据，再调用“EEPROM_Read_Nbytes()”读出该数据，如代码段 16.3.9 所示。
+ s: d4 Z! [4 @6 R1 d5 ~
9 [* u. z& I: [; {0 t代码段 16.3.9 主函数控制逻辑（main.c）
! g, _7 t/ b8 W; [$ w( \: c. |

1. // 初始化I2C
   & ?$ R: p, o7 R7 z9 f9 m. M: H7 U
2.    I2C_Init();
   
3. 
   
4.    while(1)
   - ?7 O/ }+ P: F5 r
5.    {
   
6.        if(key_flag) // 按键按下
   * e- J( _$ ~, [) z, L: u% t
7.        {
   
8.            key_flag = 0;
   ; i) {6 Y8 w7 J/ Q
9. 
   
10.            printf("\n\r");
    2 w7 ?& Z. l- z+ `/ n
11.            printf("Start write and read eeprom.\n\r");
    
12. 
    * C  B% ]9 L9 }* [/ }3 c
13.            // 读写一串字符，并打印
    : Q$ [$ I9 A; j# U0 n7 {' L
14.            EEPROM_Write_NBytes(0, tx_buffer, sizeof(tx_buffer)); // 写数据
    
15.            HAL_Delay(1);
    7 M( X8 ]1 P( Q. M# G5 _4 p
16. 
    2 ~( f2 U5 ^% y, t
17.            EEPROM_Read_NBytes(0, rx_buffer, sizeof(tx_buffer));  // 读数据
    
18.            HAL_Delay(1);
    8 |" s9 \8 B' F. x3 K6 u
19. 
    & G$ P" t2 s) x, r9 m+ g
20.            printf("EEPROM Write: %s\n\r", tx_buffer);
    " S! f: o9 H: P! @' D
21.            printf("EEPROM Read : %s\n\r", rx_buffer);
    % B' e1 f# S3 X9 v
22. 
    2 i, D  r9 J+ G; [$ m( X
23.            memset((uint8_t*)rx_buffer, 0, sizeof(rx_buffer));   // 清空接收的数据
    
24.        }
    
25. }
    

复制代码

% f$ q: `( l6 P# K16.4 实验效果
; r, r9 K/ `& S! M; Q5 Q本实验对应配套资料的“5_程序源码\8_通信—模拟I2C\”。打开工程后，编译，下载，按下按键KEY，即可看到串口如图 16.4.1 所示。

: L1 V0 f- H$ K  S

图 16.4.1 模拟I2C读写AT24C02数据

! `* R- `4 x9 b- {; @  s+ s0 n( w
作者：攻城狮子黄
' `* s- U# K% F9 x