stm32专题十七：深度解析 stm32 硬件iic （i2c）

首先是配置I2C的GPIO，然后配置I2C参数。就是常规配置，按流程来写不会错。

/**
 * @brief EEPROM IIC 配置
 */
void I2C_EE_config(void)
{
  GPIO_InitTypeDef GPIO_InitStruct;
	I2C_InitTypeDef I2C_InitStruct;
	
	// 开启I2C GPIO时钟
	EPROM_I2C_GPIO_APBxClkCmd(EEPROM_I2C_SCL_GPIO_CLK | EEPROM_I2C_SDA_GPIO_CLK, ENABLE);
	// 开启I2C 外设时钟
	EEPROM_I2C_APBxClkCmd(EEPROM_I2C_CLK, ENABLE);

  // I2C的引脚配置为复用开漏输出
	GPIO_InitStruct.GPIO_Pin = EPROM_I2C_SCL_GPIO_PIN;
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_OD;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(EPROM_I2C_SCL_GPIO_PORT, &GPIO_InitStruct);
	
	GPIO_InitStruct.GPIO_Pin = EPROM_I2C_SDA_GPIO_PIN;
  GPIO_Init(EPROM_I2C_SDA_GPIO_PORT, &GPIO_InitStruct);
	
	// 配置I2C参数（时钟速度、模式、占空比、自身地址、应答使能、7位设备地址）
	I2C_InitStruct.I2C_ClockSpeed = EEPROM_I2C_BAUDRATE;
	I2C_InitStruct.I2C_Mode = I2C_Mode_I2C;
	I2C_InitStruct.I2C_DutyCycle = I2C_DutyCycle_2;
	I2C_InitStruct.I2C_OwnAddress1 = STM32_I2C_OWN_ADDR;
	I2C_InitStruct.I2C_Ack = I2C_Ack_Enable;
	I2C_InitStruct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
	
	// 初始化
	I2C_Init(EEPROM_I2C, &I2C_InitStruct);
	
	// 使能串口
	I2C_Cmd(EEPROM_I2C, ENABLE);
}

EEPROM写入一个字节的代码，这里唯一值得注意的是，在检测到EV8事件时的状态。此时移位寄存器正在发送数据，而数据寄存器DR为空。发送data会被暂存到DR，直到移位寄存器发送完，再由DR转移到移位寄存器。

// 向EEPROM写入一个字节（因为EEPROM设备地址固定为0XA0）
void EEPROM_Byte_Write(uint8_t addr, uint8_t data)
{
	// 产生起始信号
	I2C_GenerateSTART(EEPROM_I2C, ENABLE);

	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	
	// EV5事件被检测到，发送设备地址（直接填入EEPROM的设备地址：EEPROM_ADDR）
	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDR, I2C_Direction_Transmitter);
	
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR);
	
	// EV6事件被检测到，发送要操作的存储单元地址
	I2C_SendData(EEPROM_I2C, addr);
	
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTING) == ERROR);
	
	// EV8事件被检测到（此时移位寄存器正在发送数据，而数据寄存器DR为空）
	// （发送data会被暂存到DR，直到移位寄存器发送完，再由DR转移到移位寄存器）
	I2C_SendData(EEPROM_I2C, data);
	
	// DR不再填入新的数据，移位寄存器发送完最后一个字节，结束
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED) == ERROR);
	
	// 数据传输完成，产生结束信号
	I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
}

然后是读取n个字节的代码。核心思想有几个。第一，按照EEPROM的random read时序，并检测对应的事件；第二，在读入最后一个字节之前，要把应答使能设置为disable，通知EEPROM不要再发数据；第三，接收数据指针要不断递增，防止覆盖；第四，读操作完成后，重新开启应答使能。

// 从EEPROM读取多个字节
void EEPROM_Read(uint8_t addr, uint8_t *data, uint8_t numByteToRead)
{
	// 产生起始信号
	I2C_GenerateSTART(EEPROM_I2C, ENABLE);

	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	
	// EV5事件被检测到，发送设备地址（直接填入EEPROM的设备地址：EEPROM_ADDR）
	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDR, I2C_Direction_Transmitter);
	
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR);
	
	// EV6事件被检测到，发送要操作的存储单元地址
	I2C_SendData(EEPROM_I2C, addr);
	
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTING) == ERROR);
	
	// 第二次产生起始信号
	I2C_GenerateSTART(EEPROM_I2C, ENABLE);

	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	
	// EV5事件被检测到，发送设备地址，这里方向要选为接收
	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDR, I2C_Direction_Receiver);
	
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) == ERROR);
	
	// 判断是否为最后一个字节
	while (numByteToRead) 
	{		
		if (numByteToRead == 1)
		{
			// 最后一个字节，产生非应答
			I2C_AcknowledgeConfig(EEPROM_I2C, DISABLE);
		}
		
		while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED) == ERROR);
		
		// EV7事件被检测到，即数据寄存器有新的有效数据
		*data = I2C_ReceiveData(EEPROM_I2C);
		
		data++;							// 指针指向下一个字节
		numByteToRead--;		
	}
	// 数据传输完成，产生结束信号
	I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
	
	// 重新配置Ack使能，以便下次通讯
	I2C_AcknowledgeConfig(EEPROM_I2C, ENABLE);
}

