16.1 关于I2C
16.1.1 I2C协议
3 X, w% `/ t2 V# o
4 ^3 E8 H0 [' ~2 fI²C（Inter-Integrated Circuit），常读作“I方C”,它是一种多主从架构串行通信总线。在1980年由飞利浦公司设计，用于让主板、嵌入式系统或手机连接低速周边设备。如今在嵌入式领域是非常常见通信协议，常用于MPU/MCU与外部设备连接通信、数据传输。
4 X! ]( F8 m, Z1 ]) X% x
- h( l& h3 J5 ?) [$ {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工作效率相对较高。
' K7 U6 f  }8 H7 R7 b& i* Z; \. d
关于I²C协议，通过下面例子进行一个形象的比喻方便大家理解，如图 16.1.1 所示，老师（MCU）将球（数据）传给众多学生中的一个（众多外设设备中的一个）。
4 u( ~7 _7 @$ b

& \9 C9 L4 d# K7 c0 Z

图 16.1.1 I²C协议比喻

  B( P6 P3 G2 {8 [& R! X

' m+ ^: J" u7 Z2 [! A首先老师将球踢给某学生，即主机发送数据给从机，步骤如下：

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

: |! S$ V* }7 V, R) I1 ]* l1 u2) 老师：A！我要发球给你！(地址/方向)；
/ _) m' a9 i, w; l  p
3) 学生A：到！(回应)；
! @! m: m: R0 n" H! ]
  v6 t9 V9 N0 z8 l. W4) 老师把球发出去（传输）；

5) A收到球之后，应该告诉老师一声（回应）；

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

' W$ [! F: k% E

接着老师让学生把球传给自己，即从机发送数据给主机，步骤如下：
) i, i6 B. g, P; E; m* s
- K& s9 }1 c. }$ \1) 老师：开始了(start)；
* [, V  y- g$ m1 h
% X- f1 z* m- t5 m6 t5 e2) 老师：B！把球发给我！(地址/方向)；

3) 学生B：到！

4) B把球发给老师（传输）；
+ C7 ]# _0 w$ M2 l
1 x/ Q: i0 z) m0 Q* U2 B" D9 ^3 u5) 老师收到球之后，给B说一声，表示收到球了（回应）；
2 E& Q0 F9 l. F. r% K) }
6) 老师：结束（停止）。



2 r5 U. j: w- E; o: z& w; C" p5 v! q从上面的例子可知，都是老师（主机）主导传球，按照规范的流程（通信协议），以保证传球的准确性，收发球的流程总结如下：

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

$ E7 d8 S" z9 f6 c; V, m8 a5 S8 m② 老师提醒某个学生要发球，表示发送地址和方向(address/read/write)；

③ 该学生回应老师(ack)；
- [! K0 ?: a$ B7 d
7 c: x+ P' |  K& D$ ~④ 老师发球/接球，表示数据的传输；

⑤ 收到球要回应：回应信号(ACK)；

⑥ 老师说结束，表示IIC传输结束(P)。
% X* d$ U" i) v6 y/ o; s5 |

* Q1 r5 W/ Q, @) N! }
以上就是I²C的传输协议，如果是软件模拟I²C，需要依次实现每个步骤。因此，还需要知道每一步的具体细节，比如什么时候的数据有效，开始信号怎么表示。


8 e/ R, N. K9 t8 p- J: d6 }( e7 I
5 m0 v3 Q# f1 v7 c4 q" z9 ]7 o数据有效性

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

9 H! A0 t" k* l1 M
0 I' U# k6 [" y5 V* E

图 16.1.2 数据有效性

开始信号和结束信号
% }+ R5 |  m0 `9 H
! S+ B- o$ s8 {1 |  dI²C起始信号（S）：当SCL高电平时，SDA由高电平向低电平转换；
( r" j' X5 k" m2 E
I²C停止信号（P）：当SCL高电平时，SDA由低电平向高电平转换；
6 ^& W( X( N1 H- |
: S+ `  w! g/ y; w

8 D$ j8 {9 z. g9 a/ |

图 16.1.3 开始信号和结束信号

应答信号                          
, Q/ W& Y5 Z/ u/ l* `
: {$ K& `; e2 T7 G4 ~I²C每次传输的8位数据，每次传输后需要从机反馈一个应答位，以确认从机是否正常接收了数据。当主机发送了8位数据后，会再产生一个时钟，此时主机放开SDA的控制，读取SDA电平，在上拉电阻的影响下，此时SDA默认为高，必须从机拉低，以确认收到数据。

: j0 w& T  d. u, `, A

  i7 P: v. I: f

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

完整传输流程  
! G# e9 f' A. J& \
7 b6 A2 L5 b% JI²C完整传输流程如下：
3 _. M6 w4 X% v
① SDA和SCL开始都为高，然后主机将SDA拉低，表示开始信号；
" }# J. l% Z3 h- N  A" q
+ }$ E5 B1 y8 Y) X8 [② 在接下来的8个时间周期里，主机控制SDA的高低，发送从机地址。其中第8位如果为0，表示接下来是写操作，即主机传输数据给从机；如果为1，表示接下来是读操作，即从机传输数据给主机；另外，数据传输是从最高位到最低位，因此传输方式为MSB（Most Significant Bit）。
- Z/ z3 B& ~9 x  v2 H2 Q
3 n3 H9 p2 {! ]: l8 H# A③ 总线中对应从机地址的设备，发出应答信号；

④ 在接下来的8个时间周期里，如果是写操作，则主机控制SDA的高低；如果是读操作，则从机控制SDA的高低；

  T+ {' _0 c  z: d& J+ m⑤ 每次传输完成，接收数据的设备，都发出应答信号；

" J1 {& K; R4 @* M5 w* }% R⑥ 最后，在SCL为高时，主机由低拉高SDA，表示停止信号，整个传输结束；
1 F1 G0 e$ K/ G9 _- a

图 16.1.5 I2C传输时序

16.1.2 EEPROM介绍
  X( D7 _  I3 V/ x
EEPROM的全称是“电可擦除可编程只读存储器”，即Electrically Erasable Programmable Read-Only Memory。通常用于存放用户配置信息数据，比如在开发板首次运行时，需要屏幕校准，校准后的配置信息就可以保存在EEPROM里，开发板断电后配置信息不丢失，下次启动，开发板自动读取EEPROM的校准配置信息，就不需要重新校准。
2 s4 U' ^% J. i2 l' i4 T( m
* ^2 z' N2 x/ [1 S$ H% X+ ?EEPROM和Flash的本质上是一样的，Flash包括MCU内部的Flash和外部扩展的Flash，本开发板就有一个SPI接口的外部Flash（W25Q64），在后面SPI接口再讲解。从功能上，Flash通常存放运行代码，运行过程中不会修改，而EEPROM存放用户数据，可能会反复修改。从结构上，Flash按扇区操作，EEPROM通常按字节操作。两者区别这里不再过多赘述，读者理解EEPROM在嵌入式中扮演的角色即可。
7 V+ i* n  s: T5 v, N* x  l- C


结构组成
9 u; x) ~. j( }3 f
+ v$ I/ x! P# B! z* J' UEEPROM类型众多，其中比较常见是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。
) t2 M0 M5 e- @7 Z. e! [( n3 k" h

9 j. @) s1 X. @* C" }# W

图 16.1.6 AT24C02结构示意图

! F: |' T5 W( z
设备地址  
  G# Y5 j/ H! f
  \5 C: T  p5 g& o, _& W( Z: GI²C设备都会有一个设备地址，不同容量的AT24C02，设备地址定义会有所差异，由芯片数据手册《AT24Cxx.pdf》可知，如图 16.1.7 所示。

+ I8 w2 B- `& J) R$ b9 B' Q+ I& y  {
1 k( l# ]- C& S0 B4 U& y

图 16.1.7 AT24Cxx设备地址定义

AT24C02的容量为2K，对应上图中的第一行，高四位固定为“1010”，中间三位由A2、A1、A0引脚的电平决定，比如A2~0引脚全接地，则值为“000”，最后的最低位为读写位，0代表写命令，1代表读命令。
, O5 v0 j+ J0 Y4 r+ \2 \
A2、A1、A0引脚电平需要由原理图决定，假设全接电源地，则如果需要向AT24C02写数据，则发送地址“1010 0000”，如果需要向AT24C02读数据，则发送地址“1010 0001”。

1 S1 e( E2 ~% C/ l7 f假设开发板有多个AT24C02挂在同一I²C总线上，通过这个规则，只需设计电路时，让A2、A1、A0引脚电平不同，即可区分两个AT24C02。
+ |9 s- N# q# e4 J2 p
+ E: w) R0 H7 ]5 ^) h: n9 a对于容量再大一点的AT24Cxx系列，比如AT24C04，器件地址由A2、A1引脚决定，数据空间有P0决定。比如对AT24C04的0~2K空间操作，则P0为0，对2K~4K空间操作，则P0为1。



写AT24Cxx  
/ Q* \9 h! m( J
AT24Cxx支持字节写模式和页写模式。字节写模式是一个地址一个数据的写；页写模式是连续写数据，一个地址多个数据的写，但是页写模式不能自动跨页，如果超出一页长度，超出的数据会覆盖原先写入的数据。
2 M) O* j3 {6 A3 ~: b: j' t  n
如图 16.1.8 所示，为AT24Cxx字节写模式的时序，在MCU发出开始信号（Start）后，发出8 Bit的设备地址信息（图中读写位为低电平，即写数据），待收到AT24Cxx应答信号后，再发出要写的数据地址，再次等待AT24Cxx应答，最后发出8 Bit数据写数据，待AT24Cxx应答后，发出停止信号（Stop），完成一次单字节写数据。
1 E7 A* ]! x* f, |/ |% u

1 I$ z/ x0 O" m
, i# e+ l* a. e# M) {1 _8 B' E7 C8 g

图 16.1.8 AT24Cxx字节写模式时序

" }, G, E+ |5 w8 ^: T' @% IAT24C02容量为2K，因此数据地址范围为0x00~0xFF，即0~255，每个数据地址每次写1Byte，即8bit，也就刚好256*8=2048Bit。对于1K容量的产品，数据地址范围为0x00~0x7F，最高位不会用到，因此图中数据地址的最高位为“*”，意思是对于1K容量的产品，该位无需关心。
5 X) p$ a$ H1 P

. @6 h& l  l5 k" U! Y8 N

图 16.1.9 单字节写模流程图

- Q; t3 l0 `$ p  G1 Y) f图 16.1.10 为AT24Cxx的页写模式时序，与字节写模式的差异在于，不是只发送1Byte数据，而是任意多个。需要注意，该模式不能跨页写，遇到跨页时，需要重新发送完整的时序。

' f  K- h/ e+ C6 n. C

' {) T# Q8 R5 K% T+ t/ V& Q

图 16.1.10 AT24Cxx页写模式时序

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

" e& @' Z; P% B

9 c; Y7 ?7 U- i  d% g9 D  T0 U  [

图 16.1.11 AT24Cxx写间隔

读AT24Cxx
) g: W7 s- U" Z0 B
( f3 q1 p" V9 h; h7 }AT24Cxx支持当前地址读模式、随机地址读模式和顺序读模式。当前地址读模式就是在上一次读/写操作之后的最后位置，继续读出数据，比如上次读/写在地址n，接下来可以直接从n+1处读出数据；随机地址读模式是指定数据地址，然后读出数据；顺序读模式是连续读出多个数据。

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

9 Y* d, [' D7 p* a; L( u

图 16.1.12 AT24Cxx当前地址读模式

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

# i$ Q9 ~: z$ k5 N0 Z" n* r
8 ]- j  S. U8 N1 x& r/ w

图 16.1.13 AT24Cxx随机地址读模式

& z# Q0 d6 n3 M. {
' _: C9 Q2 H6 v  Y' i8 J  o7 p
在顺序读模式下，需要先从当前地址读模式或随机地址读模式启动，随后便可连续读多个数据，时序如图 16.1.14 所示

5 T  @' j* G0 D0 {" K+ [+ M) |2 x
/ r5 g1 i) l* \7 E1 o. g/ t

图 16.1.14 AT24Cxx顺序读模式

# i. p6 g4 [5 y% T1 y1 B) n/ L



6 H0 h5 }! T- f- V" u' N9 F; J+ R16.2 硬件设计
  C' |# L. a9 D如图 16.2.1 为开发板EEPROM部分的原理图，U6为AT24C02芯片，它的A0、A1、A2都接地，因此该设备地址为“1010 000X”，当读该设备时，X为1，写该设备时，X为0。
, t' A7 _% r# |+ H& j+ C
U4的7脚为写保护引脚（Write Protect，WP），当该引脚为高，则禁止写AT24C02，这里直接拉低WP，任何时候都可直接写AT24C02。

此外，I2C的两个脚SCL和SDA都进行了上拉处理，从而保证I2C总线空闲时，两根线都必须为高电平。如果没有上拉，在主机发送完数据后，放开SDA，此时SDA的电平状态不确定，可能为高，也可能为低，无法确定是从机拉低给出应答信号。
8 J+ I1 T1 H' J$ x8 X; k
结合原理图可知，PB6作为了I2C1的SCL，PB7作为了I2C1的SDA。
8 @. t9 c( m" n

% @* k' `- u; @2 _

图 16.2.1 EEPROM模块原理图

$ g. z& N1 h# _( q1 [
# q3 }4 V9 U- {9 [
16.3 软件设计
16.3.1 软件设计思路

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

1) 引脚初始化：GPIO端口时钟使能、GPIO引脚设置为输入/输出模式（PB6、PB7）；

2) 封装I2C每个环节的时序函数：起始信号、响应信号、读写数据、停止信号；

3) 使用I2C协议函数，实现对AT24C02的读写；
5 P0 P  `4 B, `
7 e+ x2 j3 K! `& i% v$ w& ?' }4) 主函数，每按一次按键，写一次AT24C02，接着读出来验证是否和写的数据一致；
' w9 ^. \7 z6 J
本实验配套代码位于“5_程序源码\8_通信—模拟I2C\”。
# u6 K2 T* [; N9 k


16.3.2 软件设计讲解

1) GPIO选择与接口定义

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

1 Q" H# j; B4 Q& ]8 d( S代码段 16.3.1 模拟I2C引脚相关定义（driver_i2c.h）

1. /************************* I2C 硬件相关定义 *************************/
   
2. 
   
3. #define ACK                 (0)
   
4. 
   9 k: Q/ F* S4 Q! F& d( z# p7 x
5. #define NACK                (1)
   8 w1 @- [3 j- `4 s3 {
6. 
   6 M8 ?8 ]& y$ c
7. 
   * K6 ?) @# x& c( _; f
8. 
   # F% V" e( p+ ?# _1 ~
9. #define SCL_PIN             GPIO_PIN_6
   
10. 
    
11. #define SCL_PORT            GPIOB
    ) N6 h; _& l7 q5 h
12. 
    
13. #define SCL_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    : p" o' C1 g" v
14. 
    
15. 
    $ T" g& u# s+ `$ ^2 i+ m4 g* E
16. 
    ' w7 C* Y9 p+ |$ g
17. #define SDA_PIN             GPIO_PIN_7
    
18. 
    
19. #define SDA_PORT            GPIOB
    
20. 
    
21. #define SDA_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    
22. 
    
23. 
    
24. 
    
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)
    
