IIC-读写EEPROM_iic 读eeprom-CSDN博客

本文链接：https://blog.csdn.net/Lagligelang/article/details/118397016

IIC读写EEPROM

I2C协议简介

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

I2C物理层

在这里插入图片描述

它的物理层有如下特点：

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

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

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

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

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

6：具有三种传输模式：标准模式传输速率为100Kbit/s，快速模式为400Kbit/s，高速模式下可到3.4Mbit/s，但目前大多I2C设备尚不支持高速模式。

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

I2C协议层

在这里插入图片描述

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

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

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

在地址位之后，是传输方向的选择位(也就是传输8位数据的第八位数据，因为一般地址都是7位的)，该为为0时，表示后面的数据传输方向是由主机传输至从机，即主机向从机写数据。该位为1时，则相反，即主机由从机读取数据。

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

写数据

若配置的方向传输位为：写数据方向，即第一幅图的情况，广播完地址，接收到应答信号后，主机开始正式向从机传输数据(DATA)

，数据包的大小为8位，主机每发送完一个字节数据，都要等待从机的应答信号(ACK)，重复这个过程，可以向从机传输N个数据，这个N没有大小限制。当数据传输结束时，主机向从机发送一个停止传输信号§，表示不再传输数据。

读数据

若配置的方向传输位为：读数据方向，即第二幅图的情况，广播完地址，接收到应答信号后，从机开始正式向主机传输数据(DATA)

，数据包的大小为8位，从机每发送完一个字节数据，都要等待主机的应答信号(ACK)，重复这个过程，可以向主机传输N个数据，这个N没有大小限制。当主机希望通知接收数据时，就会向从机返回一个非应答信号(NACK)，则从机自动停止数据传输。

读和写数据

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

通讯的起始和停止信号

在这里插入图片描述

起始：当SCL线是高电平时，SDA线从高电平向低电平切换，这个情况就是表示通讯的开始。
停止：当SCL线是高电平时，SDA线从低电平向高电平切换，这个情况就是表示通讯的停止。

数据的有效性

在这里插入图片描述

I2C使用SDA信号线来传输数据，使用SCL信号线进行数据同步。

SDA数据线在SCL的每个时钟周期传输一位数据。
传输时，SCL为高电平的时候SDA表示数据有效，即此时的SDA为高电平时表示数据"1"，为低电平时表示数据”0“.
当SCL为低电平时，SDA的数据无效，一般在这个时候SDA进行电平切换，为下一次表示数据做好准备。

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

地址及数据方向

在这里插入图片描述

I2C总线上的每个设备都有自己的独立地址，主机发送通讯时，通过SDA信号线发送设备地址(SLAVE_ADDRESS)来查找从机。

