24. I2C—读写EEPROM¶

本章参考资料：《STM32F4xx参考手册》、《STM32F4xx规格书》、库帮助文档《stm32f4xx_dsp_stdperiph_lib_um.chm》及《I2C总线协议》。

若对I2C通讯协议不了解，可先阅读《I2C总线协议》文档的内容学习。若想了解SMBUS，可阅读《smbus20》文档。

关于EEPROM存储器，请参考“常用存储器介绍”章节，实验中的EEPROM，请参考其规格书《AT24C02》来了解。

24.1. I2C协议简介¶

I2C 通讯协议(Inter－Integrated Circuit)是由Phiilps公司开发的，由于它引脚少，硬件实现简单，可扩展性强，不需要USART、CAN等通讯协议的外部收发设备，现在被广泛地使用在系统内多个集成电路(IC)间的通讯。

下面我们分别对I2C协议的物理层及协议层进行讲解。

24.1.1. I2C物理层¶

I2C通讯设备之间的常用连接方式见图常见的I2C通讯系统。

它的物理层有如下特点：

(1) 它是一个支持多设备的总线。 “总线”指多个设备共用的信号线。在一个I2C通讯总线中，可连接多个I2C通讯设备，支持多个通讯主机及多个通讯从机。

(2) 一个I2C总线只使用两条总线线路，一条双向串行数据线(SDA) ，一条串行时钟线 (SCL)。数据线即用来表示数据，时钟线用于数据收发同步。

(3) 每个连接到总线的设备都有一个独立的地址，主机可以利用这个地址进行不同设备之间的访问。

(4) 总线通过上拉电阻接到电源。当I2C设备空闲时，会输出高阻态，而当所有设备都空闲，都输出高阻态时，由上拉电阻把总线拉成高电平。

(5) 多个主机同时使用总线时，为了防止数据冲突，会利用仲裁方式决定由哪个设备占用总线。

(6) 具有三种传输模式：标准模式传输速率为100kbit/s ，快速模式为400kbit/s ，高速模式下可达 3.4Mbit/s，但目前大多I²C设备尚不支持高速模式。

(7) 连接到相同总线的 IC 数量受到总线的最大电容 400pF 限制。

24.1.2. 协议层¶

I2C的协议定义了通讯的起始和停止信号、数据有效性、响应、仲裁、时钟同步和地址广播等环节。

24.1.2.1. I2C基本读写过程¶

先看看I2C通讯过程的基本结构，它的通讯过程见图主机写数据到从机、图主机由从机中读数据及图 I2C通讯复合格式。

这些图表示的是主机和从机通讯时，SDA线的数据包序列。

其中S表示由主机的I2C接口产生的传输起始信号(S)，这时连接到I2C总线上的所有从机都会接收到这个信号。

起始信号产生后，所有从机就开始等待主机紧接下来广播的从机地址信号 (SLAVE_ADDRESS)。在I2C总线上，每个设备的地址都是唯一的，当主机广播的地址与某个设备地址相同时，这个设备就被选中了，没被选中的设备将会忽略之后的数据信号。根据I2C协议，这个从机地址可以是7位或10位。

在地址位之后，是传输方向的选择位，该位为0时，表示后面的数据传输方向是由主机传输至从机，即主机向从机写数据。该位为1时，则相反，即主机由从机读数据。

从机接收到匹配的地址后，主机或从机会返回一个应答(ACK)或非应答(NACK)信号，只有接收到应答信号后，主机才能继续发送或接收数据。

若配置的方向传输位为“写数据”方向，即第一幅图的情况，广播完地址，接收到应答信号后，主机开始正式向从机传输数据(DATA)，数据包的大小为8位，主机每发送完一个字节数据，都要等待从机的应答信号(ACK)，重复这个过程，可以向从机传输N个数据，这个N没有大小限制。当数据传输结束时，主机向从机发送一个停止传输信号(P)，表示不再传输数据。

若配置的方向传输位为“读数据”方向，即第二幅图的情况，广播完地址，接收到应答信号后，从机开始向主机返回数据(DATA)，数据包大小也为8位，从机每发送完一个数据，都会等待主机的应答信号(ACK)，重复这个过程，可以返回N个数据，这个N也没有大小限制。当主机希望停止接收数据时，就向从机返回一个非应答信号(NACK)，则从机自动停止数据传输。

除了基本的读写，I2C通讯更常用的是复合格式，即第三幅图的情况，该传输过程有两次起始信号(S)。一般在第一次传输中，主机通过SLAVE_ADDRESS寻找到从设备后，发送一段“数据”，这段数据通常用于表示从设备内部的寄存器或存储器地址(注意区分它与SLAVE_ADDRESS的区别)；在第二次的传输中，对该地址的内容进行读或写。也就是说，第一次通讯是告诉从机读写地址，第二次则是读写的实际内容。

以上通讯流程中包含的各个信号分解如下：

24.1.2.2. 通讯的起始和停止信号¶

前文中提到的起始(S)和停止(P)信号是两种特殊的状态，见图起始和停止信号。当 SCL 线是高电平时 SDA 线从高电平向低电平切换，这个情况表示通讯的起始。当 SCL 是高电平时 SDA 线由低电平向高电平切换，表示通讯的停止。起始和停止信号一般由主机产生。

24.1.2.3. 数据有效性¶

I2C使用SDA信号线来传输数据，使用SCL信号线进行数据同步。见图数据有效性。 SDA数据线在SCL的每个时钟周期传输一位数据。传输时，SCL为高电平的时候SDA表示的数据有效，即此时的SDA为高电平时表示数据“1”，为低电平时表示数据“0”。当SCL为低电平时，SDA的数据无效，一般在这个时候SDA进行电平切换，为下一次表示数据做好准备。

每次数据传输都以字节为单位，每次传输的字节数不受限制。

24.1.2.4. 地址及数据方向¶

I2C总线上的每个设备都有自己的独立地址，主机发起通讯时，通过SDA信号线发送设备地址(SLAVE_ADDRESS)来查找从机。 I2C协议规定设备地址可以是7位或10位，实际中7位的地址应用比较广泛。紧跟设备地址的一个数据位用来表示数据传输方向，它是数据方向位(R/)，第8位或第11位。数据方向位为“1”时表示主机由从机读数据，该位为“0”时表示主机向从机写数据。见图设备地址及数据传输方向。

读数据方向时，主机会释放对SDA信号线的控制，由从机控制SDA信号线，主机接收信号，写数据方向时，SDA由主机控制，从机接收信号。

24.1.2.5. 响应¶

I2C的数据和地址传输都带响应。响应包括“应答(ACK)”和“非应答(NACK)”两种信号。作为数据接收端时，当设备(无论主从机)接收到I2C传输的一个字节数据或地址后，若希望对方继续发送数据，则需要向对方发送“应答(ACK)”信号，发送方会继续发送下一个数据；若接收端希望结束数据传输，则向对方发送“非应答(NACK)”信号，发送方接收到该信号后会产生一个停止信号，结束信号传输。见图响应与非响应信号。