28. 
    + ?7 G- P* }4 y! ^" N3 u
29. #define SCL_INPUT()         HAL_GPIO_ReadPin(SCL_PORT, SCL_PIN)
    $ w+ P3 ]* w3 l" x% J% O" x
30. 
    
31. 
    
32. 
    / |' h, q/ H! x) f; w4 ~
33. #define SDA_H()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_SET)
    ) n0 C9 m; L2 K  v
34. 
    6 A& q" @: \, ~* E
35. #define SDA_L()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_RESET)
    
36. 
    3 F% m5 k- N2 P  A! F
37. #define SDA_INPUT()         HAL_GPIO_ReadPin(SDA_PORT, SDA_PIN)

复制代码

& z1 j# G/ y. w7 T  B; ~! l( B接着将两个GPIO引脚初始化，使能引脚时钟，先默认设置为输出模式。SCL引脚为时钟信号，始终为输出模式，SDA引脚为数据引脚，可能输出或者输入，因此还需要编写函数实现输入、输出的切换，如代码段 16.3.2 所示。

8 o4 u- K1 k$ F1 V代码段 16.3.2 I2C引脚初始化（driver_i2c.c）

1. /*
   
2. *  函数名：void I2C_Init(void)
   
3. *  输入参数：
   
4. *  输出参数：无
     h# P9 V: X4 F+ H  O6 N
5. *  返回值：无
   ! D6 p+ z! {, }2 W  B0 N) P3 F% w- `
6. *  函数作用：初始化模拟I2C的引脚为输出状态且SCL/SDA都初始为高电平
   
7. */
   