I2C协议规定设备地址可以是7位或10位，实际中7位的地址应用比较广泛。紧跟设备地址的一个数据位用来表示数据传输方向，它是数据方向为(R/W#)，第8位或第11位。

数据方向位为”1“时表示主机由从机读取数据。
数据方向位为”0“时表示主机向从机写数据。

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

响应

在这里插入图片描述

I2C的数据和地址传输都带响应。响应包括应答ACK和非应答NACK两种信号。

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

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

I2C特性及架构

在这里插入图片描述

通讯引脚

I2C的所有硬件架构都是根据图中左侧SCL线和SDA线展开的(其中的SMBA线用于SMBUS的警告信号，I2C通讯没有使用)。

时钟控制逻辑

SCL线的时钟信号，由I2C接口根据时钟控制寄存器CCR控制，控制的参数主要为时钟频率。

配置I2C的CCR寄存器可修改通讯速率相关的参数：

1.可选择I2C通讯的”标准/快速“模式，这两个模式分别是I2C对应”100/400Kbit/s“的通讯速率
2.在快速模式下可选择SCL时钟的占空比，可选Tlow/Thigh=2或Tlow/Thigh=16/9模式，我们知道I2C协议在SCL高电平时对SDA信号采样，SCL低电平时SDA准备下一个数据，修改SCL的高低电平比会影响数据采样，但其实这二个模式的比例差别不是很大，如果不是严格要求，可随便选。
3.CCR寄存器中还有一个12位的配置因子CCR，它与I2C外设的输入时钟源共同作用，产生SCL时钟，STM32的I2C外设都挂载在APB1总线上，使用APB1的时钟源PCLK1，SCL信号线的输出时钟公式如下：
	标准模式：
		Thigh = CCR*Tpckl1			Tlow = CCR*Tpckl1
	快速模式中Tlow/Thigh=2时：
		Thigh = CCR*Tpckl1			Tlow = 2*CCR*Tpckl1
	快速模式中Tlow/Thigh=16/9时：
		Thigh = 9*CCR*Tpckl1		Tlow = 16*CCR*Tpckl1
	例如，我们的PCLK1=36MHz,想要配置400Kbit/s的速率，计算方法如下所示：
		PCLK时钟周期：				Tpclk1 = 1/36000000
		目标SCL时钟周期：				Tscl = 1/400000
		SCL时钟周期内的高电平时间：		Thigh = Tscl/3
		SCL时钟周期内的低电平时间：		Tlow = 2*Tsck/3
		计算CCR的值：				CCR = Thigh/Tpclk1 = 30

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

数据控制逻辑

I2C的SDA信号主要连接到数据移位寄存器上，数据移位寄存器的数据来源及目标是是数据寄存器DR、地址寄存器OAR、PEC寄存器以及SDA数据线。

当向外发送数据的时候，数据移位寄存器以”数据寄存器“为数据源，把数据一位一位地通过SDA信号线发送出去。

当从外部接收数据的时候，数据移位寄存器把SDA信号线采样到的数据一位一位地存储到”数据寄存器“中。

若使能了数据校验，接收到的数据会经过PEC计算器运算，运算结果存储到”PEC寄存器“中。

当STM32的I2C工作在从机模式的时候，接收到设备地址信号时，数据移位寄存器会把接收到的地址与STM32的自身的"I2C地址寄存器"的值做比较，以便相应主机的寻址。

STM32的自身I2C地址可通过修改”自身地址寄存器“修改，支持同时修改二个I2C设备地址，两个地址分别存储在OAR1和OAR2中。

整体控制逻辑

整体控制逻辑负责协调整个I2C外设，控制逻辑的工作模式根据我们配置的”控制寄存器(CR1/CR2)"的参数而改变。

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

通讯过程

主发送器

在这里插入图片描述

图中的是：主发送器流程，即作为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)，这个时候会产生EV8_ 2事件，SR1的TXE位及BTF位都被置1，表示通讯结束。

这里的Data1实际上是告诉从机，我们要向它的哪个地址写入数据。

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

主接收器

在这里插入图片描述

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

主接收器接收流程及事件说明如下:
(1) 同主发送流程，起始信号(S)是由主机端产生的，控制发生起始信号后，它产生事件‘“EV5”，并会对SR1寄存器的“SB”位置1,表示起始信号已经发送; 
(2)紧接着发送设备地址并等待应答信号，若有从机应答，则产生事件“EV6”这时SR1寄存器的“ADDR”位被置1,表示地址已经发送。
(3)从机端接收到地址后，开始向主机端发送数据。当主机接收到这些数据后，会产生“EV7”事件，SR1寄存器的RXNE被置1,表示接收数据寄存器非空，我们读取该寄存器后，可对数据寄存器清空，以便接收下一次数据。此时我们可以控制I2C 发送应答信号(ACK)或非应答信号(NACK),若应答，则重复以上步骤接收数据，若非应答，则停止传输;
(4) 发送非应答信号后，产生停止信号(P)，结束传输。

实验

