22. I2C—读写EEPROM¶

本章参考资料：《STM32F10X-中文参考手册》I2C章节及《I2C总线协议》。

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

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

22.1. I2C协议简介¶

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

在计算机科学里，大部分复杂的问题都可以通过分层来简化。如芯片被分为内核层和片上外设；STM32HAL库则是在寄存器与用户代码之间的软件层。对于通讯协议，我们也以分层的方式来理解，最基本的是把它分为物理层和协议层。物理层规定通讯系统中具有机械、电子功能部分的特性，确保原始数据在物理媒体的传输。协议层主要规定通讯逻辑，统一收发双方的数据打包、解包标准。简单来说物理层规定我们用嘴巴还是用肢体来交流，协议层则规定我们用中文还是英文来交流。

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

22.1.1. I2C物理层¶

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

图 23‑1 常见的I2C通讯系统

它的物理层有如下特点：

它是一个支持设备的总线。“总线”指多个设备共用的信号线。在一个I2C通讯总线中，可连接多个I2C通讯设备，支持多个通讯主机及多个通讯从机。
一个I2C总线只使用两条总线线路，一条双向串行数据线(SDA) ，一条串行时钟线 (SCL)。数据线即用来表示数据，时钟线用于数据收发同步。
每个连接到总线的设备都有一个独立的地址，主机可以利用这个地址进行不同设备之间的访问。
总线通过上拉电阻接到电源。当I2C设备空闲时，会输出高阻态，而当所有设备都空闲，都输出高阻态时，由上拉电阻把总线拉成高电平。
多个主机同时使用总线时，为了防止数据冲突，会利用仲裁方式决定由哪个设备占用总线。
具有三种传输模式：标准模式传输速率为100kbit/s ，快速模式为400kbit/s ，高速模式下可达 3.4Mbit/s，但目前大多I²C设备尚不支持高速模式。
连接到相同总线的 IC 数量受到总线的最大电容 400pF 限制。

22.1.2. 协议层¶

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

22.1.2.1. I2C基本读写过程¶

先看看I2C通讯过程的基本结构，它的通讯过程见图23_2、图23_3 及图23_4。

图 23‑2 主机写数据到从机

图 23‑3 主机由从机中读数据

图 23‑4 I2C通讯复合格式

图例：

数据由主机传输至从机

S ：传输开始信号

SLAVE_ADDRESS: 从机地址

数据由从机传输至主机

R/W- ：传输方向选择位，1为读，0为写

A/A- ：应答(ACK)或非应答(NACK)信号

P ：停止传输信号

这些图表示的是主机和从机通讯时，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的区别)；在第二次的传输中，对该地址的内容进行读或写。也就是说，第一次通讯是告诉从机读写地址，第二次则是读写的实际内容。

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

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

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

图 23‑5 起始和停止信号

22.1.2.3. 数据有效性¶

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

图 23‑6 数据有效性

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

22.1.2.4. 地址及数据方向¶

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

图 23‑7 设备地址(7位)及数据传输方向

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

22.1.2.5. 响应¶

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

图 23‑8 响应与非响应信号

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

22.2. STM32的I2C特性及架构¶

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

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

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

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

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

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

图 23‑9 I2C架构图

22.2.2.1. 通讯引脚¶

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

表 23‑1 STM32F10x的I2C引脚

引脚	I2C1	I2C2
SCL	PB6 / PB8(重映射)	PB10
SDA	PB7 / PB9(重映射)	PB11

22.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_low/T_high=2 时：

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

快速模式中 T_low/T_high=16/9 时：

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

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

PCLK时钟周期： TPCLK1 = 1/36000000

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

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

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

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

计算结果得出CCR为30，向该寄存器位写入此值则可以控制IIC的通讯速率为400KHz，其实即使配置出来的SCL时钟不完全等于标准的400KHz，IIC通讯的正确性也不会受到影响，因为所有数据通讯都是由SCL协调的，只要它的时钟频率不远高于标准即可。

22.2.2.3. 数据控制逻辑¶

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

22.2.2.4. 整体控制逻辑¶

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

22.2.3. 通讯过程¶

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

22.2.3.1. 主发送器¶

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

图 23‑10 主发送器通讯过程

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

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

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

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

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

22.2.3.2. 主接收器¶

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

图 23‑11 主接收器过程

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

同主发送流程，起始信号(S)是由主机端产生的，控制发生起始信号后，它产生事件“EV5”，并会对SR1寄存器的“SB”位置1，表示起始信号已经发送；
紧接着发送设备地址并等待应答信号，若有从机应答，则产生事件“EV6”这时SR1寄存器的“ADDR”位被置1，表示地址已经发送。

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

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

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

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

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

代码清单 23‑1 I2C初始化结构体¶

 typedef struct {
     uint32_t ClockSpeed; /*!< 设置SCL时钟频率，此值要低于40 0000*/
     uint32_t DutyCycle;  /*指定时钟占空比，可选low/high = 2:1及16:9模式*/
     uint32_t OwnAddress1; /*指定自身的I2C设备地址1，可以是 7-bit或者10-bit*/
     uint32_t AddressingMode; /*指定地址的长度模式，可以是7bit模式或者10bit模式*/

     uint32_t DualAddressMode; /*设置双地址模式 */
     uint32_t OwnAddress2;   /*指定自身的I2C设备地址2，只能是 7-bit */
     uint32_t GeneralCallMode; /*指定广播呼叫模式 */
     uint32_t NoStretchMode; /*指定禁止时钟延长模式*/
 } I2C_InitTypeDef;

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

ClockSpeed

本成员设置的是I2C的传输速率，在调用初始化函数时，函数会根据我们输入的数值写入到I2C的时钟控制寄存器CCR。这个数值的计算上一节已经说明。

DutyCycle

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

OwnAddress1

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

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

AddressingMode

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

DualAddressMode

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

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

OwnAddress2

本成员配置的是STM32的I2C设备自身地址2，每个连接到I2C总线上的设备都要有一个自己的地址，作为主机也不例外。地址可设置为7位，只要该地址是I2C总线上唯一的即可。

GeneralCallMode

本成员是关于I²C从模式时的广播呼叫模式设置。

NoStretchMode

本成员是关于I²C禁止时钟延长模式设置，用于在从模式下禁止时钟延长。它在主模式下必须保持关闭。

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

22.4. I2C—读写EEPROM实验¶

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

22.4.1. 硬件设计¶

图 23‑12a MINI开发板的EEPROM硬件连接图

图 23‑12b 指南者和霸道开发板的EEPROM硬件连接图

图 23‑12c 拂晓电机开发板的EEPROM硬件连接图

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

图 23‑13 EEPROM设备地址(摘自《AT24C02》规格书)

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

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

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

22.4.2. 软件设计¶

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

22.4.2.1. 编程要点¶

配置通讯使用的目标引脚为开漏模式；
使能I2C外设的时钟；
配置I2C外设的模式、地址、速率等参数并使能I2C外设；
编写基本I2C按字节收发的函数；
编写读写EEPROM存储内容的函数；
编写测试程序，对读写数据进行校验。

22.4.2.2. 代码分析¶

22.4.2.2.1. I2C硬件相关宏定义¶

我们把I2C硬件相关的配置都以宏的形式定义到相应的头文件当中， MINI开发板的定义在“bsp_i2c_gpio.h”中，见代码清单23_2a，指南者和霸道、拂晓电机开发板的定义在“bsp_i2c_ee.h”文件中，见代码清单23_2b、代码清单23_2c。

使用MINI开发板的朋友需要注意的是，I2C引脚PA2、PA3没有硬件自带的I2C复用功能，所以无法通过HAL库去进行I2C功能的配置，我们需要使用软件控制IO口的方式去模拟I2C协议进行通讯。