8. void I2C_Init(void)
   , }! x; @5 G$ v% C4 Q4 k/ w# Q
9. {
   ; ^  w6 @' e3 M0 O' i6 v3 d3 e
10.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
11. 
    
12.     SCL_PIN_CLK_EN();
    ; k: c3 O8 m! `3 ^
13.     SDA_PIN_CLK_EN();
    
14. 
    
15.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    % u: l; X- k' v" ~
16.     GPIO_InitStruct.Pull      = GPIO_NOPULL;
    & l2 K: `  J, w& [& V' N/ H2 J
17.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    " @/ \3 Y. w7 a4 {1 ?. N. d% z; ?
18. 
      f8 t2 l+ V, b6 k+ E* R9 Y2 C
19.     GPIO_InitStruct.Pin       = SCL_PIN;
    
20.     HAL_GPIO_Init(SCL_PORT, &GPIO_InitStruct);
    
21. 
    
22.     GPIO_InitStruct.Pin       = SDA_PIN;
    
23.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    0 t. S6 {1 E) l- z  u+ L) Z, C) Q
24. 
    0 |' p9 F, B* o- Y& K$ I. R
25.     SCL_H();
    8 k& J! P7 _" b
26.     SDA_H();
    
27. }
    
28. 
    
29. /*
    : |& x9 r3 J' O, @! k, _3 {
30. *  函数名：static void I2C_SDA_OUT(void)
    
31. *  输入参数：
    
32. *  输出参数：无
    2 w) q" y$ V; N3 v  o+ z1 U/ Q
33. *  返回值：无
    
34. *  函数作用：配置SDA引脚为输出
    
35. */
    & i# y( _; T# ]8 q
