16.1 关于I2C
16.1.1 I2C协议

I²C（Inter-Integrated Circuit），常读作“I方C”,它是一种多主从架构串行通信总线。在1980年由飞利浦公司设计，用于让主板、嵌入式系统或手机连接低速周边设备。如今在嵌入式领域是非常常见通信协议，常用于MPU/MCU与外部设备连接通信、数据传输。
* p  U, A9 y+ _
2 _7 w& L7 Z) d3 j+ _7 x1 [% g* }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工作效率相对较高。
6 E( d  q# ]# |/ x7 J: ~+ A
% j6 F. o0 _" j3 }6 D7 W* z关于I²C协议，通过下面例子进行一个形象的比喻方便大家理解，如图 16.1.1 所示，老师（MCU）将球（数据）传给众多学生中的一个（众多外设设备中的一个）。
4 v- z8 ?4 R* O8 f
3 a0 q$ o* Q4 z& C! ^


* n4 Q: p7 V3 Q+ z图 16.1.1 I²C协议比喻

" N) y0 A( u9 a) Y/ E. s7 G1 i( d首先老师将球踢给某学生，即主机发送数据给从机，步骤如下：

4 V4 h% H0 f! D& Y# Q* j1) 老师：开始了(start)；
! t0 w% F1 V! I$ n
2) 老师：A！我要发球给你！(地址/方向)；

3) 学生A：到！(回应)；
9 Z9 Q2 _1 E7 a# D- Z) Y. @: O9 M
- D  S" E4 o/ H4) 老师把球发出去（传输）；

+ n* D% h, Q# `4 n5) A收到球之后，应该告诉老师一声（回应）；
2 d8 Y& }6 X: G, `9 G# H0 U
6) 老师：结束（停止）；
4 e: f$ c! ]5 e) x* e) @
# s1 [2 Z' j! A! Y

6 X" p/ b3 i9 {接着老师让学生把球传给自己，即从机发送数据给主机，步骤如下：
- p! U) P6 T: g5 q4 Z  ~) s
; A' r. L; _+ i$ p0 B1) 老师：开始了(start)；

9 n3 N& r% s) x2 [* U5 @) ]  Y2) 老师：B！把球发给我！(地址/方向)；
8 D0 ~6 p# Y$ _; t/ P5 m
1 O. ~& @* ]5 U4 [3) 学生B：到！
' _4 r6 q$ \! t* Z* i6 [
( ~3 p( B- I0 q- T6 l3 r. g4) B把球发给老师（传输）；

5) 老师收到球之后，给B说一声，表示收到球了（回应）；
* t& V1 H7 x& H( f, r- {) A0 h
6) 老师：结束（停止）。
. ]1 h/ _- V& s8 I
: n4 s1 F4 S' E3 c7 D  F- t
从上面的例子可知，都是老师（主机）主导传球，按照规范的流程（通信协议），以保证传球的准确性，收发球的流程总结如下：

0 F0 _# ]  j4 i$ E$ F3 e① 老师说开始了，表示开始信号(start)；
) a) F' O5 }0 U+ \  l/ F1 i
% j2 K: ^4 y5 r② 老师提醒某个学生要发球，表示发送地址和方向(address/read/write)；

③ 该学生回应老师(ack)；

) {/ L# I9 z7 y3 X④ 老师发球/接球，表示数据的传输；
0 `: S/ W' F6 S9 F- p
) e+ ^8 E2 s8 ?⑤ 收到球要回应：回应信号(ACK)；
% C5 \! K  B- I
⑥ 老师说结束，表示IIC传输结束(P)。
# d: h3 y5 Y+ O$ ~' K& ~
$ x5 c4 D9 g: C
" }, X( S: Y+ _* p* m( {2 p% Z- V以上就是I²C的传输协议，如果是软件模拟I²C，需要依次实现每个步骤。因此，还需要知道每一步的具体细节，比如什么时候的数据有效，开始信号怎么表示。

