16.1 关于I2C
16.1.1 I2C协议

: Z2 ^. L$ r/ t4 O: |; V' U) FI²C（Inter-Integrated Circuit），常读作“I方C”,它是一种多主从架构串行通信总线。在1980年由飞利浦公司设计，用于让主板、嵌入式系统或手机连接低速周边设备。如今在嵌入式领域是非常常见通信协议，常用于MPU/MCU与外部设备连接通信、数据传输。
$ \( w; i% F/ N+ x# P5 _9 Y6 g( Y
- Y/ D! n& B+ `( ?9 [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工作效率相对较高。

7 P) f- F' |3 B) q4 s- s关于I²C协议，通过下面例子进行一个形象的比喻方便大家理解，如图 16.1.1 所示，老师（MCU）将球（数据）传给众多学生中的一个（众多外设设备中的一个）。
9 W. I. W, _- e  O/ C

/ H3 \4 J4 e+ x% h6 K; U  J

图 16.1.1 I²C协议比喻

, R9 i% J+ N2 M. e& Z
( H8 m# r/ z/ j% x; e1 F% S3 w6 f4 P
首先老师将球踢给某学生，即主机发送数据给从机，步骤如下：

: d) W6 ]6 ?# G% J) J3 K1) 老师：开始了(start)；
$ J$ D: l% @! @0 X
2) 老师：A！我要发球给你！(地址/方向)；
2 |- F1 r" Q7 {( R9 \
3) 学生A：到！(回应)；
5 ?1 j0 w4 s& r3 a5 O5 \
4) 老师把球发出去（传输）；

! R( B. D; r- G) X5) A收到球之后，应该告诉老师一声（回应）；
% s8 T5 @! L2 v; v# ]
" L8 O' }! \$ I/ f7 \6) 老师：结束（停止）；
' H# L% g2 ~% @' p/ _' F+ S


- |: j5 \/ \2 Z* b接着老师让学生把球传给自己，即从机发送数据给主机，步骤如下：
  W1 E- a0 H/ N# U' r9 j& u
* J* }6 C, ?" M8 g0 c8 c1) 老师：开始了(start)；

0 d1 _; v, U( \2 U; o) ]8 C9 S2) 老师：B！把球发给我！(地址/方向)；

3) 学生B：到！
6 B8 _* U# v% n: O& I% D
. h2 h/ N2 b. i5 m" U; `; l4) B把球发给老师（传输）；

, _. \) [6 `! d+ l6 P( k" M0 Q5) 老师收到球之后，给B说一声，表示收到球了（回应）；
1 ^  f+ N; x4 x# j
6) 老师：结束（停止）。



% b2 Y* G6 i; w# j  D' V# u1 Z从上面的例子可知，都是老师（主机）主导传球，按照规范的流程（通信协议），以保证传球的准确性，收发球的流程总结如下：
9 K8 n) h# E5 A2 a3 m' P) `5 M
① 老师说开始了，表示开始信号(start)；

* N: O& B; H! s2 g) e- @& e  a② 老师提醒某个学生要发球，表示发送地址和方向(address/read/write)；
* Q4 J8 c/ T, ?
③ 该学生回应老师(ack)；
  t9 p" ?. K( u% r( L- K0 r
0 a: k% F9 A* \1 j7 y" r9 ], j+ `! e④ 老师发球/接球，表示数据的传输；

⑤ 收到球要回应：回应信号(ACK)；
- A1 X* }+ S- p0 E: n. f9 T7 t
⑥ 老师说结束，表示IIC传输结束(P)。
) s4 l4 b% F$ L1 w: l) X) ~( w

+ D2 O# I/ z- d, b( z
以上就是I²C的传输协议，如果是软件模拟I²C，需要依次实现每个步骤。因此，还需要知道每一步的具体细节，比如什么时候的数据有效，开始信号怎么表示。
1 d1 R- o, j6 H0 v3 _


7 e9 }8 _) l. z' u" P数据有效性
( x7 Y8 Y5 j* ]: S: z* Y
: d, O8 m& N+ A" BI²C由两条线组成，一条双向串行数据线SDA，一条串行时钟线SCL。SDA线上的数据必须在时钟的高电平周期保持稳定，数据线的高或低电平状态只有在 SCL 线的时钟信号是低电平时才能改变。换言之，SCL为高电平时表示有效数据，SDA为高电平表示“1”，低电平表示“0”；SCL为低电平时表示无效数据，此时SDA会进行电平切换，为下次数据表示做准备。数据有效性示意图如图 16.1.2 所示。

" r0 J! K" f1 ?. C% F

6 |. F) }) ?3 r2 F6 s! P
+ X0 J% g6 {- H; E, R" E: n

图 16.1.2 数据有效性

# Q% i  M& e0 Q( S! N2 e

% U* r# P) c5 ^0 `开始信号和结束信号

9 _8 i& m: k* vI²C起始信号（S）：当SCL高电平时，SDA由高电平向低电平转换；

I²C停止信号（P）：当SCL高电平时，SDA由低电平向高电平转换；
7 G0 ?9 p1 f& K. c
7 b. a' V0 l6 J! [" p4 l2 T  I

$ y- w, U: j; R+ l+ A+ n! k* T: x
2 ~$ Q% \. ^! ~! m( L' b

图 16.1.3 开始信号和结束信号

- X) _8 C1 Y' @3 T
9 g8 p/ r+ C- ]& G, p$ O& Z
应答信号                          
6 _& l- _- n1 a( A
I²C每次传输的8位数据，每次传输后需要从机反馈一个应答位，以确认从机是否正常接收了数据。当主机发送了8位数据后，会再产生一个时钟，此时主机放开SDA的控制，读取SDA电平，在上拉电阻的影响下，此时SDA默认为高，必须从机拉低，以确认收到数据。
( b$ \0 E" G- R9 ]

7 a  W/ h  b) D$ |9 _- U$ H

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

2 H7 I5 {/ R5 o  f
5 G5 p* X4 K  {; ^7 n2 @' D+ Z完整传输流程  

I²C完整传输流程如下：

* B$ B7 n+ O  m& B- h4 g) h① SDA和SCL开始都为高，然后主机将SDA拉低，表示开始信号；
6 }1 n( ~- g9 l' z# d" x
② 在接下来的8个时间周期里，主机控制SDA的高低，发送从机地址。其中第8位如果为0，表示接下来是写操作，即主机传输数据给从机；如果为1，表示接下来是读操作，即从机传输数据给主机；另外，数据传输是从最高位到最低位，因此传输方式为MSB（Most Significant Bit）。
+ d- P& e' m) k- ~; u; z" B4 c
③ 总线中对应从机地址的设备，发出应答信号；
4 @+ @8 E' j- Z. m3 l
④ 在接下来的8个时间周期里，如果是写操作，则主机控制SDA的高低；如果是读操作，则从机控制SDA的高低；
$ i5 a& C) c2 j* K7 M
+ n7 E5 O& q1 L6 w; @+ p⑤ 每次传输完成，接收数据的设备，都发出应答信号；

5 b/ E* i9 ~* z5 |5 i⑥ 最后，在SCL为高时，主机由低拉高SDA，表示停止信号，整个传输结束；


2 l8 ]7 N& s3 K) o

