16.1 关于I2C
16.1.1 I2C协议

I²C（Inter-Integrated Circuit），常读作“I方C”,它是一种多主从架构串行通信总线。在1980年由飞利浦公司设计，用于让主板、嵌入式系统或手机连接低速周边设备。如今在嵌入式领域是非常常见通信协议，常用于MPU/MCU与外部设备连接通信、数据传输。
: W" G& r; K/ L) ~, U
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工作效率相对较高。

关于I²C协议，通过下面例子进行一个形象的比喻方便大家理解，如图 16.1.1 所示，老师（MCU）将球（数据）传给众多学生中的一个（众多外设设备中的一个）。
  ^8 H' r% f* c7 v% A  e4 K- f7 {+ k* c

: Y8 P! m$ c  n2 A

图 16.1.1 I²C协议比喻

首先老师将球踢给某学生，即主机发送数据给从机，步骤如下：
) v% w8 v9 d0 |- v( D
* ^4 b1 ?' e/ A+ Y: B4 j9 N1) 老师：开始了(start)；

# ~  A6 d( c4 M/ J+ q2 y2) 老师：A！我要发球给你！(地址/方向)；
: k1 l* J4 c: R! e+ u) z: y! I
8 I0 w2 i6 [. Z5 i0 X. t3) 学生A：到！(回应)；

7 v; y  h5 {9 y: ^2 F0 ?/ k4) 老师把球发出去（传输）；
8 I* U* {  B3 c% b* E# O
5) A收到球之后，应该告诉老师一声（回应）；