36. static void I2C_SDA_OUT(void)
    1 _: Z6 [9 h! ~
37. {
    
38.     GPIO_InitTypeDef GPIO_InitStruct = {0};
      H7 p% b% P  o9 V3 L
39. 
    
40.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    
41.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    
42.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    
43. 
    % p' \& T+ c  G$ D4 T2 x3 t2 B
44.     GPIO_InitStruct.Pin       = SDA_PIN;
    
45.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    
46. }
    
47. 
    
48. /*
    
49. *  函数名：static void I2C_SDA_IN(void)
      t0 r/ Z" q5 D
50. *  输入参数：
    
51. *  输出参数：无
    
52. *  返回值：无
    ) B' Y+ O3 n- s
53. *  函数作用：配置SDA引脚为输入
    2 F% K1 d5 P* T4 p9 q
54. */
    ) H* L" ?9 `3 U- d
55. static void I2C_SDA_IN(void)
    , G. l7 n1 w0 G  |' L" Y
56. {
    . G! M; l  y8 I+ `" U
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    ' i$ R% Y  O: p$ I- M
58. 
    
59.     GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
    : a, l$ e5 o) X
60.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    " \$ E5 o* K9 g: ~: Q' {; j. d
61. 
    
62.     GPIO_InitStruct.Pin       = SDA_PIN;
    
63.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    2 Q, w2 \6 n2 e# ~
64. }

复制代码

6 z+ c0 B9 G9 ~4 W$ H2) I2C时序函数

4 [+ h% I) i* z& \: G开始信号/结束信号

/ {7 y+ G6 a% x$ N. Q, F, f+ t9 T, R参考前面图 16.1.3 所示的开始信号和结束信号编写程序。对于开始信号，首先将SDA和SCL都拉高，随后SDA拉低，再SCL拉低。对于结束信号，首先拉低SDA，拉高SCL，再拉低SDA，代码如代码段 16.3.3 所示。
5 a7 M; H, J* U2 O2 @, K
! s: j2 c2 ~- j; j代码段 16.3.3 I2C开始信号和结束信号（driver_i2c.c）
$ ^; ?5 X' n; W! S# o
1 x& r4 R7 z5 T3 G9 v

1. /*
   , ~) J2 ~9 ]; F! B" R4 |' \
2. *  函数名：void I2C_Start(void)
   
3. *  输入参数：
   ) G8 l$ q: Q4 e6 T- ]: L( d, |+ ]
4. *  输出参数：无
   
5. *  返回值：无
   - D8 C8 i0 D6 J9 J$ z
6. *  函数作用：I2C开始信号
   2 C8 e2 H# C( C6 U: U$ X
7. */
   
8. void I2C_Start(void)
   ( l0 d8 I. R( f( n
9. {
   , N6 D4 s2 t  t$ a# T: I5 J/ X
10.     I2C_SDA_OUT();
    / K1 b$ _! T# p$ P
11. 
    + o4 k" h+ Z8 C  j7 f5 m
12.     SCL_H();
    # _2 ^5 C& v$ r+ N# x3 ~3 x' q# Z
13.     I2C_Delay();
    
14. 
    , E3 l: b: k& W9 c8 {. g
15.     SDA_H();
    ; I$ C1 N6 R: N1 F7 z7 e. m9 U
16.     I2C_Delay();
    ! Z8 _, G: S: K* H6 ^
17. 
    / j3 d! T9 P1 C5 S+ x
18.     SDA_L();
    1 Q  Y' ]6 c* `& r  U
19.     I2C_Delay();
    
20. 
    
21.     SCL_L();
    
22.     I2C_Delay();
    ; X: R) ~% i( U- ^. m, U' u# ~
23. }
    
24. 
    