我们这里的EEPROM的地址是：1010000(R/W#)。其中前4为是固定的，然后第五位到第7位是根据硬件电路板设计而确定的，我们这里都是把他们连接到了地，所以，地址是1010000(R/W#)。

如果是写方向，那么地址是：1010 0000--->>>0xA0
如果是读方向，那么地址是：1010 0001--->>>0xA1

AT24C02中的WP位表示写保护，如果使能了它，就是禁止我们写入数据；让它为低电平，就是可以写入数据。我们这里硬件是直接把WP位连接到了地，也就是不需要写保护。

关于配置I2C_InitTypeDef寄存器中的OwnAddress1表示，I2C设备自身地址，这个地址只要是I2C总线上唯一的就可以，我们这里设置成了0x0A。

I2C_EEPROM.C文件

#include "./i2c_eeprom/i2c_eeprom.h"

//I2C_EEPROM  GPIO配置
static void I2C_EEPROM_GPIO_Init(void)
{
	GPIO_InitTypeDef	GPIO_InitStructure = {0};
	//开启GPIO时钟
	I2CX_SCL_RCC_CLK_CMD(I2CX_SCL_RCC_CLK_Periph,ENABLE);
	I2CX_SDA_RCC_CLK_CMD(I2CX_SDA_RCC_CLK_Periph,ENABLE);	
	//SCL配置
	GPIO_InitStructure.GPIO_Pin = I2CX_SCL_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(I2CX_SCL_GPIO_PORT,&GPIO_InitStructure);
	//SDA配置
	GPIO_InitStructure.GPIO_Pin = I2CX_SDA_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(I2CX_SDA_GPIO_PORT,&GPIO_InitStructure);
}
static void I2C_EEPROM_Mode_Init(void)
{
	I2C_InitTypeDef	I2C_InitStructure = {0};
	//开启I2C的时钟
	I2C_EEPROM_X_RCC_CLK_CMD(I2C_EEPROM_X_RCC_CLK_Periph,ENABLE);
	//模式配置
	I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
	I2C_InitStructure.I2C_OwnAddress1 = I2C_EEPROM_X_OwnAddress;
	I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
	I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;//7位数据地址
	I2C_InitStructure.I2C_ClockSpeed = 400000;//最大不超过400kHZ
	I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_16_9;//差别不大，随便配置
	I2C_Init(I2C_EEPROM_X,&I2C_InitStructure);
	//使能I2C
	I2C_Cmd(I2C_EEPROM_X,ENABLE);
}
void I2C_EEPROM_Init(void)
{
	I2C_EEPROM_GPIO_Init();
	I2C_EEPROM_Mode_Init();
}

I2C_EEPRM.H文件

#ifndef  __I2C_EEPROM_H
#define  __I2C_EEPROM_H

#include "stm32f10x.h"
#define     I2C_EEPROM_X						I2C1
#define     I2C_EEPROM_X_RCC_CLK_CMD			RCC_APB1PeriphClockCmd
#define     I2C_EEPROM_X_RCC_CLK_Periph			RCC_APB1Periph_I2C1
//此地址只要跟I2C总线上其他设备地址不一致就可以
#define     I2C_EEPROM_X_OwnAddress				0x0A	
//SCL线宏定义
#define     I2CX_SCL_GPIO_PORT					GPIOB
#define     I2CX_SCL_GPIO_PIN					GPIO_Pin_6
#define     I2CX_SCL_RCC_CLK_CMD				RCC_APB2PeriphClockCmd
#define     I2CX_SCL_RCC_CLK_Periph				RCC_APB2Periph_GPIOB
//SDA线宏定义
#define     I2CX_SDA_GPIO_PORT					GPIOB
#define     I2CX_SDA_GPIO_PIN					GPIO_Pin_7
#define     I2CX_SDA_RCC_CLK_CMD				RCC_APB2PeriphClockCmd
#define     I2CX_SDA_RCC_CLK_Periph				RCC_APB2Periph_GPIOB

extern void I2C_EEPROM_Init(void);

#endif

有了基本的配置，接下来就要写一个简单的收发函数了，封装起来，便于其他函数调用。

然后我们写了一个发送一个字节大小的发送函数，和接收任意多字节的接收函数。代码如下：

发送一个字节

思路是：产生发送信号—>检查发送是否成功的标志位—>发送EEPROM的设备地址—>检查发送的设备地址是否成功—>发送想向EEPROM哪个地址写入数据的地址—>检查发生是否成功的标志位—>发送数据内容—>检查是否发送成功的标志位—>产生停止信号.*

.c文件 
//写一个用户的错误返回函数
static uint32_t I2C_EEPROM_ERROR_BackFunction(uint8_t ErrorCode)
{
	I2C_EEPROM_ERROR("I2C等待超时！错误代码为：%d\n",ErrorCode);
	return 0;
}

//写一个按字节写入函数,也就是文档的Figure.Byte Write
//第一个形参：向EEPROM的哪个地址写入数据
//第二个形参：向EEPROM写入什么数据内容
uint32_t I2C_EEPROM_ByteWrite(uint8_t WriteAddr,uint8_t WriteData)
{
	//产生一个起始信号
	I2C_GenerateSTART(I2C_EEPROM_X,ENABLE);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_Time;
	//判断起始信号是否产生成功
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_MODE_SELECT) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(0);
		}
	}
	//起始信号产生完毕，发送设备地址，进行广播EEPROM
	I2C_Send7bitAddress(I2C_EEPROM_X,EEPROM_OwnAddresss,I2C_Direction_Transmitter);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_Time;
	//判断设备地址是否发送完毕
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(1);
		}		
	}
	//发送EEPROM广播地址完成，发送向EEPROM哪个地址写入数据
	I2C_SendData(I2C_EEPROM_X,WriteAddr);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_Time;
	//判断地址是否发送完毕
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_BYTE_TRANSMITTING) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(2);
		}		
	}	
	//发送写入的数据
	I2C_SendData(I2C_EEPROM_X,WriteData);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_Time;
	//判断地址是否发送完毕
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_BYTE_TRANSMITTED) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(3);
		}		
	}		
	//发送完毕，发送停止信号
	I2C_GenerateSTOP(I2C_EEPROM_X,ENABLE);
	return 1;
}
//有了写函数，为了验证写入是否正确，需要一个读函数
//有了写信号，再写一个读信号函数
//形参1：读哪里的信号。
//形参2：读取数据存放在哪个缓冲区
//形参3：读多少个数据
uint32_t I2C_EEPROM_ReadData(uint8_t ReadAddr,uint8_t *ReadData,uint8_t NumOfRead)
{
	//产生一个起始信号
	I2C_GenerateSTART(I2C_EEPROM_X,ENABLE);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_LongTime;
	//判断起始信号是否产生成功
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_MODE_SELECT) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(4);
		}
	}
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_LongTime;
	//起始信号产生完毕，发送设备地址，进行广播EEPROM
	I2C_Send7bitAddress(I2C_EEPROM_X,EEPROM_OwnAddresss,I2C_Direction_Transmitter);
	//判断设备地址是否发送完毕
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(5);
		}			
	}
	I2C_Cmd(I2C_EEPROM_X, ENABLE);
	//发送EEPROM广播地址完成，发送向EEPROM哪个地址读取数据
	I2C_SendData(I2C_EEPROM_X,ReadAddr);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_LongTime;
	//判断地址是否发送完毕
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_BYTE_TRANSMITTED) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(6);
		}		
	}
	//第二次发送开启信号
	I2C_GenerateSTART(I2C_EEPROM_X,ENABLE);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_LongTime;
	//判断起始信号是否产生成功
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_MODE_SELECT) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(7);
		}
	}
	//起始信号产生完毕，发送设备地址，进行广播EEPROM,表示要接收数据了
	I2C_Send7bitAddress(I2C_EEPROM_X,EEPROM_OwnAddresss,I2C_Direction_Receiver);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_LongTime;
	//判断设备地址是否发送完毕
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(8);
		}		
	}
	while(NumOfRead)
	{
		if(NumOfRead == 1)
		{
			//发送非应答信号
			I2C_AcknowledgeConfig(I2C_EEPROM_X,DISABLE);
		}
		//检查是否接收到了数据
		while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_BYTE_RECEIVED) == ERROR)
		{
		while((I2C_EEPROM_Delay--) == 0)
			{
				return  I2C_EEPROM_ERROR_BackFunction(9);
			}		
		}	
		//此时表示接收到了数据，读取出来
		*ReadData = I2C_ReceiveData(I2C_EEPROM_X);
		ReadData++;
		NumOfRead--;
	}
	//发送停止信号
	I2C_GenerateSTOP(I2C_EEPROM_X,ENABLE);
	//重新配置ACK使能，以便下次通讯
	I2C_AcknowledgeConfig (I2C_EEPROM_X,ENABLE);
	return 1;
}
//写一个I2C读写EEPROM 等待内部时序完成函数
uint32_t I2C_EEPROM_WaitEEPROM_StandByState(void)
{
	do
	{
		//产生一个起始信号
		I2C_GenerateSTART(I2C_EEPROM_X,ENABLE);
		//给I2C判断信号时间赋值,1000次
		I2C_EEPROM_Delay = I2C_EEPROM_Delay_Time;
		//判断起始信号是否产生成功
		while(I2C_GetFlagStatus(I2C_EEPROM_X,I2C_FLAG_SB) == RESET)
		{
		while((I2C_EEPROM_Delay--) == 0)
			{
				return I2C_EEPROM_ERROR_BackFunction(10);
			}
		}
		//发送设备地址
	I2C_Send7bitAddress(I2C_EEPROM_X,EEPROM_OwnAddresss,I2C_Direction_Transmitter);
	}while(I2C_GetFlagStatus(I2C_EEPROM_X,I2C_FLAG_ADDR) == RESET);//直到地址写入完成，才跳出循环
	//EEPROM内部时序完成
	I2C_GenerateSTOP(I2C_EEPROM_X,ENABLE);
	return 1;
}