传输时主机产生时钟，在第9个时钟时，数据发送端会释放SDA的控制权，由数据接收端控制SDA，若SDA为高电平，表示非应答信号(NACK)，低电平表示应答信号(ACK)。

24.2. STM32的I2C特性及架构¶

如果我们直接控制STM32的两个GPIO引脚，分别用作SCL及SDA，按照上述信号的时序要求，直接像控制LED灯那样控制引脚的输出(若是接收数据时则读取SDA电平)，就可以实现I2C通讯。同样，假如我们按照USART的要求去控制引脚，也能实现USART通讯。所以只要遵守协议，就是标准的通讯，不管您如何实现它，不管是ST生产的控制器还是ATMEL生产的存储器，都能按通讯标准交互。

由于直接控制GPIO引脚电平产生通讯时序时，需要由CPU控制每个时刻的引脚状态，所以称之为“软件模拟协议”方式。

相对地，还有“硬件协议”方式，STM32的I2C片上外设专门负责实现I2C通讯协议，只要配置好该外设，它就会自动根据协议要求产生通讯信号，收发数据并缓存起来，CPU只要检测该外设的状态和访问数据寄存器，就能完成数据收发。这种由硬件外设处理I2C协议的方式减轻了CPU的工作，且使软件设计更加简单。

24.2.1. STM32的I²C外设简介¶

STM32的I2C外设可用作通讯的主机及从机，支持100Kbit/s和400Kbit/s的速率，支持7位、10位设备地址，支持DMA数据传输，并具有数据校验功能。它的I2C外设还支持SMBus2.0协议，SMBus协议与I2C类似，主要应用于笔记本电脑的电池管理中，本教程不展开，感兴趣的读者可参考《SMBus20》文档了解。

24.2.2. STM32的I²C架构剖析¶

24.2.2.1. 通讯引脚¶

I²C的所有硬件架构都是根据图中左侧SCL线和SDA线展开的(其中的SMBA线用于SMBUS的警告信号，I2C通讯没有使用)。 STM32芯片有多个I2C外设，它们的I2C通讯信号引出到不同的GPIO引脚上，使用时必须配置到这些指定的引脚，见表 STM32F4xx的I2C引脚。关于GPIO引脚的复用功能，可查阅《STM32F4xx规格书》，以它为准。

STM32F4xx的I2C引脚

引脚	I2C编号
	I2C1	I2C2	I2C3
SCL	PB6/PB10	PH4/PF1/PB10	PH7/PA8
SDA	PB7/PB9	PH5/PF0/PB11	PH8/PC9

注意

其中PF、PH端口在176引脚型号的芯片才有。

24.2.2.2. 时钟控制逻辑¶

SCL线的时钟信号，由I²C接口根据时钟控制寄存器(CCR)控制，控制的参数主要为时钟频率。配置I2C的CCR寄存器可修改通讯速率相关的参数：

可选择I2C通讯的“标准/快速”模式，这两个模式分别I2C对应100/400Kbit/s的通讯速率。
在快速模式下可选择SCL时钟的占空比，可选Tlow/Thigh=2或Tlow/Thigh=16/9模式，我们知道I2C协议在SCL高电平时对SDA信号采样， SCL低电平时SDA准备下一个数据，修改SCL的高低电平比会影响数据采样，但其实这两个模式的比例差别并不大，若不是要求非常严格，这里随便选就可以了。
CCR寄存器中还有一个12位的配置因子CCR，它与I2C外设的输入时钟源共同作用，产生SCL时钟，STM32的I2C外设都挂载在APB1总线上，使用APB1的时钟源PCLK1，SCL信号线的输出时钟公式如下：

标准模式：

T_high=CCR*T_PCKL1 T_low = CCR*T_PCLK1

快速模式中T:sub:`low`/T:sub:`high`=2时：

T_high = CCR*T_PCKL1 T_low = 2*CCR*T_PCKL1

快速模式中T:sub:`low`/T:sub:`high`=16/9时：

T_high = 9*CCR*T_PCKL1 T_low = 16*CCR*T_PCKL1

例如，我们的PCLK1=42MHz，想要配置400Kbit/s的速率，计算方式如下：

PCLK时钟周期： TPCLK1 = 1/42000000

目标SCL时钟周期： TSCL = 1/400000

SCL时钟周期内的高电平时间： THIGH = TSCL/3

SCL时钟周期内的低电平时间： TLOW = 2*TSCL/3

计算CCR的值： CCR = THIGH/TPCLK1 = 35

该结果刚好为整数，所以我们可直接把CCR取值为35，这样I2C的SCL实际频率即为400KHz。特别地，CCR寄存器是无法配置小数参数的，如果配置某个速率算出来CCR的结果为小数的话，需要对结果进行取整，再配置，取整后SCL的输出频率会跟原目标频率稍微不同，取整后除了通讯稍慢或稍快一点以外，不会对I2C的标准通讯造成其它影响。

24.2.2.3. 数据控制逻辑¶

I2C的SDA信号主要连接到数据移位寄存器上，数据移位寄存器的数据来源及目标是数据寄存器(DR)、地址寄存器(OAR)、PEC寄存器以及SDA数据线。当向外发送数据的时候，数据移位寄存器以“数据寄存器”为数据源，把数据一位一位地通过SDA信号线发送出去；当从外部接收数据的时候，数据移位寄存器把SDA信号线采样到的数据一位一位地存储到“数据寄存器”中。若使能了数据校验，接收到的数据会经过PCE计算器运算，运算结果存储在“PEC寄存器”中。当STM32的I2C工作在从机模式的时候，接收到设备地址信号时，数据移位寄存器会把接收到的地址与STM32的自身的“I2C地址寄存器”的值作比较，以便响应主机的寻址。STM32的自身I2C地址可通过修改“自身地址寄存器”修改，支持同时使用两个I2C设备地址，两个地址分别存储在OAR1和OAR2中。

24.2.2.4. 整体控制逻辑¶

整体控制逻辑负责协调整个I2C外设，控制逻辑的工作模式根据我们配置的“控制寄存器(CR1/CR2)”的参数而改变。在外设工作时，控制逻辑会根据外设的工作状态修改“状态寄存器(SR1和SR2)”，我们只要读取这些寄存器相关的寄存器位，就可以了解I2C的工作状态了。除此之外，控制逻辑还根据要求，负责控制产生I2C中断信号、DMA请求及各种I2C的通讯信号(起始、停止、响应信号等)。

24.2.3. 通讯过程¶

使用I2C外设通讯时，在通讯的不同阶段它会对“状态寄存器(SR1及SR2)”的不同数据位写入参数，我们通过读取这些寄存器标志来了解通讯状态。

24.2.3.1. 主发送器¶

