STM32学习笔记——十九、I2C——读写EEPROM
0 前言
本章参考资料：
- 《STM32F10X-中文参考手册》I2C 章节及《I2C 总线协议》
- 若对I2C 通讯协议不了解，可先阅读《I2C 总线协议》文档的内容学习
关于EEPROM 存储器 - 请参考“常用存储器介绍”章节
- 实验中的EEPROM，请参考其规格书《AT24C02》来了解。
1 I2C 协议简介
I2C通讯协议
- 引脚少、硬件实现简单
- 可扩展性强
- 不需要USART、CAN等通讯协议的外部收发设备
- 被广泛使用在系统内多个集成电路（IC）间的通讯
通讯协议可以分层方式来简化并理解
- 最基本的是分为物理层和协议层
- 物理层：
- 规定通讯系统中具有机械、电子功能部分的特性，确保原始数据在物理媒体的传输
- 协议层：
- 规定通讯逻辑，统一收发双方的数据打包、解包标准
- 物理层规定：我们用嘴巴还是肢体交流
- 协议层规定我们用中文还是英文交流
1.1 I2C物理层
I2C设备之间常用连接方式，见下图I2C通讯系统：
物理层特点：
- 是一个支持设备的总线
- “总线”指多个设备共用的信号线
- 一个通讯总线，可连接多个I2C通讯设备，支持多个通讯主机及多个通讯从机
- 一个I2C总线，只使用两条总线线路
- 一条双向串行数据线(SDA)：数据线用来表示数据
- 一条串行时钟线(SCL)：时钟线用来数据收发同步
- 每个连接到总线的设备，都有一个独立地址
- 主机可以通过这个地址，进行不同设备之间的访问
- 总线通过上拉电阻接到电源
- I2C设备空闲时，输出高阻态
- 当所有设备都空闲时，都输出高阻态，由上拉电阻把总线拉成高电平
- 多个主机同时使用总线时
- 防止数据冲突
- 利用冲裁方式决定由哪个设备占用总线
- 具有三种模式：
- 标准模式传输速率为100kbit/s
- 快速模式为400kbit/s
- 高速模式可达3.4Mbit/s(目前大多数I2C设备尚不支持高速模式)
- 连接到相同总线的I2C数量收到总线的最大电容400pF限制
1.2 I2C协议层
I2C的协议定义了
- 通讯的起始和停止信号
- 数据有效性
- 相应
- 仲裁
- 时钟同步
- 地址广播
- 等环节
1.2.1 I2C基本读写过程
I2C通讯过程的基本结构，见下述三图
- 主机写数据到从机图
- 主机由从机中读数据图
- I2C通讯复合格式图
这些图表示的是主机和从机通讯时，SDA线 的数据包序列
- S表示由主机的I2C接口产生的传输起始信号(S)
- 连接到I2C总线上的所有从机都会接收到这个信号
- 起始信号产生后，所有从机开始等待主机接下来广播的从机地址信号(SLAVE_ADDRESS)
- 每个设备地址唯一
- 当主机广播的地址与某个设备地址相同时，设备被选中，未选中的则忽略之后的数据信号
- I2C协议中，从机地址可以是7位或10位
- 地址位之后，是传输方向的选择位
- 该位为0时，表示后面的数据传输方向是由主机传输至从机，即主机向从机写数据
- 该位为1时，相反，即主机由从机读数据
- 从机接收到匹配地址后，主机或从机返回一个**应答(ACK)或非应答(NACK)**信号
- 只有接收到应答信号后，主机才能继续发送或接受数据
1.2.1.1 写过程
若配置的方向传输位为“写数据”方向
- 即第一幅图的情况，广播完地址，接收到应答信号后
- 主机开始正式向从机传输数据(DATA)，数据包的大小为8 位，主机每发送完一个字节数据，都要等待从机的应答信号(ACK)
- 重复这个过程
- 可以向从机传输N 个数据，这个N 没有大小限制。
- 当数据传输结束时，主机向从机发送一个停止传输信号§，表示不再传输数据。
1.2.1.2 读数据
若配置的方向传输位为“读数据”方向
- 即第二幅图的情况，广播完地址，接收到应答信号后
- 从机开始向主机返回数据(DATA)，数据包大小也为8 位
- 从机每发送完一个数据，都会等待主机的应答信号(ACK)
- 重复这个过程
- 可以返回N 个数据，这个N 也没有大小限制
- 当主机希望停止接收数据时，就向从机返回一个非应答信号(NACK)，则从机自动停止数据传输
1.2.1.3 读和写数据
除了基本的读写，I2C 通讯更常用的是复合格式
- 即第三幅图的情况，该传输过程有两次起始信号(S)
- 一般在第一次传输中，主机通过SLAVE_ADDRESS 寻找到从设备后，发送一段“数据”，这段数据通常用于表示从设备内部的寄存器或存储器地址(注意区分它与SLAVE_ADDRESS 的区别)；
- 在第二次的传输中，对该地址的内容进行读或写。
- 也就是说，第一次通讯是告诉从机读写地址，第二次则是读写的实际内容
1.2.2 通讯流程各个信号的分解：
1.2.2.1 通讯的起始和停止信号
**起始(S)和停止§**是两种特殊的状态
- 起始和停止信号一般由主机产生
- 通讯的起始：当SCL线是高电平时SDA线从高电平向低电平切换
- 通讯的停止：当SCL线是高电平时SDA线由低电平向高电平切换
1.2.2.2 数据有效性
I2C使用SDA信号线来传输数据，使用SCL信号线进行数据同步
- SDA 数据线在SCL的每个时钟周期传输一位数据
- 传输时：
- SCL为高电平时，SDA表示的数据有效
- SDA 为高电平时表示数据1，为低电平时表示数据0
- 当SCL为低电平时，SDA数据无效
- SDA进行电平切换，为下一次数据做好准备
- SCL为高电平时，SDA表示的数据有效
- 每次数据传输都以字节为单位
- 每次传输的额字节数不受限制
1.2.2.3 地址及数据方向
I2C总线上的每个设备都有自己的独立地址
主机发起通讯时，通过SDA 信号线发送设备地址(SLAVE_ADDRESS)来查找从机
- I2C协议规定：
- 设备地址可以是7位或10位，实际7位应用较广泛
- 紧跟地址的一个数据位用来表示数据传输方向
- 数据方向位(R/)，第8位或第11位
- 数据方向位为1时，表示主机由从机读数据
- 读数据方向时，主机会释放对SDA 信号线的控制，由从机控制SDA 信号线，主机接收信号
- 数据方向位为0时，表示主机向从机写数据
- 写数据方向时，SDA 由主机控制，从机接收信号
1.2.2.4 响应
I2C的数据和地址传输都带相应
- 响应包括：应答(ACK)和非应答(NACK)两种信号
- 作为数据接收端时：
- 当设备（无论主从机）接收到I2C传输的一个字节数据或地址后，
- 若希望对方继续发送数据，需要向对方发送“应答(ACK)信号”
- 发送方会继续发送下一个数据
- 若接收端希望结束数据传输，则向对方发送“非应答(NACK)”信号
- 发送方接受到信号后会产生一个停止信号，结束信号传输
- 传输时，主机产生时钟，在第9个时钟时，数据发送端会释放SDA的控制权，由数据接收端控制SDA
- 若SDA高点平，表示非应答信号(NACK)，低电平表示应答信号(ACK)
2 STM32的I2C特性及架构
软件模拟协议：
- 直接控制STM32的两个GPIO引脚，分别用作SCL及SDA，按照上述信号的时序要求，直接像控制LED灯那样控制引脚的输出，就可以实现I2C通讯
- 直接控制GPIO引脚电平产生通讯时序时，需要由CPU控制每个时刻的引脚状态
硬件协议：
- STM32的I2C片上外设专门负责实现I2C通讯协议，只要配置好外设，就会自动根据协议要求产生通讯信号，收发数据并缓存
- CPU只需要检测该外设的状态和访问数据寄存器，就能完成数据收发
- 减轻了CPU的工作，使软件设计更加简单
2.1 STM32的I2C外设简介
- STM32的I2C外设可用作通讯的主机及从机，支持100Kbit/s和400Kbit/s的速率
- 支持7位、10位设备地址
- 支持DMA数据传输
- 有数据校验功能
- I2C外设还支持SMBus2.0协议
2.2 STM32的I2C结构剖析
2.2.1 通讯引脚
- I2C的所有硬件架构，都是根据图中左侧SCL线和SDA线展开的（SMBA线用于SMBUS的警告信号，I2C通讯没有使用）
- STM32芯片有多个I2C外设
- I2C通讯信号线引出到不同的GPIO引脚上，使用时必须配置到这些指定引脚
- 关于GPIO引脚的复用功能，以规格书为准
STM32F10x的I2C引脚
2.2.2 时钟控制逻辑
SCL线的时钟信号
- 由I2C接口根据**时钟控制寄存器(CCR)**控制
- 控制的参数主要为时钟频率
- 配置I2C的CCR寄存器可修改通讯速率相关参数：
- 可选择**“标准/快速”模式**，分别对应100/400Kbit/s的通讯速率
- 快速模式下，可选择SCL时钟的占空比
- 修改SCL的高低电平会影响数据采样
- 两个模式比例差别不大，不严格要求的话，可以随便选择
- CCR寄存器还有一个12位的配置因子CCR
- 与I2C外设的输入时钟源共同作用，产生SCL时钟
- STM32的I2C外设都挂在在APB1总线上
- 使用APB1的时钟源PCLK1
- SCL信号线的输出时钟公式如下：
例子：我们的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 协调的，只要它的时钟频率不远高于标准即可。
2.2.3 数据控制逻辑
I2C的SDA信号主要连接到数据移位寄存器上
- 数据来源及目标是
- 数据寄存器(DR)
- 地址寄存器(OAR)
- PEC寄存器
- SDA数据线
- 向外发送数据时
- 数据移位寄存器以“数据寄存器”为数据源
- 把数据一位一位通过SDA信号线发送出去
- 从外部接受数据时
- 数据移位寄存器把SDA信号线采集到的数据一位一位地存储到“数据寄存器”中
- 使能了数据校验：
- 接收到地数据会经过PCE计算起运算
- 运算结果存储在“PCE寄存器”
- 从机模式时
- 接收到设备地址信号，数据移位寄存器会把接收到地地址与**“I2C地址寄存器”**地值做比较，相应主机地寻址
- STM32自身I2C地址
- 可通过修改“自身地址寄存器”修改
- 支持同时使用两个I2C设备地址
- 两个地址分别存储在OAR1和OAR2中
2.2.4 整体控制逻辑
整体控制逻辑：
- 负责协调整个I2C外设
- 控制逻辑的工作模式：
- 根据配置的**控制寄存器(CR1/CR2)**的参数而改变
- 外设工作时，控制逻辑会根据外设的工作状态修改“状态寄存器(SR1和SR2)”
- 只要读取这些寄存器相关的寄存器位，可以了解I2C的工作状态
- 负责控制产生
- I2C终端信号
- DMA请求
- 各种I2C通讯信号(起始、停止、相应信号等)
2.3 通讯过程
使用I2C 外设通讯时：
- 在通讯的不同阶段，对“状态寄存器(SR1 及SR2)”的不同数据位写入参数
- 通过读取这些寄存器标志来了解通讯状态
2.3.1 主发送器
“主发送器”流程，即作为I2C 通讯的主机端时，向外发送数据时的过程
主发送器发送流程及事件说明如下：
- 控制产生起始信号(S)，当发生起始信号后，它产生事件“EV5”，并会对SR1 寄存器的“SB”位置1，表示起始信号已经发送；
- 紧接着发送设备地址并等待应答信号，若有从机应答，则产生事件“EV6”及“EV8”，这时SR1 寄存器的“ADDR”位及“TXE”位被置1，ADDR 为1 表示地址已经发送，TXE 为1 表示数据寄存器为空；
- 以上步骤正常执行并对ADDR 位清零后，我们往I2C 的“数据寄存器DR”写入要发送的数据，这时TXE 位会被重置0，表示数据寄存器非空，I2C 外设通过SDA 信号线一位位把数据发送出去后，又会产生“EV8”事件，即TXE 位被置1，重复这个过程，就可以发送多个字节数据了；
- 当我们发送数据完成后，控制I2C 设备产生一个停止信号§，这个时候会产生EV8_2 事件，SR1 的TXE 位及BTF 位都被置1，表示通讯结束。
- 假如我们使能了I2C 中断，以上所有事件产生时，都会产生I2C 中断信号，进入同一个中断服务函数，到I2C 中断服务程序后，再通过检查寄存器位来判断是哪一个事件。
2.3.2 主接收器
主接收器过程，即作为I2C 通讯的主机端时，从外部接收数据的过程
主接收器接收流程及事件说明如下：
- 同主发送流程，起始信号(S) 是由主机端产生的，控制发生起始信号后，它产生事件“EV5”，并会对SR1 寄存器的“SB”位置1，表示起始信号已经发送；
- 紧接着发送设备地址并等待应答信号，若有从机应答，则产生事件“EV6”这时SR1 寄存器的“ADDR”位被置1，表示地址已经发送。
- 从机端接收到地址后，开始向主机端发送数据。当主机接收到这些数据后，会产生“EV7”事件，SR1 寄存器的RXNE 被置1，表示接收数据寄存器非空，我们读取该寄存器后，可对数据寄存器清空，以便接收下一次数据。此时我们可以控制I2C 发送应答信号(ACK) 或非应答信号(NACK)，若应答，则重复以上步骤接收数据，若非应答，则停止传输；
- 发送非应答信号后，产生停止信号§，结束传输。
- 在发送和接收过程中，有的事件不只是标志了我们上面提到的状态位，还可能同时标志主机状态之类的状态位，而且读了之后还需要清除标志位，比较复杂。我们可使用STM32 标准库函数来直接检测这些事件的复合标志，降低编程难度。
3 I2C 初始化结构体详解
STM32 标准库提供了I2C 初始化结构体及初始化函数来配置I2C 外设
- 初始化结构体及函数定义在库文件“stm32f10x_i2c.h”及“stm32f10x_i2c.c”中，编程时我们可以结合这两个文件内的注释使用或参考库帮助文档
- 了解初始化结构体后我们就能对I2C 外设运用自如了
3.1 I2C初始化结构体
1 typedef struct {
2 uint32_t I2C_ClockSpeed; /*!< 设置SCL 时钟频率，此值要低于400000*/
3 uint16_t I2C_Mode; /*!< 指定工作模式，可选I2C 模式及SMBUS 模式*/
4 uint16_t I2C_DutyCycle; /* 指定时钟占空比，可选low/high = 2:1 及16:9 模式*/
5 uint16_t I2C_OwnAddress1; /*!< 指定自身的I2C 设备地址*/
6 uint16_t I2C_Ack; /*!< 使能或关闭响应(一般都要使能) */
7 uint16_t I2C_AcknowledgedAddress; /*!< 指定地址的长度，可为7 位及10 位*/
8 } I2C_InitTypeDef;
结构体成员说明如下，其中括号内的文字是对应参数在STM32 标准库中定义的宏：
- I2C_ClockSpeed
- 本成员设置的是 I2C 的传输速率
- 在调用初始化函数时，函数会根据我们输入的数值经过运算后把时钟因子写入到I2C 的时钟控制寄存器CCR
- 而我们写入的这个参数值不得高于400KHz。实际上由于CCR 寄存器不能写入小数类型的时钟因子，影响到SCL 的实际频率可能会低于本成员设置的参数值，这时除了通讯稍慢一点以外，不会对I2C 的标准通讯造成其它影响。
- I2C_Mode
- 本成员是选择 I2C 的使用方式
- 有I2C 模式(I2C_Mode_I2C) 和SMBus 主、从模式(I2C_Mode_SMBusHost、I2C_Mode_SMBusDevice )
- I2C 不需要在此处区分主从模式，直接设置I2C_Mode_I2C 即可
- I2C_DutyCycle
- 本成员设置的是 I2C 的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 位地址，只有7 位。
- I2C_Ack_Enable
- 本成员是关于 I2C 应答设置，设置为使能则可以发送响应信号
- 本实验配置为允许应答(I2C_Ack_Enable)， 这是绝大多数遵循I2C 标准的设备的通讯要求， 改为禁止应答(I2C_Ack_Disable) 往往会导致通讯错误。
- I2C_AcknowledgeAddress
- 本成员选择 I2C 的寻址模式是7 位还是10 位地址
- 需要根据实际连接到I2C 总线上设备的地址进行选择
- 这个成员的配置也影响到I2C_OwnAddress1 成员，只有这里设置成10 位模式时，I2C_OwnAddress1 才支持10 位地址。
- 配置完这些结构体成员值，调用库函数I2C_Init 即可把结构体的配置写入到寄存器中
4 I2C——读写EEPROM实验
- EEPROM 是一种掉电后数据不丢失的存储器，常用来存储一些配置信息，以便系统重新上电的时候加载之
- EEPROM 芯片最常用的通讯方式就是I2C 协议，本小节以EEPROM 的读写实验为大家讲解STM32 的I2C 使用方法
- 实验中STM32 的I2C 外设采用主模式，分别用作主发送器和主接收器，通过查询事件的方式来确保正常通讯
4.1 硬件设计
- 本实验板中：
- 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》来了解
4.2 软件设计
- 把读写EEPROM 相关的代码独立分开存储，方便以后移植
- 在“工程模板”之上新建“bsp_i2c_ee.c”及“bsp_i2c_ee.h”文件
- 这些文件也可根据您的喜好命名，它们不属于STM32 标准库的内容，是由我们自己根据应用需要编写的。
4.3 编程要点
- 配置通讯使用的目标引脚为开漏模式；
- 使能I2C 外设的时钟；
- 配置I2C 外设的模式、地址、速率等参数并使能I2C 外设；
- 编写基本I2C 按字节收发的函数；
- 编写读写EEPROM 存储内容的函数；
- 编写测试程序，对读写数据进行校验。
4.3.1 代码分析
4.3.1.1 I2C 硬件相关宏定义
- 把I2C 硬件相关的配置都以宏的形式定义到“bsp_i2c_ee.h”文件中，见代码清单:I2C-2。
- 根据硬件连接，把与EEPROM 通讯使用的I2C 号、引脚号都以宏封装起来
- 并且定义了自身的I2C 地址及通讯速率，以便配置模式的时候使用。
1 /**************************I2C 参数定义，I2C1 或I2C2*********************/
2 #define EEPROM_I2Cx I2C1
3 #define EEPROM_I2C_APBxClock_FUN RCC_APB1PeriphClockCmd
4 #define EEPROM_I2C_CLK RCC_APB1Periph_I2C1
5 #define EEPROM_I2C_GPIO_APBxClock_FUN RCC_APB2PeriphClockCmd
6 #define EEPROM_I2C_GPIO_CLK RCC_APB2Periph_GPIOB
7 #define EEPROM_I2C_SCL_PORT GPIOB
8 #define EEPROM_I2C_SCL_PIN GPIO_Pin_6
9 #define EEPROM_I2C_SDA_PORT GPIOB
10 #define EEPROM_I2C_SDA_PIN GPIO_Pin_7
11
12 /* STM32 I2C 快速模式*/
13 #define I2C_Speed 400000 //*
14
15 /* 这个地址只要与STM32 外挂的I2C 器件地址不一样即可*/
16 #define I2Cx_OWN_ADDRESS7 0X0A
17
18 /* AT24C01/02 每页有8 个字节*/
19 #define I2C_PageSize 8
4.3.1.2 初始化I2C的GPIO
- 利用上面的宏，编写I2C GPIO 引脚的初始化函数，见代码清单:I2C GPIO 初始化函数。
- 开启相关的时钟并初始化GPIO 引脚，函数执行流程如下：
- 使用GPIO_InitTypeDef 定义GPIO 初始化结构体变量，以便下面用于存储GPIO 配置；
- 调用库函数RCC_APB1PeriphClockCmd（代码中为宏EEPROM_I2C_APBxClock_FUN）使能I2C外设时钟，调用RCC_APB2PeriphClockCmd（代码中为宏EEPROM_I2C_GPIO_APBxClock_FUN）来使能I2C 引脚使用的GPIO 端口时钟，调用时我们使用“|”操作同时配置两个引脚。
- 向GPIO 初始化结构体赋值，把引脚初始化成复用开漏模式，要注意I2C 的引脚必须使用这种模式。
- 使用以上初始化结构体的配置，调用GPIO_Init 函数向寄存器写入参数，完成GPIO 的初始化。
1 static void I2C_GPIO_Config(void)
2 {
3 GPIO_InitTypeDef GPIO_InitStructure;
4
5 /* 使能与I2C 有关的时钟*/
6 EEPROM_I2C_APBxClock_FUN ( EEPROM_I2C_CLK, ENABLE );
7 EEPROM_I2C_GPIO_APBxClock_FUN ( EEPROM_I2C_GPIO_CLK, ENABLE );
8
9 /* I2C_SCL、I2C_SDA*/
10 GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SCL_PIN;
11 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
12 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD; // 开漏输出
13 GPIO_Init(EEPROM_I2C_SCL_PORT, &GPIO_InitStructure);
14
15 GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SDA_PIN;
16 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
17 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD; // 开漏输出
18 GPIO_Init(EEPROM_I2C_SDA_PORT, &GPIO_InitStructure);
19 }
4.3.1.3 配置I2C的模式
- 以上只是配置了I2C 使用的引脚，还不算对I2C 模式的配置
- 熟悉STM32 I2C 结构的话，这段初始化程序就十分好理解
- 它把 I2C 外设通讯时钟SCL 的低/高电平比设置为2
- 使能响应功能
- 使用7 位地址I2C_OWN_ADDRESS7
- 速率配置为I2C_Speed(前面在bsp_i2c_ee.h 定义的宏)
- 最后调用库函数I2C_Init 把这些配置写入寄存器
- 调用I2C_Cmd函数使能外设
为方便调用，我们把I2C 的GPIO 及模式配置都用I2C_EE_Init 函数封装起来。
1 /**
2 * @brief I2C 工作模式配置
3 * @param 无
4 * @retval 无
5 */
6 static void I2C_Mode_Configu(void)
7 {
8 I2C_InitTypeDef I2C_InitStructure;
9
10 /* I2C 配置*/
11 I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
12
13 /* 高电平数据稳定，低电平数据变化SCL 时钟线的占空比*/
14 I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
15
16 I2C_InitStructure.I2C_OwnAddress1 =I2Cx_OWN_ADDRESS7;
17 I2C_InitStructure.I2C_Ack = I2C_Ack_Enable ;
18
19 /* I2C 的寻址模式*/
20 I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
21
22 /* 通信速率*/
23 I2C_InitStructure.I2C_ClockSpeed = I2C_Speed;
24
25 /* I2C 初始化*/
26 I2C_Init(EEPROM_I2Cx, &I2C_InitStructure);
27
28 /* 使能I2C */
29 I2C_Cmd(EEPROM_I2Cx, ENABLE);
30 }
31
32
33 /**
34 * @brief I2C 外设(EEPROM) 初始化
35 * @param 无
36 * @retval 无
37 */
38 void I2C_EE_Init(void)
39 {
40 I2C_GPIO_Config();
41
42 I2C_Mode_Configu();
43
44 /* 根据头文件i2c_ee.h 中的定义来选择EEPROM 要写入的设备地址*/
45 /* 选择EEPROM Block0 来写入*/
46 EEPROM_ADDRESS = EEPROM_Block0_ADDRESS;
47 }
4.3.1.4 向EEPROM 写入一个字节的数据
- 初始化好I2C 外设后，可以使用I2C 通讯，如何向EEPROM 写入一个字节的数据
- 先来分析I2C_TIMEOUT_UserCallback 函数
- 函数体里只调用了宏EEPROM_ERROR，这个宏封装了printf 函数，方便使用串口向上位机打印调试信息，阅读代码时把它当成printf 函数即可。
- 在I2C 通讯的很多过程，都需要检测事件，当检测到某事件后才能继续下一步的操作
- 但有时通讯错误或者I2C 总线被占用，我们不能无休止地等待下去，所以我们设定每个事件检测都有等待的时间上限
- 若超过这个时间，我们就调用I2C_TIMEOUT_UserCallback 函数输出调试信息(或可以自己加其它操作)，并终止I2C 通讯
- 分析I2C_EE_ByteWrite 函数，这个函数实现了前面讲的I2C 主发送器通讯流程
- 使用库函数I2C_GenerateSTART 产生I2C 起始信号，其中的EEPROM_I2C 宏是前面硬件定义相关的I2C 编号；
- 对I2CTimeout 变量赋值为宏I2CT_FLAG_TIMEOUT，这个I2CTimeout 变量在下面的while 循环中每次循环减1，该循环通过调用库函数I2C_CheckEvent 检测事件，若检测到事件，则进入通讯的下一阶段，若未检测到事件则停留在此处一直检测，当检测I2CT_FLAG_TIMEOUT 次都还没等待到事件则认为通讯失败，调用前面的I2C_TIMEOUT_UserCallback 输出调试信息，并退出通讯；
- 调用库函数I2C_Send7bitAddress 发送EEPROM 的设备地址，并把数据传输方向设置为I2C_Direction_Transmitter(即发送方向)，这个数据传输方向就是通过设置I2C 通讯中紧跟地址后面的R/W 位实现的。发送地址后以同样的方式检测EV6 标志；
- 调用库函数I2C_SendData 向EEPROM 发送要写入的内部地址，该地址是I2C_EE_ByteWrite函数的输入参数，发送完毕后等待EV8 事件。要注意这个内部地址跟上面的EEPROM 地址不一样，上面的是指I2C 总线设备的独立地址，而此处的内部地址是指EEPROM 内数据组织的地址，也可理解为EEPROM 内存的地址或I2C 设备的寄存器地址；
- 调用库函数I2C_SendData 向EEPROM 发送要写入的数据，该数据是I2C_EE_ByteWrite 函数的输入参数，发送完毕后等待EV8 事件；
- 一个I2C 通讯过程完毕，调用I2C_GenerateSTOP 发送停止信号。
- 在这个通讯过程中，STM32 实际上通过I2C 向EEPROM 发送了两个数据，但为何第一个数据被解释为EEPROM 的内存地址？这是由EEPROM 的自己定义的单字节写入时序
EEPROM 的单字节时序规定，向它写入数据的时候，第一个字节为内存地址，第二个字节是要写入的数据内容。所以我们需要理解：命令、地址的本质都是数据，对数据的解释不同，它就有了不同的功能。
1 /***************************************************************/
2 /* 通讯等待超时时间*/
3 #define I2CT_FLAG_TIMEOUT ((uint32_t)0x1000)
4 #define I2CT_LONG_TIMEOUT ((uint32_t)(10 * I2CT_FLAG_TIMEOUT))
5
6 /**
7 * @brief I2C 等待事件超时的情况下会调用这个函数来处理
8 * @param errorCode：错误代码，可以用来定位是哪个环节出错.
9 * @retval 返回0，表示IIC 读取失败.
10 */
11 static uint32_t I2C_TIMEOUT_UserCallback(uint8_t errorCode)
12 {
13 /* 使用串口printf 输出错误信息，方便调试*/
14 EEPROM_ERROR("I2C 等待超时!errorCode = %d",errorCode);
15 return 0;
16 }
17 /**
18 * @brief 写一个字节到I2C EEPROM 中
19 * @param pBuffer: 缓冲区指针
20 * @param WriteAddr: 写地址
21 * @retval 正常返回1，异常返回0
22 */
23 uint32_t I2C_EE_ByteWrite(u8* pBuffer, u8 WriteAddr)
24 {
25 /* 产生I2C 起始信号*/
26 I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
27
28 /* 设置超时等待时间*/
29 I2CTimeout = I2CT_FLAG_TIMEOUT;
30 /* 检测EV5 事件并清除标志*/
31 while (!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
32 {
33 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(0);
34 }
35
36 /* 发送EEPROM 设备地址*/
37 I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS,
38 I2C_Direction_Transmitter);
39
40 I2CTimeout = I2CT_FLAG_TIMEOUT;
41 /* 检测EV6 事件并清除标志*/
42 while (!I2C_CheckEvent(EEPROM_I2Cx,
43 I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
44 {
45 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(1);
46 }
47
48 /* 发送要写入的EEPROM 内部地址(即EEPROM 内部存储器的地址) */
49 I2C_SendData(EEPROM_I2Cx, WriteAddr);
50
51 I2CTimeout = I2CT_FLAG_TIMEOUT;
52 /* 检测EV8 事件并清除标志*/
53 while (!I2C_CheckEvent(EEPROM_I2Cx,
54 I2C_EVENT_MASTER_BYTE_TRANSMITTED))
55 {
56 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(2);
57 }
58 /* 发送一字节要写入的数据*/
59 I2C_SendData(EEPROM_I2Cx, *pBuffer);
60
61 I2CTimeout = I2CT_FLAG_TIMEOUT;
62 /* 检测EV8 事件并清除标志*/
63 while (!I2C_CheckEvent(EEPROM_I2Cx,
64 I2C_EVENT_MASTER_BYTE_TRANSMITTED))
65 {
66 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
67 }
68
69 /* 发送停止信号*/
70 I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);
71
72 return 1;
73 }
4.3.1.5 多字节写入及状态等待
- 单字节写入通讯结束后，EEPROM 芯片会根据这个通讯结果擦写该内存地址的内容，这需要一段时间，所以在多次写入数据时，要先等待EEPROM 内部擦写完毕。
- 多字节写入：
- 直接使用for 循环调用前面定义的I2C_EE_ByteWrite 函数一个字节一个字节地向EEPROM 发送要写入的数据。
- 在每次数据写入通讯前调用了I2C_EE_WaitEepromStandbyState函数等待EEPROM 内部擦写完毕
1 /**
2 * @brief 将缓冲区中的数据写到I2C EEPROM 中，采用单字节写入的方式，
3 速度比页写入慢
4 * @param pBuffer: 缓冲区指针
5 * @param WriteAddr: 写地址
6 * @param NumByteToWrite: 写的字节数
7 * @retval 无
8 */
9 uint8_t I2C_EE_ByetsWrite(uint8_t* pBuffer,uint8_t WriteAddr,
10 uint16_t NumByteToWrite)
11 {
12 uint16_t i;
13 uint8_t res;
14
15 /* 每写一个字节调用一次I2C_EE_ByteWrite 函数*/
16 for (i=0; i<NumByteToWrite; i++)
17 {
18 /* 等待EEPROM 准备完毕*/
19 I2C_EE_WaitEepromStandbyState();
20 /* 按字节写入数据*/
21 res = I2C_EE_ByteWrite(pBuffer++,WriteAddr++);
22 }
23 return res;
24 }
- I2C_EE_WaitEepromStandbyState函数定义
- 主要实现是向EEPROM 发送它设备地址
- 检测EEPROM 的响应，若EEPROM 接收到地址后返回应答信号，则表示EEPROM 已经准备好，可以开始下一次通讯。
- 函数中检测响应是通过读取STM32 的SR1 寄存器的ADDR 位及AF 位来实现的，当I2C 设备响应了地址的时候，ADDR 会置1，若应答失败，AF 位会置1。
1 /**
2 * @brief 等待EEPROM 到准备状态
3 * @param 无
4 * @retval 无
5 */
6 void I2C_EE_WaitEepromStandbyState(void)
7 {
8 vu16 SR1_Tmp = 0;
9
10 do {
11 /* 发送起始信号*/
12 I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
13
14 /* 读I2C1 SR1 寄存器*/
15 SR1_Tmp = I2C_ReadRegister(EEPROM_I2Cx, I2C_Register_SR1);
16
17 /* 发送EEPROM 地址+ 写方向*/
18 I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS,
19 I2C_Direction_Transmitter);
20 }
21 // SR1 位1 ADDR：1 表示地址发送成功，0 表示地址发送没有结束
22 // 等待地址发送成功
23 while (!(I2C_ReadRegister(EEPROM_I2Cx, I2C_Register_SR1) & 0x0002));
24
25 /* 清除AF 位*/
26 I2C_ClearFlag(EEPROM_I2Cx, I2C_FLAG_AF);
27 /* 发送停止信号*/
28 I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);
29 }
4.3.1.6 EEPROM的页写入
- 在以上的数据通讯中，每写入一个数据都需要向EEPROM 发送写入的地址
- 希望向连续地址写入多个数据的时候，只要告诉EEPROM 第一个内存地址address1，后面的数据按次序写入到address2、address3⋯这样可以节省通讯的时间，加快速度。
- 为应对这种需求，EEPROM 定义了一种页写入时序，见图EEPROM 页写入时序。
- 根据页写入时序，第一个数据被解释为要写入的内存地址address1，后续可连续发送n 个数据，这些数据会依次写入到内存中。
- 其中AT24C02 型号的芯片页写入时序最多可以一次发送8 个数据(即n = 8 )，该值也称为页大小
- 某些型号的芯片每个页写入时序最多可传输16 个数据。
- 其中AT24C02 型号的芯片页写入时序最多可以一次发送8 个数据(即n = 8 )，该值也称为页大小
- 页写入函数主体跟单字节写入函数是一样的
- 只是它在发送数据的时候，使用for 循环控制发送多个数据，发送完多个数据后才产生I2C 停止信号
- 只要每次传输的数据小于等于EEPROM时序规定的页大小，就能正常传输。
1 /**
2 * @brief 在EEPROM 的一个写循环中可以写多个字节，但一次写入的字节数
3 * 不能超过EEPROM 页的大小，AT24C02 每页有8 个字节
4 * @param
5 * @param pBuffer: 缓冲区指针
6 * @param WriteAddr: 写地址
7 * @param NumByteToWrite: 要写的字节数要求NumByToWrite 小于页大小
8 * @retval 正常返回1，异常返回0
9 */
10 uint8_t I2C_EE_PageWrite(uint8_t* pBuffer, uint8_t WriteAddr,
11 uint8_t NumByteToWrite)
12 {
13 I2CTimeout = I2CT_LONG_TIMEOUT;
14
15 while (I2C_GetFlagStatus(EEPROM_I2Cx, I2C_FLAG_BUSY))
16 {
17 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(4);
18 }
19
20 /* 产生I2C 起始信号*/
21 I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
22
23 I2CTimeout = I2CT_FLAG_TIMEOUT;
24
25 /* 检测EV5 事件并清除标志*/
26 while (!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
27 {
28 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(5);
29 }
30
31 /* 发送EEPROM 设备地址*/
32 I2C_Send7bitAddress(EEPROM_I2Cx,EEPROM_ADDRESS,I2C_Direction_Transmitter);
33
34 I2CTimeout = I2CT_FLAG_TIMEOUT;
35
36 /* 检测EV6 事件并清除标志*/
37 while (!I2C_CheckEvent(EEPROM_I2Cx,
38 I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
39 {
40 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(6);
41 }
42 /* 发送要写入的EEPROM 内部地址(即EEPROM 内部存储器的地址) */
43 I2C_SendData(EEPROM_I2Cx, WriteAddr);
44
45 I2CTimeout = I2CT_FLAG_TIMEOUT;
46
47 /* 检测EV8 事件并清除标志*/
48 while (! I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
49 {
50 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
51 }
52 /* 循环发送NumByteToWrite 个数据*/
53 while (NumByteToWrite--)
54 {
55 /* 发送缓冲区中的数据*/
56 I2C_SendData(EEPROM_I2Cx, *pBuffer);
57
58 /* 指向缓冲区中的下一个数据*/
59 pBuffer++;
60
61 I2CTimeout = I2CT_FLAG_TIMEOUT;
62
63 /* 检测EV8 事件并清除标志*/
64 while (!I2C_CheckEvent(EEPROM_I2Cx, _EVENT_MASTER_BYTE_TRANSMITTED))
65 {
66 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(8);
67 }
68 }
69 /* 发送停止信号*/
70 I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);
71 return 1;
72 }
4.3.1.7 快速写入多字节
- 利用EEPROM 的页写入方式，可以改进前面的“多字节写入”函数，加快传输速度
- 主旨就是对输入的数据进行分页(本型号芯片每页8 个字节)，见表首地址对齐到页时的情况
- 通过“整除”计算要写入的数据NumByte-ToWrite 能写满多少“完整的页”，计算得的值存储在NumOfPage 中，但有时数据不是刚好能写满完整页的，会多一点出来，通过“求余”计算得出“不满一页的数据个数”就存储在NumOfSingle中
- 计算后通过按页传输NumOfPage 次整页数据及最后的NumOfSing 个数据，使用页传输，比之前的单个字节数据传输要快很多。
- 除了基本的分页传输，还要考虑首地址的问题，见表24‑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。
- 数据传输情况如表首地址未对齐到页时的情况
- 若writeAddress=17，计算得Addr=17%8= 1，count=8-1= 7；
- 同时，若NumByteToWrite=22，
- 先把count 去掉，特殊处理，计算得新的NumByteToWrite=22-7= 15
- 计算得NumOfPage=15/8= 1，NumOfSingle=15%8= 7。
- 数据传输情况如表首地址未对齐到页时的情况
- 强调一下，EEPROM 支持的页写入只是一种加速的I2C 的传输时序，实际上并不要求每次都以页为单位进行读写，EEPROM 是支持随机访问的(直接读写任意一个地址)，如前面的单个字节写入。
- 在某些存储器，如NAND FLASH，它是必须按照Block 写入的，例如每个Block 为512或4096 字节，数据写入的最小单位是Block，写入前都需要擦除整个Block；NOR FLASH 则是写入前必须以Sector/Block 为单位擦除，然后才可以按字节写入。而我们的EEPROM 数据写入和擦除的最小单位是“字节”而不是“页”，数据写入前不需要擦除整页。
1 // AT24C01/02 每页有8 个字节
2 #define I2C_PageSize 8
3
4 /**
5 * @brief 将缓冲区中的数据写到I2C EEPROM 中
6 * @param
7 * @arg pBuffer: 缓冲区指针
8 * @arg WriteAddr: 写地址
9 * @arg NumByteToWrite: 写的字节数
10 * @retval 无
11 */
12 void I2C_EE_BufferWrite(u8* pBuffer, u8 WriteAddr,
13 u16 NumByteToWrite)
14 {
15 u8 NumOfPage=0,NumOfSingle=0,Addr =0,count=0,temp =0;
16
17 /*mod 运算求余，若writeAddr 是I2C_PageSize 整数倍，
18 运算结果Addr 值为0*/
19 Addr = WriteAddr % I2C_PageSize;
20
21 /* 差count 个数据值，刚好可以对齐到页地址*/
22 count = I2C_PageSize - Addr;
23
24 /* 计算出要写多少整数页*/
25 NumOfPage = NumByteToWrite / I2C_PageSize;
26
27 /*mod 运算求余，计算出剩余不满一页的字节数*/
28 NumOfSingle = NumByteToWrite % I2C_PageSize;
29
30 // Addr=0, 则WriteAddr 刚好按页对齐aligned
31 // 这样就很简单了，直接写就可以，写完整页后
32 // 把剩下的不满一页的写完即可
33 if (Addr == 0) {
34 /* 如果NumByteToWrite < I2C_PageSize */
35 if (NumOfPage == 0) {
36 I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
37 I2C_EE_WaitEepromStandbyState();
38 }
39 /* 如果NumByteToWrite > I2C_PageSize */
40 else {
41 /* 先把整数页都写了*/
42 while (NumOfPage--) {
43 I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
44 I2C_EE_WaitEepromStandbyState();
45 WriteAddr += I2C_PageSize;
46 pBuffer += I2C_PageSize;
47 }
48 /* 若有多余的不满一页的数据，把它写完*/
49 if (NumOfSingle!=0) {
50 I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
51 I2C_EE_WaitEepromStandbyState();
52 }
53 }
54 }
55 // 如果WriteAddr 不是按I2C_PageSize 对齐
56 // 那就算出对齐到页地址还需要多少个数据，然后
57 // 先把这几个数据写完，剩下开始的地址就已经对齐
58 // 到页地址了，代码重复上面的即可
59 else {
60 /* 如果NumByteToWrite < I2C_PageSize */
61 if (NumOfPage== 0) {
62 /* 若NumOfSingle>count，当前面写不完，要写到下一页*/
63 if (NumOfSingle > count) {
64 // temp 的数据要写到写一页
65 temp = NumOfSingle - count;
66
67 I2C_EE_PageWrite(pBuffer, WriteAddr, count);
68 I2C_EE_WaitEepromStandbyState();
69 WriteAddr += count;
70 pBuffer += count;
71
72 I2C_EE_PageWrite(pBuffer, WriteAddr, temp);
73 I2C_EE_WaitEepromStandbyState();
74 } else { /* 若count 比NumOfSingle 大*/
75 I2C_EE_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
76 I2C_EE_WaitEepromStandbyState();
77 }
78 }
79 /* 如果NumByteToWrite > I2C_PageSize */
80 else {
81 /* 地址不对齐多出的count 分开处理，不加入这个运算*/
82 NumByteToWrite -= count;
83 NumOfPage = NumByteToWrite / I2C_PageSize;
84 NumOfSingle = NumByteToWrite % I2C_PageSize;
85
86 /* 先把WriteAddr 所在页的剩余字节写了*/
87 if (count != 0) {
88 I2C_EE_PageWrite(pBuffer, WriteAddr, count);
89 I2C_EE_WaitEepromStandbyState();
90
91 /*WriteAddr 加上count 后，地址就对齐到页了*/
92 WriteAddr += count;
93 pBuffer += count;
94 }
95 /* 把整数页都写了*/
96 while (NumOfPage--) {
97 I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
98 I2C_EE_WaitEepromStandbyState();
99 WriteAddr += I2C_PageSize;
100 pBuffer += I2C_PageSize;
101 }
102 /* 若有多余的不满一页的数据，把它写完*/
103 if (NumOfSingle != 0) {
104 I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
105 I2C_EE_WaitEepromStandbyState();
106 }
107 }
108 }
109 }
4.3.1.8 从EEPROM 读取数据
-
从EEPROM 读取数据是一个复合的I2C 时序，它实际上包含一个写过程和一个读过程，见图EEPROM 数据读取时序。
-
读时序：
- 第一个通讯过程中，使用I2C 发送设备地址寻址(写方向)，接着发送要读取的“内存地址”；
- 第二个通讯过程中，再次使用I2C 发送设备地址寻址，但这个时候的数据方向是读方向；
- 在这个过程之后，EEPROM 会向主机返回从“内存地址”开始的数据，一个字节一个字节地传输，只要主机的响应为“应答信号”，它就会一直传输下去，主机想结束传输时，就发送“非应答信号”，并以“停止信号”结束通讯，作为从机的EEPROM 也会停止传输。
-
写过程跟前面的写字节函数类似， 而读过程中接收数据时， 需要使用库函数I2C_ReceiveData 来读取。
-
响应信号则通过库函数I2C_AcknowledgeConfig 来发送，DISABLE 时为非响应信号，ENABLE 为响应信号。
1 /**
2 * @brief 从EEPROM 里面读取一块数据
3 * @param pBuffer: 存放从EEPROM 读取的数据的缓冲区指针
4 * @param ReadAddr: 接收数据的EEPROM 的地址
5 * @param NumByteToRead: 要从EEPROM 读取的字节数
6 * @retval 正常返回1，异常返回0
7 */
8 uint8_t I2C_EE_BufferRead(uint8_t* pBuffer, uint8_t ReadAddr,
9 u16 NumByteToRead)
10 {
11 I2CTimeout = I2CT_LONG_TIMEOUT;
12
13 while (I2C_GetFlagStatus(EEPROM_I2Cx, I2C_FLAG_BUSY))
14 {
15 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(9);
16 }
17
18 /* 产生I2C 起始信号*/
19 I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
20
21 I2CTimeout = I2CT_FLAG_TIMEOUT;
22
23 /* 检测EV5 事件并清除标志*/
24 while (!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
25 {
26 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(10);
27 }
28
29 /* 发送EEPROM 设备地址*/
30 I2C_Send7bitAddress(EEPROM_I2Cx,EEPROM_ADDRESS,I2C_Direction_Transmitter);
31
32 I2CTimeout = I2CT_FLAG_TIMEOUT;
33
34 /* 检测EV6 事件并清除标志*/
35 while (!I2C_CheckEvent(EEPROM_I2Cx,
36 I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
37 {
38 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(11);
39 }
40 /* 通过重新设置PE 位清除EV6 事件*/
41 I2C_Cmd(EEPROM_I2Cx, ENABLE);
42
43 /* 发送要读取的EEPROM 内部地址(即EEPROM 内部存储器的地址) */
44 I2C_SendData(EEPROM_I2Cx, ReadAddr);
45
46 I2CTimeout = I2CT_FLAG_TIMEOUT;
47
48 /* 检测EV8 事件并清除标志*/
49 while (!I2C_CheckEvent(EEPROM_I2Cx,I2C_EVENT_MASTER_BYTE_TRANSMITTED))
50 {
51 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(12);
52 }
53 /* 产生第二次I2C 起始信号*/
54 I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
55
56 I2CTimeout = I2CT_FLAG_TIMEOUT;
57
58 /* 检测EV5 事件并清除标志*/
59 while (!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
60 {
61 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(13);
62 }
63 /* 发送EEPROM 设备地址*/
64 I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Receiver);
65
66 I2CTimeout = I2CT_FLAG_TIMEOUT;
67
68 /* 检测EV6 事件并清除标志*/
69 while (!I2C_CheckEvent(EEPROM_I2Cx,
70 I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
71 {
72 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(14);
73 }
74 /* 读取NumByteToRead 个数据*/
75 while (NumByteToRead)
76 {
77 /* 若NumByteToRead=1，表示已经接收到最后一个数据了，
78 发送非应答信号，结束传输*/
79 if (NumByteToRead == 1)
80 {
81 /* 发送非应答信号*/
82 I2C_AcknowledgeConfig(EEPROM_I2Cx, DISABLE);
83
84 /* 发送停止信号*/
85 I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);
86 }
87
88 I2CTimeout = I2CT_LONG_TIMEOUT;
89 while (I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_RECEIVED)==0)
90 {
91 if ((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
92 }
93 {
94 /* 通过I2C，从设备中读取一个字节的数据*/
95 *pBuffer = I2C_ReceiveData(EEPROM_I2Cx);
96
97 /* 存储数据的指针指向下一个地址*/
98 pBuffer++;
99
100 /* 接收数据自减*/
101 NumByteToRead--;
102 }
103 }
104
105 /* 使能应答，方便下一次I2C 传输*/
106 I2C_AcknowledgeConfig(EEPROM_I2Cx, ENABLE);
107 return 1;
108 }
4.3.2 main文件
4.3.2.1 EEPROM 读写测试函数
- 完成基本的读写函数后，接下来我们编写一个读写测试函数来检验驱动程序
- 先填充一个数组，数组的内容为1,2,3 至N
- 接着把这个数组的内容写入到EEPROM 中，写入时可以采用单字节写入的方式或页写入的方式。
- 写入完毕后再从EEPROM 的地址中读取数据，把读取得到的与写入的数据进行校验，若一致说明读写正常，否则读写过程有问题或者EEPROM芯片不正常。
- 其中代码用到的EEPROM_INFO 跟EEPROM_ERROR 宏类似，都是对printf 函数的封装，使用和阅读代码时把它直接当成printf 函数就好。
- 具体的宏定义在“bsp_i2c_ee.h 文件中”，在以后的代码我们常常会用类似的宏来输出调试信息。
1 /**
2 * @brief I2C(AT24C02) 读写测试
3 * @param 无
4 * @retval 正常返回1 ，不正常返回0
5 */
6 uint8_t I2C_Test(void)
7 {
8 u16 i;
9 EEPROM_INFO("写入的数据");
10
11 for ( i=0; i<=255; i++ ) //填充缓冲
12 {
13 I2c_Buf_Write[i] = i;
14
15 printf("0x%02X ", I2c_Buf_Write[i]);
16 if (i%16 == 15)
17 printf("\n\r");
18 }
19
20 //将I2c_Buf_Write 中顺序递增的数据写入EERPOM 中
21 //页写入方式
22 // I2C_EE_BufferWrite( I2c_Buf_Write, EEP_Firstpage, 256);
23 //字节写入方式
24 I2C_EE_ByetsWrite( I2c_Buf_Write, EEP_Firstpage, 256);
25
26 EEPROM_INFO("写结束");
27
28 EEPROM_INFO("读出的数据");
29 //将EEPROM 读出数据顺序保持到I2c_Buf_Read 中
30 I2C_EE_BufferRead(I2c_Buf_Read, EEP_Firstpage, 256);
31
32 //将I2c_Buf_Read 中的数据通过串口打印
33 for (i=0; i<256; i++)
34 {
35 if (I2c_Buf_Read[i] != I2c_Buf_Write[i])
36 {
37 printf("0x%02X ", I2c_Buf_Read[i]);
38 EEPROM_ERROR("错误:I2C EEPROM 写入与读出的数据不一致");
39 return 0;
40 }
41 printf("0x%02X ", I2c_Buf_Read[i]);
42 if (i%16 == 15)
43 printf("\n\r");
44
45 }
46 EEPROM_INFO("I2C(AT24C02) 读写测试成功");
47 return 1;
48 }
4.3.2.2 main函数
最后编写main 函数，函数中初始化串口、I2C 外设，然后调用上面的I2C_Test 函数进行读写测
试
1 /**
2 * @brief 主函数
3 * @param 无
4 * @retval 无
5 */
6 int main(void)
7 {
8 LED_GPIO_Config();
9
10 LED_BLUE;
11 /* 初始化USART1*/
12 Debug_USART_Config();
13
14 printf("\r\n 欢迎使用野火STM32 F103 开发板。\r\n");
15
16 printf("\r\n 这是一个I2C 外设(AT24C02) 读写测试例程\r\n");
17
18 /* I2C 外设(AT24C02) 初始化*/
19 I2C_EE_Init();
20
21 if (I2C_Test() ==1)
22 {
23 LED_GREEN;
24 }
25 else
26 {
27 LED_RED;
28 }
29
30 while (1)
31 {
32 }
33
34 }
854
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
