2021年10月22日 | 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, %#Xn", 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字节对齐，否则会出错，而且极难被发现。