接下来，就是硬件i2c要注意的几个地方。事实上，直接按如下代码操作，程序会直接卡死：

int main(void)
{	
	uint8_t readData[10] = {0};
	
	USART_config();
	I2C_EE_config();
	
	printf("这是一个IIC通讯实验\n");
	
	// 写入一个字节
	EEPROM_Byte_Write(11, 0X55);
	
	
	// 读取数据
	EEPROM_Read(11, readData, 1);
	
	printf("\n接收到的数据为： %#X", readData[0]);
		
	while (1)
	{
		
	}
}

为什么？

因为我们是写完立刻读取，而没有缓冲时间。实际上，之前我在EEPROM那篇博客中，有强调一个问题。EEPROM需要写入时间，在这期间内，不响应外部发送的数据，因此，不会产生应答。而在我们的读取函数中，（实际上是发送起始信号后，再发送设备地址然后等待响应），由于EEPROM还在写入，不会响应读取函数中的应答，所以程序会在这里卡死掉while()死循环。

https://blog.csdn.net/dingyc_ee/article/details/100042665

程序卡死的地方：

// 从EEPROM读取多个字节
void EEPROM_Read(uint8_t addr, uint8_t *data, uint8_t numByteToRead)
{
	// 产生起始信号
	I2C_GenerateSTART(EEPROM_I2C, ENABLE);

	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	
	// EV5事件被检测到，发送设备地址（直接填入EEPROM的设备地址：EEPROM_ADDR）
	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDR, I2C_Direction_Transmitter);
	
    // 程序会一直卡死在接下来这个while中
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR);

解决的方案，就是上面提到的确认轮询。通过不断的产生起始 + 设备地址信号，并检测EEPROM的应答，来判断EEPROM是否已经写入完成，如果应答，则表示写入完成，产生结束条件。这里还有几个操蛋的地方，事件检测函数直接不能用（程序中注释的代码，一用就会出错，我也不知道为什么，好像说是因为这个函数会检测好几个标志位），只能检测响应的标志位。确认轮询的代码如下：

// 确认轮询，等待EEPROM完成写入时序的操作（不断产生：起始 + 设备地址）
void EEPROM_WaitForWriteEnd(void)
{
	do 
	{
		// 产生起始信号
		I2C_GenerateSTART(EEPROM_I2C, ENABLE);
		
		// 这个函数会出错 while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
		while(I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_SB) == RESET);
		
		// EV5事件被检测到，发送设备地址（直接填入EEPROM的设备地址：EEPROM_ADDR）
		I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDR, I2C_Direction_Transmitter);
	}
	// 如果EEPROM不响应，则一直产生起始信号，直到响应为止
	// 这个函数会出错 while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR);
	while (I2C_GetFlagStatus(EEPROM_I2C, I2C_FLAG_ADDR) == RESET);
	
	
	// 如果检测到EEPROM的响应，认为内部写入时序完成，产生结束信号
	I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
}

然后在主函数中进行调用，结果正确：

int main(void)
{	
	uint8_t readData[10] = {0};
	
	USART_config();
	I2C_EE_config();
	
	printf("这是一个IIC通讯实验\n");
	
	// 写入一个字节
	EEPROM_Byte_Write(11, 0X55);
	
	// 确认轮询操作，等待EEPROM写入完成
	EEPROM_WaitForWriteEnd();
	
	// 读取数据
	EEPROM_Read(11, readData, 1);
	
	printf("\n接收到的数据为： %#X", readData[0]);
		
	while (1)
	{
		
	}
}

串口输出数据如下：

测试读两个数据：

int main(void)
{	
	uint8_t readData[10] = {0};
	
	USART_config();
	I2C_EE_config();
	
	printf("这是一个IIC通讯实验\n");
	
	// 写入一个字节
	EEPROM_Byte_Write(11, 0X55);
	
	// 确认轮询操作，等待EEPROM写入完成
	EEPROM_WaitForWriteEnd();
	
	EEPROM_Byte_Write(12, 0X56);
	EEPROM_WaitForWriteEnd();
	
	// 读取数据
	EEPROM_Read(11, readData, 2);
	
	printf("接收到的数据为： %#X, %#X\n", readData[0], readData[1]);
		
	while (1);
}

结果如下，说明多字节读取函数正确。

接下来实现页写入的函数（每次不能超过8字节，否则会卷回来到本页起始，覆盖掉之前数据）