.h文件
#ifndef  __I2C_EEPROM_H
#define  __I2C_EEPROM_H

#include "stm32f10x.h"
#include "./usart/bsp_usart.h"	
#define     I2C_EEPROM_Delay_Time				((uint32_t)0x1000)
#define     I2C_EEPROM_Delay_LongTime			((uint32_t)(10*I2C_EEPROM_Delay_Time))

#define     I2C_EEPROM_X						I2C1
#define     I2C_EEPROM_X_RCC_CLK_CMD			RCC_APB1PeriphClockCmd
#define     I2C_EEPROM_X_RCC_CLK_Periph			RCC_APB1Periph_I2C1
//此地址只要跟I2C总线上其他设备地址不一致就可以
#define     I2C_EEPROM_X_OwnAddress				0x0A	
//EEPROM的专属地址线
//写地址线
#define		EEPROM_OwnAddresss			0xA0

//SCL线宏定义
#define     I2CX_SCL_GPIO_PORT					GPIOB
#define     I2CX_SCL_GPIO_PIN					GPIO_Pin_6
#define     I2CX_SCL_RCC_CLK_CMD				RCC_APB2PeriphClockCmd
#define     I2CX_SCL_RCC_CLK_Periph				RCC_APB2Periph_GPIOB
//SDA线宏定义
#define     I2CX_SDA_GPIO_PORT					GPIOB
#define     I2CX_SDA_GPIO_PIN					GPIO_Pin_7
#define     I2CX_SDA_RCC_CLK_CMD				RCC_APB2PeriphClockCmd
#define     I2CX_SDA_RCC_CLK_Periph				RCC_APB2Periph_GPIOB