代码清单 23‑2a MINI开发板 I2C硬件配置相关的宏（bsp_i2c_gpio.h文件）¶

 #define EEPROM_I2C_WR 0   /* 写控制bit */
 #define EEPROM_I2C_RD 1   /* 读控制bit */


 /* 定义I2C总线连接的GPIO端口,
 用户只需要修改下面4行代码即可任意改变SCL和SDA的引脚
 */

 #define I2Cx_SDA_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOA_CLK_ENABLE()
 #define I2Cx_SCL_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOA_CLK_ENABLE()

 #define EEPROM_GPIO_PORT_I2C  GPIOA     /* GPIO端口 */
 #define EEPROM_I2C_SCL_PIN    GPIO_PIN_2      /* 连接到SCL时钟线的GPIO */
 #define EEPROM_I2C_SDA_PIN    GPIO_PIN_3      /* 连接到SDA数据线的GPIO */

 /* 定义读写SCL和SDA的宏，已增加代码的可移植性和可阅读性 */
 #if 0 /* 条件编译： 1 选择GPIO的库函数实现IO读写 */

 #define EEPROM_I2C_SCL_1() digitalH(EEPROM_GPIO_PORT_I2C,EEPROM_I2C_SCL_PIN)   /* SCL = 1 */
 #define EEPROM_I2C_SCL_0()  digitalL(EEPROM_GPIO_PORT_I2C,EEPROM_I2C_SCL_PIN)    /* SCL = 0 */

 #define EEPROM_I2C_SDA_1() digitalH(EEPROM_GPIO_PORT_I2C,EEPROM_I2C_SDA_PIN)   /* SDA = 1 */
 #define EEPROM_I2C_SDA_0()  digitalL(EEPROM_GPIO_PORT_I2C,EEPROM_I2C_SDA_PIN)    /* SDA = 0 */

 #define EEPROM_I2C_SDA_READ()  GPIO_ReadInputDataBit(EEPROM_GPIO_PORT_I2C, EEPROM_I2C_SDA_PIN) /* 读SDA口线状态 */

 #else /* 这个分支选择直接寄存器操作实现IO读写 */

 /*　注意：如下写法，在IAR最高级别优化时，会被编译器错误优化 */
 #define EEPROM_I2C_SCL_1()  EEPROM_GPIO_PORT_I2C->BSRR =EEPROM_I2C_SCL_PIN       /* SCL = 1 */
 #define EEPROM_I2C_SCL_0()  EEPROM_GPIO_PORT_I2C->BRR =EEPROM_I2C_SCL_PIN        /* SCL = 0 */

 #define EEPROM_I2C_SDA_1()  EEPROM_GPIO_PORT_I2C->BSRR =EEPROM_I2C_SDA_PIN       /* SDA = 1 */
 #define EEPROM_I2C_SDA_0()  EEPROM_GPIO_PORT_I2C->BRR =EEPROM_I2C_SDA_PIN        /* SDA = 0 */

 #define EEPROM_I2C_SDA_READ()  ((EEPROM_GPIO_PORT_I2C->IDR &EEPROM_I2C_SDA_PIN) != 0)  /*读SDA口线状态 */

 #endif

 /* 直接操作寄存器的方法控制IO */
 #define digitalH(p,i)     {p->BSRR=i;}        //设置为高电平
 #define digitalL(p,i)     {p->BSRR=(uint32_t)i << 16;}//输出低电平

以上代码的前6行，根据硬件连接，把与EEPROM通讯使用的GPIO引脚号都以宏封装起来，以便初始化GPIO模式的时候使用。

第6行后的代码，被条件编译宏“#if…#else…#endif”分成了两部分，当“#if ”中的条件成立，使用第一部分代码，否则使用第二部分代码。这两部分代码实现的功能完全一样，都是定义了一些宏，用于控制作为SCL、SDA线的GPIO输出高低电平，以及读取SDA线引脚的电平，这些功能在软件模拟I2C的时候用于产生时序，收发数据，实现I2C协议。这两部分的主要区别是第一部分使用库函数来控制引脚，代码比较易于理解，而第二部分则直接通过寄存器来控制引脚，它减少了函数调用的开销，在软件模拟I2C时，这些宏会被频繁调用，所以在本工程中使用第二部分的代码。

代码清单 23‑2b 指南者和霸道开发板 I2C硬件配置相关的宏（bsp_i2c_ee.h文件）¶

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

 #define I2Cx                             I2C1
 #define I2Cx_CLK_ENABLE()                __HAL_RCC_I2C1_CLK_ENABLE()
 #define I2Cx_SDA_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOB_CLK_ENABLE()
 #define I2Cx_SCL_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOB_CLK_ENABLE()

 #define I2Cx_FORCE_RESET()               __HAL_RCC_I2C1_FORCE_RESET()
 #define I2Cx_RELEASE_RESET()             __HAL_RCC_I2C1_RELEASE_RESET()

 /* Definition for I2Cx Pins */
 #define I2Cx_SCL_PIN                    GPIO_PIN_6
 #define I2Cx_SCL_GPIO_PORT              GPIOB
 #define I2Cx_SCL_AF                     GPIO_AF4_I2C1
 #define I2Cx_SDA_PIN                    GPIO_PIN_7
 #define I2Cx_SDA_GPIO_PORT              GPIOB
 #define I2Cx_SDA_AF                     GPIO_AF4_I2C1

代码清单 23‑2c 拂晓电机开发板 I2C硬件配置相关的宏（bsp_i2c_ee.h文件）¶

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

 #define I2Cx                             I2C1
 #define I2Cx_CLK_ENABLE()                __HAL_RCC_I2C1_CLK_ENABLE()
 #define I2Cx_SDA_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOB_CLK_ENABLE()
 #define I2Cx_SCL_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOB_CLK_ENABLE()

 #define I2Cx_FORCE_RESET()               __HAL_RCC_I2C1_FORCE_RESET()
 #define I2Cx_RELEASE_RESET()             __HAL_RCC_I2C1_RELEASE_RESET()

 /* Definition for I2Cx Pins */
 #define I2Cx_SCL_PIN                    GPIO_PIN_8
 #define I2Cx_SCL_GPIO_PORT              GPIOB
 #define I2Cx_SCL_AF                     GPIO_AF4_I2C1
 #define I2Cx_SDA_PIN                    GPIO_PIN_9
 #define I2Cx_SDA_GPIO_PORT              GPIOB
 #define I2Cx_SDA_AF                     GPIO_AF4_I2C1

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

22.4.2.2.2. 初始化I2C的 GPIO¶

利用上面的宏，编写I2C GPIO引脚的初始化函数，MINI开发板的见代码清单23_3a，指南者和霸道、拂晓电机开发板的见代码清单23_3b。

代码清单 23‑3a MINI开发板的 I2C GPIO初始化函数（bsp_i2c_gpio.c文件）¶

void i2c_CfgGpio(void)
 {
     GPIO_InitTypeDef  GPIO_InitStruct;
     /* Enable GPIO TX/RX clock */
     I2Cx_SCL_GPIO_CLK_ENABLE();
     I2Cx_SDA_GPIO_CLK_ENABLE();

     /* I2C TX GPIO pin configuration  */
     GPIO_InitStruct.Pin       = EEPROM_I2C_SCL_PIN |
                                 EEPROM_I2C_SDA_PIN;
     GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_OD;
     GPIO_InitStruct.Pull      = GPIO_NOPULL;
     GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;

     HAL_GPIO_Init(EEPROM_GPIO_PORT_I2C, &GPIO_InitStruct);

     /* 给一个停止信号,
     复位I2C总线上的所有设备到待机模式 */
     i2c_Stop();
 }