6) 老师：结束（停止）；
4 a5 d8 k+ N( k8 H
7 n7 c1 P! R( L8 L" u# ?, a2 z

接着老师让学生把球传给自己，即从机发送数据给主机，步骤如下：

1) 老师：开始了(start)；

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

3) 学生B：到！
/ c( j2 e( u" i
0 p5 \6 `3 Y# x$ a4) B把球发给老师（传输）；
8 C  v* L* M' g/ ~
5) 老师收到球之后，给B说一声，表示收到球了（回应）；

' h9 v* n6 l5 t" y  `( l5 J6) 老师：结束（停止）。

& e! W, u  a: Y  o
0 q* J& x. ?( E
从上面的例子可知，都是老师（主机）主导传球，按照规范的流程（通信协议），以保证传球的准确性，收发球的流程总结如下：

① 老师说开始了，表示开始信号(start)；
7 r* V: K/ V% c6 f( `! {5 ?9 w
② 老师提醒某个学生要发球，表示发送地址和方向(address/read/write)；
+ g+ W) s2 \* l: O
③ 该学生回应老师(ack)；
/ o1 a) g0 \! \5 X9 E4 Z
④ 老师发球/接球，表示数据的传输；
( Y1 t8 Z' Y" x
⑤ 收到球要回应：回应信号(ACK)；

7 t' i3 L; K, y8 j⑥ 老师说结束，表示IIC传输结束(P)。
" y7 f1 R5 T) H8 c  C
# d0 G: B. v7 R5 k5 D0 G& ^
1 t  E5 A: q$ v* H1 s+ o: f
+ s2 K( r5 e6 c2 \以上就是I²C的传输协议，如果是软件模拟I²C，需要依次实现每个步骤。因此，还需要知道每一步的具体细节，比如什么时候的数据有效，开始信号怎么表示。
7 ~* A# e' f8 X8 B+ g2 @


' w% W5 L5 R& L" C! C3 X: J数据有效性
; {. S& f+ z$ m$ v
I²C由两条线组成，一条双向串行数据线SDA，一条串行时钟线SCL。SDA线上的数据必须在时钟的高电平周期保持稳定，数据线的高或低电平状态只有在 SCL 线的时钟信号是低电平时才能改变。换言之，SCL为高电平时表示有效数据，SDA为高电平表示“1”，低电平表示“0”；SCL为低电平时表示无效数据，此时SDA会进行电平切换，为下次数据表示做准备。数据有效性示意图如图 16.1.2 所示。
" R7 L- ?& L* @* i& p' _3 ]! X

! O+ e3 E- c1 B6 [  [

图 16.1.2 数据有效性

  i$ ~, C# I7 ~0 S9 ?* @2 g
$ T' _( {* h: u
" S! w( d. E# H开始信号和结束信号
0 k& t7 F0 U9 z% _$ ~( {$ }: |
I²C起始信号（S）：当SCL高电平时，SDA由高电平向低电平转换；

I²C停止信号（P）：当SCL高电平时，SDA由低电平向高电平转换；
% G1 j9 U9 z; ~0 e2 E; J3 R" Z

5 a; K# h& ~+ ~# X

图 16.1.3 开始信号和结束信号

( G& z1 F1 N) b' ?, b/ m
/ S8 E4 k$ f) X+ M# \. d- q% a# w0 u4 c: |
) r, A4 P  n; x9 l4 C# n7 f9 s应答信号                          

I²C每次传输的8位数据，每次传输后需要从机反馈一个应答位，以确认从机是否正常接收了数据。当主机发送了8位数据后，会再产生一个时钟，此时主机放开SDA的控制，读取SDA电平，在上拉电阻的影响下，此时SDA默认为高，必须从机拉低，以确认收到数据。

; v+ d4 T) c3 h: ~

# R+ [# p* `) q' T

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

  V! F7 y7 }4 i6 N4 Z: l2 |" ^+ H! G
+ s, m! ^% W/ w# [
( c* v+ r/ q! C$ \完整传输流程  

+ J9 j! Z  m6 J. z9 M5 q0 a4 v4 b0 b: mI²C完整传输流程如下：

( W- J  [& D# n6 W① SDA和SCL开始都为高，然后主机将SDA拉低，表示开始信号；

6 H- u1 x7 r& S0 p/ T: F② 在接下来的8个时间周期里，主机控制SDA的高低，发送从机地址。其中第8位如果为0，表示接下来是写操作，即主机传输数据给从机；如果为1，表示接下来是读操作，即从机传输数据给主机；另外，数据传输是从最高位到最低位，因此传输方式为MSB（Most Significant Bit）。
  W5 z/ P6 Q4 m9 ^5 c1 T
; l2 N; }' F, v) L2 j" j8 j③ 总线中对应从机地址的设备，发出应答信号；
9 f: h) A! I! o8 G
④ 在接下来的8个时间周期里，如果是写操作，则主机控制SDA的高低；如果是读操作，则从机控制SDA的高低；

5 T" e- S# V- Z& {⑤ 每次传输完成，接收数据的设备，都发出应答信号；

⑥ 最后，在SCL为高时，主机由低拉高SDA，表示停止信号，整个传输结束；
2 w. J2 z' n9 G; S5 z/ o6 `! ~
( t% U, B8 l( z& M9 Z% n! D" H2 Y

8 v0 V" o7 ?2 t9 y$ D

图 16.1.5 I2C传输时序

8 n  Q) z- Z7 l! q# T& P3 w# T

# E5 K5 h. ~% O8 Q/ T6 N( j16.1.2 EEPROM介绍
$ d( \( |. @7 ^/ e1 c& y/ w
EEPROM的全称是“电可擦除可编程只读存储器”，即Electrically Erasable Programmable Read-Only Memory。通常用于存放用户配置信息数据，比如在开发板首次运行时，需要屏幕校准，校准后的配置信息就可以保存在EEPROM里，开发板断电后配置信息不丢失，下次启动，开发板自动读取EEPROM的校准配置信息，就不需要重新校准。
; Z2 d% f# u* F. R4 F; ?8 T
9 p6 d) l' P7 b  C( i8 ZEEPROM和Flash的本质上是一样的，Flash包括MCU内部的Flash和外部扩展的Flash，本开发板就有一个SPI接口的外部Flash（W25Q64），在后面SPI接口再讲解。从功能上，Flash通常存放运行代码，运行过程中不会修改，而EEPROM存放用户数据，可能会反复修改。从结构上，Flash按扇区操作，EEPROM通常按字节操作。两者区别这里不再过多赘述，读者理解EEPROM在嵌入式中扮演的角色即可。

1 `4 T2 n( G% O; |( N
2 @$ r) L) v2 {( q
结构组成
6 w0 m; m% H9 v4 q/ K
EEPROM类型众多，其中比较常见是AT24Cxx系列，从命名上看，AT24Cxx中xx的单位是K Bit，如AT24C08，其存储容量为8K Bit。本开发板上的EEPROM型号为AT24C02，其存储容量为2K Bit，2*1024=2048 Bit。

对于AT24C01/02，每页大小为8 Byte，对于AT24C04/08/16，每页大小为16 Byte。如图 16.1.6 所示，AT24C02由32页（Page）组成，每一页由8个字节（Byte）组成，每个Byte由8位（Bit）组成，Bit为最小存储单位，存放1个0或1。

3 \7 I# ~# i4 @$ G0 _$ r9 y

1 n- N3 H$ Q/ t1 S

图 16.1.6 AT24C02结构示意图

设备地址  
! a; h: Y) o' J- l7 I, W
I²C设备都会有一个设备地址，不同容量的AT24C02，设备地址定义会有所差异，由芯片数据手册《AT24Cxx.pdf》可知，如图 16.1.7 所示。
3 c; ~$ X7 j2 Z' k) C
4 m8 N  l1 Q& ]- f, O8 L% N2 b

0 I2 N0 m0 `; `7 o- P
$ \/ Q( {1 @) D* f/ f

图 16.1.7 AT24Cxx设备地址定义

9 M7 Y* {' ~! E9 n. T
AT24C02的容量为2K，对应上图中的第一行，高四位固定为“1010”，中间三位由A2、A1、A0引脚的电平决定，比如A2~0引脚全接地，则值为“000”，最后的最低位为读写位，0代表写命令，1代表读命令。

A2、A1、A0引脚电平需要由原理图决定，假设全接电源地，则如果需要向AT24C02写数据，则发送地址“1010 0000”，如果需要向AT24C02读数据，则发送地址“1010 0001”。

3 J0 ~9 d) Z: T+ i假设开发板有多个AT24C02挂在同一I²C总线上，通过这个规则，只需设计电路时，让A2、A1、A0引脚电平不同，即可区分两个AT24C02。
' v2 L( a2 ~( ~. F
) U- }' M% S3 S, o4 n, k对于容量再大一点的AT24Cxx系列，比如AT24C04，器件地址由A2、A1引脚决定，数据空间有P0决定。比如对AT24C04的0~2K空间操作，则P0为0，对2K~4K空间操作，则P0为1。
6 i2 N( T/ \% T* {: e. }" h6 j
6 U. E2 Q8 \" Z- i

写AT24Cxx  
/ i$ M! [9 I3 N- c
AT24Cxx支持字节写模式和页写模式。字节写模式是一个地址一个数据的写；页写模式是连续写数据，一个地址多个数据的写，但是页写模式不能自动跨页，如果超出一页长度，超出的数据会覆盖原先写入的数据。

" s% z; y, q1 [/ I- O% u) ?如图 16.1.8 所示，为AT24Cxx字节写模式的时序，在MCU发出开始信号（Start）后，发出8 Bit的设备地址信息（图中读写位为低电平，即写数据），待收到AT24Cxx应答信号后，再发出要写的数据地址，再次等待AT24Cxx应答，最后发出8 Bit数据写数据，待AT24Cxx应答后，发出停止信号（Stop），完成一次单字节写数据。
  i7 A7 G/ z! m3 O, n8 |0 \$ O4 u
2 u% k; o) Q4 d" A

图 16.1.8 AT24Cxx字节写模式时序

  f7 F$ ]4 y% ZAT24C02容量为2K，因此数据地址范围为0x00~0xFF，即0~255，每个数据地址每次写1Byte，即8bit，也就刚好256*8=2048Bit。对于1K容量的产品，数据地址范围为0x00~0x7F，最高位不会用到，因此图中数据地址的最高位为“*”，意思是对于1K容量的产品，该位无需关心。

0 `# j$ n  j; |3 Y# m

; n# F" G, S8 ?+ `

图 16.1.9 单字节写模流程图

图 16.1.10 为AT24Cxx的页写模式时序，与字节写模式的差异在于，不是只发送1Byte数据，而是任意多个。需要注意，该模式不能跨页写，遇到跨页时，需要重新发送完整的时序。
8 \- n$ h) U" d0 o' G" u

. w8 F6 Z! R  I* R9 N

图 16.1.10 AT24Cxx页写模式时序

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

( n9 c( u" n% H+ k! L1 ^

图 16.1.11 AT24Cxx写间隔

3 ~/ U: g% _/ U6 e5 R0 f% K: T

! r$ T8 S2 Y8 x  v8 k8 l/ {读AT24Cxx

, i/ {2 i) }" B0 n2 eAT24Cxx支持当前地址读模式、随机地址读模式和顺序读模式。当前地址读模式就是在上一次读/写操作之后的最后位置，继续读出数据，比如上次读/写在地址n，接下来可以直接从n+1处读出数据；随机地址读模式是指定数据地址，然后读出数据；顺序读模式是连续读出多个数据。

在当前地址读模式下，无需发送数据地址，数据地址为上一次读/写操作之后的位置，时序如图 16.1.12 所示，注意在结尾，主机接收数据后，无需产生应答信号。

图 16.1.12 AT24Cxx当前地址读模式

在随机地址读模式下，需要先发送设备地址，待读的数据地址，接着再重新发出开始信号，设备地址，读出数据，时序如图 16.1.13 所示。
+ R0 z. d6 k0 m* n2 ]) H

* l3 `' U( e1 e

图 16.1.13 AT24Cxx随机地址读模式

/ R* `# M8 v5 d" z! P- R& S
9 F+ ~' b4 p# w在顺序读模式下，需要先从当前地址读模式或随机地址读模式启动，随后便可连续读多个数据，时序如图 16.1.14 所示
: q* F# @' Z; H1 G3 \

图 16.1.14 AT24Cxx顺序读模式

, e; t7 Q, ^2 ]* H


6 O& X! A0 }, U6 y16.2 硬件设计
% F& q2 M6 W9 e9 g* Y1 N& o6 a) {如图 16.2.1 为开发板EEPROM部分的原理图，U6为AT24C02芯片，它的A0、A1、A2都接地，因此该设备地址为“1010 000X”，当读该设备时，X为1，写该设备时，X为0。
. B4 X5 o/ L# @* A% q5 e
9 a4 y! R) v" _5 U8 t$ rU4的7脚为写保护引脚（Write Protect，WP），当该引脚为高，则禁止写AT24C02，这里直接拉低WP，任何时候都可直接写AT24C02。

此外，I2C的两个脚SCL和SDA都进行了上拉处理，从而保证I2C总线空闲时，两根线都必须为高电平。如果没有上拉，在主机发送完数据后，放开SDA，此时SDA的电平状态不确定，可能为高，也可能为低，无法确定是从机拉低给出应答信号。
/ L' g3 X" Z$ o  {3 I8 e
结合原理图可知，PB6作为了I2C1的SCL，PB7作为了I2C1的SDA。
' C0 Q' ~# U8 S6 \3 k( R/ H/ ?
' ?0 ?5 K4 u2 J8 N# [& a% y& L/ h& G

5 H4 u! e2 Z) w  Z; d- |