见图主发送器通讯过程。图中的是“主发送器”流程，即作为I2C通讯的主机端时，向外发送数据时的过程。

主发送器发送流程及事件说明如下：

(1) 控制产生起始信号(S)，当发生起始信号后，它产生事件“EV5”，并会对SR1寄存器的“SB”位置1，表示起始信号已经发送；

(2) 紧接着发送设备地址并等待应答信号，若有从机应答，则产生事件“EV6”及“EV8”，这时SR1寄存器的“ADDR”位及“TXE”位被置1，ADDR 为1表示地址已经发送，TXE为1表示数据寄存器为空；

(3) 以上步骤正常执行并对ADDR位清零后，我们往I2C的“数据寄存器DR”写入要发送的数据，这时TXE位会被重置0，表示数据寄存器非空，I2C外设通过SDA信号线一位位把数据发送出去后，又会产生“EV8”事件，即TXE位被置1，重复这个过程，就可以发送多个字节数据了；

(4) 当我们发送数据完成后，控制I2C设备产生一个停止信号(P)，这个时候会产生EV2事件， SR1的TXE位及BTF位都被置1，表示通讯结束。

假如我们使能了I2C中断，以上所有事件产生时，都会产生I2C中断信号，进入同一个中断服务函数，到I2C中断服务程序后，再通过检查寄存器位来了解是哪一个事件。

24.2.3.2. 主接收器¶

再来分析主接收器过程，即作为I2C通讯的主机端时，从外部接收数据的过程，见图主接收器过程。

主接收器接收流程及事件说明如下：

(1) 同主发送流程，起始信号(S)是由主机端产生的，控制发生起始信号后，它产生事件“EV5”，并会对SR1寄存器的“SB”位置1，表示起始信号已经发送；

(2) 紧接着发送设备地址并等待应答信号，若有从机应答，则产生事件“EV6”这时SR1寄存器的“ADDR”位被置1，表示地址已经发送。

(3) 从机端接收到地址后，开始向主机端发送数据。当主机接收到这些数据后，会产生“EV7”事件，SR1寄存器的RXNE被置1，表示接收数据寄存器非空，我们读取该寄存器后，可对数据寄存器清空，以便接收下一次数据。此时我们可以控制I2C发送应答信号(ACK)或非应答信号(NACK)，若应答，则重复以上步骤接收数据，若非应答，则停止传输；

(4) 发送非应答信号后，产生停止信号(P)，结束传输。

在发送和接收过程中，有的事件不只是标志了我们上面提到的状态位，还可能同时标志主机状态之类的状态位，而且读了之后还需要清除标志位，比较复杂。我们可使用STM32标准库函数来直接检测这些事件的复合标志，降低编程难度。

24.3. I2C初始化结构体详解¶

跟其它外设一样，STM32标准库提供了I2C初始化结构体及初始化函数来配置I2C外设。初始化结构体及函数定义在库文件“stm32f4xx_i2c.h”及“stm32f4xx_i2c.c”中，编程时我们可以结合这两个文件内的注释使用或参考库帮助文档。了解初始化结构体后我们就能对I2C外设运用自如了，见代码清单:I2C-1 。

代码清单:I2C-1 I2C初始化结构体¶

typedef struct {
    uint32_t I2C_ClockSpeed; /*!< 设置SCL时钟频率，此值要低于40 0000*/
    uint16_t I2C_Mode;      /*!< 指定工作模式，可选I2C模式及SMBUS模式 */
    uint16_t I2C_DutyCycle; /*指定时钟占空比，可选low/high = 2:1及16:9模式*/
    uint16_t I2C_OwnAddress1;     /*!< 指定自身的I2C设备地址 */
    uint16_t I2C_Ack;                 /*!< 使能或关闭响应(一般都要使能) */
    uint16_t I2C_AcknowledgedAddress; /*!< 指定地址的长度，可为7位及10位 */
} I2C_InitTypeDef;

这些结构体成员说明如下，其中括号内的文字是对应参数在STM32标准库中定义的宏：

I2C_ClockSpeed

本成员设置的是I2C的传输速率，在调用初始化函数时，函数会根据我们输入的数值经过运算后把时钟因子写入到I2C的时钟控制寄存器CCR。而我们写入的这个参数值不得高于400KHz。由于CCR寄存器不能写入小数类型的时钟因子，固件库计算CCR值时会向下取整，影响到SCL的实际频率可能会低于本成员设置的参数值，这时除了通讯稍慢一点以外，不会对I2C的标准通讯造成其它影响。
I2C_Mode

本成员是选择I²C的使用方式，有I²C模式(I2C_Mode_I2C)和SMBus主、从模式(I2C_Mode_SMBusHost、 I2C_Mode_SMBusDevice ) 。 I2C不需要在此处区分主从模式，直接设置I2C_Mode_I2C即可。
I2C_DutyCycle

本成员设置的是I²C的SCL线时钟的占空比。该配置有两个选择，分别为低电平时间比高电平时间为2：1 ( I2C_DutyCycle_2)和16：9 (I2C_DutyCycle_16_9)。其实这两个模式的比例差别并不大，一般要求都不会如此严格，这里随便选就可以了。
I2C_OwnAddress1

本成员配置的是STM32的I2C设备自己的地址，每个连接到I2C总线上的设备都要有一个自己的地址，作为主机也不例外。地址可设置为7位或10位(受下面I2C_AcknowledgeAddress成员决定)，只要该地址是I2C总线上唯一的即可。

STM32的I2C外设可同时使用两个地址，即同时对两个地址作出响应，这个结构成员I2C_OwnAddress1配置的是默认的、 OAR1寄存器存储的地址，若需要设置第二个地址寄存器OAR2，可使用I2C_OwnAddress2Config函数来配置，OAR2不支持10位地址。
I2C_Ack_Enable

本成员是关于I²C应答设置，设置为使能则可以发送响应信号。该成员值一般配置为允许应答(I2C_Ack_Enable)，这是绝大多数遵循I²C标准的设备的通讯要求，改为禁止应答(I2C_Ack_Disable)往往会导致通讯错误。
I2C_AcknowledgeAddress

本成员选择I2C的寻址模式是7位还是10位地址。这需要根据实际连接到I2C总线上设备的地址进行选择，这个成员的配置也影响到I2C_OwnAddress1成员，只有这里设置成10位模式时，I2C_OwnAddress1才支持10位地址。

配置完这些结构体成员值，调用库函数I2C_Init即可把结构体的配置写入到寄存器中。

24.4. I2C—读写EEPROM实验¶

EEPROM是一种掉电后数据不丢失的存储器，常用来存储一些配置信息，以便系统重新上电的时候加载之。 EEPOM芯片最常用的通讯方式就是I²C协议，本小节以EEPROM的读写实验为大家讲解STM32的I²C使用方法。实验中STM32的I2C外设采用主模式，分别用作主发送器和主接收器，通过查询事件的方式来确保正常通讯。