//宏定义打印函数
#define     I2C_EEPROM_DEBUG_ON				0
#define     I2C_EEPROM_INFO(fmt,arg...)			printf("<<-I2C_EEPROM-INFO>>"fmt"\n",##arg)
#define     I2C_EEPROM_ERROR(fmt,arg...)		printf("<<-I2C_EEPROM-ERROR>>"fmt"\n",##arg)
#define     I2C_EERPOM_DEBUG(fmt,arg...)		do{\
												if(I2C_EEPROM_DEBUG_ON)\
												{printf("<<-EEPROM-DEBUG->>[%s][%d]"fmt"\n",__FILE__,__LINE__,##arg);}\
												}while(0);

extern void I2C_EEPROM_Init(void);
extern uint32_t I2C_EEPROM_ByteWrite(uint8_t WritrAddr,uint8_t WriteData);
extern uint32_t I2C_EEPROM_ReadData(uint8_t ReadAddr,uint8_t *ReadData,uint8_t NumOfRead);										
extern uint32_t I2C_EEPROM_WaitEEPROM_StandByState(void);
#endif

main.c文件
#include "stm32f10x.h"
#include "bsp_led.h"
#include "./usart/bsp_usart.h"
#include "./i2c_eeprom/i2c_eeprom.h"

uint8_t ByteData[8] = {9,2,3,4,5,6,7,8};
uint8_t ReadBuffer[10] = {0};
int main(void)
{		 
	USART_Config();
	I2C_EEPROM_Init();
	
	printf("\r\nI2C读写EEPROM测试函数\n\r");
	
	I2C_EEPROM_ByteWrite(0,ByteData[0]);
	I2C_EEPROM_WaitEEPROM_StandByState();
	I2C_EEPROM_ReadData(0,ReadBuffer,1);
	printf("读取到的数据是%d\n",ReadBuffer[0]);

	while (1)
	{

	}
}

有了上面的发送一个字节大小的发送函数，我们写一个发送EEPROM页大小的发送函数(通过看数据手册，可以知道EEPROM一页最多写8个字节)：

该程序是在上面程序的基础上，加的程序代码

页写入

.c文件
//写一个按页写入函数,
//第一个形参：向EEPROM的哪个地址写入数据
//第二个形参：向EEPROM写入什么数据内容
//第三个形参：写入一页的内容，即8个字节大小的内容
uint32_t I2C_EEPROM_PageWrite(uint8_t WriteAddr,uint8_t * WriteData,uint16_t NumOfWrite)
{
	//产生一个起始信号
	I2C_GenerateSTART(I2C_EEPROM_X,ENABLE);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_Time;
	//判断起始信号是否产生成功
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_MODE_SELECT) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(11);
		}
	}
	//起始信号产生完毕，发送设备地址，进行广播EEPROM
	I2C_Send7bitAddress(I2C_EEPROM_X,EEPROM_OwnAddresss,I2C_Direction_Transmitter);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_Time;
	//判断设备地址是否发送完毕
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(12);
		}		
	}
	//发送EEPROM广播地址完成，发送向EEPROM哪个地址写入数据
	I2C_SendData(I2C_EEPROM_X,WriteAddr);
	//给延时时间赋值，以便判断信号成功与否
	I2C_EEPROM_Delay = I2C_EEPROM_Delay_Time;
	//判断地址是否发送完毕
	while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_BYTE_TRANSMITTING) == ERROR)
	{
		while((I2C_EEPROM_Delay--) == 0)
		{
			return  I2C_EEPROM_ERROR_BackFunction(13);
		}		
	}
	while(NumOfWrite--)
	{
		//发送写入的数据
		I2C_SendData(I2C_EEPROM_X,*WriteData);
		//数据地址偏移
		WriteData++;
		//给延时时间赋值，以便判断信号成功与否
		I2C_EEPROM_Delay = I2C_EEPROM_Delay_Time;
		//判断地址是否发送完毕
		while(I2C_CheckEvent(I2C_EEPROM_X,I2C_EVENT_MASTER_BYTE_TRANSMITTED) == ERROR)
		{
			while((I2C_EEPROM_Delay--) == 0)
			{
				return  I2C_EEPROM_ERROR_BackFunction(14);
			}		
		}	
	}
	//发送完毕，发送停止信号
	I2C_GenerateSTOP(I2C_EEPROM_X,ENABLE);
	return 1;
}