25. /*
    
26. *  函数名：void I2C_Stop(void)
    5 y6 y+ `2 g7 l3 J  |: P
27. *  输入参数：
    
28. *  输出参数：无
    
29. *  返回值：无
    
30. *  函数作用：I2C停止信号
    
31. */
    . O( H, D0 U" o: ]5 n
32. void I2C_Stop(void)
    : _1 V% D1 S6 E' h
33. {
    
34.     I2C_SDA_OUT();
    
35. 
    $ t% T) w, w7 G( y
36.     SDA_L();
    ' b5 V* S3 p% z* s5 |" D! m
37.     I2C_Delay();
    
38. 
    
39.     SCL_H();
    
40.     I2C_Delay();
    
41. 
    8 Q, G! z& s+ V# y- l
42.     SDA_H();
    : G, `+ E- I/ Q+ k9 ^: [
43.     I2C_Delay();
    
44. }

复制代码

3 P8 J  c/ @/ g5 ~) c应答信号/非应答信号/等待应答信号

参考前面图 16.1.4 所示，编译应答信号，如代码段 16.3.4 所示。
& k, P, u$ I' F( K$ k% W
' I4 O2 _0 h) w; l4 V0 v1 D代码段 16.3.4 应答/非应答/等待应答信号（driver_i2c.c）
$ x* U! L8 T9 j4 q" G' v6 L

1. /*
   
2. *  函数名：void I2C_ACK(void)
   
3. *  输入参数：
   / a6 A  ?; @2 e
4. *  输出参数：无
   
5. *  返回值：无
   # p$ b$ C7 Z5 H
6. *  函数作用：I2C发出应答信号
   $ p* k, k# G+ f/ G" ~
7. */
   . V' V' l* T/ H( I
8. void I2C_ACK(void)
   
9. {
   3 T; }) X1 P- g- S
10.     I2C_SDA_OUT();
    
11. 
    
12.     SCL_L();
    
13.     I2C_Delay();
    + O6 h# y. I8 q: j+ E% i; u
14. 
    . |+ ^- Z# K% b
15.     SDA_L();
    
16.     I2C_Delay();
    
17. 
    
18.     SCL_H();
    
19.     I2C_Delay();
    
20. 
    - i; {( o, W$ r2 Z7 M. ?9 c# J0 ]
21.     SCL_L();
    $ B, Y3 C' k( ]* s, R
22.     I2C_Delay();
    $ I1 T. f  V9 M% I3 a' I: m
23. }
    9 ?4 }: x2 ~. Z, Q) S% y& Z  ]
24. 
    3 o0 {/ k9 f7 V7 k5 g; a
25. /*
    
26. *  函数名：void I2C_NACK(void)
    " C) J& t5 |7 [; d/ R
27. *  输入参数：
    
28. *  输出参数：无
    
29. *  返回值：无
    8 F& o7 w+ m) ^6 v1 b
30. *  函数作用：I2C发出非应答信号
    
31. */
    
32. void I2C_NACK(void)
    & ~* B( n: m" j; L& v9 X
33. {
    * g# d  g* e9 g/ |
34.     I2C_SDA_OUT();
    
35. 
    
36.     SCL_L();
    
37.     I2C_Delay();
    
38. 
    
39.     SDA_H();
    
40.     I2C_Delay();
    " Z  ^  P5 m- s5 t1 x' N/ f: [/ f
41. 
    
42.     SCL_H();
    - l2 d4 a; b9 G  `$ p
43.     I2C_Delay();
    8 [9 t3 [) q2 `! Z# q
44. 
    
45.     SCL_L();
    / y$ n* p3 s* E& V7 M7 t
46.     I2C_Delay();
    
47. }
    
48. 
    
49. /*
    - A: ]3 {& p2 l* W- n: c. \9 P
50. *  函数名：uint8_t I2C_GetACK(void)
    1 N2 E# W8 L: h7 l) N
51. *  输入参数：
    
52. *  输出参数：无
    
53. *  返回值：1无应答，0有应答
    3 N- e/ n5 _* n( {2 H
54. *  函数作用：I2C等待从机的应答信号
    * Z, ^  Y$ q$ q7 X' H4 c
55. */
    : w/ f) N! D/ Q! e
56. uint8_t I2C_GetACK(void)
    ( e" L, I) C) y: u2 r6 ?6 [
57. {
    6 g- _2 h! l# `: b0 Y
58.     uint8_t time = 0;
    
59.     I2C_SDA_IN();
    0 |" h4 V! T! h+ _& I1 c" p5 b
60. 
    ) c* N" p: D- V) N" s6 ]/ x
61.     SCL_L();
    
62.     I2C_Delay();
    1 |8 g" I( K: p2 q
63. 
    
64.     SDA_H();
    1 l5 F+ c- e/ @3 e& p5 |& w- P
65.     I2C_Delay();
    % q& b6 d" s7 m7 P
66. 
    3 z1 V6 q# e  k; R0 M9 v+ }; {, n
67.     SCL_H();
    
68.     I2C_Delay();
    $ }9 Y8 n& o- ^+ ^% k9 U
69. 
    
70.     while(SDA_INPUT())
    0 U7 v! q% S7 _9 K+ W: f1 A
71.     {
    4 M7 O! |: m" ~+ @8 z
72.         time++;
    . `4 l4 w" O. {3 E. p# i
73.         if(time>250)
    
74.         {
    
75.             SCL_L();
    
76.             return 1;
    
77.         }
    
78.     }
    
79.     SCL_L();
    " H2 X1 S: \( Z" h6 @
80. 
    
81.     return 0;
    
82. }

复制代码

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

! G8 V& g+ |+ Q3 x; M2 B32~47行：非应答信号，在一个SDA时钟周期里，将SCL拉高；
, B/ v. K9 V, r
0 c* E6 Y. x; h# ~1 I+ b- {& t( k# u56~82行：等待应答信号，拉高SDA后放开SDA，读取SDA是否被拉低，如果拉低返回0，否则返回1；
4 O2 R4 ]! r1 ~, A- r
7 g) T+ @+ ]5 x! n5 Y3 ?# @
( W- @' W8 i! n
0 k8 X5 C. F7 O5 ]) F发送/接收函数
+ p, [+ E& e+ x  x+ G
6 b7 B& A9 v. I- ^+ e, p* `- j最后还剩发送/接收函数，如代码段 16.3.5 所示。对于发送函数，控制SDA产生8个时钟周期，每个时钟周期里控制SDA高低电平发送1位数据。对于接收函数，控制SDA产生8个时钟周期，每个时钟周期里读取SDA高低电平接收1位数据。

代码段 16.3.5 发送/接收函数（driver_i2c.c）
/ z' f* F& F% z
! T  Y3 h& E! k  |( I
) p& w6 w0 }1 V) }- j& X

1. /*
   
2. *  函数名：void I2C_SendByte(uint8_t data)
   
3. *  输入参数：data->发送的数据
   $ I3 A3 ~5 Q3 @5 A
4. *  输出参数：无
   
5. *  返回值：无
   9 C- V0 H$ b& s% l8 I- ]" n$ B
6. *  函数作用：I2C发送一个字节
   8 r7 D8 h" A, g) X
7. */
   