: o* o) a( i- E$ s9 F, S
, z3 V- m; x2 D, M7 Q$ z数据有效性

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


, G, v$ S+ U; o' \, R6 I! o
图 16.1.2 数据有效性


2 Q3 @+ Z3 L# Q; P! w- `3 L开始信号和结束信号
) a" k) f5 C7 j/ ?) n$ F
) \* T# Q) N: fI²C起始信号（S）：当SCL高电平时，SDA由高电平向低电平转换；
. R) U; z6 e/ ]- N
I²C停止信号（P）：当SCL高电平时，SDA由低电平向高电平转换；
4 v2 `3 ?/ }9 A/ u# |


+ L/ |3 O! ?5 u6 [2 @1 P图 16.1.3 开始信号和结束信号
6 r4 w3 J+ w/ M% [

! b, Z$ _% @, L! c, p* @应答信号                          
5 Y  |, M0 u: K8 Y: L( ~' b
I²C每次传输的8位数据，每次传输后需要从机反馈一个应答位，以确认从机是否正常接收了数据。当主机发送了8位数据后，会再产生一个时钟，此时主机放开SDA的控制，读取SDA电平，在上拉电阻的影响下，此时SDA默认为高，必须从机拉低，以确认收到数据。



+ c, b9 O- y( t9 x/ Z# p+ O图 16.1.4 数据传输格式和应答信号
. w+ {, K$ t1 C, V

6 F2 J- }7 J  h4 ^& d% g: n7 S' b完整传输流程  

I²C完整传输流程如下：
& z6 Q! X* V' a7 `$ M+ G
; O5 [, ~0 R. k- V1 U① SDA和SCL开始都为高，然后主机将SDA拉低，表示开始信号；

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

1 h1 m# k5 r" l" T: N③ 总线中对应从机地址的设备，发出应答信号；

5 b  t! S9 m8 w* `& x8 h④ 在接下来的8个时间周期里，如果是写操作，则主机控制SDA的高低；如果是读操作，则从机控制SDA的高低；

$ T* [( _% L$ m3 c⑤ 每次传输完成，接收数据的设备，都发出应答信号；

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

% o3 G) r  W/ S, F( b

* W& E. \0 S, m7 e图 16.1.5 I2C传输时序

4 q+ S3 F; R0 D
, Z+ V' \8 E/ g1 n5 k; H16.1.2 EEPROM介绍
, t3 Y: c- r4 @" c/ M
( k5 Y" _3 d# p# qEEPROM的全称是“电可擦除可编程只读存储器”，即Electrically Erasable Programmable Read-Only Memory。通常用于存放用户配置信息数据，比如在开发板首次运行时，需要屏幕校准，校准后的配置信息就可以保存在EEPROM里，开发板断电后配置信息不丢失，下次启动，开发板自动读取EEPROM的校准配置信息，就不需要重新校准。

, |4 K+ e1 t2 Y7 y9 wEEPROM和Flash的本质上是一样的，Flash包括MCU内部的Flash和外部扩展的Flash，本开发板就有一个SPI接口的外部Flash（W25Q64），在后面SPI接口再讲解。从功能上，Flash通常存放运行代码，运行过程中不会修改，而EEPROM存放用户数据，可能会反复修改。从结构上，Flash按扇区操作，EEPROM通常按字节操作。两者区别这里不再过多赘述，读者理解EEPROM在嵌入式中扮演的角色即可。
% x6 r' _- s: D! i" \7 @

" }. \: V/ z; y结构组成

EEPROM类型众多，其中比较常见是AT24Cxx系列，从命名上看，AT24Cxx中xx的单位是K Bit，如AT24C08，其存储容量为8K Bit。本开发板上的EEPROM型号为AT24C02，其存储容量为2K Bit，2*1024=2048 Bit。
6 K1 v' _8 y( }$ a
9 d; j& o+ z! H; H; X$ V对于AT24C01/02，每页大小为8 Byte，对于AT24C04/08/16，每页大小为16 Byte。如图 16.1.6 所示，AT24C02由32页（Page）组成，每一页由8个字节（Byte）组成，每个Byte由8位（Bit）组成，Bit为最小存储单位，存放1个0或1。



3 S  {. g5 k2 T6 I4 h$ V; T& K# Q/ r图 16.1.6 AT24C02结构示意图


* {! y  P* k1 U! t; P设备地址  

I²C设备都会有一个设备地址，不同容量的AT24C02，设备地址定义会有所差异，由芯片数据手册《AT24Cxx.pdf》可知，如图 16.1.7 所示。
* N8 ~! _) A+ Q/ C2 J

% N6 B. E+ J6 V7 ~+ A; h
& a7 Q5 \$ u9 K6 G6 P6 b8 X) g图 16.1.7 AT24Cxx设备地址定义
2 {7 `# E# K& w. `
3 \: [; }* X$ P% Y- o0 h! G
$ T2 Z! m$ E6 _. O! y/ |AT24C02的容量为2K，对应上图中的第一行，高四位固定为“1010”，中间三位由A2、A1、A0引脚的电平决定，比如A2~0引脚全接地，则值为“000”，最后的最低位为读写位，0代表写命令，1代表读命令。

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

假设开发板有多个AT24C02挂在同一I²C总线上，通过这个规则，只需设计电路时，让A2、A1、A0引脚电平不同，即可区分两个AT24C02。

对于容量再大一点的AT24Cxx系列，比如AT24C04，器件地址由A2、A1引脚决定，数据空间有P0决定。比如对AT24C04的0~2K空间操作，则P0为0，对2K~4K空间操作，则P0为1。


写AT24Cxx  
" D) ~1 H' e1 A( I+ U
AT24Cxx支持字节写模式和页写模式。字节写模式是一个地址一个数据的写；页写模式是连续写数据，一个地址多个数据的写，但是页写模式不能自动跨页，如果超出一页长度，超出的数据会覆盖原先写入的数据。

如图 16.1.8 所示，为AT24Cxx字节写模式的时序，在MCU发出开始信号（Start）后，发出8 Bit的设备地址信息（图中读写位为低电平，即写数据），待收到AT24Cxx应答信号后，再发出要写的数据地址，再次等待AT24Cxx应答，最后发出8 Bit数据写数据，待AT24Cxx应答后，发出停止信号（Stop），完成一次单字节写数据。
3 h/ Z* t2 w9 @. `+ a


图 16.1.8 AT24Cxx字节写模式时序
) v2 q. M7 S% s2 I6 U' OAT24C02容量为2K，因此数据地址范围为0x00~0xFF，即0~255，每个数据地址每次写1Byte，即8bit，也就刚好256*8=2048Bit。对于1K容量的产品，数据地址范围为0x00~0x7F，最高位不会用到，因此图中数据地址的最高位为“*”，意思是对于1K容量的产品，该位无需关心。
5 H  o/ l( M. W9 a; e

( a( i9 \5 P7 j( R5 ]
  h5 n  Z$ y( e$ ]; v图 16.1.9 单字节写模流程图
! x4 k& f. I8 Y6 N$ u
图 16.1.10 为AT24Cxx的页写模式时序，与字节写模式的差异在于，不是只发送1Byte数据，而是任意多个。需要注意，该模式不能跨页写，遇到跨页时，需要重新发送完整的时序。


3 ~; h/ [- }: a* R+ Y  b  v0 s0 T
图 16.1.10 AT24Cxx页写模式时序
( V6 U- M0 ^+ k3 y" u
值得一提的是，《AT24Cxx.pdf》里提到每次写完之后，再到下次写之前，需要间隔5ms时间，以确保上次写操作在芯片内部完成，如图 16.1.11 所示。



  J, d/ K! @, C. z8 \3 E图 16.1.11 AT24Cxx写间隔
, y: P5 V6 d$ p# y6 P' X

读AT24Cxx
" b0 G% n- B/ ^8 Q3 s) D. E- o# d! X
- u- H1 M  q2 Q  lAT24Cxx支持当前地址读模式、随机地址读模式和顺序读模式。当前地址读模式就是在上一次读/写操作之后的最后位置，继续读出数据，比如上次读/写在地址n，接下来可以直接从n+1处读出数据；随机地址读模式是指定数据地址，然后读出数据；顺序读模式是连续读出多个数据。
2 m2 @$ T4 v, k0 `) N, o* y
在当前地址读模式下，无需发送数据地址，数据地址为上一次读/写操作之后的位置，时序如图 16.1.12 所示，注意在结尾，主机接收数据后，无需产生应答信号。
, L* F  Z) Z# \  S


7 R! a+ F* X4 a) v' _3 N. l3 v图 16.1.12 AT24Cxx当前地址读模式

在随机地址读模式下，需要先发送设备地址，待读的数据地址，接着再重新发出开始信号，设备地址，读出数据，时序如图 16.1.13 所示。
  R: X- X' H7 D4 r1 L2 [
, Q2 O% y# c$ c8 C3 i  Y

! j  f; p" r6 X- s图 16.1.13 AT24Cxx随机地址读模式

