16.1 关于I2C
16.1.1 I2C协议

I²C（Inter-Integrated Circuit），常读作“I方C”,它是一种多主从架构串行通信总线。在1980年由飞利浦公司设计，用于让主板、嵌入式系统或手机连接低速周边设备。如今在嵌入式领域是非常常见通信协议，常用于MPU/MCU与外部设备连接通信、数据传输。

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工作效率相对较高。

, P. _. Y! m, D/ D, T" n, G关于I²C协议，通过下面例子进行一个形象的比喻方便大家理解，如图 16.1.1 所示，老师（MCU）将球（数据）传给众多学生中的一个（众多外设设备中的一个）。
' B$ i9 o# ^/ I

7 V7 r9 Y+ _6 a( l6 ^, o- a$ j
% Y  `- Y8 f  r' b# P( s' B
& ^# z, |9 O  i7 P/ K! I( h: q图 16.1.1 I²C协议比喻
1 I( E9 `5 z2 F0 ^7 ~8 x
首先老师将球踢给某学生，即主机发送数据给从机，步骤如下：
- T( H% o3 N) g& ~0 b7 t! k8 l
& ]3 r( H+ h5 }. t1 ~1) 老师：开始了(start)；
" x3 ]7 {* x7 r  q8 h
/ q6 w7 w" j1 w7 G0 v2) 老师：A！我要发球给你！(地址/方向)；

3) 学生A：到！(回应)；

4) 老师把球发出去（传输）；
: B( A5 I, q0 M  A3 l6 Y/ S' K
- C2 A- B% U1 o$ L4 t* u* Z/ R5) A收到球之后，应该告诉老师一声（回应）；
3 D! _8 s# f1 j$ r! V# H# Q$ t
$ A! x2 l; N. C$ {6) 老师：结束（停止）；



* T1 o& n7 T: i9 r接着老师让学生把球传给自己，即从机发送数据给主机，步骤如下：

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

* @5 Q: I) n5 j2) 老师：B！把球发给我！(地址/方向)；
' ]  v' s% y& v( M# X4 J! M2 b
, U5 A& e# }0 X. ~$ T2 N. f8 ~+ i3) 学生B：到！

4) B把球发给老师（传输）；
9 `1 r8 E8 J  f$ R. u$ w
5) 老师收到球之后，给B说一声，表示收到球了（回应）；
( X$ P8 o3 n) g6 h. U
7 g$ D+ l) j# x$ D4 U& E6) 老师：结束（停止）。


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

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

1 v! }' I, @. \② 老师提醒某个学生要发球，表示发送地址和方向(address/read/write)；

1 _& T! z# f- u③ 该学生回应老师(ack)；
* U* o/ n1 {( L# k! U/ Y( W3 ]
! {8 c1 u2 R9 |$ E# I4 y! r* W④ 老师发球/接球，表示数据的传输；
! F$ J0 a  F% A& b7 W
⑤ 收到球要回应：回应信号(ACK)；
! h: J- l3 k4 M7 {8 h
⑥ 老师说结束，表示IIC传输结束(P)。
' M4 }* V( q/ a

9 x' G. J: n1 E4 [  |以上就是I²C的传输协议，如果是软件模拟I²C，需要依次实现每个步骤。因此，还需要知道每一步的具体细节，比如什么时候的数据有效，开始信号怎么表示。

# ~, P- I, `( @5 q" B
+ _3 a0 t  d. J7 v  J数据有效性

- N  z9 x) n6 v& zI²C由两条线组成，一条双向串行数据线SDA，一条串行时钟线SCL。SDA线上的数据必须在时钟的高电平周期保持稳定，数据线的高或低电平状态只有在 SCL 线的时钟信号是低电平时才能改变。换言之，SCL为高电平时表示有效数据，SDA为高电平表示“1”，低电平表示“0”；SCL为低电平时表示无效数据，此时SDA会进行电平切换，为下次数据表示做准备。数据有效性示意图如图 16.1.2 所示。
8 z- D1 ~2 N! `* [8 x9 b2 a
  v' L; _" J5 n  l1 L# c$ [0 P

/ f$ n; A, P9 }$ R# w! M* {* B- z图 16.1.2 数据有效性


开始信号和结束信号

I²C起始信号（S）：当SCL高电平时，SDA由高电平向低电平转换；

( ~/ r+ t, I5 N8 Y0 c3 BI²C停止信号（P）：当SCL高电平时，SDA由低电平向高电平转换；



图 16.1.3 开始信号和结束信号

6 g& R# e( R% I& C  {
$ e/ M4 R2 @8 k; g应答信号                          

; I' n/ K- ?- x& @I²C每次传输的8位数据，每次传输后需要从机反馈一个应答位，以确认从机是否正常接收了数据。当主机发送了8位数据后，会再产生一个时钟，此时主机放开SDA的控制，读取SDA电平，在上拉电阻的影响下，此时SDA默认为高，必须从机拉低，以确认收到数据。
/ P- @% A4 {( s9 T" ?+ v; |) N
  D0 S  R$ t# w& J3 E7 N( {3 `

图 16.1.4 数据传输格式和应答信号
* S* w  |" N/ _5 p' U/ c8 S

完整传输流程  
% T) ]' ?( F3 e
$ @/ \7 M$ ~2 g! g$ r  n/ vI²C完整传输流程如下：

2 v) a: W" Q' ]① SDA和SCL开始都为高，然后主机将SDA拉低，表示开始信号；
4 j  W* k4 @% \
1 X$ V. c/ S8 A, x" o  G② 在接下来的8个时间周期里，主机控制SDA的高低，发送从机地址。其中第8位如果为0，表示接下来是写操作，即主机传输数据给从机；如果为1，表示接下来是读操作，即从机传输数据给主机；另外，数据传输是从最高位到最低位，因此传输方式为MSB（Most Significant Bit）。
* T! y) T" r# x: I, X
+ b4 R5 ]+ }% P& X) b③ 总线中对应从机地址的设备，发出应答信号；

' U0 J; u5 u# C- N+ K& [④ 在接下来的8个时间周期里，如果是写操作，则主机控制SDA的高低；如果是读操作，则从机控制SDA的高低；
7 ~/ q  Q3 o1 ?' V1 k
⑤ 每次传输完成，接收数据的设备，都发出应答信号；

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