图 16.2.1 EEPROM模块原理图

8 O- h" x! F+ x, w  c8 \5 S  `! w
# i2 _! ]) ~2 c, {1 ^" _' Y
6 b2 L& J6 m1 d& z$ ^# u16.3 软件设计
) m* l$ r* V# r1 o; W9 @16.3.1 软件设计思路

" ~0 C7 e2 k% k3 j  R' r4 [6 N; c" u( M实验目的：本实验通过GPIO模拟I2C总线时序，对EEPROM设备AT24C02进行读写操作。
5 o1 g+ `, K+ S
  _. J5 n5 f* \. M8 t5 R1) 引脚初始化：GPIO端口时钟使能、GPIO引脚设置为输入/输出模式（PB6、PB7）；
- `" H' p% ?& A% E% m
' q# D/ S6 O; }2 J/ L% }( ^1 Q; V2) 封装I2C每个环节的时序函数：起始信号、响应信号、读写数据、停止信号；
, h# {' x) h1 {
3) 使用I2C协议函数，实现对AT24C02的读写；

4) 主函数，每按一次按键，写一次AT24C02，接着读出来验证是否和写的数据一致；
8 h! B, h4 @5 @+ R9 x+ I# H
本实验配套代码位于“5_程序源码\8_通信—模拟I2C\”。
1 m& z; m- w/ [1 N  L
5 l. r* L  I& R6 q5 {! s
( P( [4 d5 K6 n1 Z: x8 R6 e
  V7 |. a: P5 ?; E0 ]( Z' R16.3.2 软件设计讲解

) S2 M' R$ J5 V1) GPIO选择与接口定义
. H4 I: v+ _9 |
$ E3 k- J3 N+ [4 V2 J首先定义SCL和SDA引脚，引脚的高低电平宏定义，如代码段 16.3.1 所示。
4 O+ X; \4 f$ ~, g3 G1 p
代码段 16.3.1 模拟I2C引脚相关定义（driver_i2c.h）
) e- Q2 D: z% E
& Y9 f) u6 L$ o& l" u0 O

1. /************************* I2C 硬件相关定义 *************************/
   
2. 
   
3. #define ACK                 (0)
   
4. 
   ! B) P+ m3 H6 k3 g9 n! _
5. #define NACK                (1)
   
6. 
   
7. 
     v: Q% Z0 [. v- F% i7 v6 b8 N
8. 
   
9. #define SCL_PIN             GPIO_PIN_6
   
10. 
    
11. #define SCL_PORT            GPIOB
    
12. 
    
13. #define SCL_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    
14. 
    
15. 
    
16. 
    
17. #define SDA_PIN             GPIO_PIN_7
    
18. 
    * ^7 v( G6 v7 X  V! x) J7 ~" r
19. #define SDA_PORT            GPIOB
    
20. 
    
21. #define SDA_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    ; P+ X! k& F* \
22. 
    - m& ~5 e" F# b9 G
23. 
    1 [' s* u3 z$ I5 V( X+ A8 b% i/ `
24. 
    
25. #define SCL_H()             HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_SET)
    
26. 
    0 _! q4 p( Z5 ^" U& s* y
27. #define SCL_L()             HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_RESET)
    , ^# G: ?  Z& w2 }, b& |% v7 r
28. 
    
29. #define SCL_INPUT()         HAL_GPIO_ReadPin(SCL_PORT, SCL_PIN)
    ) w1 N5 m( A, x4 y8 a9 K0 i' m
30. 
    
31. 
    + o/ [3 e1 Y! [) r$ [
32. 
    6 w5 i. f/ a4 S( T; s6 }8 K
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. 
    
37. #define SDA_INPUT()         HAL_GPIO_ReadPin(SDA_PORT, SDA_PIN)

复制代码

接着将两个GPIO引脚初始化，使能引脚时钟，先默认设置为输出模式。SCL引脚为时钟信号，始终为输出模式，SDA引脚为数据引脚，可能输出或者输入，因此还需要编写函数实现输入、输出的切换，如代码段 16.3.2 所示。
% u, }0 K2 e5 w* O% @: ~" W
- o2 m+ U* G$ s代码段 16.3.2 I2C引脚初始化（driver_i2c.c）
" }0 p+ M8 @( ]: w) h- ?' O

1. /*
   # i# E' K& v: {! A! @2 `6 f
2. *  函数名：void I2C_Init(void)
   
3. *  输入参数：
   ) @7 i  J; f5 w9 Q6 V" @' y
4. *  输出参数：无
   
5. *  返回值：无
   7 B  w$ o( l, ]) s& S' ^
6. *  函数作用：初始化模拟I2C的引脚为输出状态且SCL/SDA都初始为高电平
   
7. */
     _% A: w8 ^9 k  h
8. void I2C_Init(void)
   ! B! t( k' h  v7 P* w
9. {
   
10.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
11. 
    
12.     SCL_PIN_CLK_EN();
    
13.     SDA_PIN_CLK_EN();
    $ i- J, W  }  ^" C$ q& I
14. 
    
15.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    
16.     GPIO_InitStruct.Pull      = GPIO_NOPULL;
    
17.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
18. 
    
19.     GPIO_InitStruct.Pin       = SCL_PIN;
    
20.     HAL_GPIO_Init(SCL_PORT, &GPIO_InitStruct);
    
21. 
    : v$ B* |' c! h) E
22.     GPIO_InitStruct.Pin       = SDA_PIN;
    
23.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    ) t+ _9 F$ K6 a: n% n1 h
24. 
    + H. u2 h& q3 x7 n
25.     SCL_H();
    : r) k8 h/ m; U, W
26.     SDA_H();
    ( ~2 `+ }, X) |7 a2 y
27. }
    $ f* E8 n7 A1 T1 R$ @9 @
28. 
    6 k4 D4 g1 c! ?- n- @" D  S. }! T
29. /*
    . r# t  Z8 V2 r" c6 t
30. *  函数名：static void I2C_SDA_OUT(void)
    + ^9 |: b9 s9 u: ?2 t8 [+ L" R
31. *  输入参数：
    
32. *  输出参数：无
    
33. *  返回值：无
    / N) o. D* u) }) O
34. *  函数作用：配置SDA引脚为输出
    
35. */
    
36. static void I2C_SDA_OUT(void)
      y- x! p! G" c5 y" g2 M1 T7 M
37. {
    ( p0 I9 _+ c1 [5 P0 @
38.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
39. 
    8 o* Z4 n3 B: X, U) c: P
40.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    
41.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    + j1 w* ^3 \5 z3 X3 X
42.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
43. 
    
44.     GPIO_InitStruct.Pin       = SDA_PIN;
    
45.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    
46. }
    $ Y! q" o+ p( D) _6 d& J
47. 
    
48. /*
    
49. *  函数名：static void I2C_SDA_IN(void)
    
50. *  输入参数：
    
51. *  输出参数：无
    ! I$ V( K; d/ h' A2 _: o
52. *  返回值：无
    ) [% _" @3 E& S9 p5 K4 `) I/ j
53. *  函数作用：配置SDA引脚为输入
    
54. */
    5 m, S8 c- x% r# ~9 ~1 |4 F3 b/ h  J
55. static void I2C_SDA_IN(void)
      b) \1 Y- O& D! E+ B! l
56. {
    8 E  h% k0 D! A# p( X' B- }
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    6 w# f3 s0 o  s1 b/ W8 d9 w+ R; z2 j
58. 
    
59.     GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
    
60.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    4 d4 t8 C$ z5 r: I  ?; h# ?
61. 
    $ C) p8 u: Z3 ?$ R9 C
62.     GPIO_InitStruct.Pin       = SDA_PIN;
    + E4 D2 E. t; Q8 {" w& U
63.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    
64. }

复制代码

2) I2C时序函数

开始信号/结束信号

/ W" O4 u% W4 Z( `& V参考前面图 16.1.3 所示的开始信号和结束信号编写程序。对于开始信号，首先将SDA和SCL都拉高，随后SDA拉低，再SCL拉低。对于结束信号，首先拉低SDA，拉高SCL，再拉低SDA，代码如代码段 16.3.3 所示。

; e0 ?9 J$ }' l& S$ L代码段 16.3.3 I2C开始信号和结束信号（driver_i2c.c）

1. /*
   $ _+ z$ O. ]$ D" ~
2. *  函数名：void I2C_Start(void)
   
3. *  输入参数：
   
4. *  输出参数：无
   
5. *  返回值：无
   
6. *  函数作用：I2C开始信号
   
7. */
   / I: W% u9 C( n. X5 W1 Z
8. void I2C_Start(void)
   
9. {
   2 A" t" [" `/ c0 d/ M+ `, u
10.     I2C_SDA_OUT();
    
11. 
    
12.     SCL_H();
    
13.     I2C_Delay();
    1 F5 M% w8 E$ ?2 ]7 K8 f! l# V
14. 
    
15.     SDA_H();
    
16.     I2C_Delay();
      N% E$ `* G7 P7 F0 v+ X6 T% y: g
17. 
    
18.     SDA_L();
    2 t$ n7 m% M4 u* }" c( _8 K2 ~
19.     I2C_Delay();
    
20. 
    + I3 }" t$ O; U4 ]
21.     SCL_L();
    : f. |3 t/ b9 \4 A+ q6 y
22.     I2C_Delay();
    
23. }
    * B, k% e2 o& ^- ^2 Z+ \, U
24. 
    # |& k# D$ k! F, z! V
25. /*
    1 Z# ~1 E$ F2 ~. a4 C* `
26. *  函数名：void I2C_Stop(void)
    
27. *  输入参数：
    
28. *  输出参数：无
    
29. *  返回值：无
    
30. *  函数作用：I2C停止信号
    6 L: v, w# t% [! m) @
31. */
    
32. void I2C_Stop(void)
    
33. {
    9 b* d. }! n" H6 M( V4 [6 I
34.     I2C_SDA_OUT();
    
35. 
    
36.     SDA_L();
      w% Q* k/ h% G0 j
37.     I2C_Delay();
    
38. 
    & W6 }9 V% ~$ N& p1 F1 m, P, Q2 E
39.     SCL_H();
    8 c8 A& e" p& I# @7 _% P# s
40.     I2C_Delay();
    
41. 
    
42.     SDA_H();
    5 i& D4 P3 j' X
43.     I2C_Delay();
    7 [" H% Z$ _; J% e
44. }

复制代码

4 Q* P4 g2 ]1 ^应答信号/非应答信号/等待应答信号

% ?$ D% c& g9 M8 f参考前面图 16.1.4 所示，编译应答信号，如代码段 16.3.4 所示。

代码段 16.3.4 应答/非应答/等待应答信号（driver_i2c.c）

1. /*
   ; J' f# o" t: l$ Q
2. *  函数名：void I2C_ACK(void)
   
3. *  输入参数：
   # Q9 Z7 D. r2 F3 i. {
4. *  输出参数：无
   5 N. K3 X" S7 k+ j* x$ s+ [
5. *  返回值：无
   / @: B! z2 J/ b3 e  b- }2 i$ r4 W
6. *  函数作用：I2C发出应答信号
   
7. */
   
8. void I2C_ACK(void)
   
9. {
   
10.     I2C_SDA_OUT();
    
11. 
    * F" _# e; _  _0 j
12.     SCL_L();
    2 a. k, G$ E# V5 u+ O  @) A. U  l
13.     I2C_Delay();
    ( _# b% b% c% c; Y& `
14. 
    % @5 c1 n: n: M1 f
15.     SDA_L();
    
16.     I2C_Delay();
    2 G9 A- s# P3 k3 y
17. 
    0 I& j4 e; u+ e! o$ ~
18.     SCL_H();
    
19.     I2C_Delay();
    
20. 
    
21.     SCL_L();
    
22.     I2C_Delay();
    
23. }
    
24. 
    4 s1 `2 R+ v- o& a3 ]2 {2 P$ q8 o
25. /*
    6 K! Y2 V& i/ |0 J. u# H
26. *  函数名：void I2C_NACK(void)
    6 G; m9 W- z7 H/ i9 `
27. *  输入参数：
    - m5 V+ b) z0 e5 h- ~& i' l
28. *  输出参数：无
    3 F" ^% x+ ?2 ^- V. o2 E+ Y* ]
29. *  返回值：无
    2 g8 O1 J! Q" V" Z
30. *  函数作用：I2C发出非应答信号
    
31. */
    
32. void I2C_NACK(void)
    
33. {
    . ^0 K5 }& y9 R& a) O! g* u' v2 q
34.     I2C_SDA_OUT();
    
35. 
    : O  o$ m: |7 R- ?
36.     SCL_L();
    
37.     I2C_Delay();
    , i' B* O. U- f! H
38. 
    * ]) B+ \" J8 g