( X% w2 m4 |5 _/ ^: x# Z# t1 {
5 c; b. p0 T- C* G; c在顺序读模式下，需要先从当前地址读模式或随机地址读模式启动，随后便可连续读多个数据，时序如图 16.1.14 所示


% \9 {; C- }% H4 ]( b8 s4 l
& p; d3 n2 t6 y& z4 @: Y& O+ c% T图 16.1.14 AT24Cxx顺序读模式
( S) q& [/ r0 F

16.2 硬件设计
如图 16.2.1 为开发板EEPROM部分的原理图，U6为AT24C02芯片，它的A0、A1、A2都接地，因此该设备地址为“1010 000X”，当读该设备时，X为1，写该设备时，X为0。

4 W9 m4 x) c. T+ FU4的7脚为写保护引脚（Write Protect，WP），当该引脚为高，则禁止写AT24C02，这里直接拉低WP，任何时候都可直接写AT24C02。

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

9 x( D- i! r7 F! A* R9 x结合原理图可知，PB6作为了I2C1的SCL，PB7作为了I2C1的SDA。
, [: N4 U/ R/ z& `

% e/ S2 C7 f) N8 q
! v0 M5 ?) Y* _3 f图 16.2.1 EEPROM模块原理图
) l  T  u! l5 o  K
% }/ }  h. s4 d+ b6 G* u% S) o- z; i
* O( T5 s5 J( R+ P5 ]) d1 ?16.3 软件设计
/ [6 i$ V! E1 d* r16.3.1 软件设计思路

8 n; ?8 Q/ B6 c1 ~实验目的：本实验通过GPIO模拟I2C总线时序，对EEPROM设备AT24C02进行读写操作。
  f0 V( ~. L0 C
' `+ k; t8 |) P, ?# ~2 w: j1) 引脚初始化：GPIO端口时钟使能、GPIO引脚设置为输入/输出模式（PB6、PB7）；
, B/ E( ?8 D  M. d
+ w/ R- D* w4 v2 \2) 封装I2C每个环节的时序函数：起始信号、响应信号、读写数据、停止信号；
# o( e* S# T! I
3) 使用I2C协议函数，实现对AT24C02的读写；

* [% z/ q& S( V- u! B4) 主函数，每按一次按键，写一次AT24C02，接着读出来验证是否和写的数据一致；

本实验配套代码位于“5_程序源码\8_通信—模拟I2C\”。


16.3.2 软件设计讲解

! [" n8 ~& w, h6 }# J1) GPIO选择与接口定义
# t; J: ?6 g: [! u0 U2 F6 U8 s
2 L" L7 W! u) y0 m2 u首先定义SCL和SDA引脚，引脚的高低电平宏定义，如代码段 16.3.1 所示。

代码段 16.3.1 模拟I2C引脚相关定义（driver_i2c.h）
" r: L) @0 ]  s3 R' _  M6 F3 V' y) w
1 ^9 l4 n0 E" H' `

1. /************************* I2C 硬件相关定义 *************************/
   
2. 
   " u. U4 w) K7 q" X
3. #define ACK                 (0)
   
4. 
   9 U* Z- @8 o& y- Q: e
5. #define NACK                (1)
   
6. 
   
7. 
   
8. 
   & n, f( D$ f1 g7 m7 u2 q4 _  J6 s
9. #define SCL_PIN             GPIO_PIN_6
   1 B+ {6 ], r* Q6 V4 y& y+ ?
10. 
    , S' Y: G2 |3 N' e% h2 e$ s( G
11. #define SCL_PORT            GPIOB
    
12. 
    
13. #define SCL_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    
14. 
    
15. 
    ) [+ O* U$ ?4 f$ A" M" `1 c
16. 
    0 n# \' @( V, s$ Z  z* U
17. #define SDA_PIN             GPIO_PIN_7
    
18. 
    
19. #define SDA_PORT            GPIOB
    
20. 
    & t  `7 X$ r- b2 ~
21. #define SDA_PIN_CLK_EN()    __HAL_RCC_GPIOB_CLK_ENABLE()
    9 j+ o( U1 [9 D
22. 
    
23. 
    2 [, }: t& \/ y7 M6 s3 w
24. 
    ' E6 s7 W' g" J$ h" B5 n  I
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. 
    8 H6 t" t' I# {, B0 I/ {- [9 c
29. #define SCL_INPUT()         HAL_GPIO_ReadPin(SCL_PORT, SCL_PIN)
    
30. 
    $ C) U* F; r' Q6 T9 ]
31. 
    $ q/ j8 V7 S& [( j! h
32. 
    $ T2 w* \9 c/ V) a
33. #define SDA_H()             HAL_GPIO_WritePin(SDA_PORT, SDA_PIN, GPIO_PIN_SET)
    7 @9 e6 ^+ r  T4 j9 ^  T+ i
34. 
    . s2 o+ m8 F! A! ]! P) S5 T) B" T# Z
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 `# z/ G% [( ?4 V; X5 R接着将两个GPIO引脚初始化，使能引脚时钟，先默认设置为输出模式。SCL引脚为时钟信号，始终为输出模式，SDA引脚为数据引脚，可能输出或者输入，因此还需要编写函数实现输入、输出的切换，如代码段 16.3.2 所示。

$ m% \$ C% e7 K& `  J( h  ]+ W代码段 16.3.2 I2C引脚初始化（driver_i2c.c）

/ C8 Z' z4 w- D  v

1. /*
   / Z: J) B+ b7 Q8 A, Q5 g! H
2. *  函数名：void I2C_Init(void)
   
3. *  输入参数：
   & h( ]3 {# J& g0 H- i: c% a% h' H
4. *  输出参数：无
   
5. *  返回值：无
   
6. *  函数作用：初始化模拟I2C的引脚为输出状态且SCL/SDA都初始为高电平
   3 \/ X6 t2 K* d( M; O
7. */
   
8. void I2C_Init(void)
   % N. t1 W/ g1 c6 |6 y: ~8 |; E
9. {
   
10.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    / V' a! N/ {6 |
11. 
    
12.     SCL_PIN_CLK_EN();
    ' p* E' U) W) A
13.     SDA_PIN_CLK_EN();
    
14. 
    3 ^: b7 |' M. d. c
15.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    : a4 h' g& ~0 u7 u
16.     GPIO_InitStruct.Pull      = GPIO_NOPULL;
    . V5 b0 t9 O0 C+ {+ I; _% R- e$ a
17.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    9 l: o' x6 n. Z1 m; S6 W
18. 
    
19.     GPIO_InitStruct.Pin       = SCL_PIN;
    9 }, |. C; L) w, K  k
20.     HAL_GPIO_Init(SCL_PORT, &GPIO_InitStruct);
    
21. 
    
22.     GPIO_InitStruct.Pin       = SDA_PIN;
    ' W. G% [. @5 a) @) i! q
23.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    
24. 
    
25.     SCL_H();
    
26.     SDA_H();
    
27. }
    
28. 
    
29. /*
    ! R3 L" x/ t* M; {& X) M
30. *  函数名：static void I2C_SDA_OUT(void)
    ! F, G  F* U- z- `) E! \" v) Y' E
31. *  输入参数：
    
32. *  输出参数：无
    ( ~" `7 b5 m' ^5 r/ s6 }# X
33. *  返回值：无
    - A. r6 [, s6 r* R
34. *  函数作用：配置SDA引脚为输出
    
35. */
    $ E5 E& \% F9 u/ `
36. static void I2C_SDA_OUT(void)
    
37. {
    
38.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    + @+ |5 H, D3 }1 U0 L, T: k9 s; ~; D
39. 
    
40.     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    
41.     GPIO_InitStruct.Pull      = GPIO_PULLUP;
    / ^* Q3 u* \2 a/ \5 [2 X7 z/ o8 u
42.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    ) Y* N% a8 E* G: ^3 h4 N: B
43. 
    
44.     GPIO_InitStruct.Pin       = SDA_PIN;
    1 Z3 u% x- l9 t& |4 ], X7 A
45.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    ' `/ U) V% o5 Q8 T4 ~" c* S  J7 Y
46. }
    2 m9 Y! r1 P# h8 L$ y