24.4.1. 硬件设计¶

V1

V2

本实验板中的EEPROM芯片(型号：AT24C02)的SCL及SDA引脚连接到了STM32对应的I2C引脚中，结合上拉电阻，构成了I2C通讯总线，它们通过I2C总线交互。 EEPROM芯片的设备地址一共有7位，其中高4位固定为：1010 b，低3位则由A0/A1/A2信号线的电平决定，见图 EEPROM设备地址，图中的R/W是读写方向位，与地址无关。

按照我们此处的连接，A0/A1/A2均为0，所以EEPROM的7位设备地址是：101 0000b，即0x50。由于I2C通讯时常常是地址跟读写方向连在一起构成一个8位数，且当R/W位为0时，表示写方向，所以加上7位地址，其值为“0xA0”，常称该值为I2C设备的“写地址”；当R/W位为1时，表示读方向，加上7位地址，其值为“0xA1”，常称该值为“读地址”。

EEPROM芯片中还有一个WP引脚，具有写保护功能，当该引脚电平为高时，禁止写入数据，当引脚为低电平时，可写入数据，此处直接接地，不使用写保护功能。

关于EEPROM的更多信息，可参考其数据手册《AT24C02》来了解。若您使用的实验板EEPROM的型号、设备地址或控制引脚不一样，只需根据我们的工程修改即可，程序的控制原理相同。

24.4.2. 软件设计¶

为了使工程更加有条理，我们把读写EEPROM相关的代码独立分开存储，方便以后移植。在“工程模板”之上新建“bsp_i2c_ee.c”及“bsp_i2c_ee.h”文件，这些文件也可根据您的喜好命名，它们不属于STM32标准库的内容，是由我们自己根据应用需要编写的。

24.4.2.1. 编程要点¶

(1) 配置通讯使用的目标引脚为开漏模式；

(2) 使能I2C外设的时钟；

(3) 配置I2C外设的模式、地址、速率等参数并使能I2C外设；

(4) 编写基本I2C按字节收发的函数；

(5) 编写读写EEPROM存储内容的函数；

(6) 编写测试程序，对读写数据进行校验。

24.4.2.2. 代码分析¶

I2C硬件相关宏定义

我们把I2C硬件相关的配置都以宏的形式定义到 “bsp_i2c_ee.h”文件中，见代码清单:I2C-2 。

代码清单:I2C-2 I2C硬件配置相关的宏¶

/* STM32 I2C 速率 */
#define I2C_Speed              400000

/* STM32自身的I2C地址，这个地址只要与STM32外挂的I2C器件地址不一样即可 */
#define I2C_OWN_ADDRESS7      0X0A

/*I2C接口*/
#define EEPROM_I2C                          I2C1
#define EEPROM_I2C_CLK                      RCC_APB1Periph_I2C1

#define EEPROM_I2C_SCL_PIN                  GPIO_Pin_8
#define EEPROM_I2C_SCL_GPIO_PORT            GPIOB
#define EEPROM_I2C_SCL_GPIO_CLK             RCC_AHB1Periph_GPIOB
#define EEPROM_I2C_SCL_SOURCE               GPIO_PinSource8
#define EEPROM_I2C_SCL_AF                   GPIO_AF_I2C1

#define EEPROM_I2C_SDA_PIN                  GPIO_Pin_9
#define EEPROM_I2C_SDA_GPIO_PORT            GPIOB
#define EEPROM_I2C_SDA_GPIO_CLK             RCC_AHB1Periph_GPIOB
#define EEPROM_I2C_SDA_SOURCE               GPIO_PinSource9
#define EEPROM_I2C_SDA_AF                   GPIO_AF_I2C1

以上代码根据硬件连接，把与EEPROM通讯使用的I2C号、引脚号、引脚源以及复用功能映射都以宏封装起来，并且定义了自身的I2C地址及通讯速率，以便配置模式的时候使用。

初始化I2C的 GPIO

利用上面的宏，编写I2C GPIO引脚的初始化函数，见代码清单:I2C-2 。

代码清单:I2C-3 I2C GPIO初始化函数¶

/**
* @brief  I2C1 I/O配置
* @param  无
* @retval 无
*/
static void I2C_GPIO_Config(void)
{
    GPIO_InitTypeDef  GPIO_InitStructure;

    /*使能I2C外设时钟 */
    RCC_APB1PeriphClockCmd(EEPROM_I2C_CLK, ENABLE);

    /*使能I2C引脚的GPIO时钟*/
    RCC_AHB1PeriphClockCmd(EEPROM_I2C_SCL_GPIO_CLK |
                        EEPROM_I2C_SDA_GPIO_CLK, ENABLE);

    /* 连接引脚源 PXx 到 I2C_SCL*/
    GPIO_PinAFConfig(EEPROM_I2C_SCL_GPIO_PORT, EEPROM_I2C_SCL_SOURCE,
                    EEPROM_I2C_SCL_AF);
    /* 连接引脚源 PXx 到 to I2C_SDA*/
    GPIO_PinAFConfig(EEPROM_I2C_SDA_GPIO_PORT, EEPROM_I2C_SDA_SOURCE,
                    EEPROM_I2C_SDA_AF);

    /*配置 SCL引脚 */
    GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SCL_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
    GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
    GPIO_Init(EEPROM_I2C_SCL_GPIO_PORT, &GPIO_InitStructure);

    /*配置 SDA引脚 */
    GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SDA_PIN;
    GPIO_Init(EEPROM_I2C_SDA_GPIO_PORT, &GPIO_InitStructure);
}

同为外设使用的GPIO引脚初始化，初始化的流程与“串口初始化函数”章节中的类似，主要区别是引脚的模式。函数执行流程如下：

(1) 使用GPIO_InitTypeDef定义GPIO初始化结构体变量，以便下面用于存储GPIO配置；

(2) 调用库函数RCC_APB1PeriphClockCmd使能I2C外设时钟，调用RCC_AHB1PeriphClockCmd来使能I2C引脚使用的GPIO端口时钟，调用时我们使用“|”操作同时配置两个引脚。

(3) 向GPIO初始化结构体赋值，把引脚初始化成复用开漏模式，要注意I2C的引脚必须使用这种模式。

(4) 使用以上初始化结构体的配置，调用GPIO_Init函数向寄存器写入参数，完成GPIO的初始化。

配置I2C的模式

以上只是配置了I2C使用的引脚，还不算对I2C模式的配置，见代码清单:I2C-4 。

代码清单:I2C-4 配置I2C模式¶