8. void I2C_SendByte(uint8_t data)
   9 C( {$ B2 n! s* k' G
9. {
   ; Q$ `7 Z6 _/ E# @) M
10.     uint8_t cnt = 0;
    ! o$ O9 g/ J$ m% @& z6 K% p
11. 
    
12.     I2C_SDA_OUT();
    
13. 
    : S( c9 B% R$ P$ t- T/ o
14.     for(cnt=0; cnt<8; cnt++)
    6 Z) K. ]* @! m# R% b4 k* G' |
15.     {
    2 y& Q" @4 `- @! A
16.         SCL_L();
    
17.         I2C_Delay();
    
18. 
    
19.         if(data & 0x80)
    - X+ `  r9 X" ^
20.         {
    " z# C, u- Q2 i, X: T* z
21.             SDA_H();
    
22.         }
    
23.         else
    
24.         {
    
25.             SDA_L();
    
26.         }
    7 j/ a- R; A8 K0 W" n  P
27.         data = data<<1;
    
28.         SCL_H();
    # P. t0 i' g$ f: P
29.         I2C_Delay();
    
30.     }
    
31. 
    
32.     SCL_L();
    
33.     I2C_Delay();
    
34.     I2C_GetACK();
    ; z& m9 p3 O% Z/ f, U/ n
35. }
    
36. 
    ' j/ u. N* N6 D0 O' V
37. /*
    - O" Z: O: o  u$ ~0 ^
38. *  函数名：uint8_t I2C_ReadByte(uint8_t ack)
    0 Z/ n: C* Z; @9 h6 r" Z8 ~$ i) K: V
39. *  输入参数：ack->发送的应答标志，1应答，0非应答
      M" I3 |9 A! k3 P
40. *  输出参数：无
    
41. *  返回值：返回读到的字节
    ) J8 [2 o/ w6 \6 b
42. *  函数作用：I2C读出一个字节
    
43. */
    
44. uint8_t I2C_ReadByte(uint8_t ack)
    , C) S. T3 X) S3 k2 D" x  Y* }
45. {
    
46.     uint8_t cnt;
      @, b1 n* Z2 }$ [
47.     uint8_t data = 0xFF;
    
48. 
    
49.     SCL_L();
      X9 J2 b/ q2 v) u7 x+ ^' i( Q
50.     I2C_Delay();
    
51. 
    
52.     for(cnt=0; cnt<8; cnt++)
    
53.     {
    
54.         SCL_H();                 //SCL高(读取数据)
    
55.         I2C_Delay();
    
56. 
    
57.         data <<= 1;
    9 H: w- N, z% j4 K- I! d. p
58.         if(SDA_INPUT())
    
59.         {
    
60.             data |= 0x01;        //SDA高(数据为1)
    
61.         }
    
62.         SCL_L();
    
63.         I2C_Delay();
    
64.     }
    
65.     //发送应答信号，为低代表应答，高代表非应答
    
66.     if(ack == 0)
    ! ]2 N& ~  p& o5 }  d: A7 p
67.     {
    0 c* l! z- V: \' B
68.         I2C_ACK();
    
69.     }
    ) R0 v: e, v, L5 r3 ?" l$ t
70.     else
    & H* S  x0 J) S% L3 H
71.     {
    / M5 c4 v& H: @4 {( p/ m7 |4 q2 E
72.         I2C_NACK();
    
73.     }
    
74.     return data;                 //返回数据
    
75. }

复制代码

% r. Y8 l# c/ \0 W) \! r14~31行：循环8次，每次循环：

16行：先拉低SCL；
% g2 M9 p; n0 y" j
19~26行：将输入的数据data与0x08且运算，得到最高位的值，从而控制SDA输出对应的高、低电平;

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

9 b9 |% j5 s; r! w* N8 p+ u2 i0 l29行：拉高SCL，让SDA处于稳定期，从设备即可获取SDA的值；

35行：等待从设备的应答信号；
4 ~/ }1 c; o1 i! o; l
: y2 ^. V+ a: R* V- _; E4 u53~65行：循环8次，每次循环：
. E, ?+ M; E4 ~0 H
& u8 b/ `) r2 z) A55行：先拉高SCL，此时认为从设备控制SDA电平，处于稳定期；

58行：将data左移1位，以确保收到数据按最高位在前存放；
  j# _* T$ b; _) |0 J, I
) A* n- g/ G- M: H1 j' K59~62行：读取SDA电平，如果为高，保存到data当前最低位，否则data最低位默认为0；
. i. _( [2 ^; S3 e
$ k  G! W  A; _9 n; J' N$ Y0 Y63行：SCL拉低，此时从设备继续控制SDA电平变化
- f& _2 r; f+ d. U
( y$ G6 [7 k* w0 _66~74行：根据传入的参数，决定是否发送应答信号；
  L4 G3 R6 ^2 D  F! I' [; ~, m9 u


7 u8 _7 d* {7 E, @) Q1 s+ t7 N整个I2C协议函数中，经常用到“ I2C_Delay()”来实现SCL时钟周期。对于AT24Cxx，由其芯片手册可知，时钟脉冲宽度（Clock Pulse Width）需要大于5us，也就是SCL如果刚变为高电平，需要等待至少5us才能变为低电平，因此定义“ I2C_Delay()”为5us以上即可。

! S' X, `0 D' B5 ~0 A3 `

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

复制代码

+ t% r. q% \( i7 P' N这里的“us_timer_delay()”可以由定时器提供，也可以使用循环提供，前者精度更高，效果更好。定时器的介绍在后面章节，本章不作分析，延时函数的两者方式如代码段 16.3.6 所示。
8 [8 N% z- y* ]6 c
4 g6 w8 E% Z0 M6 o代码段 16.3.6 延时函数的实现（driver_timer.c）

1. #if 0
   2 b; P  y8 I+ |8 s3 t
2. /*
   
3. *  函数名：void us_timer_delay(uint16_t t)
   0 l+ m1 b4 Y( \- n* X
4. *  输入参数：t-延时时间us
   
5. *  输出参数：无
   
6. *  返回值：无
   
7. *  函数作用：定时器实现的延时函数，延时时间为t us，为了缩短时间，函数体使用寄存器操作，用户可对照手册查看每个寄存器每一位的意义
   ' g) }: \5 I0 l! X
8. */
   ) s4 V6 k  v6 x
9. void us_timer_delay(uint16_t t)
   9 f: ^, j9 N6 d) c7 x5 \, P6 X
10. {
    " C; I& y* l! t: f
11.     uint16_t counter = 0;
    " [- D5 T7 m& P6 K; f: |2 k* A
12.     __HAL_TIM_SET_AUTORELOAD(&htim, t);
    0 Y" `6 D. p: ~' S8 q+ s4 ]+ `
13.     __HAL_TIM_SET_COUNTER(&htim, counter);
    6 O$ \9 X* ^( b  a4 O
14.     HAL_TIM_Base_Start(&htim);
    8 l) [5 I* y/ I$ o3 E; l
15.     while(counter != t)
    
16.     {
    
17.         counter = __HAL_TIM_GET_COUNTER(&htim);
    
18.     }
      E: B! y) r' T' ]6 q- M* K
19.     HAL_TIM_Base_Stop(&htim);
    0 O+ j2 m/ l: x7 G3 ~$ g9 ]* s* H  x4 I
20. }
    % @1 j( e9 i/ W2 p
21. #else
    
22. /*
    
23. *  函数名：void us_timer_delay(uint16_t t)
    + @: `9 w1 V/ l5 Y: u, w% X4 d
24. *  输入参数：t-延时时间us
    
25. *  输出参数：无
    1 l+ a3 B1 a+ _/ n& ]% ?# f
26. *  返回值：无
    * h& A2 J( R, F1 {% G% ?
27. *  函数作用：延时粗略实现的延时函数，延时时间为t us
    8 u( r0 i7 {9 |2 L
28. */
    
29. void us_timer_delay(uint16_t t)
    
30. {
    3 L' G4 o4 X3 z8 @: I
31.     uint16_t counter = 0;
    ( W) L. ~7 e; s. n  E
32. 
    
33.     while(t--)
    5 j0 g+ u6 R* m6 U5 {6 t9 k8 B
34.     {
    
35.         counter=10;
    
36. 
    1 M+ v5 H( @4 e4 K! i
37.         while(counter--) ;
    
38.     }
    . M  }+ [+ |/ n6 D' D% K( B& v: p
39. }
    
40. #endif

复制代码

3) AT24C02读写函数
" R0 B. Z! _0 v
编写好I2C协议函数后，参考AT24C02手册编写读写数据函数，如代码段 16.3.7 所示。
2 \+ L3 u; B) y7 V+ V; H7 M7 d
代码段 16.3.7 读写AT24C02一字节数据（driver_eeprom.c）
, i+ t. T3 H. p+ @0 e/ l1 W1 \+ A7 Z

1. /*
   
2. *  函数名：uint8_t EEPROM_WriteByte(uint16_t addr, uint8_t data)
   , j0 R7 r: P! b
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   8 e3 W' a: M- p2 ~( F# V
4. *            data -> 要写的数据
   0 J7 e  K# Z8 s/ A" M
5. *  输出参数：无
   6 w9 x0 ~$ ?" m" ], \
6. *  返回值：无
   
7. *  函数作用：EEPROM写一个字节
   " K/ y$ ^7 I+ `
8. */
   
9. void EEPROM_WriteByte(uint16_t addr, uint8_t data)
   ( I0 G2 q6 O& S  }  Q3 N
10. {
    
11.     /* 1. Start */
    ; i, }1 ], f. N9 d  p  f& `/ e) t
12.     I2C_Start();
    
13. 
    
14.     /* 2. Write Device Address */
    * W9 a5 O8 A  c/ _2 Z; |0 s' b
15.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    9 B% Y$ `0 a& s# L! \" h1 g
16. 
    
17.     /* 3. Data Address */
    
18.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    / ~6 z. n: X8 [' u
19.     {
    
20.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
21.     }
    
22.     else
    5 D8 W: |) S) q' D9 ]$ X- k  J6 j' g