代码清单 23‑3b 指南者和霸道、拂晓电机开发板的I2C GPIO初始化函数¶

 void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c)
 {
     GPIO_InitTypeDef  GPIO_InitStruct;

     /* ##使能使能外设和GPIO时钟*/
     /* 使能GPIO时钟*/
     I2Cx_SCL_GPIO_CLK_ENABLE();
     I2Cx_SDA_GPIO_CLK_ENABLE();
     /*使能 I2C1使能时钟 */
     I2Cx_CLK_ENABLE();

     /*##配置外设引脚 */
     /* I2C TX GPIO配置  */
     GPIO_InitStruct.Pin       = I2Cx_SCL_PIN;
     GPIO_InitStruct.Mode      = GPIO_MODE_AF_OD;
     GPIO_InitStruct.Pull      = GPIO_NOPULL;
     GPIO_InitStruct.Speed     = GPIO_SPEED_FAST;
     GPIO_InitStruct.Alternate = I2Cx_SCL_AF;

     HAL_GPIO_Init(I2Cx_SCL_GPIO_PORT, &GPIO_InitStruct);

     /* I2C RX GPIO配置  */
     GPIO_InitStruct.Pin = I2Cx_SDA_PIN;
     GPIO_InitStruct.Alternate = I2Cx_SDA_AF;

     HAL_GPIO_Init(I2Cx_SDA_GPIO_PORT, &GPIO_InitStruct);

     /*强制I2C外设时钟复位*/
     I2Cx_FORCE_RESET() ;

     /*释放I2C外设时钟复位*/
     I2Cx_RELEASE_RESET();
 }

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

使用GPIO_InitTypeDef定义GPIO初始化结构体变量，以便下面用于存储GPIO配置；
调用宏I2Cx_CLK_ENABLE()使能I2C外设时钟，调用宏定义I2Cx_SCL_GPIO_CLK_ENABLE()和I2Cx_SDA_GPIO_CLK_ENABLE()来使能I2C引脚使用的GPIO端口时钟。
向GPIO初始化结构体赋值，把引脚初始化成复用开漏模式，要注意I2C的引脚必须使用这种模式。
使用以上初始化结构体的配置，调用HAL_GPIO_Init函数向寄存器写入参数，完成GPIO的初始化。

22.4.2.2.3. 配置I2C的模式¶

以上只是配置了I2C所使用的引脚，还不算对I2C模式的配置。

对于MINI开发板，我们要自己手动去模拟I2C通信协议，所以需要编写几个函数去实现I2C的启动、停止、发送单字节、接收单字节、应答、还有延时的功能。这个便是我们针对于MINI开发板的软件模拟I2C的配置过程。见代码清单23_4a、代码清单23_4a_续1 、代码清单23_4a_续2。

而对于指南者和霸道开发板和拂晓电机开发板，与EEPROM芯片相连接的两个I2C引脚是有硬件I2C的，我们可以直接使用HAL库去配置STM32的硬件I2C，非常地方便。见代码清单23_4b。

软件模拟I2C：起始停止信号及速率配置

代码清单23_4a 起始停止信号及速率配置（bsp_i2c_gpio.c文件）¶

/*
************************************************
* 函 数 名: i2c_Delay
* 功能说明: I2C总线位延迟，最快400KHz
* 形    参：无
* 返 回 值: 无
************************************************
*/
static void i2c_Delay(void)
{
    uint8_t i;

    /*
    下面的时间是通过逻辑分析仪测试得到的。
    工作条件：CPU主频72MHz ，MDK编译环境，1级优化
    循环次数为10时，SCL频率 = 205KHz
    循环次数为7时，SCL频率 = 347KHz， SCL高电平时间1.5us，SCL低电平时间2.87us
    循环次数为5时，SCL频率 = 421KHz， SCL高电平时间1.25us，SCL低电平时间2.375us
    */
    for (i = 0; i < 10; i++);
}

/*
***********************************************
* 函 数 名: i2c_Start
* 功能说明: CPU发起I2C总线启动信号
* 形    参：无
* 返 回 值: 无
***********************************************
*/
void i2c_Start(void)
{
    /* 当SCL高电平时，SDA出现一个下跳沿表示I2C总线启动信号 */
    EEPROM_I2C_SDA_1();
    EEPROM_I2C_SCL_1();
    i2c_Delay();
    EEPROM_I2C_SDA_0();
    i2c_Delay();
    EEPROM_I2C_SCL_0();
    i2c_Delay();
}

/*
***********************************************
* 函 数 名: i2c_Start
* 功能说明: CPU发起I2C总线停止信号
* 形    参：无
* 返 回 值: 无
***********************************************
*/
void i2c_Stop(void)
{
    /* 当SCL高电平时，SDA出现一个上跳沿表示I2C总线停止信号 */
    EEPROM_I2C_SDA_0();
    EEPROM_I2C_SCL_1();
    i2c_Delay();
    EEPROM_I2C_SDA_1();
}

上述代码首先定义了一个i2c_Delay函数，该函数主要用于I2C模拟输出信号电平的延时，如控制SDA输出高电平后调用i2c_Delay延时，再控制SDA输出低电平，就达到了SDA维持高电平一段时间后切换的效果，而电平切换的延时会影响到I2C时序的通讯速率。在i2c_Delay函数内部，实际是直接使用了一个无实际操作、纯粹消耗时间的for循环，以此达到延时目的。该延时函数配置的循环次数是个经验值，在不同的芯片平台或主频不同的情况下，延时的时间会存在差异，我们使用逻辑分析仪测出了i2c_Delay函数在不同情况下对整个模拟I2C时序波特率的影响，具体的波特率见函数中的注释。

代码中的i2c_Start函数，用于控制SCL、SDA线产生I2C协议的起始信号，它利用“bsp_i2c_gpio.h”文件中的宏控制SDA、SCL线输出高低电平，而这输出高低电平的逻辑完全与图起始信号分解图中解说的I2C协议起始信号的时序一样，见图起始信号分解图对起始信号的分解，分解后的每个步骤实际就是i2c_Start函数内部对GPIO引脚的操作。

类似地，代码中的i2c_Stop函数用于控制SCL、SDA线产生I2C协议的停止信号，停止信号的分解见图停止信号分解图， i2c_Stop函数就是按该分解步骤控制GPIO的电平逻辑，实现停止信号。

软件模拟I2C：发送和接收一个字节

代码清单23_4a(续1) 收发数据（bsp_i2c_gpio.c文件）¶

/*
*************************************************
* 函 数 名: i2c_SendByte
* 功能说明: CPU向I2C总线设备发送8bit数据
* 形    参：_ucByte ： 等待发送的字节
* 返 回 值: 无
*************************************************
*/
void i2c_SendByte(uint8_t _ucByte)
{
    uint8_t i;

    /* 先发送字节的高位bit7 */
    for (i = 0; i < 8; i++) {
        if (_ucByte & 0x80) {
            EEPROM_I2C_SDA_1();
        } else {
            EEPROM_I2C_SDA_0();
        }
        i2c_Delay();
        EEPROM_I2C_SCL_1();
        i2c_Delay();
        EEPROM_I2C_SCL_0();
        if (i == 7) {
            EEPROM_I2C_SDA_1(); // 释放总线
        }
        _ucByte <<= 1;  /* 左移一个bit */
        i2c_Delay();
    }
}

/*
**********************************************
* 函 数 名: i2c_ReadByte
* 功能说明: CPU从I2C总线设备读取8bit数据
* 形    参：无
* 返 回 值: 读到的数据
**********************************************
*/
uint8_t i2c_ReadByte(void)
{
    uint8_t i;
    uint8_t value;

    /* 读到第1个bit为数据的bit7 */
    value = 0;
    for (i = 0; i < 8; i++) {
        value <<= 1;
        EEPROM_I2C_SCL_1();
        i2c_Delay();
        if (EEPROM_I2C_SDA_READ()) {
            value++;
        }
        EEPROM_I2C_SCL_0();
        i2c_Delay();
    }
    return value;
}

I2C通讯的主体是收发数据，实现时主要是根据I2C协议数据有效性的要求，读取或控制SDA信号线的电平，见上述的代码。

以发送函数i2c_SendByte为例，该函数以其输入参数作为要使用I2C协议输出的数据，该数据大小为一字节。函数的主体是一个8次的for循环，循环体执行一次将会对外发送一个数据位，循环结束时刚好发送完该字节数据。

循环体每位数据的发送逻辑见图数据有效性分解图，步骤分解如下：

(1) 程序对输入参数_ucByte和0x80“与”运算，判断其最高位的逻辑值，为1时控制SDA输出高电平，为0则控制SDA输出低电平；