47. 
    + l- P, K) n* Q7 ~6 s4 N0 k" L( Q
48. /*
    ( J$ [! v, f" \$ Z+ [/ i
49. *  函数名：static void I2C_SDA_IN(void)
    
50. *  输入参数：
    
51. *  输出参数：无
    & D0 a: r, t' @- h
52. *  返回值：无
    # e5 f& l: w. t
53. *  函数作用：配置SDA引脚为输入
    
54. */
    
55. static void I2C_SDA_IN(void)
    
56. {
    ) P' K/ N( f5 @. X9 v
57.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
58. 
      E$ ]0 v5 t$ I6 U2 y  B. j
59.     GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
    
60.     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    ) T+ h4 H+ _% P1 W+ o  D
61. 
    
62.     GPIO_InitStruct.Pin       = SDA_PIN;
    * o+ P) b, p4 h1 P! _, W, B' S
63.     HAL_GPIO_Init(SDA_PORT, &GPIO_InitStruct);
    # |1 m8 k& b% ~. k* f; r1 i
64. }

复制代码

1 ^+ j) L7 ]2 E2) I2C时序函数
8 Z! A2 ~! d+ H- h8 f# q, F% x' S
+ L/ D0 |+ a; ^8 }开始信号/结束信号
- O. x: ~5 v! i7 t" `" ^  T' U
参考前面图 16.1.3 所示的开始信号和结束信号编写程序。对于开始信号，首先将SDA和SCL都拉高，随后SDA拉低，再SCL拉低。对于结束信号，首先拉低SDA，拉高SCL，再拉低SDA，代码如代码段 16.3.3 所示。

代码段 16.3.3 I2C开始信号和结束信号（driver_i2c.c）

1. /*
   ' c. ?$ Z) i+ _0 H
2. *  函数名：void I2C_Start(void)
   . [5 M* U2 p+ _/ ]
3. *  输入参数：
   ' L2 T0 c* K- A" B" o& z
4. *  输出参数：无
   
5. *  返回值：无
   
6. *  函数作用：I2C开始信号
   / l3 N1 G4 T" J$ D' f
7. */
   0 i: c7 B. T9 b6 c: l" ?3 I
8. void I2C_Start(void)
   + U0 f! ~- |: N. U
9. {
   $ \+ p" E/ Z, L8 T& s
10.     I2C_SDA_OUT();
    : t) C: s& u( e" ?% ]
11. 
    
12.     SCL_H();
    9 y/ k; ~8 U9 @4 a8 i5 b
13.     I2C_Delay();
    
14. 
    
15.     SDA_H();
    " I4 e. [. S6 H! N- G
16.     I2C_Delay();
    
17. 
    
18.     SDA_L();
    
19.     I2C_Delay();
    : u, @' x4 |: j8 o4 c) @
20. 
    
21.     SCL_L();
    ! |! N$ H" W$ ^, z* V9 l0 J
22.     I2C_Delay();
    % f8 b, ~/ H5 F8 B+ G0 O& v
23. }
    
24. 
    ' B4 z' h' ?' R+ H+ W3 k
25. /*
      _+ p7 x8 c$ j* |6 e# h/ N
26. *  函数名：void I2C_Stop(void)
    
27. *  输入参数：
    % `( u" ]( `- C' `! h, Z( l
28. *  输出参数：无
    + E- M" x  X( Q8 w' M( {, B( z
29. *  返回值：无
    
30. *  函数作用：I2C停止信号
    
31. */
    
32. void I2C_Stop(void)
    8 G6 C+ K* Q0 H3 a( f" J
33. {
    . |& M; J7 ~8 B; ?9 G' S
34.     I2C_SDA_OUT();
    . s$ ]/ B5 C3 M$ u6 U
35. 
    7 {) \2 u8 A. I4 I, n& B0 B0 |; h
36.     SDA_L();
    
37.     I2C_Delay();
    8 h" D7 X7 Y9 d, I/ c, U
38. 
    
39.     SCL_H();
    
40.     I2C_Delay();
    
41. 
    
42.     SDA_H();
    
43.     I2C_Delay();
    3 x  {# W1 k6 e6 K( l+ |+ g
44. }

复制代码

应答信号/非应答信号/等待应答信号
# o6 M  Q! |, i! B
( B0 T7 ]. ?5 d2 D" r) `参考前面图 16.1.4 所示，编译应答信号，如代码段 16.3.4 所示。

0 w) T# Z( q+ U/ C* i' O1 l代码段 16.3.4 应答/非应答/等待应答信号（driver_i2c.c）

1. /*
   1 Q# J) h& R. C% \
2. *  函数名：void I2C_ACK(void)
   4 }  J9 P: b8 F7 i
3. *  输入参数：
   
4. *  输出参数：无
   ! l  J7 O/ t1 l+ S& S
5. *  返回值：无
   # t& Q) }1 ]% D1 _' ^
6. *  函数作用：I2C发出应答信号
   6 I; W3 p8 I0 w( J5 i
7. */
   
8. void I2C_ACK(void)
   