main.c文件
#include "stm32f10x.h"
#include "bsp_led.h"
#include "./usart/bsp_usart.h"
#include "./i2c_eeprom/i2c_eeprom.h"

uint8_t WriteData[8] = {9,2,50,4,5,20,7,8};
uint8_t ReadBuffer[10] = {0};
int main(void)
{		
	uint8_t i = 0;
	USART_Config();
	I2C_EEPROM_Init();
	
	printf("\r\nI2C读写EEPROM测试函数\n\r");
	
	I2C_EEPROM_PageWrite(0,WriteData,8);
	I2C_EEPROM_WaitEEPROM_StandByState();
	I2C_EEPROM_ReadData(0,ReadBuffer,8);
	for(i=0;i<8;i++)
	{
		printf("读取到的数据是%d  ",ReadBuffer[i]);
	}
	while (1)
	{

	}
}

在上面这个程序中，有一个问题！不知道大家有没有自己尝试着发现？

我们通过数据手册知道EEPROM一页最多可以写入8个字节的内容对吧，那如果，我写入地址不是8的倍数，我的数据会怎么样？

//比如，我输入地址是12，不是8的倍数，你会发现，数据会乱码
#include "stm32f10x.h"
#include "bsp_led.h"
#include "./usart/bsp_usart.h"
#include "./i2c_eeprom/i2c_eeprom.h"