(2) 延时，以此保证SDA线输出的电平已稳定，再进行后续操作；

(3) 控制SCL线产生高低电平跳变，也就是产生I2C协议中SCL线的通讯时钟；

(4) 在SCL线高低电平之间有个延时，该延时期间SCL线维持高电平，根据I2C协议，此时数据有效，通讯的另一方会在此时读取SDA线的电平逻辑，高电平时接收到该位为数据1，否则为0；

(5) 一次循环体执行结束， _ucByte左移一位以便下次循环发送下一位的数据；

(6) 如次循环8次，把_ucByte中的8位个数据位发送完毕，在最后一位发送完成后（此时循环计数器i=7），控制SDA线输出1（即高阻态），也就是说发送方释放SDA总线，等待接收方的应答信号；

(7) 本驱动程序中，检测应答信号由另一个独立函数i2c_WaitAck完成（后面再分析），此处释放SDA总线后直接退出循环和函数。

i2c_ReadByte函数的控制过程刚好反过来，不过由于本程序STM32都是作为I2C协议的通讯主机，所以SCL线的时钟信号依然是由STM32来控制产生的，即图数据有效性分解图中的SDA线将由另一端的发送方控制， STM32控制SCL产生通讯时钟，并在数据有效时读取SDA线的信号获得数据。

i2c_ReadByte函数也是以for循环为主体，循环体会被执行8次，执行完毕后将会接收到一个字节的数据，循环体接收数据的流程如下：

(1) 使用一个变量value暂存要接收的数据，每次循环开始前先对value的值左移1位，以给value变量的bit0腾出空间，bit0将用于缓存最新接收到的数据位，一位一位地接收并移位，最后拼出完整的8位数据；

(2) 控制SCL线进行高低电平切换，输出I2C协议通讯用的时钟；

(3) 在SCL线高低电平切换之间，有个延时，该延时确保给予了足够的时间让数据发送方进行处理，即发送方在SCL时钟驱动下通过SDA信号线发出电平逻辑信号，而这个延时之后，作为数据接收端的STM32使用宏EEPROM_I2C_SDA_READ读取SDA信号线的电平，若信号线为1，则value++，即把它的bit0置1，否则不操作（这样该位将保持为0），这样就读取到了一位的数据；

(4) SCL线切换成低电平后，加入延时，以便接收端根据需要切换SDA线输出数据；

(5) 循环结束后，value变量中包含有1个字节数据，使用return把它作为函数返回值返回；

(6) 本驱动程序中，作为接收端回复发送端的应答和非应答信号由i2c_Ack及i2c_NAck函数完成（后面再分析），此处接收完8位数据后直接返回数据退出函数。

软件模拟I2C：响应处理及返回

一次基本的I2C协议通讯过程包含起始信号、收或发8个数据位的数据、1个数据位的响应以及结束信号信号组成，这些环节中剩下最后的响应处理及返回将由下面的代码完成。

代码清单23_4a(续2) 响应处理及返回（bsp_i2c_gpio.c文件）¶

/*
*************************************************
* 函 数 名: i2c_WaitAck
* 功能说明:
CPU产生一个时钟，并读取器件的ACK应答信号
* 形    参：无
* 返 回 值: 返回0表示正确应答，1表示无器件响应
*************************************************
*/
uint8_t i2c_WaitAck(void)
{
    uint8_t re;

    EEPROM_I2C_SDA_1(); /* CPU释放SDA总线 */
    i2c_Delay();
    EEPROM_I2C_SCL_1(); /* CPU驱动SCL = 1,
                    此时器件会返回ACK应答 */
    i2c_Delay();
    if (EEPROM_I2C_SDA_READ()) {  /* CPU读取SDA口线状态 */
        re = 1;
    } else {
        re = 0;
    }
    EEPROM_I2C_SCL_0();
    i2c_Delay();
    return re;
}

/*
************************************************
* 函 数 名: i2c_Ack
* 功能说明: CPU产生一个ACK信号
* 形    参：无
* 返 回 值: 无
************************************************
*/
void i2c_Ack(void)
{
    EEPROM_I2C_SDA_0(); /* CPU驱动SDA = 0 */
    i2c_Delay();
    EEPROM_I2C_SCL_1(); /* CPU产生1个时钟 */
    i2c_Delay();
    EEPROM_I2C_SCL_0();
    i2c_Delay();
    EEPROM_I2C_SDA_1(); /* CPU释放SDA总线 */
}

/*
**********************************************
* 函 数 名: i2c_NAck
* 功能说明: CPU产生1个NACK信号
* 形    参：无
* 返 回 值: 无
**********************************************
*/
void i2c_NAck(void)
{
    EEPROM_I2C_SDA_1(); /* CPU驱动SDA = 1 */
    i2c_Delay();
    EEPROM_I2C_SCL_1(); /* CPU产生1个时钟 */
    i2c_Delay();
    EEPROM_I2C_SCL_0();
    i2c_Delay();
}

阅读下面的解释时请配合前面的图23_8 响应与非响应信号来理解，该图描述了I2C协议的响应信号时序。

首先是i2c_WaitAck函数，该函数用于STM32作为发送方时，等待及处理接收方传来的响应或非响应信号，即一般调用前面的i2c_SendByte函数后，再调用本函数检测响应。函数的实现如下：

STM32控制SDA信号线输出高阻态，释放它对SDA的控制权，由接收方控制；

(2) 控制SCL信号线切换高低电平，产生一个时钟信号，根据I2C协议，此时接收方若把SDA设置为低电平，就表示返回一个“应答”信号，若SDA保持为高电平，则表示返回一个“非应答 ”信号；

(3) 在SCL切换高低电平之间，有个延时确保给予了足够的时间让接收方返回应答信号，延时后使用宏EEPROM_I2C_SDA_READ读取SDA线的电平，根据电平值赋予re变量的值；

函数的最后返回re的值，接收到响应时返回0，未接收到响应时返回1。

当STM32作为数据接收端，调用i2c_ReadByte函数后，需要给发送端返回应答或非应答信号，此时可使用i2c_Ack及i2c_Nack函数处理，该处理与i2c_WaitAck函数相反，此时SDA线也由STM32控制，说明如下：

(1) 根据要返回“应答”还是“非应答”信号，先准备好SDA线的电平，i2c_Ack函数中把SDA线设置为低电平，表示“应答”信号，i2c_Nack函数中把SDA线设置为高电平，表示“非应答”信号；

(2) 控制SCL线进行高低电平切换，产生一个时钟信号，在SCL线的高低电平之间加入一个延时，确保有足够的时间让通讯的另一方接收到SDA信号线的电平；

(3) 在i2c_Ack函数的末尾，响应信号发送结束后，重新把SDA线设置为高电平以释放总线的控制权，方便后续的通讯。

以上就是软件模拟I2C协议的各个环节，可以看到，各个环节都是配合延时，使用内核直接控制SDA、SCL信号线GPIO的电平逻辑，产生符合I2C通讯协议的时序。若使用STM32的硬件I2C，初始化I2C外设后，调用库函数设置I2C外设的寄存器位即可产生以上各环节的起始、停止、应答及非应答信号，收发数据时也可以直接通过读写I2C的数据寄存器完成，相对而言减轻了内核的负担。

到这里，我们就完成了在MINI开发板上实现的软件模拟I2C。

下面是对指南者和霸道开发板、拂晓电机开发板使用HAL库对I2C模式的配置。

代码清单 23‑4b 指南者和霸道开发板、拂晓电机开发板：配置I2C模式¶

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

     I2C_Handle.Instance             = I2Cx;

     I2C_Handle.Init.AddressingMode  = I2C_ADDRESSINGMODE_7BIT;
     I2C_Handle.Init.ClockSpeed      = 400000;
     I2C_Handle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
     I2C_Handle.Init.DutyCycle       = I2C_DUTYCYCLE_2;
     I2C_Handle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
     I2C_Handle.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE;
     I2C_Handle.Init.OwnAddress1     = I2C_OWN_ADDRESS7 ;
     I2C_Handle.Init.OwnAddress2     = 0;
     /* Init the I2C */
     HAL_I2C_Init(&I2C_Handle);

     HAL_I2CEx_AnalogFilter_Config(&I2C_Handle, I2C_ANALOGFILTER_ENABLE);
 }

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