/**
* @brief  I2C 工作模式配置
* @param  无
* @retval 无
*/
static void I2C_Mode_Config(void)
{
    I2C_InitTypeDef  I2C_InitStructure;

    /* I2C 配置 */
    /*I2C模式*/
    I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
    /*占空比*/
    I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
    /*I2C自身地址*/
    I2C_InitStructure.I2C_OwnAddress1 =I2C_OWN_ADDRESS7;
    /*使能响应*/
    I2C_InitStructure.I2C_Ack = I2C_Ack_Enable ;
    /* I2C的寻址模式 */
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
    /* 通信速率 */
    I2C_InitStructure.I2C_ClockSpeed = I2C_Speed;
    /*写入配置*/
    I2C_Init(EEPROM_I2C, &I2C_InitStructure);
    /* 使能 I2C */
    I2C_Cmd(EEPROM_I2C, ENABLE);
}

/**
* @brief  I2C 外设初始化
* @param  无
* @retval 无
*/
void I2C_EE_Init(void)
{
    I2C_GPIO_Config();

    I2C_Mode_Config();
}

熟悉STM32 I2C结构的话，这段初始化程序就十分好理解了，它把I2C外设通讯时钟SCL的低/高电平比设置为2，使能响应功能，使用7位地址I2C_OWN_ADDRESS7以及速率配置为I2C_Speed(前面在bsp_i2c_ee.h定义的宏)。最后调用库函数I2C_Init把这些配置写入寄存器，并调用I2C_Cmd函数使能外设。

为方便调用，我们把I2C的GPIO及模式配置都用I2C_EE_Init函数封装起来。

向EEPROM写入一个字节的数据

初始化好I2C外设后，就可以使用I2C通讯了，我们看看如何向EEPROM写入一个字节的数据，见代码清单:I2C-5 。

代码清单:I2C-5 向EEPROM写入一个字节的数据¶

/***************************************************************/
/*通讯等待超时时间*/
#define I2CT_FLAG_TIMEOUT   ((uint32_t)0x1000)
#define I2CT_LONG_TIMEOUT   ((uint32_t)(10 * I2CT_FLAG_TIMEOUT))

/**
* @brief  I2C等待事件超时的情况下会调用这个函数来处理
* @param  errorCode：错误代码，可以用来定位是哪个环节出错.
* @retval 返回0，表示IIC读取失败.
*/
static  uint32_t I2C_TIMEOUT_UserCallback(uint8_t errorCode)
{
    /* 使用串口printf输出错误信息，方便调试 */
    EEPROM_ERROR("I2C 等待超时!errorCode = %d",errorCode);
    return 0;
}
/**
* @brief   写一个字节到I2C EEPROM中
* @param   pBuffer:缓冲区指针
* @param   WriteAddr:写地址
* @retval  正常返回1，异常返回0
*/
uint32_t I2C_EE_ByteWrite(u8* pBuffer, u8 WriteAddr)
{
    /* 产生I2C起始信号 */
    I2C_GenerateSTART(EEPROM_I2C, ENABLE);

    /*设置超时等待时间*/
    I2CTimeout = I2CT_FLAG_TIMEOUT;
    /* 检测 EV5 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(0);
    }

    /* 发送EEPROM设备地址 */
    I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDRESS,
                        I2C_Direction_Transmitter);

    I2CTimeout = I2CT_FLAG_TIMEOUT;
    /* 检测 EV6 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C,
                        I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(1);
    }

    /* 发送要写入的EEPROM内部地址(即EEPROM内部存储器的地址) */
    I2C_SendData(EEPROM_I2C, WriteAddr);

    I2CTimeout = I2CT_FLAG_TIMEOUT;
    /* 检测 EV8 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C,
                        I2C_EVENT_MASTER_BYTE_TRANSMITTED))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(2);
    }
    /* 发送一字节要写入的数据 */
    I2C_SendData(EEPROM_I2C, *pBuffer);

    I2CTimeout = I2CT_FLAG_TIMEOUT;
    /* 检测 EV8 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C,
                        I2C_EVENT_MASTER_BYTE_TRANSMITTED))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
    }

    /* 发送停止信号 */
    I2C_GenerateSTOP(EEPROM_I2C, ENABLE);

    return 1;
}

先来分析I2C_TIMEOUT_UserCallback函数，它的函数体里只调用了宏EEPROM_ERROR，这个宏封装了printf函数，方便使用串口向上位机打印调试信息，阅读代码时把它当成printf函数即可。在I2C通讯的很多过程，都需要检测事件，当检测到某事件后才能继续下一步的操作，但有时通讯错误或者I2C总线被占用，我们不能无休止地等待下去，所以我们设定每个事件检测都有等待的时间上限，若超过这个时间，我们就调用I2C_TIMEOUT_UserCallback函数输出调试信息(或可以自己加其它操作)，并终止I2C通讯。

了解了这个机制，再来分析I2C_EE_ByteWrite函数，这个函数实现了前面讲的I2C主发送器通讯流程

(1) 使用库函数I2C_GenerateSTART产生I2C起始信号，其中的EEPROM_I2C宏是前面硬件定义相关的I2C编号；

(2) 对I2CTimeout变量赋值为宏I2CT_FLAG_TIMEOUT，这个I2CTimeout变量在下面的while循环中每次循环减1，该循环通过调用库函数I2C_CheckEvent检测事件，若检测到事件，则进入通讯的下一阶段，若未检测到事件则停留在此处一直检测，当检测I2CT_FLAG_TIMEOUT次都还没等待到事件则认为通讯失败，调用前面的I2C_TIMEOUT_UserCallback输出调试信息，并退出通讯；

(3) 调用库函数I2C_Send7bitAddress发送EEPROM的设备地址，并把数据传输方向设置为I2C_Direction_Transmitter(即发送方向)，这个数据传输方向就是通过设置I2C通讯中紧跟地址后面的R/W位实现的。发送地址后以同样的方式检测EV6标志；

(4) 调用库函数I2C_SendData向EEPROM发送要写入的内部地址，该地址是I2C_EE_ByteWrite函数的输入参数，发送完毕后等待EV8事件。要注意这个内部地址跟上面的EEPROM地址不一样，上面的是指I2C总线设备的独立地址，而此处的内部地址是指EEPROM内数据组织的地址，也可理解为EEPROM内存的地址或I2C设备的寄存器地址；

(5) 调用库函数I2C_SendData向EEPROM发送要写入的数据，该数据是I2C_EE_ByteWrite函数的输入参数，发送完毕后等待EV8事件；

(6) 一个I2C通讯过程完毕，调用I2C_GenerateSTOP发送停止信号。

在这个通讯过程中，STM32实际上通过I2C向EEPROM发送了两个数据，但为何第一个数据被解释为EEPROM的内存地址？这是由EEPROM的自己定义的单字节写入时序，见图 EEPROM单字节写入时序。

EEPROM的单字节时序规定，向它写入数据的时候，第一个字节为内存地址，第二个字节是要写入的数据内容。所以我们需要理解：命令、地址的本质都是数据，对数据的解释不同，它就有了不同的功能。

多字节写入及状态等待