23.     {
    - w# b" p5 U+ v# w1 n$ Z
24.         I2C_SendByte( (uint8_t)(addr>>8) );
    
25.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    6 ^9 {1 e% r' @: Z& G0 v/ r# X
26.     }
    
27. 
    
28.     /* 4. Write a byte */
    
29.     I2C_SendByte(data);
    / w  O+ N* o# P; p( H  S' i$ |4 H
30. 
    
31.     /* 5. Stop */
    
32.     I2C_Stop();
    4 q- a* B# R7 V4 [' t
33. }
    
34. 
    
35. /*
    / e% X5 z3 p. ^9 x! ?' Y/ L. F
36. *  函数名：uint8_t EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    
37. *  输入参数：addr -> 读一个字节的EEPROM初始地址
      N0 P! f( o2 x+ y; Y
38. *            data -> 要读的数据指针
    - a% @- t2 l+ {# }5 @
39. *  输出参数：无
    5 C! i  P  `; K& p/ k  A; A
40. *  返回值：无
    . ]  r/ X: g2 K' v/ H: [/ H+ E
41. *  函数作用：EEPROM读一个字节
    ' [. P0 v+ @* g7 e
42. */
    
43. void EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    , X6 c1 m4 v3 T$ |3 k
44. {
    & H2 q* q/ S" B: L4 T7 c. }5 s! L
45.     /* 1. Start */
    2 s# w7 A7 o+ z: W9 H- j' D! C
46.     I2C_Start();
    " h. E, L/ U# _7 [, g: L
47. 
    2 y) A2 C6 f7 t, R) C# @
48.     /* 2. Write Device Address */
    
49.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    1 N& M4 ]+ ]& d6 [" ~
50. 
    
51.     /* 3. Data Address */
    
52.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    
53.     {
    3 K: j5 P0 _5 v' o
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) );
    
60.     }
    ! t. r/ g) G5 ]- _
61. 
    
62.     /* 4. Start Again */
    
63.     I2C_Start();
    
64. 
    " l# ?0 d7 p3 r; W0 A) h
65.     /* 5. Write Device Address Read */
    4 C1 Y$ p* ^8 q