9. {
   ! I0 Z& ]9 h* s( Z
10.     I2C_SDA_OUT();
    5 L; l; A, q; s0 t* J
11. 
    
12.     SCL_L();
    3 I. Y, O1 U# g% `1 c
13.     I2C_Delay();
    3 e1 E( u0 `; E' L' a8 T
14. 
    
15.     SDA_L();
    
16.     I2C_Delay();
    
17. 
    
18.     SCL_H();
    
19.     I2C_Delay();
    " H8 @/ j2 t( r2 v/ h3 t# _  W
20. 
    + F) e9 N/ m( ?0 Z% F3 |
21.     SCL_L();
    
22.     I2C_Delay();
      A6 Y, ]4 H8 C4 y4 p8 [
23. }
    9 M: t1 P9 M% Z$ J7 r
24. 
    
25. /*
    
26. *  函数名：void I2C_NACK(void)
    8 }% [. H8 T$ v! y3 @9 a! }5 p& m3 c
27. *  输入参数：
    
28. *  输出参数：无
    7 D0 s8 i9 \. H1 d6 @! [! j2 P
29. *  返回值：无
    
30. *  函数作用：I2C发出非应答信号
    
31. */
    & T# \3 G$ i6 V. H# v) D% J
32. void I2C_NACK(void)
    2 {5 E" r% B1 @$ a* W2 M
33. {
    7 }' @% }- B% _- ]" m6 O8 M
34.     I2C_SDA_OUT();
    
35. 
      t- p5 ^/ _3 ^* R* d+ r4 n- j9 Q3 @
36.     SCL_L();
    
37.     I2C_Delay();
    
38. 
    
39.     SDA_H();
    
40.     I2C_Delay();
    
41. 
    ; q: H9 U. K; H
42.     SCL_H();
    ) L+ C! u5 q) E# s& b& c7 B
43.     I2C_Delay();
    ( T) W$ ~2 w1 s4 Q! m/ q
44. 
    
45.     SCL_L();
    
46.     I2C_Delay();
    
47. }
    6 n7 P/ O; `9 C7 P
48. 
    ) R- e! e4 w/ V
49. /*
    
50. *  函数名：uint8_t I2C_GetACK(void)
    
51. *  输入参数：
    
52. *  输出参数：无
    / c2 J2 B5 g; v5 J$ h7 J
53. *  返回值：1无应答，0有应答
    4 t! o7 w" k; p: ?$ |; f% Z' s
54. *  函数作用：I2C等待从机的应答信号
    7 K. U. \) S: P: c" M' x
55. */
    
56. uint8_t I2C_GetACK(void)
    $ I$ s# E; M+ V9 B
57. {
    2 J/ @  Y/ l$ B( O1 B1 @
58.     uint8_t time = 0;
    1 s  m+ B* q; i. T; n0 ?3 l
59.     I2C_SDA_IN();
    
60. 
    9 }$ s6 T4 A; }/ }
61.     SCL_L();
    
62.     I2C_Delay();
    0 s3 R  r/ |5 B9 M0 p
63. 
    - j" H$ m, f! o) p& x5 l) r
64.     SDA_H();
    
65.     I2C_Delay();
    