单字节写入通讯结束后，EEPROM芯片会根据这个通讯结果擦写该内存地址的内容，这需要一段时间，所以我们在多次写入数据时，要先等待EEPROM内部擦写完毕。多个数据写入过程见代码清单:I2C-6 。

代码清单:I2C-6 多字节写入¶

/**
* @brief   将缓冲区中的数据写到I2C EEPROM中，采用单字节写入的方式，
            速度比页写入慢
* @param  pBuffer:缓冲区指针
* @param  WriteAddr:写地址
* @param  NumByteToWrite:写的字节数
* @retval  无
*/
uint8_t I2C_EE_ByetsWrite(uint8_t* pBuffer,uint8_t WriteAddr,
                        uint16_t NumByteToWrite)
{
    uint16_t i;
    uint8_t res;

    /*每写一个字节调用一次I2C_EE_ByteWrite函数*/
    for (i=0; i<NumByteToWrite; i++)
    {
        /*等待EEPROM准备完毕*/
        I2C_EE_WaitEepromStandbyState();
        /*按字节写入数据*/
        res = I2C_EE_ByteWrite(pBuffer++,WriteAddr++);
    }
    return res;
}

这段代码比较简单，直接使用for循环调用前面定义的I2C_EE_ByteWrite函数一个字节一个字节地向EEPROM发送要写入的数据。在每次数据写入通讯前调用了I2C_EE_WaitEepromStandbyState函数等待EEPROM内部擦写完毕，该函数的定义见代码清单:I2C-7 。

代码清单:I2C-7 等待EEPROM处于准备状态¶

//等待Standby状态的最大次数
#define MAX_TRIAL_NUMBER 300
/**
* @brief  等待EEPROM到准备状态
* @param  无
* @retval 正常返回1，异常返回0
*/
static uint8_t I2C_EE_WaitEepromStandbyState(void)
{
    __IO uint16_t tmpSR1 = 0;
    __IO uint32_t EETrials = 0;

    /*总线忙时等待 */
    I2CTimeout = I2CT_LONG_TIMEOUT;
    while (I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_BUSY))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(20);
    }

    /* 等待从机应答，最多等待300次 */
    while (1)
    {
        /*开始信号 */
        I2C_GenerateSTART(EEPROM_I2C, ENABLE);

        /* 检测 EV5 事件并清除标志*/
        I2CTimeout = I2CT_FLAG_TIMEOUT;
        while (!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
        {
            if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(21);
        }

        /* 发送EEPROM设备地址 */
        I2C_Send7bitAddress(EEPROM_I2C,EEPROM_ADDRESS,I2C_Direction_Transmitter);

        /* 等待ADDR标志 */
        I2CTimeout = I2CT_LONG_TIMEOUT;
        do
        {
            /* 获取SR1寄存器状态 */
            tmpSR1 = EEPROM_I2C->SR1;

            if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(22);
        }
        /* 一直等待直到addr及af标志为1 */
        while ((tmpSR1 & (I2C_SR1_ADDR | I2C_SR1_AF)) == 0);

        /*检查addr标志是否为1 */
        if (tmpSR1 & I2C_SR1_ADDR)
        {
            /* 清除addr标志该标志通过读SR1及SR2清除 */
            (void)EEPROM_I2C->SR2;

            /*产生停止信号 */
            I2C_GenerateSTOP(EEPROM_I2C, ENABLE);

            /* 退出函数 */
            return 1;
        }
        else
        {
            /*清除af标志 */
            I2C_ClearFlag(EEPROM_I2C, I2C_FLAG_AF);
        }

        /*检查等待次数*/
        if (EETrials++ == MAX_TRIAL_NUMBER)
        {
            /* 等待MAX_TRIAL_NUMBER次都还没准备好，退出等待 */
            return I2C_TIMEOUT_UserCallback(23);
        }
    }
}

这个函数主要实现是向EEPROM发送它设备地址，检测EEPROM的响应，若EEPROM接收到地址后返回应答信号，则表示EEPROM已经准备好，可以开始下一次通讯。函数中检测响应是通过读取STM32的SR1寄存器的ADDR位及AF位来实现的，当I2C设备响应了地址的时候，ADDR会置1，若应答失败，AF位会置1。

EEPROM的页写入

在以上的数据通讯中，每写入一个数据都需要向EEPROM发送写入的地址，我们希望向连续地址写入多个数据的时候，只要告诉EEPROM第一个内存地址address1，后面的数据按次序写入到address2、address3…这样可以节省通讯的内容，加快速度。为应对这种需求， EEPROM定义了一种页写入时序，见图 EEPROM页写入时序。

根据页写入时序，第一个数据被解释为要写入的内存地址address1，后续可连续发送n个数据，这些数据会依次写入到内存中。其中AT24C02型号的芯片页写入时序最多可以一次发送8个数据(即n = 8)，该值也称为页大小，某些型号的芯片每个页写入时序最多可传输16个数据。 EEPROM的页写入代码实现见代码清单:I2C-8 。

代码清单:I2C-8 EEPROM的页写入¶

/**
* @brief   在EEPROM的一个写循环中可以写多个字节，但一次写入的字节数
*          不能超过EEPROM页的大小，AT24C02每页有8个字节
* @param
* @param    pBuffer:缓冲区指针
* @param    WriteAddr:写地址
* @param    NumByteToWrite:要写的字节数要求NumByToWrite小于页大小
* @retval  正常返回1，异常返回0
*/
uint8_t I2C_EE_PageWrite(uint8_t* pBuffer, uint8_t WriteAddr,
                        uint8_t NumByteToWrite)
{
    I2CTimeout = I2CT_LONG_TIMEOUT;

    while (I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_BUSY))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(4);
    }

    /* 产生I2C起始信号 */
    I2C_GenerateSTART(EEPROM_I2C, ENABLE);

    I2CTimeout = I2CT_FLAG_TIMEOUT;

    /* 检测 EV5 事件并清除标志 */
    while (!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(5);
    }

    /* 发送EEPROM设备地址  */
    I2C_Send7bitAddress(EEPROM_I2C,EEPROM_ADDRESS,I2C_Direction_Transmitter);

    I2CTimeout = I2CT_FLAG_TIMEOUT;

    /* 检测 EV6 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C,
                        I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(6);
    }
    /* 发送要写入的EEPROM内部地址(即EEPROM内部存储器的地址) */
    I2C_SendData(EEPROM_I2C, WriteAddr);

    I2CTimeout = I2CT_FLAG_TIMEOUT;

    /* 检测 EV8 事件并清除标志*/
    while (! I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
    }
    /* 循环发送NumByteToWrite个数据 */
    while (NumByteToWrite--)
    {
        /* 发送缓冲区中的数据 */
        I2C_SendData(EEPROM_I2C, *pBuffer);

        /* 指向缓冲区中的下一个数据 */
        pBuffer++;

        I2CTimeout = I2CT_FLAG_TIMEOUT;

        /* 检测 EV8 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
        {
            if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(8);
        }
    }
    /* 发送停止信号 */
    I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
    return 1;
}