8 z) z: K/ m5 P. j/ O7 ], }

图 16.1.5 I2C传输时序

  ~, a, j" F$ J; m, ]3 C

6 [  ^; `, u* W& m/ T7 f4 `16.1.2 EEPROM介绍
) |6 x' M8 O; ^' p" f
EEPROM的全称是“电可擦除可编程只读存储器”，即Electrically Erasable Programmable Read-Only Memory。通常用于存放用户配置信息数据，比如在开发板首次运行时，需要屏幕校准，校准后的配置信息就可以保存在EEPROM里，开发板断电后配置信息不丢失，下次启动，开发板自动读取EEPROM的校准配置信息，就不需要重新校准。
4 u" m! W! D) o2 M
EEPROM和Flash的本质上是一样的，Flash包括MCU内部的Flash和外部扩展的Flash，本开发板就有一个SPI接口的外部Flash（W25Q64），在后面SPI接口再讲解。从功能上，Flash通常存放运行代码，运行过程中不会修改，而EEPROM存放用户数据，可能会反复修改。从结构上，Flash按扇区操作，EEPROM通常按字节操作。两者区别这里不再过多赘述，读者理解EEPROM在嵌入式中扮演的角色即可。
0 w2 t! z2 h" u


结构组成

EEPROM类型众多，其中比较常见是AT24Cxx系列，从命名上看，AT24Cxx中xx的单位是K Bit，如AT24C08，其存储容量为8K Bit。本开发板上的EEPROM型号为AT24C02，其存储容量为2K Bit，2*1024=2048 Bit。
' i9 u9 D- l& P
8 r- J) U; b6 k" M对于AT24C01/02，每页大小为8 Byte，对于AT24C04/08/16，每页大小为16 Byte。如图 16.1.6 所示，AT24C02由32页（Page）组成，每一页由8个字节（Byte）组成，每个Byte由8位（Bit）组成，Bit为最小存储单位，存放1个0或1。

; f2 \5 n2 Z- `

- {7 _9 s6 c& v& l; p
# Q5 c) i' H' K( b

图 16.1.6 AT24C02结构示意图

6 g1 `4 \, v; i0 Y0 R9 X
# K2 T( S: v' n1 n
设备地址  

I²C设备都会有一个设备地址，不同容量的AT24C02，设备地址定义会有所差异，由芯片数据手册《AT24Cxx.pdf》可知，如图 16.1.7 所示。

0 f' ]$ t4 h7 X6 T- |

$ {& L: Z% j! _: x

图 16.1.7 AT24Cxx设备地址定义

) q* [8 |# X  l

AT24C02的容量为2K，对应上图中的第一行，高四位固定为“1010”，中间三位由A2、A1、A0引脚的电平决定，比如A2~0引脚全接地，则值为“000”，最后的最低位为读写位，0代表写命令，1代表读命令。
$ C8 f  Z' I# s
( C4 [0 c8 Q  g  `2 H) j3 [* HA2、A1、A0引脚电平需要由原理图决定，假设全接电源地，则如果需要向AT24C02写数据，则发送地址“1010 0000”，如果需要向AT24C02读数据，则发送地址“1010 0001”。

6 `; j; R% s6 F+ E假设开发板有多个AT24C02挂在同一I²C总线上，通过这个规则，只需设计电路时，让A2、A1、A0引脚电平不同，即可区分两个AT24C02。
. I6 L# i" r" @
( L" F+ B6 x; j& `对于容量再大一点的AT24Cxx系列，比如AT24C04，器件地址由A2、A1引脚决定，数据空间有P0决定。比如对AT24C04的0~2K空间操作，则P0为0，对2K~4K空间操作，则P0为1。

) v9 p; [# y1 B* w, }4 v- y

写AT24Cxx  
; |/ O* ^( c. j/ R& i2 m
AT24Cxx支持字节写模式和页写模式。字节写模式是一个地址一个数据的写；页写模式是连续写数据，一个地址多个数据的写，但是页写模式不能自动跨页，如果超出一页长度，超出的数据会覆盖原先写入的数据。

4 o3 ]- i* f+ G. h( `% z如图 16.1.8 所示，为AT24Cxx字节写模式的时序，在MCU发出开始信号（Start）后，发出8 Bit的设备地址信息（图中读写位为低电平，即写数据），待收到AT24Cxx应答信号后，再发出要写的数据地址，再次等待AT24Cxx应答，最后发出8 Bit数据写数据，待AT24Cxx应答后，发出停止信号（Stop），完成一次单字节写数据。
  {! J$ i9 s  o' c# c

& r1 S3 C  c5 J) g' o& Z- K
% x+ ~6 c7 e& }: a. J8 k4 Y6 u

图 16.1.8 AT24Cxx字节写模式时序

7 e3 }0 _( C0 p  i& [& U6 YAT24C02容量为2K，因此数据地址范围为0x00~0xFF，即0~255，每个数据地址每次写1Byte，即8bit，也就刚好256*8=2048Bit。对于1K容量的产品，数据地址范围为0x00~0x7F，最高位不会用到，因此图中数据地址的最高位为“*”，意思是对于1K容量的产品，该位无需关心。
1 T( a6 d* g$ w7 A, I

& |; s; ~) e8 b

图 16.1.9 单字节写模流程图

; f9 [* C+ R9 b* J* b1 a( O9 [1 P图 16.1.10 为AT24Cxx的页写模式时序，与字节写模式的差异在于，不是只发送1Byte数据，而是任意多个。需要注意，该模式不能跨页写，遇到跨页时，需要重新发送完整的时序。

- x* B  x# N: D+ h! ?

5 B% Q4 O- k3 G
8 B2 a. u3 A/ c" W5 W

图 16.1.10 AT24Cxx页写模式时序

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

  M/ v" c) k$ T7 t
  X: O& x6 c" {* b+ h

图 16.1.11 AT24Cxx写间隔

7 b( _5 ], j# ^1 v& F: H$ _
2 [+ @' r) w; ~1 D/ j5 c% w3 B' N读AT24Cxx

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

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

图 16.1.12 AT24Cxx当前地址读模式

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

0 a1 `$ e  o" n+ O; m, z

. s! D/ R, q6 ~! \* z) a" f& o' J) G

图 16.1.13 AT24Cxx随机地址读模式

' e8 r' ^1 D$ J5 ]. h1 j* f
" w1 A1 i) }, T1 D
在顺序读模式下，需要先从当前地址读模式或随机地址读模式启动，随后便可连续读多个数据，时序如图 16.1.14 所示

5 N, s6 W; w* c. s  |

图 16.1.14 AT24Cxx顺序读模式

, k; M- J% }& Y6 E) o7 U
( l. G) M+ t* ^* I9 u0 y) y1 ^, G5 ~
. P9 c- D6 H6 d' q+ Q: ?! {

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。
8 ]9 r2 U1 `5 i7 y( N
0 p' @& V" {6 @3 D1 Z2 x( b: `此外，I2C的两个脚SCL和SDA都进行了上拉处理，从而保证I2C总线空闲时，两根线都必须为高电平。如果没有上拉，在主机发送完数据后，放开SDA，此时SDA的电平状态不确定，可能为高，也可能为低，无法确定是从机拉低给出应答信号。
; y/ G! N$ n! }; n, Q
4 o/ U9 s" |7 [6 x) z2 v结合原理图可知，PB6作为了I2C1的SCL，PB7作为了I2C1的SDA。
/ R1 o, L; i6 J- |0 c5 T
% w$ [9 R% ]  p$ W