39.     SDA_H();
    
40.     I2C_Delay();
    . N5 j, S' I8 @5 o+ k; U2 q0 K
41. 
    
42.     SCL_H();
    ; F* C, q- p6 {( P
43.     I2C_Delay();
    
44. 
    # ~0 o2 C( C  n
45.     SCL_L();
    # {/ K: R0 L: h1 @6 G
46.     I2C_Delay();
    ; B) T: C$ q. o, }: x/ w
47. }
    * F( b' s' ^$ L3 C
48. 
    
49. /*
    
50. *  函数名：uint8_t I2C_GetACK(void)
    
51. *  输入参数：
    $ K# {" q: [. N0 f7 J" z
52. *  输出参数：无
    
53. *  返回值：1无应答，0有应答
    4 a' R+ D' s/ {  A4 e
54. *  函数作用：I2C等待从机的应答信号
    
55. */
    
56. uint8_t I2C_GetACK(void)
    
57. {
    ' Y( }# S' ~, d8 I+ b( H
58.     uint8_t time = 0;
    # {& e7 x/ Z, W# q; y! h
59.     I2C_SDA_IN();
    
60. 
    
61.     SCL_L();
    
62.     I2C_Delay();
    6 \) K' z4 F1 l0 }: Z1 r
63. 
    ( \8 B( F# b' s6 [% s3 ~; a# N/ l
64.     SDA_H();
    
65.     I2C_Delay();
    & M- N" l  n+ p
66. 
    
67.     SCL_H();
    3 \1 l  A, m9 Z; \: |' w
68.     I2C_Delay();
    
69. 
    ) E5 R# c) E6 N
70.     while(SDA_INPUT())
    
71.     {
      G) j8 S) e: M" b" Y+ b6 Y
72.         time++;
    1 z+ x- l8 P. N9 f% v: B( K
73.         if(time>250)
    - k" x2 f3 ~7 [$ t6 V% y7 k& N  e, \
74.         {
    
75.             SCL_L();
    
76.             return 1;
    
77.         }
    0 j4 J8 @, P, Y$ S( I3 R& P$ r$ P& M
78.     }
    & D3 g& K, n) ~2 n+ |* r
79.     SCL_L();
    
80. 
    
81.     return 0;
    
82. }