熟悉STM32 I2C结构的话，这段初始化程序就十分好理解了，指定连接EEPROM的I2C为EEPROM_I2C这里是I2C4，时序配置为上面用工具计算出来的值，自身地址为0，地址设置为7bit模式，关闭双地址模式，自身地址2也为0，禁止通用广播模式，禁止时钟延长模式。最后调用库函数HAL_I2C_Init把这些配置写入寄存器。

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

22.4.2.2.4. 向EEPROM写入一个字节的数据¶

初始化好I2C外设后，就可以使用I2C通讯了，我们看看如何向EEPROM写入一个字节的数据，对于MINI开发板，见代码清单23_5a，对于指南者和霸道开发板和拂晓电机开发板，见代码清单23_5b。

检测EEPROM的响应及单字节写入

代码清单23-5a 检测EEPROM的响应¶

/**bsp_i2c_ee.h文件**/
/* 24xx02的设备地址 */
#define EEPROM_DEV_ADDR     0xA0

/**bsp_i2c_gpio.h文件**/
#define EEPROM_I2C_WR 0   /* 写控制bit */
#define EEPROM_I2C_RD 1   /* 读控制bit */

/**bsp_i2c_ee.c文件**/
/*
***************************************************
* 函 数 名: i2c_CheckDevice
* 功能说明: 检测I2C总线设备，CPU向发送设备地址，
            然后读取设备应答来判断该设备是否存在
* 形    参：_Address：设备的I2C总线地址
* 返 回 值: 返回值 0 表示正确， 返回1表示未探测到
***************************************************
*/
uint8_t ee_CheckDevice(uint8_t _Address)
{
    uint8_t ucAck;

    i2c_Start();    /* 发送启动信号 */

    /* 发送设备地址+读写控制bit（0 = w， 1 = r) bit7
                                                先传 */
    i2c_SendByte(_Address | EEPROM_I2C_WR);
    ucAck = i2c_WaitAck();  /* 检测设备的ACK应答 */

    i2c_Stop();     /* 发送停止信号 */

    return ucAck;
}

以上代码涉及到几个宏，首先是EEPROM_DEV_ADDR（宏值为0XA0），这是EERPOM的设备地址，该地址与EEPROM的硬件接法有关，可参考前面图图23_13 EEPROM设备地址中的说明理解，此设备地址是一个8位写地址，即bit0代表写方向。在应用时，一般还与下面的宏EEPROM_I2C_WR（宏值为0）及EEPROM_I2C_RD（宏值为1）配合，如“EEPROM_DEV_ADDR | EEPROM_I2C_WR”这个或运算仍然表示8位的写方向地址（运算结果的bit0=0），而“EEPROM_DEV_ADDR | EEPROM_I2C_RD”则用来表示8位的读方向地址（运算结果的bit0=1）。

这段做代码的核心是ee_CheckDevice函数，它接收一个_Address参数作为要访问的设备地址，其函数内部过程如下：

(1) 使用i2c_Start函数产生一个I2C起始信号；

(2) 调用i2c_SendByte函数把设备地址_Address发送出去，发送时使用宏EEPROM_I2C_WR与_Address作“或”运算，表示它向I2C总线上广播寻找地址为_Address的设备，若总线上有该设备且工作正常，该设备将按照I2C协议返回一个应答信号；

(3) 调用i2c_WaitAck函数检测应答信号，若检测到，说明EEPROM工作正常；

(4) 检测响应后调用i2c_Stop发送停止信号，结束本次通讯；

(5) 把响应结果作为EEPROM检测结果返回，为0时表示EEPROM正常，为1表示异常。

这个函数实现的过程其实是下图 EEPROM单字节写入时序中的一部分，该图展示了如何向ERPOM写入一个字节的数据，此处我们仅使用了开头发送设备地址的一段，主要是为了获取EEPROM响应以判断EEPROM是否正常，不需要后续的数据写入过程，所以在响应之后就发送结束信号关闭此次通讯。

在完整的单字节写入通讯过程中，I2C主机（此处为STM32）发送的第1个字节为EEPROM的设备地址，用于从I2C总线上的众多设备中寻找到EEPROM，得到EEPROM的响应后，再发送第2个字节，当EEPROM接收到这个字节后，会把它理解成将要写入的EEPROM内存地址（即EEPROM内部的0-255个存储单元，它指定要存储在哪），第3个字节是要写入的数据内容。

对于STM32来说，无论是EEPROM的设备地址、内存地址还是要写入的数据，都是一个数值而已，本质都是一样的。它们都可使用i2c_SendByte函数一个字节一个字节地发送出去，而在EEPROM端，对数值的解释不同，它就分别代表了设备地址、内存地址及要写入的数据。

关于EEPROM的单字节写入，由于它比后面要介绍的“页写入”效率要低得多，所以在本工程中都使用“页写入”函数来代替，就没有编写专门的单字节写入的代码了。

代码清单 23‑5b 向EEPROM写入一个字节的数据¶

 /**
 * @brief   写一个字节到I2C EEPROM中
 * @param
 *   @arg pBuffer:缓冲区指针
 *   @arg WriteAddr:写地址
 * @retval  无
 */
 uint32_t I2C_EE_ByteWrite(uint8_t* pBuffer, uint8_t WriteAddr)
 {
     HAL_StatusTypeDef status = HAL_OK;

     status = HAL_I2C_Mem_Write(&I2C_Handle, EEPROM_ADDRESS, (uint16_t)
             WriteAddr, I2C_MEMADD_SIZE_8BIT, pBuffer, 1, 100);

     /* Check the communication status */
     if (status != HAL_OK) {
         /* Execute user timeout callback */
         //I2Cx_Error(Addr);
     }
     while (HAL_I2C_GetState(&I2C_Handle) != HAL_I2C_STATE_READY) {

     }

     /* Check if the EEPROM is ready for a new operation */
     while (HAL_I2C_IsDeviceReady(&I2C_Handle, EEPROM_ADDRESS,
             EEPROM_MAX_TRIALS, I2Cx_TIMEOUT_MAX) == HAL_TIMEOUT);

     /* Wait for the end of the transfer */
     while (HAL_I2C_GetState(&I2C_Handle) != HAL_I2C_STATE_READY) {

     }
     return status;
 }

这里我们只是简单调用库函数HAL_I2C_Mem_Write就可以实现，通过封装一次使用更方。

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

图 23‑14 EEPROM单字节写入时序(摘自《AT24C02》规格书)

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

22.4.2.2.5. EEPROM的页写入¶

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

图 23‑15 EEPROM页写入时序(摘自《AT24C02》规格书)

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

EEPROM的页写入代码实现，对于MINI开发板，见代码清单23_6a，对于指南者和霸道开发板、拂晓电机开发板，见代码清单23_6b。

EEPROM的页写入及状态等待

代码清单23_6a MINI开发板：EEPROM的页写入及状态等待¶

/*bsp_i2c_ee.h文件*/
/* 24xx02的页面大小 */
#define EEPROM_PAGE_SIZE      8

/*bsp_i2c_ee.c文件*/
/*
****************************************************
* 函 数 名: ee_WaitStandby
* 功能说明: 等待EEPROM到准备状态，在写入数据后，必须调用本函数
            写入操作时，使用I2C把数据传输到EEPROM后，
            EEPROM会向内部空间写入数据需要一定的时间，
            当EEPROM内部写入完成后会对I2C的设备寻址有响应，
            调用本函数可等待至EEPROM内部时序写入完毕
* 形    参：无
* 返 回 值: 0表示正常，1表示等待超时
****************************************************
*/
uint8_t ee_WaitStandby(void)
{
    uint32_t wait_count = 0;

    while (ee_CheckDevice(EEPROM_DEV_ADDR)) {
        //若检测超过次数，退出循环
        if (wait_count++>0xFFFF) {
            //等待超时
            return 1;
        }
    }
    //等待完成
    return 0;
}