9 _9 b6 g& B( d- _
图 16.1.5 I2C传输时序


. D( p& u% K+ I, y& K; `: ^4 j16.1.2 EEPROM介绍
+ k& r; N& k. H! q2 v8 q
EEPROM的全称是“电可擦除可编程只读存储器”，即Electrically Erasable Programmable Read-Only Memory。通常用于存放用户配置信息数据，比如在开发板首次运行时，需要屏幕校准，校准后的配置信息就可以保存在EEPROM里，开发板断电后配置信息不丢失，下次启动，开发板自动读取EEPROM的校准配置信息，就不需要重新校准。
7 N3 W4 F, N7 h: h0 Q: {( j3 J
EEPROM和Flash的本质上是一样的，Flash包括MCU内部的Flash和外部扩展的Flash，本开发板就有一个SPI接口的外部Flash（W25Q64），在后面SPI接口再讲解。从功能上，Flash通常存放运行代码，运行过程中不会修改，而EEPROM存放用户数据，可能会反复修改。从结构上，Flash按扇区操作，EEPROM通常按字节操作。两者区别这里不再过多赘述，读者理解EEPROM在嵌入式中扮演的角色即可。

* M7 ?' C3 H2 A' K" G5 u
( c8 o& H! _& J* g结构组成
2 n3 p3 [4 {8 q* L
EEPROM类型众多，其中比较常见是AT24Cxx系列，从命名上看，AT24Cxx中xx的单位是K Bit，如AT24C08，其存储容量为8K Bit。本开发板上的EEPROM型号为AT24C02，其存储容量为2K Bit，2*1024=2048 Bit。
( Y5 @8 E2 j6 q- I) J! 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。



/ V7 E0 D! o/ u5 M, ?# Z7 a$ u3 J图 16.1.6 AT24C02结构示意图
, Y# g2 W2 _9 z
7 q2 q* W) |' j  M. u
* @' K4 K, y! e! T2 k; O1 j设备地址  

& [0 R# D# h3 T0 P. S1 HI²C设备都会有一个设备地址，不同容量的AT24C02，设备地址定义会有所差异，由芯片数据手册《AT24Cxx.pdf》可知，如图 16.1.7 所示。

- [; e, J5 E7 }8 \! J/ i: K

图 16.1.7 AT24Cxx设备地址定义
5 ]( k7 ~: Q5 ~6 Y: N

1 v7 r. b% N3 xAT24C02的容量为2K，对应上图中的第一行，高四位固定为“1010”，中间三位由A2、A1、A0引脚的电平决定，比如A2~0引脚全接地，则值为“000”，最后的最低位为读写位，0代表写命令，1代表读命令。
- c% s; N/ [  N7 s( A7 H, G9 U7 U
A2、A1、A0引脚电平需要由原理图决定，假设全接电源地，则如果需要向AT24C02写数据，则发送地址“1010 0000”，如果需要向AT24C02读数据，则发送地址“1010 0001”。
+ u3 {( l7 c6 Y; m/ v. f
假设开发板有多个AT24C02挂在同一I²C总线上，通过这个规则，只需设计电路时，让A2、A1、A0引脚电平不同，即可区分两个AT24C02。

对于容量再大一点的AT24Cxx系列，比如AT24C04，器件地址由A2、A1引脚决定，数据空间有P0决定。比如对AT24C04的0~2K空间操作，则P0为0，对2K~4K空间操作，则P0为1。
4 l! `( O) T/ P& ~. G! b

# u# U3 i) J- W8 a0 Y2 `写AT24Cxx  

) _7 v( b; ?5 S, W! JAT24Cxx支持字节写模式和页写模式。字节写模式是一个地址一个数据的写；页写模式是连续写数据，一个地址多个数据的写，但是页写模式不能自动跨页，如果超出一页长度，超出的数据会覆盖原先写入的数据。

3 m5 W2 `; o( c: D! A. ^5 ?如图 16.1.8 所示，为AT24Cxx字节写模式的时序，在MCU发出开始信号（Start）后，发出8 Bit的设备地址信息（图中读写位为低电平，即写数据），待收到AT24Cxx应答信号后，再发出要写的数据地址，再次等待AT24Cxx应答，最后发出8 Bit数据写数据，待AT24Cxx应答后，发出停止信号（Stop），完成一次单字节写数据。


4 I9 N$ L8 ~' `& @1 o9 [1 m
- R; U2 K6 J: a" G图 16.1.8 AT24Cxx字节写模式时序
8 f$ \, X5 U7 \! B- g1 KAT24C02容量为2K，因此数据地址范围为0x00~0xFF，即0~255，每个数据地址每次写1Byte，即8bit，也就刚好256*8=2048Bit。对于1K容量的产品，数据地址范围为0x00~0x7F，最高位不会用到，因此图中数据地址的最高位为“*”，意思是对于1K容量的产品，该位无需关心。
  s* ~, ]0 e0 h; F! X

! M+ N& u( o. \2 j
图 16.1.9 单字节写模流程图

& I$ I) e2 C0 p( K; ?1 z图 16.1.10 为AT24Cxx的页写模式时序，与字节写模式的差异在于，不是只发送1Byte数据，而是任意多个。需要注意，该模式不能跨页写，遇到跨页时，需要重新发送完整的时序。
0 g8 N2 u/ P+ o* \7 D) C
$ E6 ?- ^5 o  \# Y2 v

& O5 Z# s, i. w2 ?6 A* \9 B3 L4 s图 16.1.10 AT24Cxx页写模式时序

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

1 W+ @$ D) {! x6 M* C/ d
; s& ~1 y4 R+ L7 `/ I# w. N! E2 N
图 16.1.11 AT24Cxx写间隔


+ K+ X% T0 A& e- D* H! O. I读AT24Cxx
3 s! C8 p8 N7 Z9 w
AT24Cxx支持当前地址读模式、随机地址读模式和顺序读模式。当前地址读模式就是在上一次读/写操作之后的最后位置，继续读出数据，比如上次读/写在地址n，接下来可以直接从n+1处读出数据；随机地址读模式是指定数据地址，然后读出数据；顺序读模式是连续读出多个数据。

" X  i& Y& W; s- `, H) N在当前地址读模式下，无需发送数据地址，数据地址为上一次读/写操作之后的位置，时序如图 16.1.12 所示，注意在结尾，主机接收数据后，无需产生应答信号。

; g) n5 v+ u- s1 _' P3 z! H

: f2 Q$ k. d/ r) C+ _图 16.1.12 AT24Cxx当前地址读模式
. F0 o0 B0 `6 r8 y5 t
在随机地址读模式下，需要先发送设备地址，待读的数据地址，接着再重新发出开始信号，设备地址，读出数据，时序如图 16.1.13 所示。
7 X* ?4 b" E: R$ `

9 t2 C" f2 T1 l. s% f8 d
图 16.1.13 AT24Cxx随机地址读模式