复制代码

+ q+ }# p/ x: Z1 r  u8~23行：应答信号，在一个SDA时钟周期里，将SCL拉低；

4 |' E7 G5 @) n8 n+ R32~47行：非应答信号，在一个SDA时钟周期里，将SCL拉高；
" w% k2 f% t4 A, d9 k1 \7 p9 R2 g
. y, {& H% K  g* r56~82行：等待应答信号，拉高SDA后放开SDA，读取SDA是否被拉低，如果拉低返回0，否则返回1；
, T  u5 W9 k5 _0 C' L4 U# \# _


发送/接收函数

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

& a* X6 {3 W% C+ p% x  ?3 H8 h& C! A代码段 16.3.5 发送/接收函数（driver_i2c.c）
1 U) Q7 a& ?; t: j/ D2 I
4 ?- v2 b+ X6 \! e- A$ I: Q

1. /*
   
2. *  函数名：void I2C_SendByte(uint8_t data)
   
3. *  输入参数：data->发送的数据
   
4. *  输出参数：无
   - M( G0 X* [& |& b  n6 Q4 J
5. *  返回值：无
   1 ^2 L) w+ p# a" w
6. *  函数作用：I2C发送一个字节
   
7. */
     f0 J+ z  `, j% T: F" s
8. void I2C_SendByte(uint8_t data)
   
9. {
   
10.     uint8_t cnt = 0;
    0 A; R* m4 d, Z
11. 
    . y( L& y) a, a2 p$ {
12.     I2C_SDA_OUT();
    
13. 
    0 G3 _8 M$ z: T6 Z8 R) V$ b
14.     for(cnt=0; cnt<8; cnt++)
    
15.     {
    ' t: P) }% _; @" m) _9 ~5 z
16.         SCL_L();
    . B) I8 }7 I% k' m
17.         I2C_Delay();
    9 ~, u% Y" A: X) L2 b5 }- _- m' x
18. 
    2 `2 P' B8 _& q9 _+ Z, }
19.         if(data & 0x80)
    / R# a$ H# |7 A* C+ Q6 x
20.         {
    
21.             SDA_H();
    " h" X& Y& e  l0 X4 {
22.         }
    1 [4 V! R: l- C% H3 l* y
23.         else
    ; ~! b' `% E& s  J- i. [% f$ A
24.         {
    
25.             SDA_L();
    ! e! [- d+ G- n+ _$ V4 B8 s
26.         }
    1 O" F6 G, ]6 g  Y
27.         data = data<<1;
    . e5 V! A, z3 x+ x+ R" {
28.         SCL_H();
    
29.         I2C_Delay();
    & x5 \% h6 ?1 R" n4 m( t
30.     }
    4 t/ r; ?: ^2 B  S" U' j9 O
31. 
    , x1 ^+ M6 f+ a4 w8 Q8 [
32.     SCL_L();
    
33.     I2C_Delay();
    
34.     I2C_GetACK();
    8 x5 H, N( k- V* ^0 ]4 U  G
35. }
    ! I) V% @7 p; N! ?
36. 
    7 A& ?3 l3 u1 o( m" g( {7 R. ?' k, e
37. /*
    
38. *  函数名：uint8_t I2C_ReadByte(uint8_t ack)
    
39. *  输入参数：ack->发送的应答标志，1应答，0非应答
    . g9 p2 i( G9 @0 M, i9 c
40. *  输出参数：无
    
41. *  返回值：返回读到的字节
    + \! {# V' ^( I# p( @
42. *  函数作用：I2C读出一个字节
    
43. */
    % c; e3 s& @) {+ a& e& D& N
44. uint8_t I2C_ReadByte(uint8_t ack)
    5 w+ L& \" e; W; y9 G
45. {
    
46.     uint8_t cnt;
    6 r0 y/ d- B6 W* K, U! S
47.     uint8_t data = 0xFF;
    5 G: r& z7 `- Q9 r& E! e5 O
48. 
    
49.     SCL_L();
    
50.     I2C_Delay();
    & ~" Y$ ~2 V4 _/ |3 n7 ^
51. 
    , A$ x) N6 `; t6 Z% V
52.     for(cnt=0; cnt<8; cnt++)
    - S6 e1 M+ n  v8 `# t. r4 U
53.     {
    
54.         SCL_H();                 //SCL高(读取数据)
    ( M8 s$ q; Q8 r4 e0 k9 p. k
55.         I2C_Delay();
    
56. 
    
57.         data <<= 1;
    
58.         if(SDA_INPUT())
    
59.         {
    ; {3 i( U) r, P7 @3 D/ S  J
60.             data |= 0x01;        //SDA高(数据为1)
    1 c4 _1 m4 m! z0 P; B: j# ~2 }6 y
61.         }
    
62.         SCL_L();
      d2 E& B# {8 E; m
63.         I2C_Delay();
    
64.     }
    
65.     //发送应答信号，为低代表应答，高代表非应答
    
66.     if(ack == 0)
    0 k1 x/ \" Q( d9 p- z+ R
67.     {
    
68.         I2C_ACK();
    ' w! N1 ~& I0 K0 s0 \" F- J' P0 B. u
69.     }
    
70.     else
    " ^1 D& z, l9 {4 m
71.     {
    9 H( t0 B3 k- L3 A) e
72.         I2C_NACK();
    . Z& o8 l1 O+ r) X1 j% R9 j
73.     }
    + S- A8 F9 M( u% Y- V& l
74.     return data;                 //返回数据
    # U. g+ [  z5 ~& y
75. }

复制代码

14~31行：循环8次，每次循环：
1 P2 h0 R0 M6 @3 r
! x5 s- p8 \/ D16行：先拉低SCL；
$ U: [' w0 U9 m4 o( @
* {* n4 v) @* f19~26行：将输入的数据data与0x08且运算，得到最高位的值，从而控制SDA输出对应的高、低电平;
0 D2 P( T! l( M4 p# L# m
27行：将data左移一位，得到次高位；

: w! @+ G' V6 {, w0 S4 o29行：拉高SCL，让SDA处于稳定期，从设备即可获取SDA的值；
3 ?% C- a- C0 U5 |
  w# L" v/ c3 Z4 z8 c% B35行：等待从设备的应答信号；
4 r9 {! j6 Z6 c- P1 B; C* E
53~65行：循环8次，每次循环：

55行：先拉高SCL，此时认为从设备控制SDA电平，处于稳定期；
8 k: Y* {6 ?/ X7 ~2 j
1 ?8 q6 e4 b( e# f3 ]58行：将data左移1位，以确保收到数据按最高位在前存放；
; U: l. y$ E  B& q0 V8 [
1 `+ O# x' a8 @8 i$ {' d0 \59~62行：读取SDA电平，如果为高，保存到data当前最低位，否则data最低位默认为0；
& F6 F% `1 ]+ A
# X# a2 L5 L" N7 b' q9 l* {63行：SCL拉低，此时从设备继续控制SDA电平变化
2 H, X6 F: b" E0 ]0 e/ _6 E6 d9 V+ m
2 }/ F. U- p0 I+ X) ~+ r66~74行：根据传入的参数，决定是否发送应答信号；
+ s8 n: x0 x2 p8 [. W5 s

' T" b, w) V" U  ~
整个I2C协议函数中，经常用到“ I2C_Delay()”来实现SCL时钟周期。对于AT24Cxx，由其芯片手册可知，时钟脉冲宽度（Clock Pulse Width）需要大于5us，也就是SCL如果刚变为高电平，需要等待至少5us才能变为低电平，因此定义“ I2C_Delay()”为5us以上即可。

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

复制代码

这里的“us_timer_delay()”可以由定时器提供，也可以使用循环提供，前者精度更高，效果更好。定时器的介绍在后面章节，本章不作分析，延时函数的两者方式如代码段 16.3.6 所示。
! u2 [7 S& D6 v# S% C  s
& ]4 y5 T3 T% c. }; P' C# b: a代码段 16.3.6 延时函数的实现（driver_timer.c）
8 Z5 O7 o8 S9 T, S6 \0 Z5 A

1. #if 0
   
2. /*
   
3. *  函数名：void us_timer_delay(uint16_t t)
   
4. *  输入参数：t-延时时间us
   
5. *  输出参数：无
   # \$ ~3 f! S4 f" f, c* ^
6. *  返回值：无
   
7. *  函数作用：定时器实现的延时函数，延时时间为t us，为了缩短时间，函数体使用寄存器操作，用户可对照手册查看每个寄存器每一位的意义
   
8. */
   
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);
    8 V: f: ]) I+ _9 }' R
14.     HAL_TIM_Base_Start(&htim);
    
15.     while(counter != t)
    & l+ f( V3 ?' x8 ^" @; \3 D
16.     {
    
17.         counter = __HAL_TIM_GET_COUNTER(&htim);
    
18.     }
    
19.     HAL_TIM_Base_Stop(&htim);
    4 t$ Z8 Z0 Q  ]- e" G- k
20. }
    4 p, t; I9 X! y2 ^5 C8 O) K2 o
21. #else
    
22. /*
    
23. *  函数名：void us_timer_delay(uint16_t t)
    $ v4 w' T. j8 e8 B: ?% \3 l
24. *  输入参数：t-延时时间us
    1 m# w* @6 h7 m
25. *  输出参数：无
    
26. *  返回值：无
    
27. *  函数作用：延时粗略实现的延时函数，延时时间为t us
    
28. */
    
29. void us_timer_delay(uint16_t t)
    
30. {
    * Q3 n  s0 R% t$ M! n) `; h
31.     uint16_t counter = 0;
    4 X3 F! F' B) O( V8 O
32. 
    
33.     while(t--)
    . T* M2 H4 T) o$ U  O  U' n: P
34.     {
    
35.         counter=10;
    
36. 
    
37.         while(counter--) ;
    7 M- i  R; ~) F7 B" c
38.     }
    
39. }
    
40. #endif

复制代码

3) AT24C02读写函数

