【STM32学习笔记】目录

参考资料：除《【STM32学习笔记】目录》文章中提到的，还有《AT24C02手册》

I2C 简介及其架构介绍

I2C 初始化结构体详解

 /* I2C 初始化结构体 */
 
 typedef struct {
    
 uint32_t I2C_ClockSpeed;           // 设置SCL 时钟频率，此值要低于400000
 uint16_t I2C_Mode;                 // 指定工作模式，可选 I2C 模式及 SMBUS 模式 
 uint16_t I2C_DutyCycle;            // 指定时钟占空比，可选 low/high = 2:1 及 16:9 模式
 uint16_t I2C_OwnAddress1;          // 指定自身的 I2C 设备地址 
 uint16_t I2C_Ack;                  // 使能或关闭响应(一般都要使能) 
 uint16_t I2C_AcknowledgedAddress;  // 指定地址的长度，可为 7 位及 10 位 
 } I2C_InitTypeDef;

• I2C_ClockSpeed:设置的是I2C 的传输速率，在调用初始化函数时，函数会根据我们输入的数值经过运算后把时钟因子写入到I2C 的时钟控制寄存器CCR。由于CCR 寄存器不能写入小数类型的时钟因子，影响到SCL 的实际频率可能会低于本成员设置的参数值
• I2C_Mode：本成员是选择I2C 的使用方式，有I2C 模式(I2C_Mode_I2C )和SMBus 主、从模式(I2C_Mode_SMBusHost、 I2C_Mode_SMBusDevice ) 。I2C 不需要在此处区分主从模式，直接设置I2C_Mode_I2C 即可。
• I2C_DutyCycle：本成员设置的是I2C 的SCL 线时钟的占空比，设置I2C_CCR的DUTY位。
• I2C_OwnAddress1：配置STM32 的I2C 设备自己的地址。STM32 的I2C 外设可同时使用两个地址，即同时对两个地址作出响应，这个结构成员I2C_OwnAddress1 配置的是默认的、OAR1 寄存器存储的地址，若需要设置第二个地址寄存器OAR2，可使用I2C_OwnAddress2Config 函数来配置，OAR2 不支持10 位地址，只有7 位。
• I2C_Ack_Enable：一般都要使能，设置I2C_CR1的ACK位。
• I2C_AcknowledgeAddress：选择I2C的寻址模式是7位还是10位地址，这需要根据实际连接到I2C总线上设备的地址进行选择。这个成员的配置也影响到I2C_OwnAddress1 成员，只有这里设置成10 位模式时，I2C_OwnAddress1 才支持10 位地址。

硬件

开发板中的EEPROM的引脚配置

野火F103[霸道_V2]开发板

• 由上图可以看出，本实验板中的EEPROM芯片（型号：AT24C02）连接的是STM32的PB6、PB7引脚，即使用STM32的 I2C1 外设，结合上拉电阻，构成了I2C 通讯总线，它们通过I2C 总线交互。
• WP 引脚，具有写保护功能，当该引脚电平为高时，禁止写入数据，当引脚为低电平时，可写入数据，此开发板中EEPROM 的 WP 引脚直接接地，不使用写保护功能。

EEPROM（AT24C02）地址

• EEPROM芯片的设备地址一共有7 位，其中高4 位固定为：1010 b，低3 位则由A0/A1/A2信号线的电平决定，有上图可知，A0/A1/A2信号线通通接地，所以EEPROM 的7 位设备地址是：1010000b ，即0x50。
• I2C 通讯时常常是地址跟读写方向连在一起构成一个8 位数
  • 当R/W位为0 时，表示写方向，加上7 位地址，其值为“0xA0”，常称该值为I2C 设备的“写地址”；
  • 当R/W位为1 时，表示读方向，加上7 位地址，其值为“0xA1”，常称该值为I2C 设备的“读地址”。
    

向EEPROM写入数据

按字节写入

1. 发送起始信号（START）
2. 写入EEPROM设备的地址（DEVICE ADDRESS），紧接着写读写信号（R / ~W），此时选写信号，即低电平
3. 收到应答信号后，写入一个字节的数据（WORD ADDRESS），表示EEPROM中的某个字的地址（假如该地址为 0x01）
4. 收到应答信号后，写入一个字节的数据（DATA），写到EEPROM的0x01地址。
5. 收到应答信号后，发送停止信号（STOP）
6. 若要继续写数据，需要从头开始（即重复步骤 1~5 ），但是，EEPROM的写入速度远低于STM32，所以在写第二个数据时，要判断第一个数据是否已写入完成。
   检测的方法：发送起始信号，并写入设备地址后，如果应答信号为0，表示写入完成，可执行后续工作。