/*
****************************************************
* 函 数 名: ee_WriteBytes
* 功能说明: 向串行EEPROM指定地址写入若干数据，采用页写操作提高写入效率
* 形    参：_usAddress : 起始地址
*          _usSize     : 数据长度，单位为字节
*          _pWriteBuf  : 存放读到的数据的缓冲区指针
* 返 回 值: 0 表示失败，1表示成功
****************************************************
*/
uint8_t ee_WriteBytes(uint8_t *_pWriteBuf, uint16_t _usAddress,
uint16_t _usSize)
{
    uint16_t i,m;
    uint16_t usAddr;

    /*
    写串行EEPROM不像读操作可以连续读取很多字节，每次写操作只能在同一个page。
    对于24xx02，page size = 8
    简单的处理方法为：按字节写操作模式，每写1个字节，都发送地址
    为了提高连续写的效率: 本函数采用page wirte操作。
    */

    usAddr = _usAddress;
    for (i = 0; i < _usSize; i++) {
        /* 当发送第1个字节或是页面首地址时，需要重新发起启动信号和地址 */
        if ((i == 0) || (usAddr & (EEPROM_PAGE_SIZE - 1)) == 0) {
            /*　第０步：发停止信号，结束上一页的通讯，准备下一次通讯　*/
            i2c_Stop();

            /* 通过检查器件应答的方式，判断内部写操作是否完成,一般小于 10ms
            CLK频率为200KHz时，查询次数为30次左右
            原理同 ee_WaitStandby 函数，但该函数检查完成后会产生停止信号，
            不适用于此处*/
            for (m = 0; m < 1000; m++) {
                /* 第1步：发起I2C总线启动信号 */
                i2c_Start();

            /* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
                i2c_SendByte(EEPROM_DEV_ADDR | EEPROM_I2C_WR);  /* 此处是写指令 */

                /* 第3步：发送一个时钟，判断器件是否正确应答 */
                if (i2c_WaitAck() == 0) {
                    break;
                }
            }
            if (m  == 1000) {
                goto cmd_fail;  /* EEPROM器件写超时 */
            }

            /* 第4步：发送字节地址，24C02只有256字节，因此1个字节就够了，
            如果是24C04以上，那么此处需要连发多个地址 */
            i2c_SendByte((uint8_t)usAddr);

            /* 第5步：等待ACK */
            if (i2c_WaitAck() != 0) {
                goto cmd_fail;  /* EEPROM器件无应答 */
            }
        }

        /* 第6步：开始写入数据 */
        i2c_SendByte(_pWriteBuf[i]);

        /* 第7步：发送ACK */
        if (i2c_WaitAck() != 0) {
            goto cmd_fail;  /* EEPROM器件无应答 */
        }

        usAddr++; /* 地址增1 */
    }

    /* 命令执行成功，发送I2C总线停止信号 */
    i2c_Stop();

    //等待最后一次EEPROM内部写入完成
    if (ee_WaitStandby() == 1)
        goto cmd_fail;

    return 1;

cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
    /* 发送I2C总线停止信号 */
    i2c_Stop();
    return 0;
}

这段代码中包含了一个ee_WaitStandby函数，它的作用是等待EEPROM准备就绪。当EEPROM接收完STM32传来要写入的数据后（即一次I2C通讯完毕），它会启动内部时序，往存储单元内写入接收到的数据，而这个过程需要花费一点时间，在此期间EEPROM不会响应外部的任何I2C信号，所以下一次操作前需要确保EEPROM内部写入时序完成。ee_WaitStandby函数就实现了这样的功能，它直接循环调用ee_CheckDevice函数，前面已经讲解了ee_CheckDevice函数的功能是发送EEPROM设备地址然后检查响应，所以此处实质是循环等待直至获取到EEPROM的响应信号，或检测超过次数认为响应失败，一旦获取到EEPROM的响应即可认为它的内部写入时序完成，可以进行后续操作。

接下来分析ee_WriteBytes函数，它接收三个输入参数：_pWriteBuf、_usAddress和_usSize分别表示要存储到EEPROM的数据，要存储到EEPROM的存储单元起始地址及要存储多少个数据，函数的执行流程如下：

(1) 整个函数的操作主要由第58行的for循环完成，它循环_usSize次，即有多少个要发送的数据它就执行多少次，每次循环会发送一个字节的数据；

(2) 由于本函数采用的是页写入方式，一个发送过程最多可以发送8个字节的数据，所以每发送8个数据后发送一次起始信号、设备地址及内存地址即可，第60行的if就是作这样的判断，每发送完一页数据EEPROM_PAGE_SIZE（8个字节），那么条件成立，执行第60-90行的if分支；

(3) 在这个分支中，先调用i2c_Stop函数，结束上一次的页写入过程，准备下一次通讯；

(4) 在第68行的for循环，使用i2c_Start、i2c_SendByte及i2c_WaitAck函数产生新的一次起始信号、对EEPROM设备寻址并检测EEPROM是否有响应，若有响应跳出这个循环，若尝试了1000次还没接收到响应则认为EEPROM寻址超时，可能存在硬件错误，使用goto跳转到函数尾的错误处理并退出函数。此处使用for循环跟前面等待EEPROM内部写入时序完成的ee_WaitStandby函数思路是一样的，它等待至上一次写入完成后才进行下次的操作，不直接调用ee_WaitStandby函数是因为该函数检测后会发送I2C停止信号，而此处希望等待完成后进行后续的页写入操作；

(5) 若检测到EEPROM响应，本函数将执行到第86行，这里调用i2c_SendByte函数发送将要写入的EEPROM内部存储单元地址，发送后检查应答；

(6) 若一切顺利，就可以开始发送数据了，程序执行到第95行，注意这里的代码已经不属于前面第60行if语句每8个数据执行一次的条件执行区域了，所以这个i2c_SendByte将在每个循环执行一次，它把输入参数_pWriteBuf存储的数据通过I2C协议发送出去，而EEPROM也将把这些数值写入到对应的存储单元中；

(7) 第102行的usAddr地址变量自增1，该变量参与到前面第60行if语句判断中，每8个循环执行一次，并把该地址发送给EEPORM；

(8) 第106行，已经退出发送数据循环，所有数据已经发送完成，这里调用i2c_Stop结束最后一次页写入；

(9) 第109行，调用ee_WaitStandby函数等待最后一次页写入操作的内部时序完成，防止调用本函数后用户立刻执行其它EEPROM操作时无响应，等待结束后使用return退出函数；

(10) 第114行是标号cmd_fail的处理，前面写入过程产生各种错误后都跳转至此处，调用i2c_Stop函数发送停止信号，释放I2C总线，然后使用return退出函数。

代码清单23_6b 指南者和霸道开发板、拂晓电机开发板：EEPROM的页写入¶

 /**
 * @brief  在EEPROM的一个写循环中可以写多个字节，但一次写入的字节数
 *         不能超过EEPROM页的大小，AT24C02每页有8个字节
 * @param
 *   @arg pBuffer:缓冲区指针
 *   @arg WriteAddr:写地址
 *     @arg NumByteToWrite:写的字节数
 * @retval  无
 */
 uint32_t I2C_EE_PageWrite(uint8_t* pBuffer, uint8_t WriteAddr,
 uint8_t NumByteToWrite)
 {
     HAL_StatusTypeDef status = HAL_OK;
     /* Write EEPROM_PAGESIZE */
     status=HAL_I2C_Mem_Write(&I2C_Handle, EEPROM_ADDRESS,WriteAddr,
 I2C_MEMADD_SIZE_8BIT, (uint8_t*)(pBuffer),NumByteToWrite, 100);

     while (HAL_I2C_GetState(&I2C_Handle) != HAL_I2C_STATE_READY) {

     }

     /* Check if the EEPROM is ready for a new operation */
     while (HAL_I2C_IsDeviceReady(&I2C_Handle, EEPROM_ADDRESS,
 EEPROM_MAX_TRIALS, I2Cx_TIMEOUT_MAX) == HAL_TIMEOUT);
     /* Wait for the end of the transfer */
     while (HAL_I2C_GetState(&I2C_Handle) != HAL_I2C_STATE_READY) {

     }
     return status;
 }

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