, D8 _( G* X6 E% n编写好I2C协议函数后，参考AT24C02手册编写读写数据函数，如代码段 16.3.7 所示。
, c, Y8 J, e+ R" l+ Y& @+ k7 F1 N
代码段 16.3.7 读写AT24C02一字节数据（driver_eeprom.c）
/ l$ ]- P7 c2 O1 F9 l% K0 p

1. /*
   
2. *  函数名：uint8_t EEPROM_WriteByte(uint16_t addr, uint8_t data)
   7 j0 D9 P4 x; K3 A* U% Q+ N3 c; p7 G
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   
4. *            data -> 要写的数据
   
5. *  输出参数：无
   
6. *  返回值：无
   
7. *  函数作用：EEPROM写一个字节
   
8. */
   
9. void EEPROM_WriteByte(uint16_t addr, uint8_t data)
   0 C( Q4 s/ [% m: T, J: H
10. {
    
11.     /* 1. Start */
    . P6 z1 i8 n/ H; g# d
12.     I2C_Start();
    # X% R4 t/ ~" F6 ^
13. 
    
14.     /* 2. Write Device Address */
    
15.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    
16. 
    ) D+ i! I! [0 Z# s, A) O( R
17.     /* 3. Data Address */
    
18.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    
19.     {
    % v7 l! q) N, g  v
20.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    1 }2 V2 a) [9 a+ T( b
21.     }
    
22.     else
    " B. x' H2 y$ `- Q, V/ Y
23.     {
    / R9 ?1 z: |% h2 V: p
24.         I2C_SendByte( (uint8_t)(addr>>8) );
    $ e* K0 K- h# z( V" F) K
25.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    / v3 L$ X) ^7 t2 H( b
26.     }
    
27. 
      j- _4 U& _: ~
28.     /* 4. Write a byte */
    # s; L# Y2 }  E. v+ R
29.     I2C_SendByte(data);
    1 }+ l$ I( l/ v8 Y" C
30. 
    6 F% h1 A0 d: V2 k9 q
31.     /* 5. Stop */
    
32.     I2C_Stop();
    2 Y3 j! I$ V8 {
33. }
    * y5 x+ n8 T" x( p# Y6 \
34. 
    
35. /*
    7 z0 m  [5 F( e) E$ y1 m
36. *  函数名：uint8_t EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    6 C& t. `& @! }1 B
37. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    7 W/ F6 r" Y! N% E6 N% Q
38. *            data -> 要读的数据指针
    - H2 u/ i+ j) a. w
39. *  输出参数：无
    8 ]# l9 z+ F4 \
40. *  返回值：无
    ( V1 |" e3 V5 `7 ~$ f
41. *  函数作用：EEPROM读一个字节
      a1 M& x, Q; W: \1 o
42. */
    
43. void EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    
44. {
    7 z6 \  o2 `) ?* ?8 Z1 v/ l
45.     /* 1. Start */
    5 r9 w. C8 S( S  Q
46.     I2C_Start();
    - J0 h: b5 u. y
47. 
    
48.     /* 2. Write Device Address */
    
49.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    3 B7 z5 q- Y* S# e+ _4 l
50. 
    5 k+ Y+ M8 B' V& @5 X
51.     /* 3. Data Address */
    
52.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    / ~0 {. v( O3 \1 y/ V
53.     {
    ( k& D4 E& u( N" O* y2 [3 [6 H
54.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    . p7 {% g/ q  R# Z8 ?# [
55.     }
    # r  Y* A+ c) K6 k. u9 ~4 v) p
56.     else
    
57.     {
    
58.         I2C_SendByte( (uint8_t)(addr>>8) );
    
59.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
60.     }
    , f# }5 O- J5 E" x: J
61. 
    * S8 e4 W- T: k
62.     /* 4. Start Again */
    
63.     I2C_Start();
    
64. 
    
65.     /* 5. Write Device Address Read */
    / ^- A2 Z, I% |
66.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_RD );
    * h' V* r" n- y6 @2 d6 J- V, Q$ d! @
67. 
    
68.     /* 6.Read a byte */
    
69.     *pdata = I2C_ReadByte(NACK);
    
70. 
    ! ~% |' X# Z( _1 |- W: p
71.     /* 7. Stop */
    & q* o* B, T2 \
72.     I2C_Stop();
    
73. }

复制代码

参加前面图 16.2.1 和图 16.1.13 所示的介绍时序，编写AT24C02一字节读写程序。
- t5 w! c: D5 U) S# W. e* s/ V
' n, H2 P$ S5 J+ @) ~8 |& y- b; h6 X9~33行：写AT24C02一字节数据；
. Y& Q$ Z* p( V8 F! z& P* r/ b4 L8 N
9 F) x' N% q% c" B4 @# N1 v12行：发送I2C开始信号；
- {- ^+ c& k1 d" ~5 I. ]1 Q
6 l. ], `( n# r) [% i! m9 o/ S15行：发送AT24C02的设备地址，最后一位表示写操作；
% ]. ?5 t, G9 d  ^5 y& b7 m
18~26行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；
8 I! N' M  K4 Q" }
29行：发送数据；

32行：发送I2C停止信号；
* Z( O: l' D% X3 r% j" [  g
% g( C+ _! P' {) K6 u43~73行：读AT24C02一字节数据；
3 n9 C; y# g$ P* [
46行：发送I2C开始信号；

49行：发送AT24C02的设备地址，最后一位表示写操作（接下来要写数据地址）；
* u+ L2 A+ Z: e8 ~; S( Q
$ p- e) M1 E: h0 C52~60行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；

63行：再次发送I2C开始信号；
( P! _9 v& T5 I8 F$ l1 f1 |
66行：发送AT24C02的设备地址，最后一位表示读操作；

4 t0 }9 n+ N# m5 H0 R69行：读取AT24C02数据，且无需ACK；

) q6 g( W3 |" }: A" R* Z72行：发送I2C停止信号；
9 L; |1 E: u1 U
实现了对AT24C02单字节的读写，还需要实现多字节的读写。多字节读写可以通过AT24Cxx的页写模式和顺序读模式，实现多个数据的连续读写。在页写模式时，需要程序上设置，不能跨页写，这里简单处理，直接多次调用前面的单次读写即可，如代码段 16.3.8 所示。
# ~* i6 k. t9 x+ u
代码段 16.3.8 读写AT24C02多字节数据（driver_eeprom.c）
) x5 |: X! ]- U) R' T$ a2 W
% w: t4 u- o; u# a( G3 H# e+ p* m

1. /*
   
2. *  函数名：void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
   
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   
4. *            data -> 要写的数据指针
   
5. *            sz   -> 要写的字节个数
   1 H, p' W2 }0 R; n( @
6. *  输出参数：无
   
7. *  返回值：无
   ' _  w- n1 L3 p' W/ \4 T
8. *  函数作用：EEPROM写N个字节
   
9. */
   
10. void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    8 V: F1 c7 U8 a. y& r# @
11. {
    
12.     uint16_t i = 0;
    
13. 
    ( S) |) V% U5 P1 _4 d
14.     for(i=0; i<sz; i++)
    ' v+ x0 L( I* q5 W; x  {; R
15.     {
    
16.         EEPROM_WriteByte(addr, pdata<i>);
    
17.         addr++;
    
18.         HAL_Delay(10); // Write Cycle Time 5ms
    
19.     }
    8 h7 ~2 Y2 {: ~3 d
20. }
    * p3 s- z$ ]+ N
21. 
    4 I- f9 _4 D# y$ D  E; t
22. /*
    6 u% P9 a! z4 j& K5 d6 m5 F; j, Y
23. *  函数名：void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
24. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    - ~6 N1 [8 B% a+ z& l) L1 P
25. *            data -> 要读的数据指针
    
26. *            sz   -> 要读的字节个数
    6 d4 c/ W& r+ G! y
27. *  输出参数：无
    , h6 e* [$ z& E6 r. N
28. *  返回值：无
    5 M) ?( @, E( t9 z9 L! P( g
29. *  函数作用：EEPROM读N个字节
    ( B. ~9 f. [/ n
30. */
    
31. void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
32. {
    4 R$ d1 f5 k( h( D( |( W) ~
33.     uint16_t i = 0;
    
34. 
    
35.     for(i=0; i<sz; i++)
    
36.     {
      N4 V' m- C# a+ p" U5 o
37.         EEPROM_ReadByte(addr, &pdata<i>);
    
38.         addr++;
    ! J; l+ V! \% r  ~$ d
39.     }
    6 G0 |0 G- y: C. r* s. b
40. }</i></i>

复制代码

需要注意的是，AT24Cxx每次写操作后，有一个写间隔，需要间隔5ms以上，因此在写多个字节时，每次写完都需要延时5ms以上。
8 ]% z! `1 G7 O5 u6 ~
1 [+ }  ?$ C- x3 `: T2 D
1 g; y  F, n* {3 d' w1 C9 d
( c( Z; ^# ^. Z2 a* @! E5 M( O9 t4) 主函数控制逻辑

# \: a0 ~: g9 Z9 J- m在主函数里，每按一下按键，调用“EEPROM_Write_Nbytes()”对AT24C02写一串数据，再调用“EEPROM_Read_Nbytes()”读出该数据，如代码段 16.3.9 所示。

' o0 t! S+ ^$ h/ ]$ t7 L. ?代码段 16.3.9 主函数控制逻辑（main.c）

1. // 初始化I2C
   ! _: i& I+ W! X
2.    I2C_Init();
   
3. 
   
4.    while(1)
   
5.    {
   
6.        if(key_flag) // 按键按下
   
7.        {
   8 z; V/ y% E- s& X2 L
8.            key_flag = 0;
   
9. 
   + @9 B" G2 N. T4 B/ O% f# ^
10.            printf("\n\r");
    " _6 y& e# j5 |$ G( B
11.            printf("Start write and read eeprom.\n\r");
    
12. 
    : U4 A' `/ s; I8 O
13.            // 读写一串字符，并打印
    * H# Y6 j3 [# z7 P$ M
14.            EEPROM_Write_NBytes(0, tx_buffer, sizeof(tx_buffer)); // 写数据
    
15.            HAL_Delay(1);
    
16. 
    5 Y, d1 |0 C, `7 g5 X0 R
17.            EEPROM_Read_NBytes(0, rx_buffer, sizeof(tx_buffer));  // 读数据
    ( x# Y: y+ Q' W9 r2 M4 k
18.            HAL_Delay(1);
    ; b* M, ^# A6 [8 j
19. 
    
20.            printf("EEPROM Write: %s\n\r", tx_buffer);
    : h7 S8 N* a( E5 M3 ^. y
21.            printf("EEPROM Read : %s\n\r", rx_buffer);
    # ~, A3 b& ]* t8 G2 K
22. 
    4 K- N8 l5 m+ e1 W( o
23.            memset((uint8_t*)rx_buffer, 0, sizeof(rx_buffer));   // 清空接收的数据
    
24.        }
    
25. }
    

复制代码

" @( u4 j. a: E/ J3 I6 W+ C
& H" D" S: b9 D) a/ B7 E9 }4 Z  C% B16.4 实验效果
7 G1 O3 c  a2 \) N) G本实验对应配套资料的“5_程序源码\8_通信—模拟I2C\”。打开工程后，编译，下载，按下按键KEY，即可看到串口如图 16.4.1 所示。

6 p% X: q/ F0 M& I
9 i- j; J. h8 J5 ~# Z% s

图 16.4.1 模拟I2C读写AT24C02数据

/ W  ]$ Q+ F1 a% M3 A- V2 d8 a作者：攻城狮子黄

' L( y$ F! \! v3 V7 e* {