uint8_t WriteData[8] = {9,2,50,4,5,20,7,8};
uint8_t ReadBuffer[10] = {0};
int main(void)
{		
	uint8_t i = 0;
	USART_Config();
	I2C_EEPROM_Init();
	
	printf("\r\nI2C读写EEPROM测试函数\n\r");
	
	I2C_EEPROM_PageWrite(2,WriteData,8);
	I2C_EEPROM_WaitEEPROM_StandByState();
	I2C_EEPROM_ReadData(2,ReadBuffer,8);
	for(i=0;i<8;i++)
	{
		printf("读取到的数据是%d  ",ReadBuffer[i]);
	}
	while (1)
	{

	}
}

输出的结果是：9、2、50、4、5、20、8、9，会发现什么，是不是最后二个数有问题，是的，这就是数据对齐的问题，我们从第二位开始写，一页还剩下6个可以写入，所以前6个正常，第7个开始，就不正常了！

接下来我们要做的就是解决掉数据对齐的问题。

对齐写入

.c文件
//解决对齐问题的代码
//第一个形参：向EEPROM的哪个地址写入数据
//第二个形参：向EEPROM写入什么数据内容
//第三个形参：写入多少个字节
uint32_t I2C_EEPROM_BufferWrite(uint8_t WriteAddr,uint8_t * WriteData,uint16_t NumOfWrite)
{
	//NumOfPage：写入的数据能装多少页;NumOfSingle:不足一页的数据还剩多少;Addr:中间变量;count:不对齐的情况第一页写多少数据
	uint8_t NumOfPage = 0 , NumOfSingle = 0 , Addr = 0 , count = 0;
	//用写入地址与一页的大小取余，比如写入地址是7,7%8==7
	Addr = WriteAddr % I2C_EEPROM_PageSize;
	//计算不对齐的情况第一页写多少，8-7==1
	count = I2C_EEPROM_PageSize - Addr;
	NumOfPage = NumOfWrite / I2C_EEPROM_PageSize;
	NumOfSingle = NumOfWrite % I2C_EEPROM_PageSize;
	//情况1：数据对齐的情况
	if(Addr == 0)
	{
		//情况1.1 如果写入的数据不够8个字节的话
		if(NumOfPage == 0)
		{
			//页写入数据，并等待EEPROM内部时序完成
			I2C_EEPROM_PageWrite(WriteAddr,WriteData,NumOfWrite);
			I2C_EEPROM_WaitEEPROM_StandByState();
		}
		else	//情况1.2 写入的数据大于8个字节
		{
			while(NumOfPage--)
			{
				I2C_EEPROM_PageWrite(WriteAddr,WriteData,NumOfWrite);
				I2C_EEPROM_WaitEEPROM_StandByState();
				WriteAddr = WriteAddr + I2C_EEPROM_PageSize;//写完一页，地址要加8
				WriteData = WriteData + I2C_EEPROM_PageSize;//数据地址，同样加8
			}
			//最后数据，不足一页的内容
			if(NumOfSingle != 0)
			{
				I2C_EEPROM_PageWrite(WriteAddr,WriteData,NumOfWrite);
				I2C_EEPROM_WaitEEPROM_StandByState();				
			}
		}
	}
	//情况2：数据不对齐的情况
	else
	{
		//情况2.1 写入的数据不足8个字节，小于一页能写入的最大值
		if(Addr == 0)
		{
			//页写入数据，并等待EEPROM内部时序完成
			I2C_EEPROM_PageWrite(WriteAddr,WriteData,NumOfWrite);
			I2C_EEPROM_WaitEEPROM_StandByState();			
		}
		else  //情况2.2 写入的数据大于8个字节，并且写入的地址不对齐
		{
			NumOfWrite = NumOfWrite - count;//总数减去第一页不对齐的情况下写入的数据值
			NumOfPage = NumOfWrite / I2C_EEPROM_PageSize;
			NumOfSingle = NumOfWrite % I2C_EEPROM_PageSize;
			if(count != 0)//第一页不对齐要写入多少个数据
			{
				//页写入数据，并等待EEPROM内部时序完成
				I2C_EEPROM_PageWrite(WriteAddr,WriteData,NumOfWrite);
				I2C_EEPROM_WaitEEPROM_StandByState();	
				WriteAddr = WriteAddr + count;//第一页不对齐写完后，地址加count位，方便后面写入
				WriteData = WriteData + count;//数据内容地址同样加count
			}
			while(NumOfPage--)
			{
				I2C_EEPROM_PageWrite(WriteAddr,WriteData,NumOfWrite);
				I2C_EEPROM_WaitEEPROM_StandByState();
				WriteAddr = WriteAddr + I2C_EEPROM_PageSize;//写完一页，地址要加8
				WriteData = WriteData + I2C_EEPROM_PageSize;//数据地址，同样加8
			}
			//最后数据，不足一页的内容
			if(NumOfSingle != 0)
			{
				I2C_EEPROM_PageWrite(WriteAddr,WriteData,NumOfWrite);
				I2C_EEPROM_WaitEEPROM_StandByState();				
			}	
		}
	}
	return 1;
}