按页写入

1. 发送起始信号（START）
2. 写入EEPROM设备的地址（DEVICE ADDRESS），紧接着写读写信号（R / ~W），此时选写信号，即低电平
3. 收到应答信号后，写入一个字节的数据（ WORD ADDRESS(n) ），表示EEPROM中的一段连续地址的首地址（假如该地址为 0x01）
4. 收到应答信号后，写入一个字节的数据（DATA(n)），写到EEPROM的0x01地址。
5. 收到应答信号后，写入下一个字节的数据（DATA(n+1)），写到EEPROM的0x02地址。
6. 数据持续写入，地址自动加 1，直到收到停止信号（STOP）
7. AT24C02 的一页为 8 个字节，所以最多可以连续写入 8 个字节。若要继续写入数据，需从头开始（即重复步骤 1~6），但是，EEPROM的写入速度远低于STM32，所以在写第二组连续数据时，要判断第一组的最后一个数据是否已写入完成，检测方法同上（按字节写入）。

从EEEPROM中读取数据

当前地址读取

1. 发送起始信号（START）
2. 写入EEPROM设备的地址（DEVICE ADDRESS），紧接着写读写信号（R / ~W），此时选读信号，即高电平
3. 收到应答信号后，读取当前地址单元（EEPROM中某字的地址（地址一般不确定））的数据（DATA）
4. 读取完成后，发送非应答信号，再发送停止信号
5. 若要继续读数据，需要从头开始（即重复步骤 1~4 ）

随机读取

1. 发送起始信号（START）
2. 写入EEPROM设备的地址（DEVICE ADDRESS），紧接着写读写信号（R / ~W），此时选写信号，即低电平
3. 收到应答信号后，写入一个字节的数据（WORD ADDRESS n），表示EEPROM中的某个字的地址（假如该地址为 0x01）
4. 收到应答信号后，再次发送起始信号和设备地址及读写信号，此时读写信号选读信号，即高电平
5. 收到应答信号后，读取0x01地址单元的数据（DATA n）
6. 读取完成后，发送非应答信号，再发送停止信号
7. 若要继续读数据，需要从头开始（即重复步骤 1~6 ）

顺序读取

工作的过程和随机读取一样，但是在第 5 个步骤结束后，并不发送非应答信号，而是继续（按上一个数据地址增 1 的地址）读取数据。原则上可以无限的读取，但是AT24C02 只有256个字节，当读到最后一个字节时，将执行**“roll over”**，即从 0 号地址开始继续读取数据。

软件

初始化 I2C 相关的GPIO

/* I2C GPIO 引脚定义 */
#define EEPROM_I2C_SCL_GPIO_CLK     RCC_APB2Periph_GPIOB
#define EEPROM_I2C_SDA_GPIO_CLK     RCC_APB2Periph_GPIOB

#define EEPROM_I2C_GPIO_APBxClkCmd  RCC_APB2PeriphClockCmd
 
#define EEPROM_I2C_SCL_GPIO_MODE    GPIOB
#define EEPROM_I2C_SCL_GPIO_PIN     GPIO_Pin_6
#define EEPROM_I2C_SDA_GPIO_MODE    GPIOB
#define EEPROM_I2C_SDA_GPIO_PIN     GPIO_Pin_7	


void EEPROM_I2C_Config(void){
    

	GPIO_InitTypeDef  GPIO_InitStructure;
	
	/*** 初始化 I2C 需要用到的GPIO ***/
	
	/* 打开 I2C GPIO 的时钟 */
	EEPROM_I2C_GPIO_APBxClkCmd(EEPROM_I2C_SCL_GPIO_CLK | EEPROM_I2C_SDA_GPIO_CLK, ENABLE);
	
	/* 将 I2C SCL 的 GPIO 配置为开漏复用输出模式 */
	GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SCL_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(EEPROM_I2C_SCL_GPIO_MODE, &GPIO_InitStructure);
	
	/* 将 I2C SDA 的 GPIO 配置为开漏复用输出模式 */
	GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SDA_GPIO_PIN;
	GPIO_Init(EEPROM_I2C_SDA_GPIO_MODE, &GPIO_InitStructure);
	
}