这段页写入函数主体跟单字节写入函数是一样的，只是它在发送数据的时候，使用for循环控制发送多个数据，发送完多个数据后才产生I2C停止信号，只要每次传输的数据小于等于EEPROM时序规定的页大小，就能正常传输。

快速写入多字节

利用EEPROM的页写入方式，可以改进前面的“多字节写入”函数，加快传输速度，见代码清单:I2C-9 。

代码清单:I2C-9 快速写入多字节函数¶

/* AT24C01/02每页有8个字节 */
#define I2C_PageSize           8

/**
* @brief   将缓冲区中的数据写到I2C EEPROM中，采用页写入的方式，加快写入速度
* @param  pBuffer:缓冲区指针
* @param  WriteAddr:写地址
* @param  NumByteToWrite:写的字节数
* @retval  无
*/
void I2C_EE_BufferWrite(uint8_t* pBuffer, uint8_t WriteAddr,
                        u16 NumByteToWrite)
{
    uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0;

    /*mod运算求余，若writeAddr是I2C_PageSize整数倍，运算结果Addr值为0*/
    Addr = WriteAddr % I2C_PageSize;

    /*差count个数据，刚好可以对齐到页地址*/
    count = I2C_PageSize - Addr;
    /*计算出要写多少整数页*/
    NumOfPage =  NumByteToWrite / I2C_PageSize;
    /*mod运算求余，计算出剩余不满一页的字节数*/
    NumOfSingle = NumByteToWrite % I2C_PageSize;

    /* Addr=0,则WriteAddr 刚好按页对齐 aligned  */
    if (Addr == 0)
    {
        /* 如果 NumByteToWrite < I2C_PageSize */
        if (NumOfPage == 0)
        {
            I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
            I2C_EE_WaitEepromStandbyState();
        }
        /* 如果 NumByteToWrite > I2C_PageSize */
        else
        {
            /*先把整数页都写了*/
            while (NumOfPage--)
            {
                I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
                I2C_EE_WaitEepromStandbyState();
                WriteAddr +=  I2C_PageSize;
                pBuffer += I2C_PageSize;
            }

            /*若有多余的不满一页的数据，把它写完*/
            if (NumOfSingle!=0)
            {
                I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
                I2C_EE_WaitEepromStandbyState();
            }
        }
    }
    /* 如果 WriteAddr 不是按 I2C_PageSize 对齐  */
    else
    {
        /* 如果 NumByteToWrite < I2C_PageSize */
        if (NumOfPage== 0)
        {
            I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
            I2C_EE_WaitEepromStandbyState();
        }
        /* 如果 NumByteToWrite > I2C_PageSize */
        else
        {
            /*地址不对齐多出的count分开处理，不加入这个运算*/
            NumByteToWrite -= count;
            NumOfPage =  NumByteToWrite / I2C_PageSize;
            NumOfSingle = NumByteToWrite % I2C_PageSize;

            /*先把WriteAddr所在页的剩余字节写了*/
            if (count != 0)
            {
                I2C_EE_PageWrite(pBuffer, WriteAddr, count);
                I2C_EE_WaitEepromStandbyState();

                /*WriteAddr加上count后，地址就对齐到页了*/
                WriteAddr += count;
                pBuffer += count;
            }
            /*把整数页都写了*/
            while (NumOfPage--)
            {
                I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
                I2C_EE_WaitEepromStandbyState();
                WriteAddr +=  I2C_PageSize;
                pBuffer += I2C_PageSize;
            }
            /*若有多余的不满一页的数据，把它写完*/
            if (NumOfSingle != 0)
            {
                I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
                I2C_EE_WaitEepromStandbyState();
            }
        }
    }
}

很多读者觉得这段代码的运算很复杂，看不懂，其实它的主旨就是对输入的数据进行分页(本型号芯片每页8个字节)，见表首地址对齐到页时的情况。通过“整除”计算要写入的数据NumByteToWrite能写满多少“完整的页”，计算得的值存储在NumOfPage中，但有时数据不是刚好能写满完整页的，会多一点出来，通过“求余”计算得出“不满一页的数据个数”就存储在NumOfSingle中。计算后通过按页传输NumOfPage次整页数据及最后的NumOfSing个数据，使用页传输，比之前的单个字节数据传输要快很多。

除了基本的分页传输，还要考虑首地址的问题，见表 24‑3。若首地址不是刚好对齐到页的首地址，会需要一个count值，用于存储从该首地址开始写满该地址所在的页，还能写多少个数据。实际传输时，先把这部分count个数据先写入，填满该页，然后把剩余的数据(NumByteToWrite-count)，再重复上述求出NumOPage及NumOfSingle的过程，按页传输到EEPROM。

1. 若writeAddress=16，计算得Addr=16%8= 0 ，count=8-0= 8；

2. 同时，若NumByteToWrite=22，计算得NumOfPage=22/8= 2，NumOfSingle=22%8= 6。

数据传输情况如表首地址对齐到页时的情况。

3. 若writeAddress=17，计算得Addr=17%8= 1，count=8-1= 7；

4. 同时，若NumOfPage=22，

5. 先把count去掉，特殊处理，计算得新的NumOfPage=22-7= 15

6. 计算得NumOfPage=15/8= 1， NumOfSingle=15%8= 7。

数据传输情况如表首地址未对齐到页时的情况。

最后，强调一下，EEPROM支持的页写入只是一种加速的I2C的传输时序，实际上并不要求每次都以页为单位进行读写，EEPROM是支持随机访问的(直接读写任意一个地址)，如前面的单个字节写入。在某些存储器，如NANDFLASH，它是必须按照Block写入的，例如每个Block为512或4096字节，数据写入的最小单位是Block，写入前都需要擦除整个Block；NORFLASH则是写入前必须以Sector/Block为单位擦除，然后才可以按字节写入。而我们的EEPROM数据写入和擦除的最小单位是“字节”而不是“页”，数据写入前不需要擦除整页。

从EEPROM读取数据

从EEPROM读取数据是一个复合的I2C时序，它实际上包含一个写过程和一个读过程，见图 EEPROM数据读取时序。

读时序的第一个通讯过程中，使用I2C发送设备地址寻址(写方向)，接着发送要读取的“内存地址”；第二个通讯过程中，再次使用I2C发送设备地址寻址，但这个时候的数据方向是读方向；在这个过程之后，EEPROM会向主机返回从“内存地址”开始的数据，一个字节一个字节地传输，只要主机的响应为“应答信号”，它就会一直传输下去，主机想结束传输时，就发送“非应答信号”，并以“停止信号”结束通讯，作为从机的EEPROM也会停止传输。实现代码见代码清单:I2C-10 。

代码清单:I2C-10 从EEPROM读取数据¶