main.c文件
#include "stm32f10x.h"
#include "bsp_led.h"
#include "./usart/bsp_usart.h"
#include "./i2c_eeprom/i2c_eeprom.h"

uint8_t WriteData[8] = {9,2,50,4,5,20,7,8};
uint8_t ReadBuffer[10] = {0};
int main(void)
{		
	uint8_t i = 0;
	USART_Config();
	I2C_EEPROM_Init();
	
	printf("\r\nI2C读写EEPROM测试函数\n\r");
	
	I2C_EEPROM_BufferWrite(2,WriteData,8);
	I2C_EEPROM_WaitEEPROM_StandByState();
	I2C_EEPROM_ReadData(2,ReadBuffer,8);
	for(i=0;i<8;i++)
	{
		printf("读取到的数据是%d  ",ReadBuffer[i]);
	}
	while (1)
	{

	}
}

我们通过串口打印可以看到，即使我输入的地址不对齐，但是结果就会是正确的。这就是对齐写入的意义。

学有所成，以图强国！

	}
		//最后数据，不足一页的内容
		if(NumOfSingle != 0)
		{
			I2C_EEPROM_PageWrite(WriteAddr,WriteData,NumOfWrite);
			I2C_EEPROM_WaitEEPROM_StandByState();				
		}	
	}
}
return 1;

}


---

```c
main.c文件
#include "stm32f10x.h"
#include "bsp_led.h"
#include "./usart/bsp_usart.h"
#include "./i2c_eeprom/i2c_eeprom.h"

uint8_t WriteData[8] = {9,2,50,4,5,20,7,8};
uint8_t ReadBuffer[10] = {0};
int main(void)
{		
	uint8_t i = 0;
	USART_Config();
	I2C_EEPROM_Init();
	
	printf("\r\nI2C读写EEPROM测试函数\n\r");
	
	I2C_EEPROM_BufferWrite(2,WriteData,8);
	I2C_EEPROM_WaitEEPROM_StandByState();
	I2C_EEPROM_ReadData(2,ReadBuffer,8);
	for(i=0;i<8;i++)
	{
		printf("读取到的数据是%d  ",ReadBuffer[i]);
	}
	while (1)
	{

	}
}

我们通过串口打印可以看到，即使我输入的地址不对齐，但是结果就会是正确的。这就是对齐写入的意义。

学有所成，以图强国！