22.4.2.2.6. 多字节写入¶

多次写入数据时，利用EEPROM的页写入方式，避免单字节读写时候的等待。多个数据写入过程见代码清单23_7。

代码清单 23‑7 指南者和霸道开发板、拂晓电机开发板：多字节写入¶

 /**
 * @brief   将缓冲区中的数据写到I2C EEPROM中
 * @param
 *   @arg pBuffer:缓冲区指针
 *   @arg WriteAddr:写地址
 *     @arg NumByteToWrite:写的字节数
 * @retval  无
 */
 void I2C_EE_BufferWrite(uint8_t* pBuffer, uint8_t WriteAddr,
 uint16_t NumByteToWrite)
 {
     uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0;

     Addr = WriteAddr % EEPROM_PAGESIZE;
     count = EEPROM_PAGESIZE - Addr;
     NumOfPage =  NumByteToWrite / EEPROM_PAGESIZE;
     NumOfSingle = NumByteToWrite % EEPROM_PAGESIZE;

     /* If WriteAddr is I2C_PageSize aligned  */
     if (Addr == 0) {
         /* If NumByteToWrite < I2C_PageSize */
         if(NumByteToWrite <= count)
         {
             I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
         }
         /* If NumByteToWrite > I2C_PageSize */
         else {
             while (NumOfPage--) {
                 I2C_EE_PageWrite(pBuffer, WriteAddr, EEPROM_PAGESIZE);
                 WriteAddr +=  EEPROM_PAGESIZE;
                 pBuffer += EEPROM_PAGESIZE;
             }

             if (NumOfSingle!=0) {
                 I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
             }
         }
     }
     /* If WriteAddr is not I2C_PageSize aligned  */
     else {
         /* If NumByteToWrite < I2C_PageSize */
         if (NumOfPage== 0) {
             I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
         }
         /* If NumByteToWrite > I2C_PageSize */
         else {
             NumByteToWrite -= count;
             NumOfPage =  NumByteToWrite / EEPROM_PAGESIZE;
             NumOfSingle = NumByteToWrite % EEPROM_PAGESIZE;

             if (count != 0) {
                 I2C_EE_PageWrite(pBuffer, WriteAddr, count);
                 WriteAddr += count;
                 pBuffer += count;
             }

             while (NumOfPage--) {
                 I2C_EE_PageWrite(pBuffer, WriteAddr, EEPROM_PAGESIZE);
                 WriteAddr +=  EEPROM_PAGESIZE;
                 pBuffer += EEPROM_PAGESIZE;
             }
             if (NumOfSingle != 0) {
                 I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
             }
         }
     }
 }

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

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

若writeAddress=16，计算得Addr=16%8= 0 ，count=8-0= 8；
同时，若NumOfPage=22，计算得NumOfPage=22/8= 2，NumOfSingle=22%8= 6。
数据传输情况如表 23‑2

表 23‑2 首地址对齐到页时的情况

不影响	0	1	2	3	4	5	6	7
不影响	8	9	10	11	12	13	14	15
第1页	16	17	18	19	20	21	22	23
第2页	24	25	26	27	28	29	30	31
NumOfSingle=6	32	33	34	35	36	37	38	39

若writeAddress=17，计算得Addr=17%8= 1，count=8-1= 7；
同时，若NumOfPage=22，
先把count去掉，特殊处理，计算得新的NumOfPage=22-7= 15
计算得NumOfPage=15/8= 1，NumOfSingle=15%8= 7。
数据传输情况如表 23‑3

表 23‑3 首地址未对齐到页时的情况

不影响	0	1	2	3	4	5	6	7
不影响	8	9	10	11	12	13	14	15
count=7	16	17	18	19	20	21	22	23
第1页	24	25	26	27	28	29	30	31
NumOfSingle=7	32	33	34	35	36	37	38	39

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

22.4.2.2.7. 从EEPROM读取数据¶

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

图 23‑16 EEPROM数据读取时序

读时序的第一个通讯过程中，使用I2C发送设备地址寻址(写方向)，接着发送要读取的“内存地址”；第二个通讯过程中，再次使用I2C发送设备地址寻址，但这个时候的数据方向是读方向；在这个过程之后，EEPROM会向主机返回从“内存地址”开始的数据，一个字节一个字节地传输，只要主机的响应为“应答信号”，它就会一直传输下去，主机想结束传输时，就发送“非应答信号”，并以“停止信号”结束通讯，作为从机的EEPROM也会停止传输。HAL库已经帮我们实现了这一个过程，我们只是简单封装一下就可以直接使用，实现代码对于MINI开发板，见代码清单23_8a，对于指南者和霸道开发板、拂晓电机开发板，见代码清单23_8b。

代码清单23-8a MINI开发板：从EEPROM读取数据¶