配置 I2C 外设的工作模式

/* I2C 引脚定义 */
#define EEPROM_I2C                  I2C1
#define EEPROM_I2C_CLK              RCC_APB1Periph_I2C1
#define EEPROM_I2C_APBxClkCmd       RCC_APB1PeriphClockCmd
#define EEPROM_I2C_BAUDRATE         400000

#define STM32_I2C_OWN_ADDR          0x5f

void EEPROM_I2C_Config(void){
    
	
	I2C_InitTypeDef   I2C_InitStructure;
	
	/*** 配置 I2C 的工作参数 ***/
	
	/* 打开 I2C 外设的时钟 */
	EEPROM_I2C_APBxClkCmd(EEPROM_I2C_CLK, ENABLE);

	I2C_InitStructure.I2C_ClockSpeed = EEPROM_I2C_BAUDRATE;                       // 配置SCL时钟频率
	I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;                                    // I2C 模式
	I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;                            // 时钟占空比，low/high = 2:1
	I2C_InitStructure.I2C_OwnAddress1 = STM32_I2C_OWN_ADDR;                       // STM32 IIC 自身设备地址，只要是总线上唯一的地址即可
	I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;                                   // 使能应答
	I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;     // 使用7位地址模式
	I2C_Init(EEPROM_I2C, &I2C_InitStructure);                                     // 完成 I2C 的初始化配置
	
	/*** 使能 I2C ***/
	
	I2C_Cmd(EEPROM_I2C, ENABLE);
}

编写 I2C 写入 EEPROM 的 Byte_Write 函数

/* 发送一个字节数据 */
void EEPROM_Byte_Write(uint8_t addr, uint8_t data){
    
	
	/* 产生起始信号 */
	I2C_GenerateSTART(EEPROM_I2C, ENABLE);
	
	/* 检验事件 EV5 */
	while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	
	/* EV5事件被检测到，发送设备地址 */
	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_I2C_ADDR, I2C_Direction_Transmitter);
	
	/* 检测事件 EV6 */
	while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR);
	
	/* EV6事件被检测到，发送要操作的存储单元地址 */
	I2C_SendData(EEPROM_I2C, addr);
	
	/* 检测事件 EV8 */
	while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTING) == ERROR);
	
	/* EV8事件被检测到，发送要存储的数据 */
	I2C_SendData(EEPROM_I2C, data);
	
	/* 检测事件 EV8_2 */
	while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTED) == ERROR);
	
	/* EV8_2 事件被检测到, 数据传输完成 */
	I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
	
}

编写 I2C 写入 EEPROM 的 Page_Write函数

/* 发送多个字节数据，按页发送，不能超多 8 个字节 */
void EEPROM_Page_Write(uint8_t addr, uint8_t *data, uint8_t numByteToWrite){
    
	
	/* 产生起始信号 */
	I2C_GenerateSTART(EEPROM_I2C, ENABLE);
	
	/* 检验事件 EV5 */
	while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	
	/* EV5事件被检测到，发送设备地址 */
	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_I2C_ADDR, I2C_Direction_Transmitter);
	
	/* 检测事件 EV6 */
	while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR);
	
	/* EV6事件被检测到，发送要操作的存储单元地址 */
	I2C_SendData(EEPROM_I2C, addr);
	
	/* 检测事件 EV8 */
	while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTING) == ERROR);
	
	/* 发送 numByteToWrite 个字节的数据 */
	while(numByteToWrite){
    
	
		/* EV8事件被检测到，发送要存储的数据 */
		I2C_SendData(EEPROM_I2C, *data);
		
		/* 检测事件 EV8_2 */
		while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTED) == ERROR);
		
		numByteToWrite--;
		data++;
	}
	
	/* EV8_2 事件被检测到, 数据传输完成 */
	I2C_GenerateSTOP(EEPROM_I2C, ENABLE);
	
}

编写 I2C 读取 EEPROM 的 Read 函数

