16.1 关于I2C
16.1.1 I2C协议

/ H' z! ?( n( H0 dI²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工作效率相对较高。
( ?. U/ {$ l9 }' O
1 h) p: D/ H+ Q1 g关于I²C协议，通过下面例子进行一个形象的比喻方便大家理解，如图 16.1.1 所示，老师（MCU）将球（数据）传给众多学生中的一个（众多外设设备中的一个）。

+ c$ b6 G, A/ B- V/ y" n
3 v0 L! ]9 S" ?+ r

图 16.1.1 I²C协议比喻

% j. E. o4 q2 M& G+ D4 K! c
- I5 q# U9 U/ n3 U8 Q2 z& G1 J0 V
首先老师将球踢给某学生，即主机发送数据给从机，步骤如下：
8 C- @4 i2 i& j; k2 M  p: a
1 t. e, U& a6 ^4 Z) I8 r( c0 j! g1) 老师：开始了(start)；

; e1 u5 m2 E- S. V2) 老师：A！我要发球给你！(地址/方向)；
5 W6 t( V: h1 \& P6 T- u/ ?
3) 学生A：到！(回应)；

4) 老师把球发出去（传输）；

. Y! @8 s7 o+ q2 Y  J5) A收到球之后，应该告诉老师一声（回应）；
  C& A: t# S% b, ^6 v
6) 老师：结束（停止）；
" s6 I( n0 h2 Q0 P2 H; D( X4 ?( i