, z6 G- K( ~  J7 v' h: R5 [, M9 g' m4 c在顺序读模式下，需要先从当前地址读模式或随机地址读模式启动，随后便可连续读多个数据，时序如图 16.1.14 所示
+ E! O. j; X- ~' }- S& J- P9 p; b* x
* d9 L5 h% w1 D6 D1 g9 c

图 16.1.14 AT24Cxx顺序读模式
8 J. @, c1 S$ }+ t' k& K- w
. v8 y; {! s1 I( z6 m9 O
3 s  u% h+ A. X8 r$ y1 C' N16.2 硬件设计
如图 16.2.1 为开发板EEPROM部分的原理图，U6为AT24C02芯片，它的A0、A1、A2都接地，因此该设备地址为“1010 000X”，当读该设备时，X为1，写该设备时，X为0。
* d& ~; M* G+ Q) C: _: m
U4的7脚为写保护引脚（Write Protect，WP），当该引脚为高，则禁止写AT24C02，这里直接拉低WP，任何时候都可直接写AT24C02。

6 q) U; l, W5 W# w7 K8 E8 x此外，I2C的两个脚SCL和SDA都进行了上拉处理，从而保证I2C总线空闲时，两根线都必须为高电平。如果没有上拉，在主机发送完数据后，放开SDA，此时SDA的电平状态不确定，可能为高，也可能为低，无法确定是从机拉低给出应答信号。

结合原理图可知，PB6作为了I2C1的SCL，PB7作为了I2C1的SDA。
' N4 {# P1 ]% ^6 S
) h  K& |5 _4 x. {2 k

0 T. D9 X4 [6 Y2 w% f) G  ~) R图 16.2.1 EEPROM模块原理图

% ~% G8 f; u9 [2 y7 T& C
16.3 软件设计
16.3.1 软件设计思路

+ X) V# F. V, Z" N3 _% s. a6 x实验目的：本实验通过GPIO模拟I2C总线时序，对EEPROM设备AT24C02进行读写操作。
7 @1 K& o( {0 d! g3 k, c: t! a
1) 引脚初始化：GPIO端口时钟使能、GPIO引脚设置为输入/输出模式（PB6、PB7）；

2) 封装I2C每个环节的时序函数：起始信号、响应信号、读写数据、停止信号；
# O7 p" c+ Q1 j4 E, ]# A: d
& ]* `5 ^1 M6 a8 s4 r2 ]3) 使用I2C协议函数，实现对AT24C02的读写；
) K3 L, X2 S4 Q, c7 _1 u$ I
4) 主函数，每按一次按键，写一次AT24C02，接着读出来验证是否和写的数据一致；
& ^& {( k, C9 @* ^5 T: o- H
本实验配套代码位于“5_程序源码\8_通信—模拟I2C\”。
( z; o) o: z* S: q
; K' P' s1 s* p- C$ ]
16.3.2 软件设计讲解

1) GPIO选择与接口定义
% w7 a% V0 F  j, w8 G
! A% W9 t0 H7 R- e, K% k& r# M首先定义SCL和SDA引脚，引脚的高低电平宏定义，如代码段 16.3.1 所示。

7 E% @+ O4 j8 _/ [代码段 16.3.1 模拟I2C引脚相关定义（driver_i2c.h）
5 ~4 m4 S9 u1 S8 Z) m  i
# n# c8 k5 H3 `! k  `) w! u

1. /************************* I2C 硬件相关定义 *************************/
   - \4 y/ w' C" m/ ?  w4 Y" d
2. 
   / c. [/ ^. d0 |, d
3. #define ACK                 (0)
   
4. 
   
5. #define NACK                (1)
   
6. 
   
7. 
   7 ?& m5 b+ G0 l  d
8. 
   2 |* q- ]  B; P% Q/ v
9. #define SCL_PIN             GPIO_PIN_6
   
10. 
    7 r9 F2 F9 [* c! Z, m. ?) _2 A
11. #define SCL_PORT            GPIOB
    . c8 a/ `* p# l# E4 o" ~
12. 
    / b" b( d9 c: S. M5 \9 x( @8 W
13. #define SCL_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    5 M3 W# s; o0 y5 ~8 x
14. 
    
15. 
    7 f% v: b5 \. b. A
16. 
    ) ?* I" M* v$ V! B) Z0 c
17. #define SDA_PIN             GPIO_PIN_7
    5 a) O( C9 v& q6 C/ V, @& x% F) P
18. 
    
19. #define SDA_PORT            GPIOB
    
20. 
    
21. #define SDA_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    ' y$ x; F/ Z: v: l+ S+ t
22. 
    
23. 
    ! I+ M2 K! |) G
24. 
    ' q7 O) }3 \2 s
25. #define SCL_H()             HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_SET)
    
26. 
    6 M/ k5 E: M  x' R
27. #define SCL_L()             HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_RESET)
    
28. 
    0 d  j0 h, e' K2 p; x
29. #define SCL_INPUT()         HAL_GPIO_ReadPin(SCL_PORT, SCL_PIN)
    
30. 
    % _( @# }+ ]. B
31. 
    
32. 
    
33. #define SDA_H()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_SET)
    7 ]/ V+ \( k: w& t6 y+ Z, L# B+ J
34. 
    / \  }$ u, f. `1 S. ]2 a& E  o8 u
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)

复制代码

8 I7 s- }  B2 z/ t* v9 w6 q% n2 X* s接着将两个GPIO引脚初始化，使能引脚时钟，先默认设置为输出模式。SCL引脚为时钟信号，始终为输出模式，SDA引脚为数据引脚，可能输出或者输入，因此还需要编写函数实现输入、输出的切换，如代码段 16.3.2 所示。
1 ^& L  y% ~8 D; h  V# K
( ]' P" ?, I0 m# U5 t$ T0 O代码段 16.3.2 I2C引脚初始化（driver_i2c.c）
+ D0 e! e5 k% p; P1 b+ j

1. /*
   0 ~. `3 ]9 Q; \4 G0 v7 {) V! o