/* 从 EEPROM 中读取数据 */
void EEPROM_Read(uint8_t addr, uint8_t *data, uint8_t numByteToRead){
    
	
	/*--- 第一次发送起始信号 ---*/
	I2C_GenerateSTART(EEPROM_I2C, ENABLE);
	
	/* 检验事件 EV5 */
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	
	/* EV5事件被检测到，发送设备地址 */
	/* 注意：此过程为发送地址 */
	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_I2C_ADDR, I2C_Direction_Transmitter);
	
	/* 检测事件 EV6 */
	/* 注意：此过程为检测发送数据是否完成 */
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR);
	
	/* EV6事件被检测到，发送要操作的存储单元地址 */
	I2C_SendData(EEPROM_I2C, addr);
	
	/* 检测事件 EV8 */
	while(I2C_CheckEvent(EEPROM_I2C,I2C_EVENT_MASTER_BYTE_TRANSMITTING) == ERROR);
	
	/*--- 第二次发送起始信号 ---*/
	I2C_GenerateSTART(EEPROM_I2C, ENABLE);
	
	/* 检验事件 EV5 */
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_MODE_SELECT) == ERROR);
	
	/* EV5事件被检测到，发送设备地址 */
	/* 注意：此过程为接收地址 */
	I2C_Send7bitAddress(EEPROM_I2C, EEPROM_I2C_ADDR, I2C_Direction_Receiver);
	
	/* 检测事件 EV6 */
	/* 注意：此过程为检测接收数据是否完成 */
	while(I2C_CheckEvent(EEPROM_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) == ERROR);
	
	/* 读取 numByteToRead 个字节数据 */
	while(numByteToRead){
    
		
		/* 如果为最后一个字节，产生非应答信号
		 * 注意：非应答信号需在读取最后一个数据前产生
		 */
		if(numByteToRead == 1){
    
			I2C_AcknowledgeConfig(EEPROM_I2C, DISABLE);
		}
		
		/* 注意：虽然在通讯图中显示的是先有数据DATA，再产生 EV7 事件。
		 * 		但是读过程需要读取数据寄存器，即当数据寄存器非空时，才能读取。
		 *		因此需先检测 EV7 事件，判断数据寄存器是否非空，若非空，才可读取数据。
		 */		

		/* 检测事件 EV7 */
		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);
}

等待EEPROM内部时序完成函数

/* 等待EEPROM内部时序完成 */
void EEPROM_WaitForWriteEnd(void){
    
	
	do{
    		
		/* 产生起始信号 */
		I2C_GenerateSTART(EEPROM_I2C,ENABLE);
		
		/* 检测 SB 位 */
		while(I2C_GetFlagStatus (EEPROM_I2C,I2C_FLAG_SB) == RESET);
		
		/* SB 位为 1，发送设备地址 */
		I2C_Send7bitAddress(EEPROM_I2C,EEPROM_I2C_ADDR,I2C_Direction_Transmitter);
		
	}  while(I2C_GetFlagStatus (EEPROM_I2C,I2C_FLAG_ADDR) == RESET ); // 检测到 ADDR 位为 1 时停止

	/*  EEPROM内部时序完成传输完成 */
	I2C_GenerateSTOP(EEPROM_I2C,ENABLE);	
}

使用 write 函数和 read 函数进行读写校验

#define ArrNum 10

uint8_t writeData[8] = {
    2,3,4,5,6,7,8,9};
uint8_t readData[ArrNum] = {
    0};

int main(){
    
	
	uint8_t i;
	
	USART_Config();
	EEPROM_I2C_Config();
	
	printf("I2C--EEPROM 实验 \n");
	
	/* 写 读 1 个字节的数据 */
	
	EEPROM_Byte_Write(11, 1);     // 在 11 地址写入数据 1	
	EEPROM_WaitForWriteEnd();     // 等待写操作完成	
	EEPROM_Read(11, readData, 1); // 读出 11 地址的数据，读取 1 个字节	
	printf("%d\n",readData[0]);   // 通过串口发送给上位机显示
	
	
	
	/* 写 读 8 个字节的数据 */
	
	EEPROM_Page_Write(0, writeData, 8); // 在 8 地址写入数据
	EEPROM_WaitForWriteEnd();           // 等待写操作完成	
	EEPROM_Read(0, readData, 8);        // 读出 8 地址的数据，读取 8 个字节
	for(i=0;i<8;i++){
    
		printf("%d ", readData[i]);
	}
	putchar('\n');

	while(1){
    
		
	}
}