66. 
    : z* V6 l9 {( S# K0 j, x4 @+ f" r
67.     SCL_H();
    
68.     I2C_Delay();
      o  y3 M- n. {- ?
69. 
    
70.     while(SDA_INPUT())
    
71.     {
    
72.         time++;
    5 Z1 C6 X$ u/ k( ]1 a
73.         if(time>250)
    " X0 ?% S6 V4 f5 n) ~! ?, r0 s
74.         {
    
75.             SCL_L();
    
76.             return 1;
    
77.         }
    ) ?( X0 Y: v1 N, Q' {
78.     }
    
79.     SCL_L();
      w3 Y- p( k; Q
80. 
    * }% r9 y1 Q7 K/ A  ^) M) L
81.     return 0;
    7 f2 S, F( t' R; P# b
82. }

复制代码

5 P) L9 N  E+ S& {6 o, J4 j8~23行：应答信号，在一个SDA时钟周期里，将SCL拉低；
& O2 g0 F3 |+ O% i# r- A
% Z7 @* z2 o0 T( b+ Q$ `32~47行：非应答信号，在一个SDA时钟周期里，将SCL拉高；
* M' H' S/ U* o+ w
4 P. s2 m1 V1 F  C6 l  z56~82行：等待应答信号，拉高SDA后放开SDA，读取SDA是否被拉低，如果拉低返回0，否则返回1；

& ^% c" b- L1 H. p, Z( I; u1 ?9 N
( r, O; W) `' `- m; G; K发送/接收函数
( ^( w, V; e$ t, R
6 H0 N1 \5 N$ R% u% B+ o! `最后还剩发送/接收函数，如代码段 16.3.5 所示。对于发送函数，控制SDA产生8个时钟周期，每个时钟周期里控制SDA高低电平发送1位数据。对于接收函数，控制SDA产生8个时钟周期，每个时钟周期里读取SDA高低电平接收1位数据。

5 R; F" _/ D6 e7 M1 \5 ]6 j代码段 16.3.5 发送/接收函数（driver_i2c.c）
" E% I$ y1 J8 G- B
7 T  F3 g: C' H

1. /*
   3 o$ S& S7 u" J2 \/ ^# |7 y
2. *  函数名：void I2C_SendByte(uint8_t data)
   0 ?( I/ Z8 {$ B$ X( s! e5 }& s( |
3. *  输入参数：data->发送的数据
   7 @1 I- J9 n7 M; _9 t7 p- X- D
4. *  输出参数：无
   : C, r0 Y8 o* z& Z
5. *  返回值：无
   
6. *  函数作用：I2C发送一个字节
   
7. */
   % n! K7 Y4 t0 Y7 A& T0 e
8. void I2C_SendByte(uint8_t data)
   ' E$ a4 b7 ~9 `0 M- l: `9 [! D* J
9. {
   
10.     uint8_t cnt = 0;
    - s  o/ R. L. y" |4 @$ Z7 Z
11. 
    ' g5 o6 j0 O; S. ^
12.     I2C_SDA_OUT();
    
13. 
    
14.     for(cnt=0; cnt<8; cnt++)
    
15.     {
      u8 _' ^5 D* B: X6 N
16.         SCL_L();
    / _1 U) W8 @% g% W  L/ G
17.         I2C_Delay();
    6 j  I. Q6 n6 i3 _$ k" u2 h
18. 
    $ m' k7 P/ A* ?* h& l/ F4 }* n
19.         if(data & 0x80)
    
20.         {
    ( w% z8 ~# D4 I
21.             SDA_H();
    7 r: V4 G& R1 a5 ]
22.         }
    % u: f3 ~0 p0 `$ D2 G9 m; U
23.         else
    : ~8 @, p4 Y4 h4 m: m+ ^! L" j) k$ O
24.         {
    
25.             SDA_L();
    7 {+ s5 V# C/ Z& i
26.         }
    & _# h4 C2 |1 Q& E+ H& ]* }
27.         data = data<<1;
    
28.         SCL_H();
    
29.         I2C_Delay();
    5 V# X) |9 I0 }1 F7 t
30.     }
    7 h1 i9 J: X+ @* b4 P. ]
31. 
    
32.     SCL_L();
    
33.     I2C_Delay();
    
34.     I2C_GetACK();
    7 _1 j5 j9 K' U; z( H, a; d
35. }
    
36. 
    
37. /*
    4 y! G4 ~% g- S
38. *  函数名：uint8_t I2C_ReadByte(uint8_t ack)
    . |- I6 ]* G3 m5 t, r; X
39. *  输入参数：ack->发送的应答标志，1应答，0非应答
    $ }& N8 ^5 q6 [5 S, g
40. *  输出参数：无
    6 j& |9 N+ _' _4 ]0 f+ J8 G. z3 r
41. *  返回值：返回读到的字节
    ; Z' O* c0 N# t$ H% I- t( r
42. *  函数作用：I2C读出一个字节
    
43. */
    . C/ p) Q! n# W3 `2 m
44. uint8_t I2C_ReadByte(uint8_t ack)
    
45. {
    & [, J/ s( j! ]- C# }
46.     uint8_t cnt;
    
47.     uint8_t data = 0xFF;
    
48. 
    / n9 z/ b( O( Z" t2 l) K. L. F
49.     SCL_L();
    
50.     I2C_Delay();
    
51. 
    
52.     for(cnt=0; cnt<8; cnt++)
    
53.     {
    0 o3 n* ^) i  s& `! K2 Y
54.         SCL_H();                 //SCL高(读取数据)
    / d6 e( z) W1 g3 `$ J
55.         I2C_Delay();
    
56. 
    1 }% R% Q/ ^4 _5 _$ o4 S% T# o
57.         data <<= 1;
    
58.         if(SDA_INPUT())
    8 e$ U0 d9 O: V% f% G+ S
59.         {
    
60.             data |= 0x01;        //SDA高(数据为1)
    8 f& T1 y9 D/ Q5 i
61.         }
    / |1 w' v/ y7 Y' f/ x
62.         SCL_L();
    
63.         I2C_Delay();
    
64.     }
    
65.     //发送应答信号，为低代表应答，高代表非应答
    5 C3 [1 K5 D/ o" F2 Y
66.     if(ack == 0)
    6 H0 S- D5 u- ?; B4 h9 L
67.     {
    
68.         I2C_ACK();
    
69.     }
    
70.     else
    
71.     {
    5 H3 d: F7 u: ^% g1 o
72.         I2C_NACK();
    % z+ @8 Y. K$ `- m; M, ~; m
73.     }
    ! h2 Y( H  p" I2 ^2 |
74.     return data;                 //返回数据
    
75. }

复制代码

14~31行：循环8次，每次循环：

16行：先拉低SCL；
  F. h0 x! j, G( p0 e+ A+ u
8 `% M! O, Y! ]19~26行：将输入的数据data与0x08且运算，得到最高位的值，从而控制SDA输出对应的高、低电平;
. s+ U. a! y; A) B
27行：将data左移一位，得到次高位；
+ T* Z8 K9 R; C, Z  k( x
9 t6 f0 j/ f1 ~1 F6 |29行：拉高SCL，让SDA处于稳定期，从设备即可获取SDA的值；

35行：等待从设备的应答信号；
/ v8 H5 y( x/ E
2 d: L3 _$ K4 l7 O9 d+ d0 H) G+ o53~65行：循环8次，每次循环：
  [  S- E) U; j& G4 r6 e
55行：先拉高SCL，此时认为从设备控制SDA电平，处于稳定期；
# N+ N3 a9 N( p, a! E9 F
58行：将data左移1位，以确保收到数据按最高位在前存放；

& P/ v3 k4 D. d' F9 y0 _  t7 a: O! Z/ P59~62行：读取SDA电平，如果为高，保存到data当前最低位，否则data最低位默认为0；

63行：SCL拉低，此时从设备继续控制SDA电平变化
% J- F. }0 H8 u; ?
* {+ x6 B6 |% t66~74行：根据传入的参数，决定是否发送应答信号；

* ^$ \0 Y+ s" K( X1 ?整个I2C协议函数中，经常用到“ I2C_Delay()”来实现SCL时钟周期。对于AT24Cxx，由其芯片手册可知，时钟脉冲宽度（Clock Pulse Width）需要大于5us，也就是SCL如果刚变为高电平，需要等待至少5us才能变为低电平，因此定义“ I2C_Delay()”为5us以上即可。
9 W" v  p6 ]( ~! e  G/ W

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

复制代码

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

) |, N" M+ h% T9 n1 r) y代码段 16.3.6 延时函数的实现（driver_timer.c）
" e# c5 e' ]( A+ _$ j* y. C# U

1. #if 0
   
2. /*
   
3. *  函数名：void us_timer_delay(uint16_t t)
   
4. *  输入参数：t-延时时间us
   
5. *  输出参数：无
   2 J3 L2 Y5 ^$ K; m7 R7 l3 o
6. *  返回值：无
   6 z6 i: W) h/ p/ V# k1 L0 W
7. *  函数作用：定时器实现的延时函数，延时时间为t us，为了缩短时间，函数体使用寄存器操作，用户可对照手册查看每个寄存器每一位的意义
   ( q" Y1 j0 S+ t: c
8. */
   3 |4 C# B4 l9 e! _, B3 t" }$ f
9. void us_timer_delay(uint16_t t)
   ! q1 V2 N- V; }9 ~# F9 k, S
10. {
      y/ }/ x& y3 T2 b& F; h+ ?* X
11.     uint16_t counter = 0;
    - E+ Z* {, p5 v, m* b
12.     __HAL_TIM_SET_AUTORELOAD(&htim, t);
    8 m* S( K% |) p$ ?1 ?
13.     __HAL_TIM_SET_COUNTER(&htim, counter);
    & @9 V) T( u" z8 S) \, e8 C$ S7 r
14.     HAL_TIM_Base_Start(&htim);
    8 \, N  b  H' S) |: S1 O0 f
15.     while(counter != t)
    % G/ D+ j0 g0 w5 O& u) B+ A
16.     {
    
17.         counter = __HAL_TIM_GET_COUNTER(&htim);
    
18.     }
    
19.     HAL_TIM_Base_Stop(&htim);
    % ?& O: f2 b, b  q7 i9 \
20. }
    
21. #else
    
22. /*
    ) C6 c4 x( V# T/ Z  L1 t
23. *  函数名：void us_timer_delay(uint16_t t)
    
24. *  输入参数：t-延时时间us
    
25. *  输出参数：无
    
26. *  返回值：无
    
27. *  函数作用：延时粗略实现的延时函数，延时时间为t us
    7 [. Q6 K- A! l5 b- f
28. */
    
29. void us_timer_delay(uint16_t t)
    
30. {
    & j! q/ ~! J4 U, N: _" [
31.     uint16_t counter = 0;
    : P; X- f* M4 P3 k8 O3 X& Y
32. 
    % j& U4 {6 {3 k+ b6 L" V
33.     while(t--)
    
34.     {
    $ w* Q0 U% h- N1 |$ H
35.         counter=10;
    
36. 
    1 l8 g2 t! o2 X- j
37.         while(counter--) ;
    
38.     }
    
39. }
    2 r' c. a& `6 t/ ^
40. #endif

复制代码

- L$ L* z( }+ n# W! o. S* G& m6 U3) AT24C02读写函数

) k" n: J* s3 z$ X编写好I2C协议函数后，参考AT24C02手册编写读写数据函数，如代码段 16.3.7 所示。

代码段 16.3.7 读写AT24C02一字节数据（driver_eeprom.c）

, p1 r6 @7 g1 v. D0 S

1. /*
   
2. *  函数名：uint8_t EEPROM_WriteByte(uint16_t addr, uint8_t data)
   . j0 E+ B6 o9 f
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   
4. *            data -> 要写的数据
   ( }# g) `/ D1 ?- D
5. *  输出参数：无
   
6. *  返回值：无
   
7. *  函数作用：EEPROM写一个字节
   0 H. ]) @7 G3 P
8. */
   : \& E) N' C/ e8 u; J! @  t
9. void EEPROM_WriteByte(uint16_t addr, uint8_t data)
   
10. {
    2 D5 V) @* k/ X8 K" a$ d
11.     /* 1. Start */
    
12.     I2C_Start();
      S5 a. s5 L/ s5 K! D
13. 
    
14.     /* 2. Write Device Address */
    
15.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    ! t7 X' \. m) }1 H% U$ B6 `
16. 
    + _  T! H% u# f$ Z" H& ]+ [
17.     /* 3. Data Address */
    
18.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    
19.     {
    , B* |* L  \  l7 |/ G/ f! j, h
20.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    ; l, H& ~. F( g- P
21.     }
    
22.     else
    : m  ~, `5 V& x+ s- w
23.     {
    0 G. I5 T' D9 j6 L- }. y5 a
24.         I2C_SendByte( (uint8_t)(addr>>8) );
    
25.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    , r$ Q. `: Q  T8 I5 N' d
26.     }
    
27. 
    5 e% M0 C: o* g, l% E8 S: G; l/ Z" b
28.     /* 4. Write a byte */
    , Z& B- u; |  q( q% R
29.     I2C_SendByte(data);
    % z/ q+ f* t2 U/ H" [' [7 f
30. 
    
31.     /* 5. Stop */
    
32.     I2C_Stop();
    
33. }
    
34. 
    
35. /*
    
36. *  函数名：uint8_t EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    9 ^1 s  l8 L# K, b/ {- h
37. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    
38. *            data -> 要读的数据指针
    0 a2 K% s, T; z. Z
39. *  输出参数：无
    ; w( P2 |2 `4 K3 }6 d- X
40. *  返回值：无
    9 u2 W& q+ J5 y* z5 g% `& Z
41. *  函数作用：EEPROM读一个字节
    
42. */
    9 b$ J& r& c7 B
43. void EEPROM_ReadByte(uint16_t addr, uint8_t *pdata)
    
44. {
    
45.     /* 1. Start */
    . |2 H' ?* q* Q1 c2 B
46.     I2C_Start();
    ; h3 e: a* f& q; N! K8 M
47. 
    4 _6 H7 |5 K' D* N
48.     /* 2. Write Device Address */
    
49.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_WR );
    
50. 
    
51.     /* 3. Data Address */
    
52.     if(EEPROM_WORD_ADDR_SIZE==0x08)
    
53.     {
    ) Y% r& d' Z7 H3 W- b: U7 g4 \2 l; m" [
54.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    ( `  e/ Q+ h+ E0 \
55.     }
    7 O5 E/ K  e7 S$ {: Y( c" U
56.     else
    
57.     {
    . @, U  W+ l# m0 l1 T% q
58.         I2C_SendByte( (uint8_t)(addr>>8) );
    
59.         I2C_SendByte( (uint8_t)(addr & 0x00FF) );
    
60.     }
    
61. 
    : J5 t; K' G4 B* ~( I7 Q3 L9 p' K
62.     /* 4. Start Again */
    1 h* G6 H& ~1 M0 C4 A
63.     I2C_Start();
    # l1 d6 Q( ^! P3 K# `- S4 r; d
64. 
    
65.     /* 5. Write Device Address Read */
    5 C+ N9 O6 m9 p" g# k7 D; r$ D
66.     I2C_SendByte( EEPROM_DEV_ADDR | EEPROM_RD );
    
67. 
    
68.     /* 6.Read a byte */
    
69.     *pdata = I2C_ReadByte(NACK);
    * X, o9 }  O  Z  Q
70. 
    ) r7 p1 k& o  a2 i