// 向EEPROM写入多个字节（页写入），最大不能超过8字节
void EEPROM_Page_Write(uint8_t addr, uint8_t *data, uint8_t numByteToRead)
{
	// 产生起始信号
	I2C_GenerateSTART(EEPROM_I2C, ENABLE);

	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	
	// EV5事件被检测到，发送设备地址（直接填入EEPROM的设备地址：EEPROM_ADDR）
	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_ADDR, I2C_Direction_Transmitter);
	
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR);
	
	// EV6事件被检测到，发送要操作的存储单元地址
	I2C_SendData(EEPROM_I2C, addr);
	
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTING) == ERROR);
	
	while (numByteToRead)
	{
		// EV8事件被检测到
		I2C_SendData(EEPROM_I2C, *data);
		
		// DR不再填入新的数据，移位寄存器发送完最后一个字节，结束
		while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED) == ERROR);
	
		data++;							// 指针指向下一个字节
		numByteToRead--;		
	}
	// 数据传输完成，产生结束信号
	I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
}

测试代码：

int main(void)
{	
	uint8_t i = 0;
	uint8_t readData[8] = {0};
	uint8_t writeData[8] = {1, 2, 3, 4, 5, 6, 7, 8};
	
	USART_config();
	I2C_EE_config();
	
	printf("这是一个IIC通讯实验\n");
	
	EEPROM_Page_Write(16, writeData, 8);

	// 确认轮询操作，等待EEPROM写入完成
	EEPROM_WaitForWriteEnd();

	EEPROM_Read(16, readData, 8);
	
	for (i = 0; i < 8; i++)
	{
		printf("%4d", readData[i]);
	}
	printf("\n");
		
	while (1);
}

测试结果：

接下来，演示的是一些很不好的操作，如果写入的数据超过一页，诗句是怎么被覆盖掉的？我们尝试向一页中写入10个数据，然后读取这一页（8）个数据，看看会有什么现象：

测试代码：

int main(void)
{	
	uint8_t i = 0;
	uint8_t readData[8] = {0};
	uint8_t writeData[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	
	USART_config();
	I2C_EE_config();
	
	printf("这是一个IIC通讯实验\n");
	
	EEPROM_Page_Write(16, writeData, 10);

	// 确认轮询操作，等待EEPROM写入完成
	EEPROM_WaitForWriteEnd();

	EEPROM_Read(16, readData, 8);
	
	for (i = 0; i < 8; i++)
	{
		printf("%4d", readData[i]);
	}
	printf("\n");
		
	while (1);
}

接下来就是见证奇迹的时刻，最后的9 10两个数据，把之前的1 2给覆盖掉了

还有一个问题，关于地址对齐。AT24C02每页为8字节，所以每页的起始地址为0 8 16...，如果我们以对齐的地址来写入，则数据和地址都是正确的。但是，如果我们错开地址，会如何？接下来，从地址2开始连续写入8字节，然后读取8字节，观察结果

测试代码：

int main(void)
{	
	uint8_t i = 0;
	uint8_t readData[8] = {0};
	uint8_t writeData[8] = {1, 2, 3, 4, 5, 6, 7, 8};
	
	USART_config();
	I2C_EE_config();
	
	printf("这是一个IIC通讯实验\n");
	
	EEPROM_Page_Write(2, writeData, 8);

	// 确认轮询操作，等待EEPROM写入完成
	EEPROM_WaitForWriteEnd();

	EEPROM_Read(2, readData, 8);
	
	for (i = 0; i < 8; i++)
	{
		printf("%4d", readData[i]);
	}
	printf("\n");
		
	while (1);
}

测试结果：

可以看到，前面6个数据是正确的，而后2个数据是错误的。分析：后面两个数据，由于反卷，直接写到了第一页的开始两个字节，而我们读取到的数据，则是第二页的前2个数据，验证一下：

测试代码：

int main(void)
{	
	uint8_t i = 0;
	uint8_t readData[8] = {0};
	uint8_t writeData[8] = {1, 2, 3, 4, 5, 6, 7, 8};
	
	USART_config();
	I2C_EE_config();

	printf("这是一个IIC通讯实验\n");
	

	// 读取第一页的前2个数据
	EEPROM_Read(0, readData, 2);
	// 读取第二页的前2个数据
	EEPROM_Read(8, (readData + 2), 2);
	
	printf("读取第一页的前2个数据\n");
	for (i = 0; i < 2; i++)
	{
		printf("%4d", readData[i]);
	}
	printf("\n");
	
	printf("读取第二页的前2个数据\n");
	for (i = 2; i < 4; i++)
	{
		printf("%4d", readData[i]);
	}
	printf("\n");
		
	while (1);
}

测试结果：

与设想的一致。7 8由于反卷，写入到了第一页的前两个字节。而我们读数据时，地址是直接递增的，所以在读取完前6个后，按顺序（不会反卷）读取第二页的数据，因此会导致出错。

那么，我们在使用EEPROM进行页写入时，一定要注意地址8字节对齐，否则会出错，而且极难被发现。