/**
* @brief   从EEPROM里面读取一块数据
* @param  pBuffer:存放从EEPROM读取的数据的缓冲区指针
* @param  ReadAddr:接收数据的EEPROM的地址
* @param  NumByteToRead:要从EEPROM读取的字节数
* @retval  正常返回1，异常返回0
*/
uint8_t I2C_EE_BufferRead(uint8_t* pBuffer, uint8_t ReadAddr,
                        u16 NumByteToRead)
{
    I2CTimeout = I2CT_LONG_TIMEOUT;

    while (I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_BUSY))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(9);
    }

    /* 产生I2C起始信号 */
    I2C_GenerateSTART(EEPROM_I2C, ENABLE);

    I2CTimeout = I2CT_FLAG_TIMEOUT;

    /* 检测 EV5 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(10);
    }

    /* 发送EEPROM设备地址 */
    I2C_Send7bitAddress(EEPROM_I2C,EEPROM_ADDRESS,I2C_Direction_Transmitter);

    I2CTimeout = I2CT_FLAG_TIMEOUT;

    /* 检测 EV6 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C,
                        I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(11);
    }
    /*通过重新设置PE位清除EV6事件 */
    I2C_Cmd(EEPROM_I2C, ENABLE);

    /* 发送要读取的EEPROM内部地址(即EEPROM内部存储器的地址) */
    I2C_SendData(EEPROM_I2C, ReadAddr);

    I2CTimeout = I2CT_FLAG_TIMEOUT;

    /* 检测 EV8 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTED))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(12);
    }
    /* 产生第二次I2C起始信号 */
    I2C_GenerateSTART(EEPROM_I2C, ENABLE);

    I2CTimeout = I2CT_FLAG_TIMEOUT;

    /* 检测 EV5 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(13);
    }
    /* 发送EEPROM设备地址 */
    I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDRESS, I2C_Direction_Receiver);

    I2CTimeout = I2CT_FLAG_TIMEOUT;

    /* 检测 EV6 事件并清除标志*/
    while (!I2C_CheckEvent(EEPROM_I2C,
                        I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
    {
        if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(14);
    }
    /* 读取NumByteToRead个数据*/
    while (NumByteToRead)
    {
        /*若NumByteToRead=1，表示已经接收到最后一个数据了，
        发送非应答信号，结束传输*/
        if (NumByteToRead == 1)
        {
            /* 发送非应答信号 */
            I2C_AcknowledgeConfig(EEPROM_I2C, DISABLE);

            /* 发送停止信号 */
            I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
        }

        I2CTimeout = I2CT_LONG_TIMEOUT;
        while (I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED)==0)
        {
            if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
        }
        {
            /*通过I2C，从设备中读取一个字节的数据 */
            *pBuffer = I2C_ReceiveData(EEPROM_I2C);

            /* 存储数据的指针指向下一个地址 */
            pBuffer++;

            /* 接收数据自减 */
            NumByteToRead--;
        }
    }

    /* 使能应答，方便下一次I2C传输 */
    I2C_AcknowledgeConfig(EEPROM_I2C, ENABLE);
    return 1;
}

这段中的写过程跟前面的写字节函数类似，而读过程中接收数据时，需要使用库函数I2C_ReceiveData来读取。响应信号则通过库函数I2C_AcknowledgeConfig来发送， DISABLE时为非响应信号，ENABLE为响应信号。

24.4.2.3. main文件¶

EEPROM读写测试函数

完成基本的读写函数后，接下来我们编写一个读写测试函数来检验驱动程序，见代码清单:I2C-11 。

代码清单:I2C-11 EEPROM读写测试函数¶

/**
* @brief  I2C(AT24C02)读写测试
* @param  无
* @retval 正常返回1 ，不正常返回0
*/
uint8_t I2C_Test(void)
{
    u16 i;
    EEPROM_INFO("写入的数据");

    for ( i=0; i<=255; i++ ) //填充缓冲
    {
        I2c_Buf_Write[i] = i;

        printf("0x%02X ", I2c_Buf_Write[i]);
        if (i%16 == 15)
            printf("\n\r");
    }

    //将I2c_Buf_Write中顺序递增的数据写入EERPOM中
    //页写入方式
    //  I2C_EE_BufferWrite( I2c_Buf_Write, EEP_Firstpage, 256);
    //字节写入方式
    I2C_EE_ByetsWrite( I2c_Buf_Write, EEP_Firstpage, 256);

    EEPROM_INFO("写结束");

    EEPROM_INFO("读出的数据");
    //将EEPROM读出数据顺序保持到I2c_Buf_Read中
    I2C_EE_BufferRead(I2c_Buf_Read, EEP_Firstpage, 256);

    //将I2c_Buf_Read中的数据通过串口打印
    for (i=0; i<256; i++)
    {
        if (I2c_Buf_Read[i] != I2c_Buf_Write[i])
        {
            printf("0x%02X ", I2c_Buf_Read[i]);
            EEPROM_ERROR("错误:I2C EEPROM写入与读出的数据不一致");
            return 0;
        }
        printf("0x%02X ", I2c_Buf_Read[i]);
        if (i%16 == 15)
            printf("\n\r");

    }
    EEPROM_INFO("I2C(AT24C02)读写测试成功");
    return 1;
}

代码中先填充一个数组，数组的内容为1,2,3至N，接着把这个数组的内容写入到EEPROM中，写入时可以采用单字节写入的方式或页写入的方式。写入完毕后再从EEPROM的地址中读取数据，把读取得到的与写入的数据进行校验，若一致说明读写正常，否则读写过程有问题或者EEPROM芯片不正常。其中代码用到的EEPROM_INFO跟EEPROM_ERROR宏类似，都是对printf函数的封装，使用和阅读代码时把它直接当成printf函数就好。具体的宏定义在“bsp_i2c_ee.h文件中”，在以后的代码我们常常会用类似的宏来输出调试信息。

main函数

最后编写main函数，函数中初始化了LED、串口、I2C外设，然后调用上面的I2C_Test函数进行读写测试，见代码清单:I2C-12 。

代码清单:I2C-12 main函数¶

/**
* @brief  主函数
* @param  无
* @retval 无
*/
int main(void)
{
    LED_GPIO_Config();

    LED_BLUE;
    /*初始化USART1*/
    Debug_USART_Config();

    printf("\r\n 欢迎使用野火  STM32 F407 开发板。\r\n");

    printf("\r\n 这是一个I2C外设(AT24C02)读写测试例程 \r\n");

    /* I2C 外设(AT24C02)初始化 */
    I2C_EE_Init();

    if (I2C_Test() ==1)
    {
        LED_GREEN;
    }
    else
    {
        LED_RED;
    }

    while (1)
    {
    }

}

24.4.3. 下载验证¶

用USB线连接开发板“USB TO UART”接口跟电脑，在电脑端打开串口调试助手，把编译好的程序下载到开发板。在串口调试助手可看到EEPROM测试的调试信息。