71.     /* 7. Stop */
    ' N, l: N$ y- b# g
72.     I2C_Stop();
    ; c8 p2 o8 Q5 L7 ?( z2 }; ^( r
73. }

复制代码

& a+ N. R8 \$ ]; `2 }  x, T8 a
参加前面图 16.2.1 和图 16.1.13 所示的介绍时序，编写AT24C02一字节读写程序。

9~33行：写AT24C02一字节数据；
3 T! y8 e: z+ H1 v; m! {
3 @! J3 ^! o( w# f12行：发送I2C开始信号；
- k# ?7 \! `* a
15行：发送AT24C02的设备地址，最后一位表示写操作；

3 v6 G0 I- L9 F$ i+ b5 t" x18~26行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；
6 v- r; q% v& G, l! Y7 I4 t
29行：发送数据；

+ F( v- o# V# G7 I# C9 v' \32行：发送I2C停止信号；

43~73行：读AT24C02一字节数据；
  U8 u3 H( O6 f6 o5 d
  X6 S5 R  w! @3 {" {; u8 m( o46行：发送I2C开始信号；

49行：发送AT24C02的设备地址，最后一位表示写操作（接下来要写数据地址）；
7 n2 h* n8 J9 Y1 p6 X5 N9 [8 n
52~60行：根据EEPROM型号，调用不同的数据地址长度设置函数（AT24C01/02为8位，AT24C04/08/16为16位）；

63行：再次发送I2C开始信号；
# Z# ~, m& y/ J. a! s$ t
66行：发送AT24C02的设备地址，最后一位表示读操作；
( }8 [1 N& q$ n0 z  L  \/ Q
69行：读取AT24C02数据，且无需ACK；

/ B  w( ?) J, ?* a) K: @# i8 u' h/ J72行：发送I2C停止信号；
+ {- `/ H3 M) y7 V0 h
实现了对AT24C02单字节的读写，还需要实现多字节的读写。多字节读写可以通过AT24Cxx的页写模式和顺序读模式，实现多个数据的连续读写。在页写模式时，需要程序上设置，不能跨页写，这里简单处理，直接多次调用前面的单次读写即可，如代码段 16.3.8 所示。

2 i0 |% Z& d* E5 M' O3 L; m! @' g代码段 16.3.8 读写AT24C02多字节数据（driver_eeprom.c）
% R& g% r; M* ^" s. b$ p; K
, {0 r, i2 D4 |( I

1. /*
   / O" t2 B# r" B( a1 q: @/ k' N
2. *  函数名：void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
   ) ?' M# e1 G8 [! v: h
3. *  输入参数：addr -> 写一个字节的EEPROM初始地址
   ; p* x. o2 y- O5 v0 ]9 O, M  R
4. *            data -> 要写的数据指针
   ! @( ~* X3 b0 J; @
5. *            sz   -> 要写的字节个数
   - J4 G# p, J' ^* B# N0 U, N
6. *  输出参数：无
   
7. *  返回值：无
   
8. *  函数作用：EEPROM写N个字节
   ; U1 Z& g3 C$ y- U
9. */
   5 Q% e9 E$ T; i5 n5 I1 a
10. void EEPROM_Write_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
11. {
    
12.     uint16_t i = 0;
    
13. 
    
14.     for(i=0; i<sz; i++)
    * z; o/ R- I4 `& ]
15.     {
    ' _3 ?3 e6 [: Z" A( C5 E1 L. z; I
16.         EEPROM_WriteByte(addr, pdata<i>);
    
17.         addr++;
    9 ~2 k* w0 @3 G3 _3 C9 R, s
18.         HAL_Delay(10); // Write Cycle Time 5ms
    : W: e: h% m/ [
19.     }
    
20. }
    
21. 
    , u- v7 ]  C5 T
22. /*
    # k3 v( {% B+ Y# _: _9 a
23. *  函数名：void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    
24. *  输入参数：addr -> 读一个字节的EEPROM初始地址
    
25. *            data -> 要读的数据指针
    
26. *            sz   -> 要读的字节个数
    
27. *  输出参数：无
    % {( ?4 a8 X5 A, ]
28. *  返回值：无
    7 f" v; t5 v1 v1 q- K6 x% j
29. *  函数作用：EEPROM读N个字节
    
30. */
    
31. void EEPROM_Read_NBytes(uint16_t addr, uint8_t *pdata, uint16_t sz)
    9 H0 t+ _! N: V; p, n
32. {
    # u) S' o4 |% U' y5 G5 N. M" a1 _* }, D
33.     uint16_t i = 0;
    
34. 
    $ y9 l% K  Y' i, ~$ Q( ]
35.     for(i=0; i<sz; i++)
    ' M; q! G% G# ]5 }5 }) c: W- d" R
36.     {
    8 J5 `: ?; d- s8 h: o! k
37.         EEPROM_ReadByte(addr, &pdata<i>);
    
38.         addr++;
    $ E. J+ V2 i/ ]5 a- d  C
39.     }
    
40. }</i></i>

复制代码

需要注意的是，AT24Cxx每次写操作后，有一个写间隔，需要间隔5ms以上，因此在写多个字节时，每次写完都需要延时5ms以上。
$ G1 K! E9 y% K5 X% `: Q- \$ S

4) 主函数控制逻辑
' ^! {$ C" R# e6 V; w$ B
$ W5 S% e7 Y& a8 f7 w在主函数里，每按一下按键，调用“EEPROM_Write_Nbytes()”对AT24C02写一串数据，再调用“EEPROM_Read_Nbytes()”读出该数据，如代码段 16.3.9 所示。

代码段 16.3.9 主函数控制逻辑（main.c）
/ g5 P3 K% _6 y: c1 M
1 F6 C, `# a. T: F

1. // 初始化I2C
   3 S! }6 i1 W6 y( \$ U
2.    I2C_Init();
   
3. 
   
4.    while(1)
   $ a# R  `& z% Z; o; C1 W  d/ B" A
5.    {
   7 D8 J. `/ R$ r' n
6.        if(key_flag) // 按键按下
   8 O  E' M( A" b# D) G& E
7.        {
   : b4 s. ~$ u; M7 `/ f' |
8.            key_flag = 0;
   / G5 z) b$ b* S( l* p
9. 
   
10.            printf("\n\r");
    
11.            printf("Start write and read eeprom.\n\r");
    
12. 
    + U2 ^; e5 P/ Y" V2 w
13.            // 读写一串字符，并打印
    
14.            EEPROM_Write_NBytes(0, tx_buffer, sizeof(tx_buffer)); // 写数据
    0 Z  L! ]& X/ L  g& v
15.            HAL_Delay(1);
    
16. 
    
17.            EEPROM_Read_NBytes(0, rx_buffer, sizeof(tx_buffer));  // 读数据
    - j, R7 n: X" k- g
18.            HAL_Delay(1);
    
19. 
    
20.            printf("EEPROM Write: %s\n\r", tx_buffer);
    
21.            printf("EEPROM Read : %s\n\r", rx_buffer);
    ) v$ {- o5 U- T4 c  A4 r" H7 ?8 B
22. 
    
23.            memset((uint8_t*)rx_buffer, 0, sizeof(rx_buffer));   // 清空接收的数据
      l: b6 E6 X+ h/ U# C
24.        }
    % Q5 S# R  j* c8 ?  ]+ g
25. }

复制代码

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


2 S" Y2 }( ?2 ]& Q+ H0 c8 [( k
图 16.4.1 模拟I2C读写AT24C02数据

  W, y8 Z2 I  U" y
, u/ o. p9 a- \9 _( Z( ~- h6 Q0 k