2. *  函数名：void I2C_Init(void)
   ) T% l( Z* I+ k2 s
3. *  输入参数：
   
4. *  输出参数：无
   ( E0 ]8 @0 J: ?
5. *  返回值：无
   - D. h9 f2 C6 K# D  l) u  r( q" G
6. *  函数作用：初始化模拟I2C的引脚为输出状态且SCL/SDA都初始为高电平
   
7. */
   6 i: U! R* C7 \* n! e
8. void I2C_Init(void)
   - a: @# ~  a- \/ R4 B
9. {
   
10.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    $ i5 u" B, [; Z( a+ Y/ k! S6 i
11. 
    
12.     SCL_PIN_CLK_EN();
    
13.     SDA_PIN_CLK_EN();
    & l( I1 J5 ^3 y/ c' c" h, Q
14. 
    2 C) K$ M& z! \
15.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    # k* V# ~; j9 G3 z3 ~3 b! z  ]
16.     GPIO_InitStruct.Pull      = GPIO_NOPULL;
      U$ q5 o0 v8 N" @) O' e+ Y
17.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    % g5 \; k7 E- l
18. 
    9 B4 W( s: h3 T0 y6 g
19.     GPIO_InitStruct.Pin       = SCL_PIN;
    " B, I  Y- D# G* W# |" k# K/ u
20.     HAL_GPIO_Init(SCL_PORT, &GPIO_InitStruct);
    
21. 
    
22.     GPIO_InitStruct.Pin       = SDA_PIN;
    
23.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    
24. 
    
25.     SCL_H();
    1 t- l, _+ e7 y3 g
26.     SDA_H();
    
27. }
    + o: P5 b; w4 W0 a3 s6 w
28. 
    
29. /*
    9 I6 I0 j# r& _" D7 l$ P' s
30. *  函数名：static void I2C_SDA_OUT(void)
    
31. *  输入参数：
    ' G) \. ~5 I. J5 M3 W4 s+ O
32. *  输出参数：无
      a6 L! s- m& z9 t3 N$ @  l" e
33. *  返回值：无
    
34. *  函数作用：配置SDA引脚为输出
    ; m6 I7 f  u( g+ Z5 \! T
35. */
    & V$ n% ^; r" c6 }
36. static void I2C_SDA_OUT(void)
    
37. {
    
38.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    / x% ?. ]" f" w( S- x
39. 
    
40.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    
41.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    ; V7 x/ [9 N" S& \' q  `1 c
42.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    4 X8 t- N! l2 X- A: k, E
43. 
    
44.     GPIO_InitStruct.Pin       = SDA_PIN;
    4 P0 B, y4 A8 }
45.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    % J( Z# C$ @% m/ i: R& O  G5 e
46. }
    
47. 
    
48. /*
    
49. *  函数名：static void I2C_SDA_IN(void)
    3 ], \- z; ]( g
50. *  输入参数：
    
51. *  输出参数：无
    
52. *  返回值：无
    
53. *  函数作用：配置SDA引脚为输入
    
54. */
    3 v4 F, C$ {  D  B  g
55. static void I2C_SDA_IN(void)
    
56. {
    6 J) n) h  h! f3 \# I, O5 D: E
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    : E7 |2 B% K5 N8 [# M# I5 n
58. 
    6 n9 O7 O; B6 L( ^5 i, R
59.     GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
    , F3 s, G: t& T# B3 H& u
60.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    ( y& R! X1 V5 f& W0 ~
61. 
    3 X+ w$ }7 p9 X/ r0 q7 i
62.     GPIO_InitStruct.Pin       = SDA_PIN;
    
63.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    
64. }

复制代码

# j4 A7 g7 {: w5 K/ [" d
2) I2C时序函数

/ A% r3 W4 D1 D开始信号/结束信号

% x- }& X. l2 i. G8 B: ?参考前面图 16.1.3 所示的开始信号和结束信号编写程序。对于开始信号，首先将SDA和SCL都拉高，随后SDA拉低，再SCL拉低。对于结束信号，首先拉低SDA，拉高SCL，再拉低SDA，代码如代码段 16.3.3 所示。

7 S5 u4 I4 ?5 w1 Y- B+ l  p; X. ^代码段 16.3.3 I2C开始信号和结束信号（driver_i2c.c）

" |* _- ?- x; [, q4 U

1. /*
   
2. *  函数名：void I2C_Start(void)
   . W3 u2 U4 p9 \# M3 @
3. *  输入参数：
   
4. *  输出参数：无
   
5. *  返回值：无
   9 r! `' u; H& f
6. *  函数作用：I2C开始信号
   
7. */
   
8. void I2C_Start(void)
   % a3 [6 K: y, J+ E+ K. r0 m
9. {
   
10.     I2C_SDA_OUT();
    * s/ p# h, z- N# @
11. 
    
12.     SCL_H();
      |* I) k0 J0 F9 @! {
13.     I2C_Delay();
    3 ?/ X& E; e  u  s, w: n$ {( c
14. 
    5 f8 I2 D! S8 m9 i: p& J
15.     SDA_H();
    
16.     I2C_Delay();
    
17. 
    . y' ?# S2 E0 E6 X: @: c- o6 C
18.     SDA_L();
    0 u9 S; h: E, N# s  d# N/ O
19.     I2C_Delay();
    0 |5 X5 Y4 q3 S6 H
20. 
    : S2 g& X4 {9 d- D0 c) D
21.     SCL_L();
    $ B  t/ l/ x3 v  t
22.     I2C_Delay();
    2 l0 H( F1 z9 }7 ^; M2 L
23. }
    
24. 
    
25. /*
    
26. *  函数名：void I2C_Stop(void)
    , m( l$ S' ]( J4 j: t
27. *  输入参数：
    
28. *  输出参数：无
    
29. *  返回值：无
    
30. *  函数作用：I2C停止信号
    4 }/ r. O! X' `
31. */
    
32. void I2C_Stop(void)
    
33. {
    ; B; x' s/ y6 J& H0 [
34.     I2C_SDA_OUT();
    + @; j5 z( B! q* C) D, i; ^
35. 
    + \! N  d1 z+ S" K2 t( H" |
36.     SDA_L();
    1 p3 g- b. L/ i& v, W; Y, {
37.     I2C_Delay();
    
38. 
    
39.     SCL_H();
    
40.     I2C_Delay();
    + k; R& Q* F% B. c
41. 
    
42.     SDA_H();
    
43.     I2C_Delay();
    8 |, ^5 E) p4 A. G& i
44. }

复制代码

( c( z5 [! W" z! V# E' Z
应答信号/非应答信号/等待应答信号
- [7 \5 D  q6 [0 Y/ D% S: e$ T" h
' @4 g( h1 Z! H8 d+ _; [, e# ~  |参考前面图 16.1.4 所示，编译应答信号，如代码段 16.3.4 所示。

. |0 T' p) o7 v) D" y! b8 \代码段 16.3.4 应答/非应答/等待应答信号（driver_i2c.c）

# S3 T; ^3 F2 d4 m" i

1. /*
   . ~; s( w$ G) s' l
2. *  函数名：void I2C_ACK(void)
   % f5 a9 i4 Y5 \* _7 J+ M/ I6 [
3. *  输入参数：
   
4. *  输出参数：无
   
5. *  返回值：无
   : V- z4 F. m! m$ m+ z
6. *  函数作用：I2C发出应答信号
   ; z- M7 w% V) @. K* }
7. */
   / s7 ]( o- [% D4 Y' R
8. void I2C_ACK(void)
   5 T4 K  n2 G3 ]2 e( R3 @3 V
9. {
   & N7 U7 [/ p+ z" Y. o: d* w
10.     I2C_SDA_OUT();
    
11. 
    ) @) {* T( I; r2 I( Y2 `  b
12.     SCL_L();
    
13.     I2C_Delay();
    
14. 
    
15.     SDA_L();
    & @7 B0 g, ^: N; h/ v2 d
16.     I2C_Delay();
    ; H9 H  z; m. ?9 ~3 a
17. 
    
18.     SCL_H();
    " \/ G/ _# e5 y5 d" W- ]
19.     I2C_Delay();
    . A5 w6 W. v, [) n: N. ~8 F
20. 
    
21.     SCL_L();
    
22.     I2C_Delay();
    6 d: L. X2 R7 w& e
23. }
    , U$ c. Q2 C+ a" n7 m) C- F9 ]+ c
24. 
    / {* ^5 `& W! [6 u, G
25. /*
    * l7 B, G( l. Y8 H
26. *  函数名：void I2C_NACK(void)
    
27. *  输入参数：
    
28. *  输出参数：无
    
29. *  返回值：无
    
30. *  函数作用：I2C发出非应答信号
    ' h) q& i- v& F
31. */
    
32. void I2C_NACK(void)
    
33. {
    ( m/ \5 z1 A5 n* Y8 J' k
34.     I2C_SDA_OUT();
    
35. 
    
36.     SCL_L();
    . P+ Z* x# I% D' @
37.     I2C_Delay();
    # _' a; M; a& N% v
38. 
    
39.     SDA_H();
    2 r/ W( o" @9 Y' g( G" d$ H
40.     I2C_Delay();
    , r5 f& ~/ h$ L/ c5 ^5 M
41. 
    ) u- |& `5 X* w" c  O
42.     SCL_H();
    
43.     I2C_Delay();
    
44. 
    & [2 p+ g: Y- f) W
45.     SCL_L();
      K( X! [( c# Q9 t
46.     I2C_Delay();
    ' f4 q! d8 l9 t$ M8 {3 y3 ^
47. }
    2 \) Q; E9 V1 D
48. 
    
49. /*
    
50. *  函数名：uint8_t I2C_GetACK(void)
    1 d- O) ^! n7 [" @$ B
51. *  输入参数：
    8 l! S, C9 b" t( e" y1 s3 Z
52. *  输出参数：无
    - f7 O3 P1 v3 r
53. *  返回值：1无应答，0有应答
    5 `9 s' x; G; E
54. *  函数作用：I2C等待从机的应答信号
    6 J+ g0 M3 e0 V8 v6 {3 P% H6 {. ?
55. */
    0 ^! }; h% s9 k* E
56. uint8_t I2C_GetACK(void)
    0 F3 Z0 }6 L& S: F4 z. k' a
57. {
    5 [7 a) T# d5 Z# k# f
58.     uint8_t time = 0;
    1 U8 A% ^# y/ i& {. s/ [  D* g5 a: H8 r
59.     I2C_SDA_IN();
    $ r( ]; s: a+ e9 L
60. 
    1 X$ N, |2 v+ r% B3 Q8 d; G8 s" r! F
61.     SCL_L();
    
62.     I2C_Delay();
    + T0 F# K; \' z0 A; U
63. 
    
64.     SDA_H();
    
65.     I2C_Delay();
      Q5 L1 v$ }9 e3 d6 t- Y
66. 
    + m, o) S. Y5 t) m* Y' }, C
67.     SCL_H();
    
68.     I2C_Delay();
    1 d6 k  Q- b; N1 _5 \1 i
69. 
    % o9 ~6 f* E4 B. ~' \& Z2 ^
70.     while(SDA_INPUT())
    
71.     {
    9 j7 S. c( N9 |" C
72.         time++;
    ! n2 D2 Z3 ^9 O# D
73.         if(time>250)
    
74.         {
    ' ?7 ?7 Q0 o3 H5 f
75.             SCL_L();
    1 }4 q; J% L# z' F! j+ E
76.             return 1;
    + S" }! i/ n4 r/ g$ e3 V% U+ B& D
77.         }
    4 j" h& f% d# A4 }( U4 R: Q0 M" v
78.     }
    ; k! n2 B* M4 b+ H/ r$ Y& @: k
79.     SCL_L();
    % C0 O) d; \4 |8 p. o, ?1 |' {
80. 
    
81.     return 0;
    
82. }

复制代码

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

8 b- I7 F) G& b5 M8 V$ b32~47行：非应答信号，在一个SDA时钟周期里，将SCL拉高；

" k3 }( v( ^% `7 T0 A4 M56~82行：等待应答信号，拉高SDA后放开SDA，读取SDA是否被拉低，如果拉低返回0，否则返回1；
2 _7 Y& E8 N7 a7 o
6 I; x, l+ u3 \
发送/接收函数
# u5 W$ n* R0 E, s' c/ q1 c7 M
最后还剩发送/接收函数，如代码段 16.3.5 所示。对于发送函数，控制SDA产生8个时钟周期，每个时钟周期里控制SDA高低电平发送1位数据。对于接收函数，控制SDA产生8个时钟周期，每个时钟周期里读取SDA高低电平接收1位数据。
( d1 U9 q3 F) A( X$ Z, P, p! i
* k1 Q( F0 U0 Z代码段 16.3.5 发送/接收函数（driver_i2c.c）

7 c+ ?8 g% [/ ?8 O

1. /*
   
2. *  函数名：void I2C_SendByte(uint8_t data)
   
3. *  输入参数：data->发送的数据
   ' O0 Y7 C, k% _# S" @+ N2 h& _- C
4. *  输出参数：无
   " @% f# g5 O6 b1 U# C
5. *  返回值：无
   
6. *  函数作用：I2C发送一个字节
   
7. */
   
8. void I2C_SendByte(uint8_t data)
   ) I3 n/ I; F" L5 }. e
9. {
   
10.     uint8_t cnt = 0;
    
11. 
    & y' T6 N+ ]. w
12.     I2C_SDA_OUT();
    % y- ?4 M( g8 \; s% ^
13. 
    
14.     for(cnt=0; cnt<8; cnt++)
    1 w: v0 s) z9 K9 _% G' Q/ e5 K
15.     {
    6 j3 L3 ^: w" e/ e' P) S9 d
16.         SCL_L();
    
17.         I2C_Delay();
    * J: \6 A1 u' q
18. 
    
19.         if(data & 0x80)
    
20.         {
    - h- y5 z, w: ^& u4 X
21.             SDA_H();
    
22.         }
    6 ]1 n1 n- h& {/ E
23.         else
    " q/ q/ K# }* ^4 l2 g6 g1 Z
24.         {
    7 Q% t( }9 ]: v0 L- s9 P7 W, B# p
25.             SDA_L();
    
26.         }
    + G6 ?" L8 o/ @3 D4 y
27.         data = data<<1;
    
28.         SCL_H();
    
29.         I2C_Delay();
    / t+ A9 Q2 Z; w2 @+ t1 X3 b9 P$ z
30.     }
    4 y% d) y( B" Y  w$ [1 ]
31. 
    
32.     SCL_L();
    8 Z+ h! {- C$ m# C
33.     I2C_Delay();
    : o% B: [$ e' X0 {7 S9 S+ i
34.     I2C_GetACK();
    , U8 b0 I% }1 E. u
35. }
    / C- S$ G9 q% }7 E: J
36. 
    % l/ s( h, C0 Y) l' f, O
37. /*
    
38. *  函数名：uint8_t I2C_ReadByte(uint8_t ack)
    
39. *  输入参数：ack->发送的应答标志，1应答，0非应答
    
40. *  输出参数：无
    4 Y# c/ h" i; T4 s% H9 i7 y* p
41. *  返回值：返回读到的字节
    
42. *  函数作用：I2C读出一个字节
    
43. */
    
44. uint8_t I2C_ReadByte(uint8_t ack)
    $ {; N* t' m+ K! z2 i& i
45. {
    : X+ a$ i( \6 ~/ [0 C
46.     uint8_t cnt;
    . [, K$ e0 W. |: h/ w
47.     uint8_t data = 0xFF;
    
48. 
    
49.     SCL_L();
    
50.     I2C_Delay();
    
51. 
    ) g% a+ ^6 o- X) e# }6 i% ^& ?
52.     for(cnt=0; cnt<8; cnt++)
    
53.     {
    ' J8 R) l' p2 W! W
54.         SCL_H();                 //SCL高(读取数据)
    9 p7 C' o( d; q6 ^) K
55.         I2C_Delay();
    
56. 
    
57.         data <<= 1;
    
58.         if(SDA_INPUT())
    " ~* V6 X' y" _$ `
59.         {
    - p( |- \' m# b
60.             data |= 0x01;        //SDA高(数据为1)
    
61.         }
    
62.         SCL_L();
    
63.         I2C_Delay();
    
64.     }
    1 N. e0 q+ P. a! r+ L; S
65.     //发送应答信号，为低代表应答，高代表非应答
      J. _$ n8 C5 y/ B
66.     if(ack == 0)
    
67.     {
    , \; a  c- G/ {3 S% Y* N
68.         I2C_ACK();
    
69.     }
    
70.     else
    # P4 E$ {2 |- n( g
71.     {
    
72.         I2C_NACK();
    
73.     }
    
74.     return data;                 //返回数据
    
75. }

复制代码

; S2 W6 s/ x: r% `( Q; U9 g* }& e14~31行：循环8次，每次循环：

16行：先拉低SCL；

; Q0 w7 Q, @, y* P. G+ {19~26行：将输入的数据data与0x08且运算，得到最高位的值，从而控制SDA输出对应的高、低电平;
5 S' U3 Z) U! }4 R0 v3 e, b, V
27行：将data左移一位，得到次高位；
7 @+ y% l) d& O( V0 B  y, m
29行：拉高SCL，让SDA处于稳定期，从设备即可获取SDA的值；

8 R2 y6 F, Z. q$ [* U: u35行：等待从设备的应答信号；
) b* e" ^' b& T& |8 ~
53~65行：循环8次，每次循环：

, {3 |2 _8 i+ c1 d, p; S$ ?55行：先拉高SCL，此时认为从设备控制SDA电平，处于稳定期；

" r* G4 f) S6 N6 Z* H; |* y58行：将data左移1位，以确保收到数据按最高位在前存放；
& D) `* h' J/ W* H6 e9 p
59~62行：读取SDA电平，如果为高，保存到data当前最低位，否则data最低位默认为0；
( r0 M. x7 z; ^# _% `  @
$ m) o) E, f1 r/ O& H63行：SCL拉低，此时从设备继续控制SDA电平变化
1 y* S# Z8 _1 B7 |$ G% h
/ x- r+ ?: G/ ^- H9 z& R  A66~74行：根据传入的参数，决定是否发送应答信号；

整个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 所示。
  G5 R9 @  _6 k* b6 X
代码段 16.3.6 延时函数的实现（driver_timer.c）
& M/ G. e' n( b

1. #if 0
   
2. /*
   7 W& M9 `0 `. c, k1 Y5 C% N
3. *  函数名：void us_timer_delay(uint16_t t)
   
4. *  输入参数：t-延时时间us
   % u& V9 X; g; \- U( j: r
5. *  输出参数：无
   7 P/ K; s& F/ o: U7 [5 g
6. *  返回值：无
   
7. *  函数作用：定时器实现的延时函数，延时时间为t us，为了缩短时间，函数体使用寄存器操作，用户可对照手册查看每个寄存器每一位的意义
   ) S& r# T6 X+ ^8 f
8. */
   1 k2 a$ ~6 _2 D% c2 _
9. void us_timer_delay(uint16_t t)
   
10. {
    ) m+ f8 |! G! i" n! g0 K$ R& w
11.     uint16_t counter = 0;
    # B/ i8 K' \2 r, N! e! s( |
12.     __HAL_TIM_SET_AUTORELOAD(&htim, t);
    
13.     __HAL_TIM_SET_COUNTER(&htim, counter);
    
14.     HAL_TIM_Base_Start(&htim);
    - U) C  R+ k: f7 g6 z/ l
15.     while(counter != t)
    
16.     {
    - y- B# y+ A3 B. J. d$ C0 H( L
17.         counter = __HAL_TIM_GET_COUNTER(&htim);
    
18.     }
    , R( @1 \* B) Q! S* W8 D$ \: w
19.     HAL_TIM_Base_Stop(&htim);
    
20. }
    
21. #else
    * ]) d  F; q3 y, O% Z/ O" Z
22. /*
    ( A- T/ T4 \1 E; w) G& w
23. *  函数名：void us_timer_delay(uint16_t t)
      [+ Q) l" R( r# s
24. *  输入参数：t-延时时间us
    
25. *  输出参数：无
    
26. *  返回值：无
    2 z- A2 Y$ W# ?1 O4 p6 Z
27. *  函数作用：延时粗略实现的延时函数，延时时间为t us
    
28. */
    
29. void us_timer_delay(uint16_t t)
    6 Z, L. J( o# F" y
30. {
      f3 t5 W7 p- j9 X, u0 a4 w
31.     uint16_t counter = 0;
    
32. 
    9 r, k% R. ^: o& i9 {9 t9 @
33.     while(t--)
    - s# c# }! n* `
34.     {
    . N7 h8 N% Z* v3 P. N4 Y+ w
35.         counter=10;
    
36. 
    2 T3 G9 d5 X* e, m9 X( K% S. H8 \
37.         while(counter--) ;
    7 E* }9 n/ X7 b3 m4 ]" q# e: C5 x7 d
38.     }
    ! i& Z" x) L4 O2 g
39. }
    
40. #endif

复制代码

3 z! k3 p; _0 C. @3) AT24C02读写函数
: i) z/ T; x) Y$ s* e
编写好I2C协议函数后，参考AT24C02手册编写读写数据函数，如代码段 16.3.7 所示。

代码段 16.3.7 读写AT24C02一字节数据（driver_eeprom.c）
& Y& `) W0 Y, p# H9 W

1. /*
   
2. *  函数名：uint8_t EEPROM_WriteByte(uint16_t addr, uint8_t data)
   * e5 M2 Q) w* K% f. u( a
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   
4. *            data -> 要写的数据
   
5. *  输出参数：无
   $ \  x  N* T: [- T) d- S
6. *  返回值：无
   
7. *  函数作用：EEPROM写一个字节
   ' w' @1 Q. D0 x' w( {& i
8. */
   # w# E; O- K* p9 y1 `0 T" J
9. void EEPROM_WriteByte(uint16_t addr, uint8_t data)
   : A2 N& j+ T5 G" \
10. {
    1 s* y8 L$ \/ f/ I  x
11.     /* 1. Start */
    1 G$ Z# u8 X; T. r+ {! X
12.     I2C_Start();
    
13. 
    % f1 o* C+ Q% t8 |5 y  E& z$ L
14.     /* 2. Write Device Address */
    
15.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    ' u: u& F4 ?# y6 ^6 v
16. 
    
17.     /* 3. Data Address */
    ! V8 z3 q. q! S- _- b
18.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    
19.     {
    + I$ a) k/ R$ K- R" T4 w5 D* }# P
20.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
21.     }
    ( b' j! \  I' H; C, z9 X, ?
22.     else
    3 d% I; J' @2 U" |2 [
23.     {
    
24.         I2C_SendByte( (uint8_t)(addr>>8) );
    
25.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
26.     }
    2 U3 n2 V# r- k/ j$ D
27. 
    
28.     /* 4. Write a byte */
    9 `9 R5 p- @+ I9 ^& U3 m4 q
29.     I2C_SendByte(data);
    , Q- _  ]3 [4 A8 }. B
30. 
    ; l- G# I) a- ?  K: Z
31.     /* 5. Stop */
    / t5 f: i8 G, ^; ?8 o
32.     I2C_Stop();
    3 f4 f. a/ r3 H4 \9 s/ Y; }
33. }
    / K& J7 k* g3 V5 f
34. 
    % y1 i5 R) P0 V2 d
35. /*
    
36. *  函数名：uint8_t EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    
37. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    1 S' e" V$ y5 {, l  H7 B
38. *            data -> 要读的数据指针
    
39. *  输出参数：无
    9 r" `% m: ^. E; `0 U; F
40. *  返回值：无
    ! A* C" ?! k0 I9 I8 p/ X# e8 y
41. *  函数作用：EEPROM读一个字节
    0 r, F* ?  S# F
42. */
    
43. void EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    % L/ c: s" m9 w* @8 O
44. {
    
45.     /* 1. Start */
    
46.     I2C_Start();
    ) u; E# v+ X7 h; K
47. 
    * q' L0 s6 k1 y+ E: z
48.     /* 2. Write Device Address */
    ' @1 u- i5 d0 ]2 [5 y
49.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    
50. 
    5 q: |8 A& A4 A; R, g; h- E( e
51.     /* 3. Data Address */
    
52.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    
53.     {
    6 n1 g$ U- j. j) {  x$ \! x
54.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
55.     }
    - W5 }* C1 W3 x3 c$ ?
56.     else
    + y- \0 r; Y0 W# e& s
57.     {
    
58.         I2C_SendByte( (uint8_t)(addr>>8) );
    1 r+ L+ u6 m2 c' m% H
59.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    : R: g) I6 m* W( j! P% j& x
60.     }
    
61. 
    7 k7 L7 E/ K  z" s1 {) e
62.     /* 4. Start Again */
    
63.     I2C_Start();
    
64. 
    
65.     /* 5. Write Device Address Read */
    6 k, {0 Y: R$ \+ S0 K
66.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_RD );
    6 L* f( ~8 K9 [( ?8 c3 V
67. 
    
68.     /* 6.Read a byte */
    : h* i' o7 T, L* y7 a/ o
69.     *pdata = I2C_ReadByte(NACK);
    4 M# ~" c$ k# h% e( {1 ?( @" [( L
70. 
    
71.     /* 7. Stop */
    : J4 }/ r$ e- ^0 H7 I
72.     I2C_Stop();
    % B/ |1 y* M" C5 c
73. }

复制代码

3 Y  I8 [! ]" T( W2 S. n  F
' k" [+ R7 y5 q参加前面图 16.2.1 和图 16.1.13 所示的介绍时序，编写AT24C02一字节读写程序。

9~33行：写AT24C02一字节数据；

* V4 G% i0 K# X  b! ]% m" F4 N12行：发送I2C开始信号；

0 K( Z4 m: C# c15行：发送AT24C02的设备地址，最后一位表示写操作；

18~26行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；
; E6 s, Q) O* h* E* ?
8 w: ^  Q8 }2 g+ C29行：发送数据；

32行：发送I2C停止信号；
* _! n" i5 R1 |  i' p3 _$ I7 m
6 q# q1 A9 u0 t+ S% B43~73行：读AT24C02一字节数据；
" R/ M5 R  {: g# H8 b; s0 G
! }0 ]% [% O( y$ i3 c7 b' a+ d/ R46行：发送I2C开始信号；
. @  [' \& `& N8 R
49行：发送AT24C02的设备地址，最后一位表示写操作（接下来要写数据地址）；
7 t2 v- o; j0 L7 Q* |
52~60行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；
0 G1 |$ Y3 X9 x! P  D. Q: n
6 f) ~& x3 r* P2 a6 i: d63行：再次发送I2C开始信号；
- y- O( @* O7 |% D3 Z: [
66行：发送AT24C02的设备地址，最后一位表示读操作；
% t% ~! a2 Y4 Z0 n0 {- s
/ E. W3 \! q9 [' r( P69行：读取AT24C02数据，且无需ACK；
( f! B, f) D3 v+ X) v+ o" [, L
$ w9 _, H5 V* i' |+ a# Q72行：发送I2C停止信号；

实现了对AT24C02单字节的读写，还需要实现多字节的读写。多字节读写可以通过AT24Cxx的页写模式和顺序读模式，实现多个数据的连续读写。在页写模式时，需要程序上设置，不能跨页写，这里简单处理，直接多次调用前面的单次读写即可，如代码段 16.3.8 所示。

代码段 16.3.8 读写AT24C02多字节数据（driver_eeprom.c）

1. /*
   
2. *  函数名：void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
   * H  |! U+ ]) A& g
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   
4. *            data -> 要写的数据指针
   # M, j& I$ L! I. T# m& Q: u  d1 {
5. *            sz   -> 要写的字节个数
   
6. *  输出参数：无
   # i# e. V( r, P+ d- c8 D
7. *  返回值：无
   7 e6 `  \8 ^* }. u
8. *  函数作用：EEPROM写N个字节
   5 G. K* i* O7 ]
9. */
   - Z/ \! R8 |/ i0 t: S
10. void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    # m, q5 S6 K& Z9 e! U5 v& b( r
11. {
    
12.     uint16_t i = 0;
    
13. 
    ; ?& a, T# j, e7 q
14.     for(i=0; i<sz; i++)
    , S+ ?" f+ p5 ?3 G0 j
15.     {
    4 {1 R* l$ |$ {8 F# A/ t# X1 z0 y- o
16.         EEPROM_WriteByte(addr, pdata<i>);
    6 Q, i9 w- Z6 F
17.         addr++;
    
18.         HAL_Delay(10); // Write Cycle Time 5ms
    ! }2 t) l# m$ I0 Q+ ~+ ]' {" a
19.     }
    
20. }
    
21. 
    0 E, n9 `' {# H; j/ O
22. /*
    
23. *  函数名：void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
24. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    8 K3 P+ K- A+ h& t- {- V& P% n* H
25. *            data -> 要读的数据指针
    
26. *            sz   -> 要读的字节个数
      s# [$ J/ n5 k+ B7 f2 g) c
27. *  输出参数：无
    
28. *  返回值：无
    0 ?- A+ y. T5 D; l8 q; Z
29. *  函数作用：EEPROM读N个字节
    : J  r2 N, D  J
30. */
    
31. void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    * I7 n5 ]) `, K9 D% c# i
32. {
    8 i0 O, J5 ^" d& w# a
33.     uint16_t i = 0;
    % N# F7 C& A) R* i: K8 z
34. 
    & v9 r1 [8 S8 {3 G9 l
35.     for(i=0; i<sz; i++)
    6 ?+ l! }, W. X" Y- m, T
36.     {
    4 R9 k. [& k1 S! b$ F
37.         EEPROM_ReadByte(addr, &pdata<i>);
    
38.         addr++;
    0 l! }, ^( u  y# [: ]
39.     }
    5 w" G2 c) @6 ^. p2 r) q
40. }</i></i>

复制代码

需要注意的是，AT24Cxx每次写操作后，有一个写间隔，需要间隔5ms以上，因此在写多个字节时，每次写完都需要延时5ms以上。


: o1 ~/ @" s% E# b) Y4) 主函数控制逻辑
! k7 y4 P0 f) c
在主函数里，每按一下按键，调用“EEPROM_Write_Nbytes()”对AT24C02写一串数据，再调用“EEPROM_Read_Nbytes()”读出该数据，如代码段 16.3.9 所示。
" z0 |4 _9 X3 R
  @8 `( C! w0 O代码段 16.3.9 主函数控制逻辑（main.c）

& Q' Q. t, a) f1 d3 u& l6 h3 @

1. // 初始化I2C
   
2.    I2C_Init();
   + V1 d/ V- f4 T6 `& W: [" e+ y3 o4 w
3. 
   
4.    while(1)
   
5.    {
   
6.        if(key_flag) // 按键按下
   
7.        {
   ) n5 S, \" q2 V
8.            key_flag = 0;
   8 T7 p6 T* u! `+ _3 y
9. 
   : t/ f- `$ [5 G: h7 n
10.            printf("\n\r");
    8 J0 N8 `$ _5 @' h" u" p$ S
11.            printf("Start write and read eeprom.\n\r");
    
12. 
    
13.            // 读写一串字符，并打印
    / ~& L. Y' A  Q& b- u1 a$ }
14.            EEPROM_Write_NBytes(0, tx_buffer, sizeof(tx_buffer)); // 写数据
    : v8 K6 M% o6 w; Z
15.            HAL_Delay(1);
    / n" a4 M/ P' M2 `6 s# B
16. 
    
17.            EEPROM_Read_NBytes(0, rx_buffer, sizeof(tx_buffer));  // 读数据
    $ ~% x+ C+ L) x  t/ \0 {
18.            HAL_Delay(1);
    
19. 
      o1 A' P, P+ E2 k
20.            printf("EEPROM Write: %s\n\r", tx_buffer);
    
21.            printf("EEPROM Read : %s\n\r", rx_buffer);
    
22. 
    1 p8 \. }; W$ a: z
23.            memset((uint8_t*)rx_buffer, 0, sizeof(rx_buffer));   // 清空接收的数据
    , s9 O, ~4 w- e4 x( [
24.        }
    ) d  ^# C* E5 b0 K: `, A$ C" V: N
25. }

复制代码

16.4 实验效果
1 a/ q0 f! b5 Z1 Y- |8 X本实验对应配套资料的“5_程序源码\8_通信—模拟I2C\”。打开工程后，编译，下载，按下按键KEY，即可看到串口如图 16.4.1 所示。
2 G" n$ |8 l( y9 }- R
& j; l7 x' O; ~* [( t# ~9 j

图 16.4.1 模拟I2C读写AT24C02数据
- y% Z5 J" o7 ?5 \0 E  I& G+ o
) e: E5 z6 B! G- K* F' Z0 Q3 n  v2 p4 e