66.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_RD );
    , ^1 v. E* {% |( `# [) @
67. 
    5 K+ z) a5 e! F# F. E% _5 g* B
68.     /* 6.Read a byte */
    
69.     *pdata = I2C_ReadByte(NACK);
    
70. 
    
71.     /* 7. Stop */
    - }/ t+ N/ `9 o8 x5 b! d" }
72.     I2C_Stop();
    ( _/ h. d7 s0 h& U% h6 }
73. }

复制代码

参加前面图 16.2.1 和图 16.1.13 所示的介绍时序，编写AT24C02一字节读写程序。

8 N  T- `" U9 }7 |# D4 o  U9~33行：写AT24C02一字节数据；
2 e+ v( H9 E- z& p; A5 o
12行：发送I2C开始信号；
3 r0 D0 v# _% \
15行：发送AT24C02的设备地址，最后一位表示写操作；

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

6 p% L- E' F6 b4 S9 X29行：发送数据；

. j% {7 q) j% U; N; C: d+ j32行：发送I2C停止信号；
5 e" v& i" \5 [% D( J/ @  x3 t
43~73行：读AT24C02一字节数据；

" i2 C  _. U6 i& L: Q1 X6 d- N9 N46行：发送I2C开始信号；

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

4 j* z6 H; i# r/ E- E5 Q8 h# b52~60行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；

63行：再次发送I2C开始信号；
8 i7 C& @' f# p4 {; S' I
66行：发送AT24C02的设备地址，最后一位表示读操作；

69行：读取AT24C02数据，且无需ACK；

72行：发送I2C停止信号；
, a8 x5 p9 C7 C/ G, W* j- z
实现了对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)
   
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   2 K1 i, D+ |6 a' T6 m
4. *            data -> 要写的数据指针
   % f- }$ u- w1 o. A. G/ l5 b  i
5. *            sz   -> 要写的字节个数
   * n: ~2 I5 K7 w0 w- ?1 B4 L
6. *  输出参数：无
   . ?1 h6 w# Y% c! |  K# n; q4 }
7. *  返回值：无
   / x! @( Q* J2 t: e, E! C+ b# X
8. *  函数作用：EEPROM写N个字节
   ( A) M- O! X% p5 B2 H. l# r8 T
9. */
   
10. void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    1 `+ {0 N% U0 Z
11. {
    / T; J! m0 `7 P: p0 k
12.     uint16_t i = 0;
    9 e; p4 m, N# w0 m  w
13. 
    : m, P! f8 V  M0 H
14.     for(i=0; i<sz; i++)
    : ]) I' G* N* z. k( m. s
15.     {
    
16.         EEPROM_WriteByte(addr, pdata<i>);
    3 {6 g# j' Q2 q: J
17.         addr++;
      z  D, W, |# M, o8 z9 p
18.         HAL_Delay(10); // Write Cycle Time 5ms
    " k# l2 z  M" ^
19.     }
    , I8 b" ?' Q. D$ ~& v0 N( t5 i" @
20. }
    / @5 k9 j, @$ l9 X' b
21. 
    
22. /*
    
23. *  函数名：void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    7 G! H& A+ ~" C- J( H4 [7 S& }9 q
24. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    
25. *            data -> 要读的数据指针
    
26. *            sz   -> 要读的字节个数
    ; D" O# @5 J$ e! n, Z" c2 b$ R
27. *  输出参数：无
    9 r% y3 }# w- N$ r
28. *  返回值：无
    5 y. |+ @* O+ i# P% w* Y2 z9 E
29. *  函数作用：EEPROM读N个字节
    0 W, t5 b8 d9 w) J8 @6 U& [- ^
30. */
    
31. void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
32. {
    ) }. z4 u! v1 {- \9 B+ y. s
33.     uint16_t i = 0;
    1 E1 H! H# S( f. e( V4 q; t/ E
34. 
    
35.     for(i=0; i<sz; i++)
    8 I- v( {& A! l4 _5 Q! Z
36.     {
    $ e/ {2 B; A! T! f- I# t
37.         EEPROM_ReadByte(addr, &pdata<i>);
    " [$ E2 q9 K* l! X
38.         addr++;
    
39.     }
    - m2 n7 V; ~- Q( t6 R; V
40. }</i></i>

复制代码

* O2 U, W, X  u8 e5 ^5 j需要注意的是，AT24Cxx每次写操作后，有一个写间隔，需要间隔5ms以上，因此在写多个字节时，每次写完都需要延时5ms以上。

0 \* w+ y6 p) B; E9 c+ _

/ s4 Z8 {% P% ~- x& u% e5 R4) 主函数控制逻辑
# V  i7 T, c, f% o
6 y6 C3 @; X: A$ L, `, [在主函数里，每按一下按键，调用“EEPROM_Write_Nbytes()”对AT24C02写一串数据，再调用“EEPROM_Read_Nbytes()”读出该数据，如代码段 16.3.9 所示。

% Y: U, S7 O# L  \1 B! Y代码段 16.3.9 主函数控制逻辑（main.c）
' i8 b% E+ g) }8 X% w) u$ ^
3 W* b$ }/ l% {. a9 {

1. // 初始化I2C
   & g+ g/ w6 C/ [$ [; z' O/ h
2.    I2C_Init();
   
3. 
   
4.    while(1)
   9 t9 Y3 F# i+ V
5.    {
   " h; u8 \5 |3 B+ \! m
6.        if(key_flag) // 按键按下
   1 d3 a" F* Q0 j: d: X
7.        {
   
8.            key_flag = 0;
   ! K% ^7 h' J( ~. }. [1 x0 e
9. 
   3 N9 |( V3 o5 M# r- V$ E6 j
10.            printf("\n\r");
    
11.            printf("Start write and read eeprom.\n\r");
    6 c0 A+ _% m0 g( H
12. 
    
13.            // 读写一串字符，并打印
    - Z2 }( `7 i8 X5 q/ i/ A3 u- \
14.            EEPROM_Write_NBytes(0, tx_buffer, sizeof(tx_buffer)); // 写数据
    
15.            HAL_Delay(1);
    
16. 
    , T& v3 [1 c5 t
17.            EEPROM_Read_NBytes(0, rx_buffer, sizeof(tx_buffer));  // 读数据
    - `, ~; v" a; v! J
18.            HAL_Delay(1);
    
19. 
    3 v% t; r* H, q3 a; X8 n- J
20.            printf("EEPROM Write: %s\n\r", tx_buffer);
    " [  n" r. E2 w8 I( C7 z6 d1 l: s
21.            printf("EEPROM Read : %s\n\r", rx_buffer);
    
22. 
    ( C/ w, q7 i& m& E
23.            memset((uint8_t*)rx_buffer, 0, sizeof(rx_buffer));   // 清空接收的数据
    - W- b8 K9 Q8 p' P
24.        }
    
25. }
    

复制代码

. _( s0 E! c1 B$ B- ], P$ g
& z3 g7 W8 t5 P1 S8 S) [16.4 实验效果
4 T5 \/ H( n; u- C! r; }( A, C" q本实验对应配套资料的“5_程序源码\8_通信—模拟I2C\”。打开工程后，编译，下载，按下按键KEY，即可看到串口如图 16.4.1 所示。
8 u2 Y+ S5 X+ z/ F

( i& ]+ T: Q% M$ D% J2 P3 |% f& V

图 16.4.1 模拟I2C读写AT24C02数据

. F- w( s( |: F0 b! m" x
作者：攻城狮子黄
. L9 V" N) \* R( a2 v: c, N
8 }* ^+ ^% J1 n