/*
****************************************************
* 函 数 名: ee_ReadBytes
* 功能说明: 从串行EEPROM指定地址处开始读取若干数据
* 形    参：_usAddress : 起始地址
    *      _usSize     : 数据长度，单位为字节
    *      _pReadBuf   : 存放读到的数据的缓冲区指针
* 返 回 值: 0 表示失败，1表示成功
****************************************************
*/
uint8_t ee_ReadBytes(uint8_t *_pReadBuf, uint16_t _usAddress,
                    uint16_t _usSize)
{
    uint16_t i;

    /* 采用串行EEPROM随即读取指令序列，连续读取若干字节 */

    /* 第1步：发起I2C总线启动信号 */
    i2c_Start();

    /* 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读 */
    i2c_SendByte(EEPROM_DEV_ADDR | EEPROM_I2C_WR);  /* 此处是写方向 */

    /* 第3步：等待ACK */
    if (i2c_WaitAck() != 0) {
        goto cmd_fail;  /* EEPROM器件无应答 */
    }

    /* 第4步：发送字节地址，24C02只有256字节，因此1个字节就够了，
    如果是24C04以上，那么此处需要连发多个地址 */
    i2c_SendByte((uint8_t)_usAddress);

    /* 第5步：等待ACK */
    if (i2c_WaitAck() != 0) {
        goto cmd_fail;  /* EEPROM器件无应答 */
    }

    /* 第6步：重新启动I2C总线。
    前面的代码的目的向EEPROM传送地址，下面开始读取数据 */
    i2c_Start();

    /* 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，
    0表示写，1表示读 */
    i2c_SendByte(EEPROM_DEV_ADDR | EEPROM_I2C_RD);  /* 此处是读指令 */

    /* 第8步：发送ACK */
    if (i2c_WaitAck() != 0) {
        goto cmd_fail;  /* EEPROM器件无应答 */
    }

    /* 第9步：循环读取数据 */
    for (i = 0; i < _usSize; i++) {
        _pReadBuf[i] = i2c_ReadByte();  /* 读1个字节 */

        /* 每读完1个字节后，需要发送Ack， 最后一个字节不需要Ack，发Nack */
        if (i != _usSize - 1) {
            i2c_Ack();  /* 中间字节读完后，CPU产生ACK信号(驱动SDA = 0) */
        } else {
            i2c_NAck(); /* 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1)

        }
    }
    /* 发送I2C总线停止信号 */
    i2c_Stop();
    return 1; /* 执行成功 */

cmd_fail: /* 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备 */
    /* 发送I2C总线停止信号 */
    i2c_Stop();
    return 0;
}

这段读取EEPROM内容的ee_ReadBytes函数写过程跟前面的写入函数类似：

产生第一次起始信号，并发送EEPROM设备地址，地址中的bit0表示写方向；
接收到应答后，向EEPROM发送要读取的存储单元地址；

(3) 接收到应答后，产生第二次起始信号，发送EEPROM的设备地址，地址中的bit0表示读方向，注意两次起始信号间没有停止信号，这依然是同一次通讯过程；

在for循环中，连续调用i2c_ReadByte函数一个字节一个字节地接收EEPROM返回的数据内容并存储到数组中；
接收到足够的数据后，产生停止信号，退出函数。

代码清单 23‑8b 指南者和霸道开发板、拂晓电机开发板：从EEPROM读取数据¶

 /**
 * @brief   从EEPROM里面读取一块数据
 * @param
 *   @arg pBuffer:存放从EEPROM读取的数据的缓冲区指针
 *   @arg WriteAddr:接收数据的EEPROM的地址
 *     @arg NumByteToWrite:要从EEPROM读取的字节数
 * @retval  无
 */
 uint32_t I2C_EE_BufferRead(uint8_t* pBuffer, uint8_t ReadAddr, uint16_t NumByteToRead)
 {
     HAL_StatusTypeDef status = HAL_OK;

     status=HAL_I2C_Mem_Read(&I2C_Handle,EEPROM_ADDRESS,ReadAddr,
     I2C_MEMADD_SIZE_8BIT, (uint8_t *)pBuffer, NumByteToRead, 1000);

     return status;
 }

这里代码非常简单，我们只需要确定I2C的地址，数据格式，数据存储指针，数据大小，超时设置就可以把想要的数据读回来。

22.4.2.3. main文件¶

22.4.2.3.1. EEPROM读写测试函数¶

完成基本的读写函数后，接下来我们编写一个读写测试函数来检验驱动程序。对于MINI开发板，见代码清单23_9a，对于指南者和霸道开发板、拂晓电机开发板，见代码清单23_9b。

代码清单23-9a MINI开发板的 EEPROM读写测试函数¶

/*
* eeprom AT24C02 读写测试
* 正常返回1，异常返回0
*/
uint8_t ee_Test(void)
{
    uint16_t i;
    uint8_t write_buf[EEPROM_SIZE];
    uint8_t read_buf[EEPROM_SIZE];

    /*----------------------------------------------------*/
    if (ee_CheckDevice(EEPROM_DEV_ADDR) == 1) {
        /* 没有检测到EEPROM */
        printf("没有检测到串行EEPROM!\r\n");

        return 0;
    }
    /*----------------------------------------------------*/
    /* 填充测试缓冲区 */
    for (i = 0; i < EEPROM_SIZE; i++) {
        write_buf[i] = i;
    }
    /*----------------------------------------------------*/
    if (ee_WriteBytes(write_buf, 0, EEPROM_SIZE) == 0) {
        printf("写eeprom出错！\r\n");
        return 0;
    } else {
        printf("写eeprom成功！\r\n");
    }

    /*----------------------------------------------------*/
    if (ee_ReadBytes(read_buf, 0, EEPROM_SIZE) == 0) {
        printf("读eeprom出错！\r\n");
        return 0;
    } else {
        printf("读eeprom成功，数据如下：\r\n");
    }
    /*----------------------------------------------------*/
    for (i = 0; i < EEPROM_SIZE; i++) {
        if (read_buf[i] != write_buf[i]) {
            printf("0x%02X ", read_buf[i]);
            printf("错误:EEPROM读出与写入的数据不一致");
            return 0;
        }
        printf(" %02X", read_buf[i]);

        if ((i & 15) == 15) {
            printf("\r\n");
        }
    }
    printf("eeprom读写测试成功\r\n");
    return 1;
}

在这个测试函数中先调用了ee_CheckDevice函数检测EEPROM的响应，通过是否接收到响应来判断EEPROM是否工作正常；接着填充一个数组，数组的内容为0，1，2，3至N，然后把这个数组的内容写入到EEPROM中，写入完毕后再从EEPROM的地址中读取数据，把读取得到的与写入的数据进行校验，若一致说明读写正常，否则读写过程有问题或者EEPROM芯片不正常。

代码清单 23‑9b 指南者和霸道开发板、拂晓电机开发板的 EEPROM读写测试函数¶

 /**
 * @brief  I2C(AT24C02)读写测试
 * @param  无
 * @retval 正常返回1 ，不正常返回0
 */
 uint8_t I2C_Test(void)
 {
     uint16_t i;

     EEPROM_INFO("写入的数据");

     for ( i=0; i<DATA_Size; 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, DATA_Size);

     EEPROM_INFO("读出的数据");
     //将EEPROM读出数据顺序保持到I2c_Buf_Read中
     I2C_EE_BufferRead(I2c_Buf_Read, EEP_Firstpage, DATA_Size);
     //将I2c_Buf_Read中的数据通过串口打印
     for (i=0; i<DATA_Size; 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文件中”，在以后的代码我们常常会用类似的宏来输出调试信息。

22.4.2.3.2. main函数¶

最后编写main函数，函数中初始化串口、I2C外设，然后调用上面的I2C_Test函数进行读写测试，对于MINI开发板，见代码清单23_10a，对于指南者和霸道开发板、拂晓电机开发板，见代码清单23_10b。

代码清单 23-10a MINI开发板的 main函数¶

int main(void)
{
    HAL_Init();
    /* 配置系统时钟为72 MHz */
    SystemClock_Config();

    /*初始化USART 配置模式为 115200 8-N-1，中断接收*/
    DEBUG_USART_Config();

    printf("\r\n 这是一个EEPROM 读写小数和长整数实验\r\n");

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

    /*读取数据标志位*/
    ee_ReadBytes(&cal_flag, 0, 1);

    if ( cal_flag != 0xCD ) {
        /*若标志等于0xcd，表示之前已有写入数据*/
        printf("\r\n没有检测到数据标志，FLASH没有存储数据，即将进行小数写入实验\r\n");
        cal_flag =0xCD;

        /*写入标志到0地址*/
        ee_WriteBytes(&cal_flag, 0, 1);

        /*生成要写入的数据*/
        for ( k=0; k<7; k++ ) {
            double_buffer[k] = k +0.1;
            int_bufffer[k]=k*500+1 ;
        }

        /*写入小数数据到地址10*/
        ee_WriteBytes((void*)double_buffer,DOUBLE_ADDR, sizeof(double_buffer));
        /*写入整数数据到地址60*/
        ee_WriteBytes((void*)int_bufffer, LONGINT_ADDR, sizeof(int_bufffer));

        printf("向芯片写入数据：");
        /*打印到串口*/
        for ( k=0; k<7; k++ ) {
            printf("小数tx = %LF\r\n",double_buffer[k]);
            printf("整数tx = %d\r\n",int_bufffer[k]);
        }

        printf("\r\n请复位开发板，以读取数据进行检验\r\n");

    } else {
        printf("\r\n检测到数据标志\r\n");

        /*读取小数数据*/
        ee_ReadBytes((void*)double_buffer, DOUBLE_ADDR, sizeof(double_buffer));

        /*读取整数数据*/
        ee_ReadBytes((void*)int_bufffer, LONGINT_ADDR, sizeof(int_bufffer));

        printf("\r\n从芯片读到数据：\r\n");
        for ( k=0; k<7; k++ ) {
            printf("小数 rx = %LF \r\n",double_buffer[k]);
            printf("整数 rx = %d \r\n",int_bufffer[k]);
        }

    }

    while (1) {
    }
}

代码清单 23‑10b 指南者和霸道开发板、拂晓电机开发板的 main函数¶

 /**
 * @brief  主函数
 * @param  无
 * @retval 无
 */
 int main(void)
 {
     /* 配置系统时钟为72 MHz */
     SystemClock_Config();

     /* 初始化RGB彩灯 */
     LED_GPIO_Config();

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

     printf("\r\n 欢迎使用野火  STM32 F103 开发板。\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) {
     }

22.4.3. 下载验证¶

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

图 23‑17 MINI开发板 EEPROM 测试成功

图 23‑17 指南者和霸道开发板、拂晓电机开发板 EEPROM 测试成功