图 16.2.1 EEPROM模块原理图

1 |' N- M! L- @: [' v3 @! R( S

16.3 软件设计
) y9 e6 d* ?. {5 z( M, J2 P2 v16.3.1 软件设计思路
! W- R7 J# H) H+ G3 l8 }: b
8 L& I. I* e1 o9 D' u8 T  v实验目的：本实验通过GPIO模拟I2C总线时序，对EEPROM设备AT24C02进行读写操作。
0 q+ h7 Y, ^3 {# h2 s% h
  _$ }+ ^& L% X2 O, ]1) 引脚初始化：GPIO端口时钟使能、GPIO引脚设置为输入/输出模式（PB6、PB7）；

; a; T( s3 X% q6 l" N2 q* S2) 封装I2C每个环节的时序函数：起始信号、响应信号、读写数据、停止信号；
. H2 J4 }  S% k- e" S0 d7 U/ j
3) 使用I2C协议函数，实现对AT24C02的读写；
" g/ e) ~9 x& F% V: K2 h7 Y6 @( h% W
4) 主函数，每按一次按键，写一次AT24C02，接着读出来验证是否和写的数据一致；
9 P5 D4 Z8 |/ c6 m% |
本实验配套代码位于“5_程序源码\8_通信—模拟I2C\”。

) p" ^! a! x1 G! l# G) C

! B5 j) f1 S7 K  T& ?6 d16.3.2 软件设计讲解
0 n' m. }6 b1 L+ _7 h9 w
1) GPIO选择与接口定义
  H/ Q4 ?7 P5 d, E
首先定义SCL和SDA引脚，引脚的高低电平宏定义，如代码段 16.3.1 所示。

代码段 16.3.1 模拟I2C引脚相关定义（driver_i2c.h）
* T$ ?$ w$ q/ f( A( J1 w+ }0 a

1. /************************* I2C 硬件相关定义 *************************/
   , X  a- |, u% c& }
2. 
   
3. #define ACK                 (0)
   
4. 
   # _: N9 }/ G  ]3 E% \3 m' b1 l/ U$ `
5. #define NACK                (1)
   
6. 
   0 `& b! J6 a0 p9 n. c( b
7. 
   
8. 
   7 Q. S: q5 Q0 l/ {& q, ^, k- f- s
9. #define SCL_PIN             GPIO_PIN_6
   # o% T5 c0 E$ t3 n3 U
10. 
    
11. #define SCL_PORT            GPIOB
      u/ |: g6 F  a; u0 ^0 t
12. 
    
13. #define SCL_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    ; M  O$ ~7 {. M4 y
14. 
    
15. 
    
16. 
    
17. #define SDA_PIN             GPIO_PIN_7
    
18. 
    
19. #define SDA_PORT            GPIOB
    2 p! o' ~7 u1 }! A# Q
20. 
    / _: j& J" [% D/ c( B( f  x
21. #define SDA_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    6 ]2 F# ?. Y6 X
22. 
    
23. 
    
24. 
    " U3 E+ J  e) ^
25. #define SCL_H()             HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_SET)
    9 d( @& ], q" o  x
26. 
    
27. #define SCL_L()             HAL_GPIO_WritePin(SCL_PORT, SCL_PIN, GPIO_PIN_RESET)
    
28. 
    / h- U% b& ~# [+ K9 s. g8 v6 `