% {/ u, G, ~  P6 M  r
接着老师让学生把球传给自己，即从机发送数据给主机，步骤如下：

. R7 B* X- o( T! Q' j1 e1) 老师：开始了(start)；

$ W& n( t8 [9 [& Z% {2) 老师：B！把球发给我！(地址/方向)；

3) 学生B：到！
# d* u& H4 K& z  g  r* n( d3 V; C& r
7 n1 H* O5 j( u% `' g4) B把球发给老师（传输）；
% D2 |5 |. G9 L# _" Y( w
; V/ y4 C: O; _& D2 H, Z  w2 N5) 老师收到球之后，给B说一声，表示收到球了（回应）；
9 g4 A9 A" q3 u/ R
: }% f" A9 M1 l5 |( d- m6) 老师：结束（停止）。
7 S. G$ {# h) M& T) c8 o. q

# e9 j7 c; E# a# j* s+ f2 I
, R0 g$ G$ X/ ?8 @从上面的例子可知，都是老师（主机）主导传球，按照规范的流程（通信协议），以保证传球的准确性，收发球的流程总结如下：
1 E& j2 G+ d$ b  }' B0 c, ]/ g
" W' O7 n0 {' X① 老师说开始了，表示开始信号(start)；
) ~- _- l! t& a1 o" x: K& Z
② 老师提醒某个学生要发球，表示发送地址和方向(address/read/write)；

③ 该学生回应老师(ack)；
" ~9 n* Z) q. b, K5 c. M) X
* @7 w+ Z1 e2 m; c/ |: z3 ~; K④ 老师发球/接球，表示数据的传输；
3 G8 g: N* j2 u) c% ~, d9 b# G
2 |- w8 f8 W0 |* r- x3 d9 E7 L⑤ 收到球要回应：回应信号(ACK)；
9 c/ ?9 S! r* C, ]( y; ]8 E
. Q6 w4 [1 i3 ]/ ^( J9 A⑥ 老师说结束，表示IIC传输结束(P)。


3 W( A+ q! ]) V. H: @( n0 G
以上就是I²C的传输协议，如果是软件模拟I²C，需要依次实现每个步骤。因此，还需要知道每一步的具体细节，比如什么时候的数据有效，开始信号怎么表示。

5 `( D$ G; D) s; H+ Y
- M) }2 u& q9 w% d: d+ c
数据有效性

I²C由两条线组成，一条双向串行数据线SDA，一条串行时钟线SCL。SDA线上的数据必须在时钟的高电平周期保持稳定，数据线的高或低电平状态只有在 SCL 线的时钟信号是低电平时才能改变。换言之，SCL为高电平时表示有效数据，SDA为高电平表示“1”，低电平表示“0”；SCL为低电平时表示无效数据，此时SDA会进行电平切换，为下次数据表示做准备。数据有效性示意图如图 16.1.2 所示。
( T+ e( F' V' g8 \$ }# L. ]

  C, c" m4 ^- q
0 |% O; \( M5 l

图 16.1.2 数据有效性

' b# D% q8 W) _, z
- c+ V, m; I/ K- @5 R/ O开始信号和结束信号
1 y' [* d( {4 R2 Q/ T; }7 i
. `) y# H, s8 X6 x5 \) }I²C起始信号（S）：当SCL高电平时，SDA由高电平向低电平转换；
2 I6 i9 r, w) R) D7 c; Q$ n
I²C停止信号（P）：当SCL高电平时，SDA由低电平向高电平转换；
0 f& O6 r* x1 K% I
8 p8 n3 n; U" \" d

- r( W+ I5 n- g

图 16.1.3 开始信号和结束信号

+ t7 K4 M, T# r+ n9 V
( y( d4 W/ Q4 g6 j
应答信号                          

% R* ?; }% g! q& S# T. N, Y4 ]I²C每次传输的8位数据，每次传输后需要从机反馈一个应答位，以确认从机是否正常接收了数据。当主机发送了8位数据后，会再产生一个时钟，此时主机放开SDA的控制，读取SDA电平，在上拉电阻的影响下，此时SDA默认为高，必须从机拉低，以确认收到数据。

5 @1 H7 I* G/ p) t

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

0 D4 G, l3 {& N/ P7 }
+ x" W6 a3 u) P
0 P- L. X: ?+ T+ x5 _( Y2 J完整传输流程  
# g2 y9 z0 a9 f4 m; t, T' O! w5 {. Q
+ S% o8 k) H4 F; K0 I8 ^% }# H1 _I²C完整传输流程如下：
% F: l$ v# Z/ H; S6 U& {' U* Y0 L
① SDA和SCL开始都为高，然后主机将SDA拉低，表示开始信号；

& V. [" N: g8 V② 在接下来的8个时间周期里，主机控制SDA的高低，发送从机地址。其中第8位如果为0，表示接下来是写操作，即主机传输数据给从机；如果为1，表示接下来是读操作，即从机传输数据给主机；另外，数据传输是从最高位到最低位，因此传输方式为MSB（Most Significant Bit）。

③ 总线中对应从机地址的设备，发出应答信号；
: Q) B! e& I) f. `; L
2 P) |" y4 p2 B( t④ 在接下来的8个时间周期里，如果是写操作，则主机控制SDA的高低；如果是读操作，则从机控制SDA的高低；

  j0 Z# A  Z% e9 n⑤ 每次传输完成，接收数据的设备，都发出应答信号；
/ m$ t: i' T# _/ ^
⑥ 最后，在SCL为高时，主机由低拉高SDA，表示停止信号，整个传输结束；
) z0 ]( M# X8 A/ F* i& s* L
- V( ], d- ^0 N' X7 A: X+ n

3 l  W! k+ u$ V6 k7 f

图 16.1.5 I2C传输时序

. S: J" I& S6 ?# ?1 A' h* t/ Q7 `

) r  Q/ _7 e1 p. w; r! R" n0 G16.1.2 EEPROM介绍

) G% q- T. A' d+ L+ I! v5 tEEPROM的全称是“电可擦除可编程只读存储器”，即Electrically Erasable Programmable Read-Only Memory。通常用于存放用户配置信息数据，比如在开发板首次运行时，需要屏幕校准，校准后的配置信息就可以保存在EEPROM里，开发板断电后配置信息不丢失，下次启动，开发板自动读取EEPROM的校准配置信息，就不需要重新校准。
- J: G0 b" }0 J) X
EEPROM和Flash的本质上是一样的，Flash包括MCU内部的Flash和外部扩展的Flash，本开发板就有一个SPI接口的外部Flash（W25Q64），在后面SPI接口再讲解。从功能上，Flash通常存放运行代码，运行过程中不会修改，而EEPROM存放用户数据，可能会反复修改。从结构上，Flash按扇区操作，EEPROM通常按字节操作。两者区别这里不再过多赘述，读者理解EEPROM在嵌入式中扮演的角色即可。
6 B8 Y" H6 H* H2 `

2 e& c# a; a  y3 b- g+ r8 D! O
* o( c1 I! Z, [结构组成

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。
# w2 P/ d2 z( E. @; \' @

图 16.1.6 AT24C02结构示意图

设备地址  
  |, ]7 [* r6 O7 o% J& E4 F; o* w
; L2 i- E( Q3 j" h. }: DI²C设备都会有一个设备地址，不同容量的AT24C02，设备地址定义会有所差异，由芯片数据手册《AT24Cxx.pdf》可知，如图 16.1.7 所示。
; \, I1 j' `- p8 g4 P& P* u& S
/ j( R, L  z% @5 ]& j1 j1 [% F

9 M  z3 i, f( k; M2 B9 r. V5 i* l
7 I9 e  ~% f6 W  o' H+ Z

图 16.1.7 AT24Cxx设备地址定义

( F3 y: G, H! |, _9 H

; _" M7 {* C& W" g$ `" z% OAT24C02的容量为2K，对应上图中的第一行，高四位固定为“1010”，中间三位由A2、A1、A0引脚的电平决定，比如A2~0引脚全接地，则值为“000”，最后的最低位为读写位，0代表写命令，1代表读命令。
# ?6 _6 g& Y& R: t; U
+ O7 `6 E* ^+ \; jA2、A1、A0引脚电平需要由原理图决定，假设全接电源地，则如果需要向AT24C02写数据，则发送地址“1010 0000”，如果需要向AT24C02读数据，则发送地址“1010 0001”。

* j6 Y' m/ m! p6 _( t4 |7 D) K假设开发板有多个AT24C02挂在同一I²C总线上，通过这个规则，只需设计电路时，让A2、A1、A0引脚电平不同，即可区分两个AT24C02。
2 g/ ~0 f4 {, j7 N
对于容量再大一点的AT24Cxx系列，比如AT24C04，器件地址由A2、A1引脚决定，数据空间有P0决定。比如对AT24C04的0~2K空间操作，则P0为0，对2K~4K空间操作，则P0为1。


' P( H3 t  ]6 o  M& u) `
4 T  S: b- |/ B# P2 o2 K- ?& i# E写AT24Cxx  
% j0 u' O# B, u! Y4 X
AT24Cxx支持字节写模式和页写模式。字节写模式是一个地址一个数据的写；页写模式是连续写数据，一个地址多个数据的写，但是页写模式不能自动跨页，如果超出一页长度，超出的数据会覆盖原先写入的数据。
4 {, a' k3 E4 \) _# U
如图 16.1.8 所示，为AT24Cxx字节写模式的时序，在MCU发出开始信号（Start）后，发出8 Bit的设备地址信息（图中读写位为低电平，即写数据），待收到AT24Cxx应答信号后，再发出要写的数据地址，再次等待AT24Cxx应答，最后发出8 Bit数据写数据，待AT24Cxx应答后，发出停止信号（Stop），完成一次单字节写数据。

% y1 y8 h# d% S! }- L! a2 P/ t$ s/ E

6 O& A& V& [+ q5 I6 I  ^

图 16.1.8 AT24Cxx字节写模式时序

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

0 _! m4 [5 W8 ~8 z

图 16.1.9 单字节写模流程图

图 16.1.10 为AT24Cxx的页写模式时序，与字节写模式的差异在于，不是只发送1Byte数据，而是任意多个。需要注意，该模式不能跨页写，遇到跨页时，需要重新发送完整的时序。

图 16.1.10 AT24Cxx页写模式时序

值得一提的是，《AT24Cxx.pdf》里提到每次写完之后，再到下次写之前，需要间隔5ms时间，以确保上次写操作在芯片内部完成，如图 16.1.11 所示。
8 p7 K7 G9 |! K9 a4 A$ c4 W
3 n) R1 E+ U* v) W0 t: t

图 16.1.11 AT24Cxx写间隔

+ N# y3 c  u! p3 s0 |
! G% r  u: {5 J
读AT24Cxx
0 O; Z; A" G! ~2 S! ~
3 U9 Q; P2 k- p/ G; BAT24Cxx支持当前地址读模式、随机地址读模式和顺序读模式。当前地址读模式就是在上一次读/写操作之后的最后位置，继续读出数据，比如上次读/写在地址n，接下来可以直接从n+1处读出数据；随机地址读模式是指定数据地址，然后读出数据；顺序读模式是连续读出多个数据。
6 R2 M5 x7 \0 T* D( W9 x
5 k/ D  c, z% t& ^在当前地址读模式下，无需发送数据地址，数据地址为上一次读/写操作之后的位置，时序如图 16.1.12 所示，注意在结尾，主机接收数据后，无需产生应答信号。
9 a6 {/ S$ y; G0 Z

7 q. o3 G. r- J, M

图 16.1.12 AT24Cxx当前地址读模式

+ G6 j* y9 N0 q$ q6 }% }在随机地址读模式下，需要先发送设备地址，待读的数据地址，接着再重新发出开始信号，设备地址，读出数据，时序如图 16.1.13 所示。
) s* F; h8 Y$ \

) r2 q- M. s( E1 w
. e& j0 Q2 R/ a: g9 n

图 16.1.13 AT24Cxx随机地址读模式

5 [9 c% R8 S9 ?& l" x
: F" v! v" N) W$ r1 Z  T
在顺序读模式下，需要先从当前地址读模式或随机地址读模式启动，随后便可连续读多个数据，时序如图 16.1.14 所示

' o9 @4 S' J4 w2 Y- J$ h+ }

8 o; |9 p+ f7 n+ a5 K4 r
& m9 x. H2 ?& M  K! K

图 16.1.14 AT24Cxx顺序读模式

+ W- X: o$ G( ^$ G  @7 q( q& B0 ?
. `. I" g5 S+ I/ I6 N
0 m& }# s* X& r
16.2 硬件设计
如图 16.2.1 为开发板EEPROM部分的原理图，U6为AT24C02芯片，它的A0、A1、A2都接地，因此该设备地址为“1010 000X”，当读该设备时，X为1，写该设备时，X为0。

U4的7脚为写保护引脚（Write Protect，WP），当该引脚为高，则禁止写AT24C02，这里直接拉低WP，任何时候都可直接写AT24C02。

6 |1 X  a0 Z! S- X0 [' X, T1 F此外，I2C的两个脚SCL和SDA都进行了上拉处理，从而保证I2C总线空闲时，两根线都必须为高电平。如果没有上拉，在主机发送完数据后，放开SDA，此时SDA的电平状态不确定，可能为高，也可能为低，无法确定是从机拉低给出应答信号。
0 T- E* ]' V3 Y+ G9 s6 q& h
+ [$ @$ f6 g) W* |. c结合原理图可知，PB6作为了I2C1的SCL，PB7作为了I2C1的SDA。
6 c+ h% R) k2 j. v& l+ x- Q
% |' e7 k% {- |9 I

, y* {- G: w" q% }8 ]; |
5 ?( f% l+ f6 S

图 16.2.1 EEPROM模块原理图

  M) r. I3 `9 }' X
0 R" C9 Y/ t: Z2 T+ I8 Y16.3 软件设计
/ j3 s" R; ~! w) B( N% p$ g" h* Q16.3.1 软件设计思路
: l0 z2 \, s5 I1 F0 w8 x$ n: v1 ^
实验目的：本实验通过GPIO模拟I2C总线时序，对EEPROM设备AT24C02进行读写操作。
$ o7 H8 d8 j$ Q
; X; e' M* f7 `+ Z" _" B7 l1) 引脚初始化：GPIO端口时钟使能、GPIO引脚设置为输入/输出模式（PB6、PB7）；
. y' l* }6 P% u: s  `7 |
% `" v( J% Z# ~2) 封装I2C每个环节的时序函数：起始信号、响应信号、读写数据、停止信号；
* Z5 E3 D$ ?1 f; Y& D
* S, b  b% p/ J; X3) 使用I2C协议函数，实现对AT24C02的读写；

4) 主函数，每按一次按键，写一次AT24C02，接着读出来验证是否和写的数据一致；
1 R$ Y# W! \; m( {# r8 ^
9 @& y" }' B/ B4 J. f本实验配套代码位于“5_程序源码\8_通信—模拟I2C\”。


7 Y& @( H+ E& T6 }; i2 O+ X
16.3.2 软件设计讲解
. y) w9 m$ O% |; Q. K5 ?1 a
/ q* N5 j; c; d6 l1 j: ?1) GPIO选择与接口定义
$ C3 R' o  @4 e% @; e
! m4 _8 s) P" Z$ n% Q* P' a' r首先定义SCL和SDA引脚，引脚的高低电平宏定义，如代码段 16.3.1 所示。

7 q  l$ O3 E* G8 B. a代码段 16.3.1 模拟I2C引脚相关定义（driver_i2c.h）
3 h# v& W& p7 W" ]7 s
" k( H+ s- f* L# V( V. n

1. /************************* I2C 硬件相关定义 *************************/
   
2. 
   + [! k" ~0 A0 X2 j5 T# Y5 j' A3 s. I9 `
3. #define ACK                 (0)
   
4. 
   , Y4 s" U/ b% z- g& `1 {
5. #define NACK                (1)
   
6. 
   
7. 
   * K1 |) S4 L8 t6 U! ^: W
8. 
   2 B  {7 |& J- V( F" [( R# X2 u
9. #define SCL_PIN             GPIO_PIN_6
   - [8 z" L- H; Z7 i& \
10. 
    * L! ]8 M0 D* Q* Y
11. #define SCL_PORT            GPIOB
    9 g$ R) k' z$ _3 S7 {+ I  [
12. 
    
13. #define SCL_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
      m# `: i+ k3 z" U
14. 
    
15. 
    
16. 
    
17. #define SDA_PIN             GPIO_PIN_7
    
18. 
    
19. #define SDA_PORT            GPIOB
    1 U. A1 {8 L/ e4 B, l
20. 
    . ?6 b5 O6 d. b! N, }0 k
21. #define SDA_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    
22. 
    2 h9 R9 D+ m# V( ?4 l. w  a2 M4 g
23. 
    
24. 
      }! _2 t$ p) j
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)
    6 [9 J8 N; U1 j; q& e
28. 
    ( B9 x- k4 K( n; g: ]9 ]
29. #define SCL_INPUT()         HAL_GPIO_ReadPin(SCL_PORT, SCL_PIN)
    3 p9 M- t' \& L$ L8 h- L! @& [* b/ E
30. 
    
31. 
    
32. 
    
33. #define SDA_H()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_SET)
    ' T$ ?: M1 |2 T$ Q) G8 Q; a( l
34. 
    ) p- y: p. v  ~- P" ~
35. #define SDA_L()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_RESET)
    
36. 
    & h; T  B5 H2 J' A3 m" G1 C
37. #define SDA_INPUT()         HAL_GPIO_ReadPin(SDA_PORT, SDA_PIN)

复制代码

" X4 y* N  F& _6 H接着将两个GPIO引脚初始化，使能引脚时钟，先默认设置为输出模式。SCL引脚为时钟信号，始终为输出模式，SDA引脚为数据引脚，可能输出或者输入，因此还需要编写函数实现输入、输出的切换，如代码段 16.3.2 所示。
: ~- I& m0 @* s+ f
代码段 16.3.2 I2C引脚初始化（driver_i2c.c）
+ e5 F# @0 y5 p4 j6 k! A5 v2 C
$ X) W1 P- X( c. o! z

1. /*
   
2. *  函数名：void I2C_Init(void)
   
3. *  输入参数：
   
4. *  输出参数：无
   
5. *  返回值：无
   
6. *  函数作用：初始化模拟I2C的引脚为输出状态且SCL/SDA都初始为高电平
   " b* ^+ r" J6 q! E& ^9 K. N! v% J4 Q
7. */
   4 d) O" E4 C, o8 G$ k
8. void I2C_Init(void)
   
9. {
   % a  \, b6 T3 n1 g% J
10.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    7 ~4 m% Q* x* D" r) L
11. 
    
12.     SCL_PIN_CLK_EN();
    , N! w6 t$ X7 q7 d3 {
13.     SDA_PIN_CLK_EN();
    9 L: E' B; D& w3 r1 V
14. 
    " K& P8 B+ u" Z* R) @
15.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    & Z+ h* b8 o; N
16.     GPIO_InitStruct.Pull      = GPIO_NOPULL;
    8 ~, N. G, ]( l3 I! D
17.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
18. 
    
19.     GPIO_InitStruct.Pin       = SCL_PIN;
    ( U$ l& S- B" C
20.     HAL_GPIO_Init(SCL_PORT, &GPIO_InitStruct);
    ( u8 B: M& f1 G8 `8 a
21. 
    $ S% o& h) g# \0 Q; `
22.     GPIO_InitStruct.Pin       = SDA_PIN;
    0 V3 J4 U/ n  f4 T# @7 C
23.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    , P/ H! p7 R5 {  c5 y* R1 k
24. 
    
25.     SCL_H();
    
26.     SDA_H();
    ( [# M" x# R' R8 _8 h9 ]
27. }
    
28. 
    
29. /*
    
30. *  函数名：static void I2C_SDA_OUT(void)
    8 R) S! P! g. r1 i. v& U
31. *  输入参数：
    0 c. g. c( T# B1 n0 k. D0 J
32. *  输出参数：无
    
33. *  返回值：无
    
34. *  函数作用：配置SDA引脚为输出
    " E; O. y' f; r, R
35. */
    . l/ p: P4 c4 G' b8 R
36. static void I2C_SDA_OUT(void)
    
37. {
    
38.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    2 k' I6 ?: ]$ e" p& I
39. 
    % q0 ~" v9 f" J2 S
40.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    4 q4 j3 s3 j, A. Q2 g
41.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
42.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    - A+ U7 R; g3 p5 t* ~1 G
43. 
    ( s+ Q( F! @7 R* M, F0 s2 l. Q
44.     GPIO_InitStruct.Pin       = SDA_PIN;
      }" h, g& K0 W; m$ m
45.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    ) u) ]! y( f6 }* b( E
46. }
    ( l: {9 d! m+ {$ T8 b# c* Y
47. 
    3 u3 j( i  N! B. ?/ T3 D, N) K7 T
48. /*
    & n2 e5 L# ]) e3 n0 Q! P7 c& C
49. *  函数名：static void I2C_SDA_IN(void)
    
50. *  输入参数：
    # h8 R; b, Q; ^( Y0 f" {# h+ o! d& i
51. *  输出参数：无
    
52. *  返回值：无
    9 \9 z8 N8 S6 F
53. *  函数作用：配置SDA引脚为输入
    
54. */
    0 Z# G. r' T% _/ Y+ a$ z
55. static void I2C_SDA_IN(void)
    
56. {
    " s3 s" l, g, R: @, z0 X# L4 J
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
58. 
    . U/ \( W7 I. L9 v8 z7 h7 w8 U
59.     GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
    " R; k- F1 C- ?
60.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    - Y9 Z3 v( R( R! g6 H( b+ h4 P
61. 
    2 |) I1 `( m" j$ \% {, q4 P
62.     GPIO_InitStruct.Pin       = SDA_PIN;
    # v9 X6 j) x9 }( O, A: e
63.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    
64. }

复制代码

2) I2C时序函数

开始信号/结束信号
6 ^+ k5 l% L9 z
参考前面图 16.1.3 所示的开始信号和结束信号编写程序。对于开始信号，首先将SDA和SCL都拉高，随后SDA拉低，再SCL拉低。对于结束信号，首先拉低SDA，拉高SCL，再拉低SDA，代码如代码段 16.3.3 所示。
# A" K2 t+ k' n6 l
/ P6 @, G0 y7 I1 }: {' o. F代码段 16.3.3 I2C开始信号和结束信号（driver_i2c.c）

( l) M6 @, W8 I9 J+ h; a4 \3 ~& I

1. /*
   & h3 p+ h# E' |7 Z# y$ V. A
2. *  函数名：void I2C_Start(void)
   ) x) E3 J4 f6 D' c4 _3 [$ w$ t2 [
3. *  输入参数：
   
4. *  输出参数：无
   
5. *  返回值：无
   
6. *  函数作用：I2C开始信号
   . y3 n+ L3 E) D( @1 O0 G: V
7. */
   8 B+ P0 \1 b+ P3 ?% H) ~
8. void I2C_Start(void)
   & s2 r# k1 m! [% @6 ?
9. {
   
10.     I2C_SDA_OUT();
    0 f9 ]  H" i: b$ V, d
11. 
      }+ Q3 t  i* |2 F" S) s
12.     SCL_H();
    4 R% R, ?1 U1 p6 ^4 t& X/ ?
13.     I2C_Delay();
    
14. 
    
15.     SDA_H();
    ; Q7 k" P# U& o  g5 Y$ l; I. V- g
16.     I2C_Delay();
    
17. 
    
18.     SDA_L();
    5 [# \& d5 \* k( x( ?% l; G
19.     I2C_Delay();
    
20. 
    
21.     SCL_L();
    4 K4 W- o) @. n
22.     I2C_Delay();
    6 {* G% C. y3 X; }; G0 X# C+ y
23. }
    " R2 A' w9 v' d, e9 v/ c5 R, L* l
24. 
    
25. /*
    3 M  o2 ^$ C9 |8 j4 o% D' F0 m' i
26. *  函数名：void I2C_Stop(void)
    
27. *  输入参数：
    1 t  z0 Z4 o$ e! v0 I8 l3 b2 e
28. *  输出参数：无
    
29. *  返回值：无
    % P/ s1 i( O9 h9 q7 m) u2 u
30. *  函数作用：I2C停止信号
    
31. */
    
32. void I2C_Stop(void)
    ; D: ]2 g& H1 G  \6 O
33. {
    
34.     I2C_SDA_OUT();
    
35. 
    
36.     SDA_L();
    
37.     I2C_Delay();
    $ \0 \: M6 Y5 |
38. 
    ' `2 y8 Y1 O9 |, F* h1 K
39.     SCL_H();
    
40.     I2C_Delay();
    ) Y) x2 k5 W5 `6 h) m" B+ [
41. 
    
42.     SDA_H();
    
43.     I2C_Delay();
    + h4 e& n6 V% Z5 d
44. }

复制代码

# @! z+ q" x$ ^  T. F/ p应答信号/非应答信号/等待应答信号
% v" g. Y( A" F1 C( ]+ u
" w1 `, W' I* {- k+ x参考前面图 16.1.4 所示，编译应答信号，如代码段 16.3.4 所示。

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

, x  ^" d/ o7 E# ]# E: r

1. /*
   # T4 r2 |1 R4 j
2. *  函数名：void I2C_ACK(void)
   
3. *  输入参数：
   
4. *  输出参数：无
   3 b* y, g4 w7 E
5. *  返回值：无
   
6. *  函数作用：I2C发出应答信号
   7 K( _6 i& E" L: f# N* h- \$ l
7. */
   
8. void I2C_ACK(void)
   / {  d& ]8 N; C9 b
9. {
   ! W% r4 q0 s/ l
10.     I2C_SDA_OUT();
    5 b- M% T* _1 {5 L7 c, t. T
11. 
    
12.     SCL_L();
    ! q5 ^" }+ u' {- |8 F
13.     I2C_Delay();
    ' |8 Y/ l& Y; z. z3 x0 |9 L, @  T3 ~
14. 
    / {, g  S3 \; v* [, M; Q
15.     SDA_L();
    3 c1 E. W  @$ v  |' r
16.     I2C_Delay();
    / q4 C6 b  L! {1 s
17. 
    
18.     SCL_H();
    
19.     I2C_Delay();
    1 F% U' u) [: {! Z5 D
20. 
    
21.     SCL_L();
    
22.     I2C_Delay();
    8 s5 d/ v) c8 |4 e2 q0 K/ Q
23. }
    
24. 
    
25. /*
    
26. *  函数名：void I2C_NACK(void)
    1 M# \9 N5 o, c4 m$ W$ w
27. *  输入参数：
    
28. *  输出参数：无
    
29. *  返回值：无
    
30. *  函数作用：I2C发出非应答信号
    : [& V& i% h& K$ o1 ?- ^
31. */
    # @/ q, i$ V. }
32. void I2C_NACK(void)
    9 ~% o  T3 p) @+ X9 V
33. {
    6 k2 H6 n' M# G
34.     I2C_SDA_OUT();
    
35. 
    
36.     SCL_L();
    - y3 u/ z$ m& N& E1 v* ?2 Z% N
37.     I2C_Delay();
    * `: d+ T( w  r: \  {
38. 
    , i" J5 D% A% r) K8 f1 C
39.     SDA_H();
    - W4 V- z, Q) {+ |+ }
40.     I2C_Delay();
    2 Q. W3 n: ]5 \6 i! q/ N, A/ _* T
41. 
    
42.     SCL_H();
    6 E- p8 r+ f+ s" J4 A0 S% T
43.     I2C_Delay();
    ) B! I1 q- ]6 T3 d( Y+ d
44. 
    
45.     SCL_L();
    8 M; H8 p2 C' C7 p2 i; h
46.     I2C_Delay();
    
47. }
    
48. 
    
49. /*
    $ O2 E& V  e+ E+ s8 ]3 X" V8 z
50. *  函数名：uint8_t I2C_GetACK(void)
    
51. *  输入参数：
      Y7 h& d3 q& m7 b0 h8 x3 f1 {& J
52. *  输出参数：无
    : P2 c. p4 P, D0 L: A
53. *  返回值：1无应答，0有应答
    
54. *  函数作用：I2C等待从机的应答信号
    
55. */
    
56. uint8_t I2C_GetACK(void)
    
57. {
    
58.     uint8_t time = 0;
    2 a- j& ~: p0 O3 h! f" f
59.     I2C_SDA_IN();
    & c6 n( i4 k. C1 Z
60. 
    ! O- h  K* I! M' z) k/ g
61.     SCL_L();
    
62.     I2C_Delay();
    * [& W' t+ _& h; n
63. 
    
64.     SDA_H();
    
65.     I2C_Delay();
    + H2 z9 ~! a$ n. ]
66. 
    ! w3 m3 T& S% C! B$ ?  s
67.     SCL_H();
    
68.     I2C_Delay();
    # V0 L, T9 I+ w$ F3 z5 r  A; d$ N) u
69. 
    
70.     while(SDA_INPUT())
    
71.     {
    ; i4 @+ Y6 E! }& E9 y0 d/ M* x8 E8 o
72.         time++;
    + U6 }8 l* D" {! Y+ z& t4 h8 [- W9 F8 P
73.         if(time>250)
    
74.         {
    
75.             SCL_L();
    + I( l! z; y" y/ V7 Q6 P6 r# q
76.             return 1;
    ; n9 b8 d8 ^. o! W
77.         }
    / R5 L- d' T4 y: b
78.     }
    - `. n' I. b' U1 x2 t( ~+ Z
79.     SCL_L();
    # V. v+ {, [3 `  d0 }& N: j
80. 
    ! o. C! R. G, _: _$ b  V, ^0 J
81.     return 0;
    * T, v, j3 I; U
82. }

复制代码

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

0 U0 e5 ]7 v  x" u8 }( O) R: E32~47行：非应答信号，在一个SDA时钟周期里，将SCL拉高；
  ~. a$ D1 S  ?3 e
3 ?# W) x' U; \; \, e' W0 q56~82行：等待应答信号，拉高SDA后放开SDA，读取SDA是否被拉低，如果拉低返回0，否则返回1；

/ v% p1 @0 Y9 g# M4 t$ R! }1 S% H8 @

! ~# e/ n6 o* n* Y发送/接收函数
! @8 V# ~; K, a% P
最后还剩发送/接收函数，如代码段 16.3.5 所示。对于发送函数，控制SDA产生8个时钟周期，每个时钟周期里控制SDA高低电平发送1位数据。对于接收函数，控制SDA产生8个时钟周期，每个时钟周期里读取SDA高低电平接收1位数据。

1 I- z4 S0 m9 w, U代码段 16.3.5 发送/接收函数（driver_i2c.c）
0 ]0 K* Z6 `. B4 y) [
7 e8 l- c% H8 I+ g
! a7 [: k8 y+ t6 [" ^3 Z
$ p0 d# |; a5 m

1. /*
   : W. Z7 b2 z  t) J+ d  z
2. *  函数名：void I2C_SendByte(uint8_t data)
   
3. *  输入参数：data->发送的数据
   ; f" y& X" }& a$ k8 B6 q3 [7 D6 e
4. *  输出参数：无
   
5. *  返回值：无
   
6. *  函数作用：I2C发送一个字节
   8 J) c% s; H# a0 t
7. */
   
8. void I2C_SendByte(uint8_t data)
   
9. {
   $ x8 X* x" v: @/ S
10.     uint8_t cnt = 0;
    
11. 
    
12.     I2C_SDA_OUT();
    
13. 
    ' C" `5 f, d' S. K/ ^
14.     for(cnt=0; cnt<8; cnt++)
    ( X2 G" |5 T/ S5 u  r6 R
15.     {
    - b+ p7 M* x; q3 h/ G
16.         SCL_L();
    
17.         I2C_Delay();
    
18. 
    0 B. L% h' B0 @1 ?  Y- b$ @( p
19.         if(data & 0x80)
    ( T5 ?- `" Q' h6 s# B! ~7 ^
20.         {
    
21.             SDA_H();
    + M' F) t( I$ }6 L2 |
22.         }
    8 J' V8 q: v, ?, i  A
23.         else
    
24.         {
    
25.             SDA_L();
    " g6 u, s0 T& \3 R$ |9 @6 o
26.         }
    ! a1 r4 {+ z# Y9 \' V# t) c
27.         data = data<<1;
    1 J+ {0 A. e0 ]3 _* i' w4 E
28.         SCL_H();
    
29.         I2C_Delay();
    
30.     }
    
31. 
    7 ?; N/ E2 |# v; W6 I
32.     SCL_L();
    
33.     I2C_Delay();
    
34.     I2C_GetACK();
    
35. }
    , j& [! x9 L& h1 m1 A
36. 
    / n' X) F$ g0 h1 G  d6 y: o
37. /*
    3 F. M! u+ z& @
38. *  函数名：uint8_t I2C_ReadByte(uint8_t ack)
    
39. *  输入参数：ack->发送的应答标志，1应答，0非应答
    - _2 W/ Y; w7 ^
40. *  输出参数：无
    
41. *  返回值：返回读到的字节
    
42. *  函数作用：I2C读出一个字节
    
43. */
    
44. uint8_t I2C_ReadByte(uint8_t ack)
    # u$ g  U. X8 I5 Y  H
45. {
    
46.     uint8_t cnt;
    
47.     uint8_t data = 0xFF;
    
48. 
    
49.     SCL_L();
    2 C7 h6 u9 ~, E& o: x6 b
50.     I2C_Delay();
      C. N2 ]+ a2 C) r
51. 
    " O  O' P! c% H; A) L
52.     for(cnt=0; cnt<8; cnt++)
    
53.     {
      D# ]% G/ P$ D8 }$ n. i0 y2 x
54.         SCL_H();                 //SCL高(读取数据)
    
55.         I2C_Delay();
    
56. 
    
57.         data <<= 1;
    & ]9 b6 V% F: |
58.         if(SDA_INPUT())
    
59.         {
    % z; \7 {, T% F. ]
60.             data |= 0x01;        //SDA高(数据为1)
    ' X- b& `8 ]6 k. t2 E" V7 X' }
61.         }
    
62.         SCL_L();
    : M% K: ~$ H7 }( d
63.         I2C_Delay();
    , z$ m$ x3 e, d, G
64.     }
    
65.     //发送应答信号，为低代表应答，高代表非应答
    
66.     if(ack == 0)
    - Z8 z# k$ C- h3 D4 M
67.     {
    
68.         I2C_ACK();
    
69.     }
    " ~- f( J7 w# G1 T" Q
70.     else
    
71.     {
    
72.         I2C_NACK();
    
73.     }
    
74.     return data;                 //返回数据
    
75. }

复制代码

' s* T8 y/ s9 M- |14~31行：循环8次，每次循环：

( ?7 H1 S& \# o, R: @$ ]16行：先拉低SCL；
/ T4 X5 [3 Q$ ]* ?/ ^. X. B
7 r% b0 h. A; I; l" S( R* G19~26行：将输入的数据data与0x08且运算，得到最高位的值，从而控制SDA输出对应的高、低电平;

0 [. X5 b9 E# j9 E- E3 \- e# F2 b27行：将data左移一位，得到次高位；

. ]- {# K" X8 u# p& {+ ^$ p* r" s29行：拉高SCL，让SDA处于稳定期，从设备即可获取SDA的值；

8 b" g" I+ l. D" v) i2 D! K35行：等待从设备的应答信号；

53~65行：循环8次，每次循环：
8 l! Y0 S2 E5 W# C4 i/ \# d
55行：先拉高SCL，此时认为从设备控制SDA电平，处于稳定期；
( P8 v" O& u. L, h( d8 w
58行：将data左移1位，以确保收到数据按最高位在前存放；
# g5 ?7 ~2 s" h! Z
2 Y9 w+ T( ~8 e; M$ r3 W0 n59~62行：读取SDA电平，如果为高，保存到data当前最低位，否则data最低位默认为0；
5 E. s- ^4 y" H) s3 i
63行：SCL拉低，此时从设备继续控制SDA电平变化
. f; s8 M4 t+ j2 `3 n. s, A8 V' K  l
66~74行：根据传入的参数，决定是否发送应答信号；
% {( X% z! ]9 z  z5 n

8 B7 ]) ~# y# M- o( l( A
2 L0 J' r, e' f" k' e' v整个I2C协议函数中，经常用到“ I2C_Delay()”来实现SCL时钟周期。对于AT24Cxx，由其芯片手册可知，时钟脉冲宽度（Clock Pulse Width）需要大于5us，也就是SCL如果刚变为高电平，需要等待至少5us才能变为低电平，因此定义“ I2C_Delay()”为5us以上即可。
0 Q1 N. U7 p. D+ v3 T: l  V0 Y

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

复制代码

这里的“us_timer_delay()”可以由定时器提供，也可以使用循环提供，前者精度更高，效果更好。定时器的介绍在后面章节，本章不作分析，延时函数的两者方式如代码段 16.3.6 所示。
* f4 d, H$ T  I0 [
代码段 16.3.6 延时函数的实现（driver_timer.c）

1 G- g* \* K: ~3 K9 V, \: Q8 \

1. #if 0
   ! G% m4 L/ h3 X5 B: m: a0 q/ E/ e8 {
2. /*
   
3. *  函数名：void us_timer_delay(uint16_t t)
   
4. *  输入参数：t-延时时间us
   ; ]: t; |( C  ^( o
5. *  输出参数：无
   
6. *  返回值：无
   5 d* ]/ g; t; ^0 t" ?- S
7. *  函数作用：定时器实现的延时函数，延时时间为t us，为了缩短时间，函数体使用寄存器操作，用户可对照手册查看每个寄存器每一位的意义
   
8. */
   
9. void us_timer_delay(uint16_t t)
   & C$ u# ]0 @, w2 `
10. {
    , U, l8 \' Z* d! R) I
11.     uint16_t counter = 0;
    
12.     __HAL_TIM_SET_AUTORELOAD(&htim, t);
    
13.     __HAL_TIM_SET_COUNTER(&htim, counter);
    6 ~: H/ l# B" S7 j0 o. w1 f8 I
14.     HAL_TIM_Base_Start(&htim);
    
15.     while(counter != t)
    
16.     {
    
17.         counter = __HAL_TIM_GET_COUNTER(&htim);
    $ I, n1 b  k' G7 c9 K2 l
18.     }
    0 }# e# k& l6 k8 y+ k
19.     HAL_TIM_Base_Stop(&htim);
    
20. }
    : L4 x* q1 Z! a, K
21. #else
    
22. /*
    
23. *  函数名：void us_timer_delay(uint16_t t)
    7 y" c8 o9 X/ B9 q! D) g
24. *  输入参数：t-延时时间us
    
25. *  输出参数：无
    
26. *  返回值：无
    
27. *  函数作用：延时粗略实现的延时函数，延时时间为t us
    4 t* _7 n1 }0 f$ ~$ t% y
28. */
    " b0 g$ W0 W" n, g9 P9 }( l
29. void us_timer_delay(uint16_t t)
    
30. {
    
31.     uint16_t counter = 0;
    
32. 
    * w/ T9 i/ f' V& X' I$ J3 p
33.     while(t--)
    , m9 G/ D8 {- d. }6 D, O6 L
34.     {
    
35.         counter=10;
    
36. 
    6 c# _: O+ h1 L+ S+ ^+ V* v
37.         while(counter--) ;
    
38.     }
    
39. }
    4 Z/ N3 V. x; m8 H3 w( u
40. #endif

复制代码

/ h/ ~0 Y& y( y, {1 v8 E; Z3) AT24C02读写函数

编写好I2C协议函数后，参考AT24C02手册编写读写数据函数，如代码段 16.3.7 所示。
+ j& ?: G$ c' T3 Z# F) `
代码段 16.3.7 读写AT24C02一字节数据（driver_eeprom.c）

1. /*
   
2. *  函数名：uint8_t EEPROM_WriteByte(uint16_t addr, uint8_t data)
   
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   
4. *            data -> 要写的数据
   
5. *  输出参数：无
   
6. *  返回值：无
   
7. *  函数作用：EEPROM写一个字节
   7 N6 q. |. m+ ?5 @
8. */
   . W. \# g/ U6 T+ l
9. void EEPROM_WriteByte(uint16_t addr, uint8_t data)
   
10. {
    ; r; Y& E! i; H( r' O9 @. z7 `6 c
11.     /* 1. Start */
    
12.     I2C_Start();
    2 u3 I8 I, |/ O: L; w+ o
13. 
    3 u* n! a$ @6 C& C9 o' F# e: P9 v
14.     /* 2. Write Device Address */
    
15.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    
16. 
    + N: Z' ?  T3 D( p# t
17.     /* 3. Data Address */
    8 @, x) n7 c) [1 \; M
18.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    
19.     {
    
20.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    ) L3 E% v7 f; |  \
21.     }
    1 m' b. [0 T6 {% o( `
22.     else
    
23.     {
    
24.         I2C_SendByte( (uint8_t)(addr>>8) );
    
25.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    * G: D! f( k& [5 U
26.     }
    5 Y* i' I1 g- j+ u
27. 
    3 N3 h+ g0 r  `9 ^$ `
28.     /* 4. Write a byte */
    
29.     I2C_SendByte(data);
    & I5 ^3 N$ ^- h* ~: ~; y4 x; O. j) ^
30. 
    
31.     /* 5. Stop */
    5 K$ P' ?/ ^# X5 a3 \
32.     I2C_Stop();
    
33. }
    
34. 
    
35. /*
    
36. *  函数名：uint8_t EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    5 g/ Y3 A( G- S9 V1 P) f5 n! F
37. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    
38. *            data -> 要读的数据指针
    
39. *  输出参数：无
    
40. *  返回值：无
    
41. *  函数作用：EEPROM读一个字节
    2 j1 P) b& ^7 |) l
42. */
    
43. void EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    ' X* i5 J* P- q4 c1 ~' Q# M+ m- s
44. {
    
45.     /* 1. Start */
    / c/ c- u, ]! {8 |5 l9 j+ M6 W+ A! Q! B
46.     I2C_Start();
    
47. 
    0 W  F  b6 l! z, x. N8 y9 o( a
48.     /* 2. Write Device Address */
    
49.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    6 J* Y# F: l. m
50. 
    ( q7 S: ?$ @. g2 W2 G
51.     /* 3. Data Address */
    
52.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    
53.     {
    
54.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
55.     }
    
56.     else
    
57.     {
    
58.         I2C_SendByte( (uint8_t)(addr>>8) );
    
59.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    " O: q, ~3 s; m; ^
60.     }
    1 s) V7 Y2 ~2 o1 h; k  _6 x' y+ C
61. 
    
62.     /* 4. Start Again */
    ) |6 ?% X5 I$ k
63.     I2C_Start();
    ( F* E" t  |) N9 E1 R
64. 
    ) W0 S" I5 |* E9 f
65.     /* 5. Write Device Address Read */
    ! a$ s4 y$ [: ?% n+ n
66.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_RD );
    - i7 L& T( _) }( p* f5 ~/ R# L5 n
67. 
    
68.     /* 6.Read a byte */
    
69.     *pdata = I2C_ReadByte(NACK);
    
70. 
    / W6 Q5 e$ d, Y0 _. X' v
71.     /* 7. Stop */
    4 _- R$ A% c0 @' r7 Z
72.     I2C_Stop();
    
73. }

复制代码

- a3 S  t( s( \" F# r: z: p, g参加前面图 16.2.1 和图 16.1.13 所示的介绍时序，编写AT24C02一字节读写程序。
+ v! h0 K  f9 l; g' P* y
9~33行：写AT24C02一字节数据；
- R! a& l. V) _
$ e" V' Y/ T1 m: o! _( p! H12行：发送I2C开始信号；

15行：发送AT24C02的设备地址，最后一位表示写操作；

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

: v6 R" E: P+ I0 O9 ]2 X* t  F29行：发送数据；
$ b0 U6 C* g- e: V
* d& u# r* S1 R% W4 ^4 J32行：发送I2C停止信号；
; Z, E+ _" s( z4 K
43~73行：读AT24C02一字节数据；

2 P3 r( U' U+ G. T/ q' F46行：发送I2C开始信号；
/ C- [1 }( \  |( W
49行：发送AT24C02的设备地址，最后一位表示写操作（接下来要写数据地址）；
+ Q) K) A1 T  l9 Q, b! n
52~60行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；

63行：再次发送I2C开始信号；

66行：发送AT24C02的设备地址，最后一位表示读操作；
- ~* f$ Q. `9 n" t4 n" ^
/ v' L& \9 g5 {+ W) T8 C69行：读取AT24C02数据，且无需ACK；
6 k7 R" v- W( b; Q
72行：发送I2C停止信号；
8 ^% u) x8 b. M6 y$ H
, p6 P" z. o' V实现了对AT24C02单字节的读写，还需要实现多字节的读写。多字节读写可以通过AT24Cxx的页写模式和顺序读模式，实现多个数据的连续读写。在页写模式时，需要程序上设置，不能跨页写，这里简单处理，直接多次调用前面的单次读写即可，如代码段 16.3.8 所示。
/ r8 d% F  f. a1 Z% g1 ]4 d
代码段 16.3.8 读写AT24C02多字节数据（driver_eeprom.c）

1. /*
   
2. *  函数名：void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
   
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   5 c$ I4 m3 N/ _) B1 K( @
4. *            data -> 要写的数据指针
   4 C* y5 N! i. v7 ?: r9 p
5. *            sz   -> 要写的字节个数
   
6. *  输出参数：无
   
7. *  返回值：无
   * Y$ i/ e: m# k
8. *  函数作用：EEPROM写N个字节
   
9. */
   
10. void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    + ~- M% {' Q- u1 b  Y* d
11. {
    7 z1 j! b6 U  j& R$ z
12.     uint16_t i = 0;
    3 u5 j; P' Z% S
13. 
    ' z8 R0 H1 i% J5 x1 T( T0 L
14.     for(i=0; i<sz; i++)
    : x: f0 {8 U, A* f' l
15.     {
    
16.         EEPROM_WriteByte(addr, pdata<i>);
    , I) e7 n% u' w
17.         addr++;
    
18.         HAL_Delay(10); // Write Cycle Time 5ms
    
19.     }
    " m) w+ H. {& U9 I. U' J. `( x* [
20. }
    
21. 
    ) z. N  h1 J5 S* S' c4 Y' |: y! F
22. /*
    
23. *  函数名：void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
      |# q3 |9 [" f6 u3 g8 u: E! I) L
24. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    
25. *            data -> 要读的数据指针
    ( d6 B9 g7 t$ o! J. r# a! E' Q
26. *            sz   -> 要读的字节个数
    
27. *  输出参数：无
    
28. *  返回值：无
    
29. *  函数作用：EEPROM读N个字节
    / D" o- Q5 e$ h' Q0 i# h6 m* S4 h
30. */
    : l: o. a3 ^6 G+ d! e
31. void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
32. {
    " A1 r% ^% M4 R9 ]
33.     uint16_t i = 0;
    
34. 
    $ S$ H9 {) Y. |" L: ~
35.     for(i=0; i<sz; i++)
    
36.     {
    
37.         EEPROM_ReadByte(addr, &pdata<i>);
    
38.         addr++;
    % S$ f7 |* c/ h! _+ H4 j2 y
39.     }
    
40. }</i></i>

复制代码

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



0 [; Z" |; Q% \4) 主函数控制逻辑

在主函数里，每按一下按键，调用“EEPROM_Write_Nbytes()”对AT24C02写一串数据，再调用“EEPROM_Read_Nbytes()”读出该数据，如代码段 16.3.9 所示。
1 U4 j3 M) G3 V% I3 \
" d" y! ?& Q" w" c/ e. L代码段 16.3.9 主函数控制逻辑（main.c）

1. // 初始化I2C
   : R, \$ t% Z1 s' J
2.    I2C_Init();
   5 |( R) L& k$ k7 g2 G
3. 
   7 c$ D" ?9 j. h$ [9 J4 j) |9 t
4.    while(1)
   
5.    {
   
6.        if(key_flag) // 按键按下
   
7.        {
   
8.            key_flag = 0;
   6 p. [0 }/ K& s8 G5 W
9. 
   
10.            printf("\n\r");
    
11.            printf("Start write and read eeprom.\n\r");
    % ^$ _* @: J- w" F2 a
12. 
    
13.            // 读写一串字符，并打印
    
14.            EEPROM_Write_NBytes(0, tx_buffer, sizeof(tx_buffer)); // 写数据
    
15.            HAL_Delay(1);
    ( m$ h- n6 F" g+ }0 C
16. 
    
17.            EEPROM_Read_NBytes(0, rx_buffer, sizeof(tx_buffer));  // 读数据
    
18.            HAL_Delay(1);
    
19. 
    ) s7 V- Y5 C3 l* L
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));   // 清空接收的数据
    / F1 c2 z/ s: U, q! j
24.        }
    + k: n6 c0 R+ y8 C
25. }
    / x: e; f  H' V# a4 h/ Q; n; ?% T2 a

复制代码

16.4 实验效果
本实验对应配套资料的“5_程序源码\8_通信—模拟I2C\”。打开工程后，编译，下载，按下按键KEY，即可看到串口如图 16.4.1 所示。

) [+ V& D  b, F; S4 L% B6 }

* [5 Y, r4 u) z& W8 V; b

图 16.4.1 模拟I2C读写AT24C02数据

& {) [* S' i: n% K# \
作者：攻城狮子黄
  P. q+ A6 M( r5 f- {
) E* t% T9 z/ _" ?. x