29. #define SCL_INPUT()         HAL_GPIO_ReadPin(SCL_PORT, SCL_PIN)
    6 ]6 a* {* d! M
30. 
    , g' B' R/ \6 Z( W- n, V/ R
31. 
    
32. 
    2 t0 l' K; j# H2 t4 l0 ~, b
33. #define SDA_H()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_SET)
    
34. 
    ' t; T/ \, S6 |! T# J( G
35. #define SDA_L()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_RESET)
    0 ~% ?+ a6 i5 {: O* v
36. 
    2 c6 [" J+ P2 E' ~# i' y
37. #define SDA_INPUT()         HAL_GPIO_ReadPin(SDA_PORT, SDA_PIN)

复制代码

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

代码段 16.3.2 I2C引脚初始化（driver_i2c.c）
5 Y! w$ W% V1 Q

1. /*
   
2. *  函数名：void I2C_Init(void)
   1 F0 \+ X5 V, L! {1 v$ u
3. *  输入参数：
   
4. *  输出参数：无
     X  M# l  ]( w
5. *  返回值：无
   
6. *  函数作用：初始化模拟I2C的引脚为输出状态且SCL/SDA都初始为高电平
   / j- x* z  K. o- o( j
7. */
   
8. void I2C_Init(void)
   . n1 J4 G2 k# M, k
9. {
   . p5 K' ?6 U' e6 y$ X, p
10.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    5 `* H& j. C# A; R9 `+ p/ Y' n
11. 
    
12.     SCL_PIN_CLK_EN();
    
13.     SDA_PIN_CLK_EN();
    - I1 N: Z, R' A4 h5 J8 I6 q
14. 
    ! ^4 Z1 W. j- j& V
15.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
      I0 C) A2 p* ?) K5 P$ ~
16.     GPIO_InitStruct.Pull      = GPIO_NOPULL;
    # a0 S$ B  l4 b' E, h4 Q: s
17.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    / s6 F  v: b3 _' G0 b# [" b
18. 
    2 `- F! _+ h9 f7 @( I
19.     GPIO_InitStruct.Pin       = SCL_PIN;
    
20.     HAL_GPIO_Init(SCL_PORT, &GPIO_InitStruct);
    3 w, A( f8 D" z* T# i
21. 
    
22.     GPIO_InitStruct.Pin       = SDA_PIN;
    
23.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    
24. 
    % T$ K$ z" ]4 B( f1 Y
25.     SCL_H();
    
26.     SDA_H();
    . s& k/ h) ?& v' [: |
27. }
    # ^# \9 z7 F% o- H
28. 
    
29. /*
    
30. *  函数名：static void I2C_SDA_OUT(void)
    9 @: B% u1 C/ ]' r; B% I- a& P
31. *  输入参数：
    
32. *  输出参数：无
    * p7 c: n; d+ |- Z# I) Q; |
33. *  返回值：无
    6 X& r1 O( J. j) [" q4 A' @
34. *  函数作用：配置SDA引脚为输出
    
35. */
    
36. static void I2C_SDA_OUT(void)
    / J* |  ?$ |- @+ k( ^: L1 T  K
37. {
    
38.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
39. 
    
40.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    & {- C; k& J/ y! W# y
41.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
42.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    2 |, V3 d3 L) H8 J% G: |8 d
43. 
    
44.     GPIO_InitStruct.Pin       = SDA_PIN;
    
45.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    ' c" p9 H. W" p0 P+ j
46. }
    & Y  S, `1 _# Q
47. 
    ) z! |/ e& ]. F% d- G6 T% f
48. /*
      u' W7 {7 w3 n% ^
49. *  函数名：static void I2C_SDA_IN(void)
    
50. *  输入参数：
    
51. *  输出参数：无
    
52. *  返回值：无
    - y2 f. l5 [* m# S% I* W
53. *  函数作用：配置SDA引脚为输入
    ! l% j6 }: b9 {9 C2 x1 ~6 R& N5 D
54. */
    
55. static void I2C_SDA_IN(void)
    
56. {
    
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
58. 
    ) ~6 k! K. N' O2 g6 ~' f
59.     GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
    9 D) e  _7 L) |& \
60.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
61. 
    
62.     GPIO_InitStruct.Pin       = SDA_PIN;
    
63.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    5 {9 A' m% U% \2 M8 ]" W
64. }

复制代码

8 N7 O5 x5 {) o2) I2C时序函数
2 e( E% e, i9 r) E
开始信号/结束信号
- j, `5 S+ E5 h* d5 Z" J' I
2 U' a4 ]- o! p( x# G参考前面图 16.1.3 所示的开始信号和结束信号编写程序。对于开始信号，首先将SDA和SCL都拉高，随后SDA拉低，再SCL拉低。对于结束信号，首先拉低SDA，拉高SCL，再拉低SDA，代码如代码段 16.3.3 所示。
/ \5 C4 b( t8 {* D. H4 e- Q3 M
代码段 16.3.3 I2C开始信号和结束信号（driver_i2c.c）

1. /*
   5 Y' L: `  k; o5 i9 ~
2. *  函数名：void I2C_Start(void)
   
3. *  输入参数：
   0 U! ?8 l' C: h) h2 _! l
4. *  输出参数：无
   " v1 u; T. }6 \* \' t
5. *  返回值：无
   
6. *  函数作用：I2C开始信号
   ) d/ [1 u8 s6 x
7. */
   - c6 D* g4 h. d3 |" Z, g- G/ W2 z- C3 N
8. void I2C_Start(void)
   ) M% f" v$ _2 n5 z9 U
9. {
   0 I& `2 v3 m) x$ k- W4 [
10.     I2C_SDA_OUT();
    4 X/ Q1 V4 R5 l4 ?8 P
11. 
    4 ^1 [, V; G0 f* n6 Y4 X
12.     SCL_H();
    8 p0 J% a8 t8 I/ O. h
13.     I2C_Delay();
    
14. 
    # p( _: U# y- n+ r& R9 u# ]! f
15.     SDA_H();
    9 R0 B3 ?2 f3 J% I
16.     I2C_Delay();
    5 D+ D, r! `) |3 [! D4 a7 J
17. 
    
18.     SDA_L();
    
19.     I2C_Delay();
    + Q4 [3 s. j7 A5 h
20. 
    * e$ @% R% [, C& U2 P  r
21.     SCL_L();
    
22.     I2C_Delay();
    
23. }
    3 E2 d* ~( X( q5 j( w- F
24. 
    
25. /*
    % l) P. P7 u* [) b2 t
26. *  函数名：void I2C_Stop(void)
    . [  l; K: }& w; n" u- K% }
27. *  输入参数：
    / z& c! a+ V  J
28. *  输出参数：无
    9 r' T+ k4 k+ ?
29. *  返回值：无
    
30. *  函数作用：I2C停止信号
    
31. */
    $ q4 w. i; M; p+ S
32. void I2C_Stop(void)
    
33. {
    
34.     I2C_SDA_OUT();
    
35. 
    
36.     SDA_L();
      G( D" l, h6 _. m; b
37.     I2C_Delay();
    * ~* ~4 y/ W  O  |/ e  s
38. 
    
39.     SCL_H();
    # B" L# }" Y! B" s2 y% }
40.     I2C_Delay();
    ' ?8 y1 G+ y! B& N" ~* [: Q- v
41. 
    # q! O/ l: |/ f4 y- E* U
42.     SDA_H();
    
43.     I2C_Delay();
    
44. }

复制代码

3 [0 h& B( a, t1 T# e& ~应答信号/非应答信号/等待应答信号

* U% Y! f/ ?$ x  F参考前面图 16.1.4 所示，编译应答信号，如代码段 16.3.4 所示。

2 y( J" \: F- n4 e代码段 16.3.4 应答/非应答/等待应答信号（driver_i2c.c）

! m5 z2 X& W  g  R+ L; q6 Q* u

1. /*
   
2. *  函数名：void I2C_ACK(void)
   6 }( ]/ x+ n# N; m. M
3. *  输入参数：
   * \, i) c* _8 W: J
4. *  输出参数：无
   , Q. F- e: j$ n
5. *  返回值：无
   
6. *  函数作用：I2C发出应答信号
   " J, f6 Q" ]; w2 F; s% ^8 u' v' e
7. */
   
8. void I2C_ACK(void)
   
9. {
   
10.     I2C_SDA_OUT();
    
11. 
    * I7 l  \) N; r+ }: g0 q
12.     SCL_L();
    * P; n: |  b1 o- v
13.     I2C_Delay();
    
14. 
    
15.     SDA_L();
    0 c2 F+ ]6 N& A# |! `% k
16.     I2C_Delay();
    
17. 
    
18.     SCL_H();
    
19.     I2C_Delay();
    6 `5 j7 ?6 b. _7 B. z9 h# {# ?
20. 
    / o0 L# i1 \: N. q9 T
21.     SCL_L();
    ; \1 A$ O. O: t) d0 ~# X: h" B
22.     I2C_Delay();
    
23. }
    
24. 
    ! n) ?6 R. J( ?3 ]5 r- _1 O7 a
25. /*
    / t9 E; x4 S; P9 P7 w0 B& h* v
26. *  函数名：void I2C_NACK(void)
    
27. *  输入参数：
    
28. *  输出参数：无
    + `' Z0 p1 M3 Y! C% Y% l8 Z2 ]
29. *  返回值：无
    
30. *  函数作用：I2C发出非应答信号
    
31. */
    
32. void I2C_NACK(void)
    , i9 u+ }& i! e! O! R
33. {
    
34.     I2C_SDA_OUT();
    6 ^0 x2 \: W- o7 q
35. 
    * J0 a) D3 s( ]9 o3 e
36.     SCL_L();
    
37.     I2C_Delay();
    # m: l; \% G7 n# a9 g
38. 
    
39.     SDA_H();
    
40.     I2C_Delay();
    * M# }, R$ v! Y8 I$ K1 ^) Q9 [8 X
41. 
    
42.     SCL_H();
    6 ^) I1 N5 x: i, L9 R! @
43.     I2C_Delay();
    
44. 
    
45.     SCL_L();
    4 {0 n, S8 Y+ h" j
46.     I2C_Delay();
    
47. }
    1 L' S# ^" G: r, d
48. 
    
49. /*
      y& G' j$ j8 P
50. *  函数名：uint8_t I2C_GetACK(void)
    
51. *  输入参数：
    ) {( h$ Q& T0 H
52. *  输出参数：无
    
53. *  返回值：1无应答，0有应答
    7 {8 n' R% i2 ~9 [$ x( ]
54. *  函数作用：I2C等待从机的应答信号
    
55. */
      x( s3 @8 ?. L( {8 g3 ^* D
56. uint8_t I2C_GetACK(void)
    : M6 O( F/ I* J* t* i! U
57. {
    
58.     uint8_t time = 0;
    1 D9 ^! l- Z" n- ~4 I) c
59.     I2C_SDA_IN();
    
60. 
    + i* K/ M4 P4 |0 g% b
61.     SCL_L();
    / ]- {8 W8 R1 E  d. C, p
62.     I2C_Delay();
    
63. 
    
64.     SDA_H();
    + f, G. O: c8 F/ y7 s0 y9 A9 B
65.     I2C_Delay();
    
66. 
    
67.     SCL_H();
    ; D* `0 p  x" E- y& \) p/ c
68.     I2C_Delay();
    + B, z0 Y/ |! O; i2 q' M* y/ M
69. 
    6 T( Q1 k+ {3 M( D
70.     while(SDA_INPUT())
    
71.     {
    2 f4 F  e$ Q3 \7 y2 L2 ~* a, |. W
72.         time++;
    0 v/ @6 S: h# \1 G# t2 Y
73.         if(time>250)
    7 C, i! Z! x& l' w- p
74.         {
    
75.             SCL_L();
    
76.             return 1;
    
77.         }
    # k9 @$ F* ~+ M
78.     }
    
79.     SCL_L();
    + k( o2 f4 \9 h! w
80. 
    
81.     return 0;
    
82. }

复制代码

2 ^9 L4 X% _; ^8 [8~23行：应答信号，在一个SDA时钟周期里，将SCL拉低；
9 b$ D, l* D8 A, Q
32~47行：非应答信号，在一个SDA时钟周期里，将SCL拉高；

56~82行：等待应答信号，拉高SDA后放开SDA，读取SDA是否被拉低，如果拉低返回0，否则返回1；

+ i1 c' H2 N& m5 e5 s
! o& i4 U6 N- v$ J: G' k* M/ K
发送/接收函数

/ S* \& K2 f9 P" \% i% P, r: n最后还剩发送/接收函数，如代码段 16.3.5 所示。对于发送函数，控制SDA产生8个时钟周期，每个时钟周期里控制SDA高低电平发送1位数据。对于接收函数，控制SDA产生8个时钟周期，每个时钟周期里读取SDA高低电平接收1位数据。

代码段 16.3.5 发送/接收函数（driver_i2c.c）
2 [4 X6 e' W( c9 w8 Q

3 S* ]; `! N" p. G

1. /*
   
2. *  函数名：void I2C_SendByte(uint8_t data)
   9 Q. w% J% b# V5 k; h8 j. M
3. *  输入参数：data->发送的数据
   
4. *  输出参数：无
   
5. *  返回值：无
   ! H( g( P7 B7 I9 \/ U% I
6. *  函数作用：I2C发送一个字节
   + L8 }( z0 x/ V, t, U
7. */
   , [7 |: W' A) n; V& A. f
8. void I2C_SendByte(uint8_t data)
   ) y9 e  N( E+ l1 E/ V* L
9. {
   ) j% J% b3 ^1 ^0 _$ q
10.     uint8_t cnt = 0;
    
11. 
    4 F1 T* s7 _* Q
12.     I2C_SDA_OUT();
    
13. 
    
14.     for(cnt=0; cnt<8; cnt++)
    7 v# w9 |; i( P0 y' _
15.     {
    + d" q# Q0 s$ D
16.         SCL_L();
    ) {9 Z) l4 p6 w$ f0 i, e; g1 r
17.         I2C_Delay();
    ; n) J$ F& D3 e
18. 
    * X/ N; w. d* `
19.         if(data & 0x80)
      ^! x6 k0 C+ G/ m
20.         {
    ! Q1 K7 ]0 ~; p7 j, }9 Z  U& o7 X% S
21.             SDA_H();
    
22.         }
    
23.         else
    
24.         {
    , c% t4 G- `/ s" C2 L0 i1 s
25.             SDA_L();
    
26.         }
    8 J) j- i$ _6 y. D# I2 E) ]4 b
27.         data = data<<1;
    
28.         SCL_H();
    4 ]$ B' @+ p: ?$ ^
29.         I2C_Delay();
    ) v2 v! d( S- h/ ~
30.     }
    
31. 
    , v1 U: v0 Q2 a, W7 ~9 G$ Y
32.     SCL_L();
    
33.     I2C_Delay();
    
34.     I2C_GetACK();
    3 k: s1 ]5 t) J7 O; I
35. }
    
36. 
    : s/ C! O" ?/ r
37. /*
    
38. *  函数名：uint8_t I2C_ReadByte(uint8_t ack)
    ; z% D% C8 q" M4 Y/ l9 D4 s# E
39. *  输入参数：ack->发送的应答标志，1应答，0非应答
    # Q6 p/ r- i, f* Y
40. *  输出参数：无
    
41. *  返回值：返回读到的字节
    % ^7 @) N9 B+ O2 c$ E
42. *  函数作用：I2C读出一个字节
    
43. */
    " Y' E/ X* o* E9 @! a2 z3 D8 {
44. uint8_t I2C_ReadByte(uint8_t ack)
    
45. {
    
46.     uint8_t cnt;
    
47.     uint8_t data = 0xFF;
    
48. 
    $ f" d+ X' p# }. G
49.     SCL_L();
    & }7 H+ D; `3 W. h1 l0 W! z6 e
50.     I2C_Delay();
    ! C! {, Q# |, \, P7 l$ d
51. 
    9 p3 Y4 }8 M+ `
52.     for(cnt=0; cnt<8; cnt++)
    
53.     {
    5 H, K' C- p* ~6 n/ X8 n1 ]
54.         SCL_H();                 //SCL高(读取数据)
    * k; k+ a6 N$ L( o# Y: l2 j; Z
55.         I2C_Delay();
    $ c( @9 o# {7 w
56. 
    & V% N$ }, z# M! a& u
57.         data <<= 1;
    " v3 A5 }6 U( k
58.         if(SDA_INPUT())
    4 R* N- w7 J6 H+ d8 o2 I  }; _/ u4 H
59.         {
    
60.             data |= 0x01;        //SDA高(数据为1)
    
61.         }
    
62.         SCL_L();
    
63.         I2C_Delay();
    7 H' {6 I% Y5 n" l: f, _
64.     }
    & }8 X, N0 S5 Q- Y" b
65.     //发送应答信号，为低代表应答，高代表非应答
      s2 t& m* A  y) k7 I" f" N
66.     if(ack == 0)
    $ J+ M+ x2 a, @8 D
67.     {
    
68.         I2C_ACK();
    / H# ~  y; q6 Y% V2 P) o+ \, k5 Y: H( D& I
69.     }
    - w, V% e/ l5 X' K; Y3 [  G- [
70.     else
      q7 j2 j1 ~+ L/ h2 g
71.     {
    
72.         I2C_NACK();
      J5 W" I2 z, q# o2 D, R5 m1 W
73.     }
    9 v  C& C8 l# {1 n6 |+ J& w& W
74.     return data;                 //返回数据
    ! k5 ]% [) p* r' _. {3 ~" C+ D
75. }

复制代码

14~31行：循环8次，每次循环：
6 N1 Q+ E3 i6 h4 w
8 S+ a2 ^' p1 ^0 k% @- z& i16行：先拉低SCL；
% [2 M9 F$ I2 c% q
. V+ \) q3 T) ^0 o, `19~26行：将输入的数据data与0x08且运算，得到最高位的值，从而控制SDA输出对应的高、低电平;

27行：将data左移一位，得到次高位；

29行：拉高SCL，让SDA处于稳定期，从设备即可获取SDA的值；

35行：等待从设备的应答信号；
0 E, o$ ^1 o) b: s9 M# f; L
53~65行：循环8次，每次循环：
' D+ i* I& f# Q2 c/ A8 M: Y) F2 T
- N) ^9 S- Q& l" b# f' K; C# I5 N55行：先拉高SCL，此时认为从设备控制SDA电平，处于稳定期；
$ T' m: C& z+ v0 ?4 R
( ?) S4 g- D' I: h; h58行：将data左移1位，以确保收到数据按最高位在前存放；
" O5 x9 Z' O5 H1 S
59~62行：读取SDA电平，如果为高，保存到data当前最低位，否则data最低位默认为0；

# O( E' w- B( t8 E63行：SCL拉低，此时从设备继续控制SDA电平变化

66~74行：根据传入的参数，决定是否发送应答信号；
* G) |; {- ?( z/ R$ C0 C


% h) M/ j1 g$ c! ^整个I2C协议函数中，经常用到“ I2C_Delay()”来实现SCL时钟周期。对于AT24Cxx，由其芯片手册可知，时钟脉冲宽度（Clock Pulse Width）需要大于5us，也就是SCL如果刚变为高电平，需要等待至少5us才能变为低电平，因此定义“ I2C_Delay()”为5us以上即可。
1 }! I! o1 u. Z7 m9 b6 I

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

复制代码

0 C4 R$ E3 W% X( N: s8 p这里的“us_timer_delay()”可以由定时器提供，也可以使用循环提供，前者精度更高，效果更好。定时器的介绍在后面章节，本章不作分析，延时函数的两者方式如代码段 16.3.6 所示。

代码段 16.3.6 延时函数的实现（driver_timer.c）
, [5 |% A( Q# j. H1 K

1. #if 0
   
2. /*
   
3. *  函数名：void us_timer_delay(uint16_t t)
   ! A& Q% Y, d1 b" G
4. *  输入参数：t-延时时间us
   
5. *  输出参数：无
   
6. *  返回值：无
   . n# B7 z: O/ s6 f$ K( ~
7. *  函数作用：定时器实现的延时函数，延时时间为t us，为了缩短时间，函数体使用寄存器操作，用户可对照手册查看每个寄存器每一位的意义
   
8. */
   
9. void us_timer_delay(uint16_t t)
     B; m. \9 P4 B2 `% Z( Z! g, f" l% C' f4 d" M
10. {
    
11.     uint16_t counter = 0;
    / C! v$ C7 q( S9 H
12.     __HAL_TIM_SET_AUTORELOAD(&htim, t);
    + q1 U0 x0 \5 A8 Q- y( F1 s
13.     __HAL_TIM_SET_COUNTER(&htim, counter);
    
14.     HAL_TIM_Base_Start(&htim);
    : p0 P5 Z& |6 V$ G# w  X( {
15.     while(counter != t)
    
16.     {
    & S( s7 i$ k& m
17.         counter = __HAL_TIM_GET_COUNTER(&htim);
    
18.     }
    
19.     HAL_TIM_Base_Stop(&htim);
    
20. }
    0 ]8 \% w. O. d4 A' N
21. #else
    
22. /*
    
23. *  函数名：void us_timer_delay(uint16_t t)
    
24. *  输入参数：t-延时时间us
    4 G0 J/ T. V4 I, d, R5 Z- ~
25. *  输出参数：无
    8 Z. [) i2 D7 y) I+ g% f
26. *  返回值：无
    
27. *  函数作用：延时粗略实现的延时函数，延时时间为t us
    7 w6 b& Z- u; ]
28. */
    ' V( O- d$ o) h; k( K
29. void us_timer_delay(uint16_t t)
    % F* @& g& R( v
30. {
    ' K' Q9 `" J" Q. d: J( {5 f
31.     uint16_t counter = 0;
    
32. 
    
33.     while(t--)
    
34.     {
    
35.         counter=10;
    
36. 
    
37.         while(counter--) ;
    3 c$ q3 g1 W* M: N8 [" h
38.     }
    
39. }
    + }8 n7 B# Z/ L% d1 {4 H
40. #endif

复制代码

; ?" k& f5 ~( k5 u
3) AT24C02读写函数

编写好I2C协议函数后，参考AT24C02手册编写读写数据函数，如代码段 16.3.7 所示。

代码段 16.3.7 读写AT24C02一字节数据（driver_eeprom.c）
& s3 q4 b* m+ K

1. /*
   " E3 M- L% I) F
2. *  函数名：uint8_t EEPROM_WriteByte(uint16_t addr, uint8_t data)
   
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   ! E9 e- l- ^1 Y4 M0 F
4. *            data -> 要写的数据
   # s) Y7 v1 m( w
5. *  输出参数：无
   
6. *  返回值：无
   - t' \6 b6 f( x) L
7. *  函数作用：EEPROM写一个字节
   ; E2 s1 w' f' h
8. */
   
9. void EEPROM_WriteByte(uint16_t addr, uint8_t data)
   
10. {
    ! R# F( C3 p/ e1 N1 b; B. b2 Q1 B
11.     /* 1. Start */
    ; W1 }, V9 x. [" z! q9 Y- n4 y. c
12.     I2C_Start();
    # W" j% X) `! o* B" p9 T9 D" E
13. 
    # N2 a/ E4 P! a7 l
14.     /* 2. Write Device Address */
    
15.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    
16. 
    $ f# y) e2 J$ m1 }( T0 O& J! D
17.     /* 3. Data Address */
    7 v2 D) O* K, j- n1 Y
18.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    9 q% Z1 E0 b+ h# q  r- h0 [" M: x
19.     {
    
20.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
21.     }
    * o( H7 g- Y1 X0 k
22.     else
    / {# I8 Z1 N7 M% }/ j" D/ m
23.     {
    
24.         I2C_SendByte( (uint8_t)(addr>>8) );
    . U) f9 S4 _5 A
25.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    $ l: y# L/ ]! ~9 F
26.     }
    
27. 
    
28.     /* 4. Write a byte */
    
29.     I2C_SendByte(data);
    
30. 
    . d3 J. T2 c# C, O3 y! R
31.     /* 5. Stop */
    
32.     I2C_Stop();
    
33. }
    
34. 
    
35. /*
    
36. *  函数名：uint8_t EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    % g6 e0 g( z5 ~5 i, |2 q
37. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    
38. *            data -> 要读的数据指针
    . Q9 F- C1 f1 q& W; N& N, d
39. *  输出参数：无
    
40. *  返回值：无
    
41. *  函数作用：EEPROM读一个字节
    
42. */
    / F' g; p" c! s/ R
43. void EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    
44. {
    9 j! S9 B3 Q  [9 J
45.     /* 1. Start */
    & p# u7 ?1 N! j1 }4 F7 i
46.     I2C_Start();
    6 N' k3 b2 i+ b
47. 
    0 U$ E4 f% w3 X4 [, p
48.     /* 2. Write Device Address */
    1 C4 |" H, g2 x' }
49.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    
50. 
    - n2 M0 q. z6 }9 N9 W9 ~8 {
51.     /* 3. Data Address */
    6 O; [# L" n1 _. W- }& j
52.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    6 \  k5 Z" }: ]" g5 a, `. M
53.     {
    
54.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
55.     }
    
56.     else
    ' Z3 o; P6 L# n: ]6 j
57.     {
    : W0 @  T/ Q1 u" \/ ^
58.         I2C_SendByte( (uint8_t)(addr>>8) );
    8 k! `  l6 F4 h! f
59.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
60.     }
    
61. 
    
62.     /* 4. Start Again */
    : o7 M  K, p* o* P! F
63.     I2C_Start();
    
64. 
    " T- a( H1 e& @' O. s, R
65.     /* 5. Write Device Address Read */
    
66.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_RD );
    
67. 
    
68.     /* 6.Read a byte */
    ) g1 i! i; y4 F8 g$ v7 i7 s$ x
69.     *pdata = I2C_ReadByte(NACK);
    . e& @2 A4 J9 r; m" \
70. 
    
71.     /* 7. Stop */
    
72.     I2C_Stop();
    
73. }

复制代码

# s  Z9 O+ {* v& F) M- Y参加前面图 16.2.1 和图 16.1.13 所示的介绍时序，编写AT24C02一字节读写程序。

  z3 D3 d$ d( R8 I9~33行：写AT24C02一字节数据；
& ?. z# `! o6 G/ y- I4 ^
0 I$ p/ Z: G' x! n" h/ c; t; M( }8 b12行：发送I2C开始信号；

" o7 {4 S# O( k8 m' W1 Q" [15行：发送AT24C02的设备地址，最后一位表示写操作；

18~26行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；
  L! M6 ^" g7 w, v/ |+ e
/ E5 v4 ?2 [% X, o29行：发送数据；
( z9 v: L* Z+ g" O. V$ q) n/ h* D
32行：发送I2C停止信号；

43~73行：读AT24C02一字节数据；
% }7 Q. {# Q% _4 Q" z6 ]2 ~: j. F# O
7 G! U' T3 j. l/ e/ p9 @3 L46行：发送I2C开始信号；
+ k3 W* _5 ~9 y9 m* U7 I6 Z
" O% W/ p4 W1 K( F$ ?49行：发送AT24C02的设备地址，最后一位表示写操作（接下来要写数据地址）；

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

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

2 ], p1 S) o6 e7 ^3 M# n' p( _66行：发送AT24C02的设备地址，最后一位表示读操作；
9 u4 \( n* i* O9 r- j# o
1 a! F: U/ Z& Q) z% S69行：读取AT24C02数据，且无需ACK；
7 \1 U% f3 G! @
& n4 r% o0 v# c) W, Y72行：发送I2C停止信号；

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

5 t  |) c5 l: ?$ J0 W: ?代码段 16.3.8 读写AT24C02多字节数据（driver_eeprom.c）

. |: L! f, t2 B$ X% ?7 w

1. /*
   6 c! I' o/ A2 S# r# c4 T' ]
2. *  函数名：void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
   $ S1 _$ d7 g* t! Q1 e9 X
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   
4. *            data -> 要写的数据指针
   ( c; |  R. j8 Q
5. *            sz   -> 要写的字节个数
   
6. *  输出参数：无
   : `7 m' u3 v3 ~# M- v
7. *  返回值：无
   0 f; ?; C9 @7 ~; E
8. *  函数作用：EEPROM写N个字节
   
9. */
   + [3 J' F7 T7 Y# z7 S
10. void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
11. {
    6 j3 s1 `; W6 P8 N  x4 g
12.     uint16_t i = 0;
    
13. 
    0 I' U- a7 e% ~4 x
14.     for(i=0; i<sz; i++)
    2 U5 C+ k7 B3 F
15.     {
    
16.         EEPROM_WriteByte(addr, pdata<i>);
    
17.         addr++;
    
18.         HAL_Delay(10); // Write Cycle Time 5ms
    0 D( B. T2 H6 {- k0 V* w* h
19.     }
    
20. }
    
21. 
    / d' f7 D, j1 u4 ~
22. /*
    
23. *  函数名：void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
24. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    
25. *            data -> 要读的数据指针
    
26. *            sz   -> 要读的字节个数
    
27. *  输出参数：无
    + L& R. k. M9 e0 ]) a$ X2 ]% L
28. *  返回值：无
    
29. *  函数作用：EEPROM读N个字节
    
30. */
    4 D* }! s; p" _( _4 B
31. void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
32. {
    
33.     uint16_t i = 0;
    
34. 
    , X- S& ]8 O/ T" A  V* {
35.     for(i=0; i<sz; i++)
    9 @# s' y7 m, c# w6 @" o
36.     {
    * ]! V. Z  {( A3 a0 h0 _
37.         EEPROM_ReadByte(addr, &pdata<i>);
    
38.         addr++;
    , [7 s( u% u' t5 O6 c' z( _9 b
39.     }
    
40. }</i></i>

复制代码

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

5 |6 q9 N7 e  K  R  ]) X# x, K

4) 主函数控制逻辑
" E' v) Z; p2 [( D$ H# D) ]( @6 c
. G  T" U$ I6 S* Q; X" l在主函数里，每按一下按键，调用“EEPROM_Write_Nbytes()”对AT24C02写一串数据，再调用“EEPROM_Read_Nbytes()”读出该数据，如代码段 16.3.9 所示。

代码段 16.3.9 主函数控制逻辑（main.c）

1. // 初始化I2C
   $ N" [% h4 q! b- F3 l! T
2.    I2C_Init();
   
3. 
   
4.    while(1)
   8 D7 O  @5 _: R8 m( }
5.    {
   . c# ?0 r9 F- s/ ?( d2 G( E1 q+ @
6.        if(key_flag) // 按键按下
   . E* H0 C) C% s8 e" C$ ]) U0 R
7.        {
   7 s3 b5 s1 s: W$ Y
8.            key_flag = 0;
   8 q* h. b+ c' `: r) _' k
9. 
   
10.            printf("\n\r");
    8 t# H: X9 ]5 A; j# C: j8 i
11.            printf("Start write and read eeprom.\n\r");
    . @( I/ w( G) i. `+ r& |
12. 
    
13.            // 读写一串字符，并打印
    
14.            EEPROM_Write_NBytes(0, tx_buffer, sizeof(tx_buffer)); // 写数据
    ' `# V4 X3 b% X
15.            HAL_Delay(1);
    
16. 
    $ b/ k# l2 c3 E1 O+ G
17.            EEPROM_Read_NBytes(0, rx_buffer, sizeof(tx_buffer));  // 读数据
    
18.            HAL_Delay(1);
    
19. 
    
20.            printf("EEPROM Write: %s\n\r", tx_buffer);
    * I5 c- o, V' I; R: o2 u
21.            printf("EEPROM Read : %s\n\r", rx_buffer);
    % h6 I) h/ G- Q. R+ \* U- `
22. 
    / e' }) K8 Q5 B/ v% h
23.            memset((uint8_t*)rx_buffer, 0, sizeof(rx_buffer));   // 清空接收的数据
    % S1 q) a. r& e# u# r
24.        }
    1 t0 A, ]5 @6 X6 \1 R& n  R
25. }
      `2 `0 Y' n/ f* x& O: \3 q

复制代码

16.4 实验效果
: p. k7 A) w+ K# W' r5 H本实验对应配套资料的“5_程序源码\8_通信—模拟I2C\”。打开工程后，编译，下载，按下按键KEY，即可看到串口如图 16.4.1 所示。

" t* m) j0 x. T5 r+ U7 G' [

图 16.4.1 模拟I2C读写AT24C02数据

作者：攻城狮子黄
+ I) ?! q) m9 E# D6 Q# b

+ @3 Q( A9 F! r0 ^  \