STM32 硬件I2C中断实现

目录

1、初始化I2C

2、启动传输

3、发送数据流程

4、接收数据

5、Code

6、注意：

---

对于有嵌入式开发经历的人来说，I2C是使用场合较多的一种通讯方式，比如MPU6050、AT24C02、LRC9663等等都有I2C通讯接口。我们常用的都是用IO去模拟，然而I2C通讯的速度并不高，一般模拟CLK周期为6us左右，

如果发送一个字节给某个地址 

    1个起始位+8（地址）+1应答+寄存1 应答 +数据 8 器地址 8++1应答 +1结束= 29个CLK   

    29个CLK*6us= 174us   

   针对通常用的400kbps的传输速率  29个CLK * 2.5us = 72us 

一般传输过程不允许被中断打断，所以会影响系统实时性。

 

以下内容是在STM32F411上实现的，和MPU9250已移植验证通过。搞了一天时间，稳定性还没怎么测，欢迎留言评论。

---

转入重点，I2C硬件中断实现过程如下

1、初始化I2C

初始化好相关GPIO,I2C,RCC,NVIC模块，

---

2、启动传输

准备好发送的器件地址，寄存器地址，数据

发送起始信号，开启中断，启动发送

I2C_ITConfig(i2cPort, I2C_IT_BUF, DISABLE);

I2C_ITConfig(i2cPort, I2C_IT_EVT, ENABLE);

i2cPort->CR1 = (I2C_CR1_START | I2C_CR1_PE);//

接下来就是中断的事了

---

3、发送数据流程

• 起始信号完成中断 I2C_SR1_SB

发送器件地址(不设置应答)

• 器件地址传输完成中断 I2C_SR1_ADDR

    发送寄存器地址，使能发送完成中断I2C_IT_BUF

• 字节发送完成中断

    发送数据

    判断有无等待发送的数据，没有则关闭中断，发送停止位，发送结束

 

如果中途检测到应答失败，会进入异常中断I2C1_ER_IRQHandler

---

4、接收数据

• 触发起始信号完成中断 I2C_SR1_SB

发送器件地址(不设置应答)

• 器件地址传输完成中断 I2C_SR1_ADDR

    发送寄存器地址，使能发送完成中断I2C_IT_BUF

• 字节发送完成中断

    再次发送起始位

• 起始信号发送完中断

    发送器件读地址，开启自动应答使能

• 器件地址传输完成中断

   判断待发送的数据长度，如果为空，关闭应答使能

• 字节接受完成中断

继续读取数据，判断待读取目标数据长度，

如果只剩下一个字节，取消应答使能

如果为无待接收数据，关闭中断，发送停止位，接受结束。

---

5、Code

typedef enum
{
	i2cWrite,
	i2cRead
} I2cDirection;


typedef enum
{
	I2C_STATUS_FREE = 0,
	I2C_STATUS_START,
	I2C_STATUS_ADDRESS,
	I2C_STATUS_START_R,//读数据时第二次发送起始信号
	I2C_STATUS_REDATA,
	I2C_STATUS_FINSIH,//操作完成
	I2C_STATUS_ERR,//错误

}I2C_STATUS;

typedef struct _I2cMessage
{
	uint32_t         Length;		
	uint32_t 		 Index;
	uint8_t          slaveAddress;		
	I2cDirection     direction;    
	I2C_STATUS        status;         
	uint16_t         regAddress;   
	uint8_t          *buffer;        
} I2cMessage;


static I2cMessage Message;
 
 
void i2cdrvInitBus()
{
	I2C_InitTypeDef  I2C_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	GPIO_InitTypeDef GPIO_InitStructure;


	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);


	GPIO_StructInit(&GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8; // SCL
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; // SDA
	GPIO_Init(GPIOB, &GPIO_InitStructure);


	GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_I2C1);
	GPIO_PinAFConfig(GPIOB, GPIO_Pin_9Source, GPIO_AF_I2C1);

	I2C_DeInit(I2C1);
	I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
	I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
	I2C_InitStructure.I2C_OwnAddress1 = 0x30;;
	I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
	I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
	I2C_InitStructure.I2C_ClockSpeed = 400000;
	I2C_Init(I2C1, &I2C_InitStructure);

	I2C_ITConfig(I2C1, I2C_IT_ERR, ENABLE);

	NVIC_InitStructure.NVIC_IRQChannel = I2C1_EV_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 7;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	NVIC_InitStructure.NVIC_IRQChannel = I2C1_ER_IRQn;
	NVIC_Init(&NVIC_InitStructure);

	GPIO_SetBits(GPIOB, GPIO_Pin_8);
	GPIO_SetBits(GPIOB, GPIO_Pin_9);

}



//读取数据
bool i2cdevRead(uint8_t devAddr, uint8_t ReadAddr, uint8_t DatasLen, uint8_t *DataRead)
{
	int waitTime;
	Message.status = I2C_STATUS_START;
	Message.slaveAddress = devAddr;
	Message.Index = 0;

	Message.buffer = DataRead;

	Message.Length = DatasLen;
	Message.regAddress = ReadAddr;//寄存器地址
	Message.direction = i2cRead;

	I2C_ITConfig(I2C1, I2C_IT_BUF, DISABLE);
	I2C_ITConfig(I2C1, I2C_IT_EVT, ENABLE);
	I2C1->CR1 = (I2C_CR1_START | I2C_CR1_PE);//1 触发起始中断
	waitTime = clock();
	while (1)//等待接收完成
	{
		if (Message.status == I2C_STATUS_FINSIH)
		{
			return true;
		}
		if (Message.status == I2C_STATUS_ERR)
		{
			return false;
		}
		if (clock() - waitTime > 10)
		{
			I2C_ITConfig(I2C1, I2C_IT_EVT | I2C_IT_BUF, DISABLE);
			return false;
		}
	}
}


//发送一个字节
bool i2cdevWriteByte(uint8_t devAddr, uint8_t WriteAddr, uint8_t DataToWrite)
{
	int waitTime;
	Message.status = I2C_STATUS_START;
	Message.slaveAddress = devAddr;
	Message.Index = 0;

	Message.buffer = &DataToWrite;

	Message.Length = 1;
	Message.regAddress = WriteAddr;//寄存器地址
	Message.direction = i2cWrite;

	I2C_ITConfig(I2C1, I2C_IT_BUF, DISABLE);
	I2C_ITConfig(I2C1, I2C_IT_EVT, ENABLE);
	I2C1->CR1 = (I2C_CR1_START | I2C_CR1_PE);//1 触发了起始中断
	waitTime = clock();
	while (1)//等待发送完成
	{
		if (Message.status == I2C_STATUS_FINSIH)
		{
			return true;
		}
		if (Message.status == I2C_STATUS_ERR)
		{
			return false;
		}
		if (clock() - waitTime > 10)
		{
			I2C_ITConfig(I2C1, I2C_IT_EVT | I2C_IT_BUF, DISABLE);
			return false;
		}
	}
}

void  I2C1_ER_IRQHandler(void)
{
	if (I2C_GetFlagStatus(I2C1, I2C_FLAG_AF))
	{
		I2C_ITConfig(I2C1, I2C_IT_EVT | I2C_IT_BUF, DISABLE);

		I2C_ClearFlag(I2C1, I2C_FLAG_AF);

		Message.status = I2C_STATUS_ERR;
	}
	if (I2C_GetFlagStatus(I2C1, I2C_FLAG_BERR))
	{
		I2C_ClearFlag(I2C1, I2C_FLAG_BERR);
	}
	if (I2C_GetFlagStatus(I2C1, I2C_FLAG_OVR))
	{
		I2C_ClearFlag(I2C1, I2C_FLAG_OVR);
	}
	if (I2C_GetFlagStatus(I2C1, I2C_FLAG_ARLO))
	{
		I2C_ClearFlag(I2C1, I2C_FLAG_ARLO);
	}
}



void I2C1_EV_IRQHandler()
{
	uint16_t SR1;
	uint16_t SR2;

	SR1 = I2C1->SR1;

	// Start bit event
	if (SR1 & I2C_SR1_SB)
	{
		if (Message.status == I2C_STATUS_START)
		{
			I2C_Send7bitAddress(I2C1, Message.slaveAddress << 1, I2C_Direction_Transmitter);//2
			Message.status = I2C_STATUS_ADDRESS;
		}
		else if (Message.status == I2C_STATUS_START_R)
		{
			I2C_AcknowledgeConfig(I2C1, ENABLE);//5 转为读数据
			I2C_Send7bitAddress(I2C1, Message.slaveAddress << 1, I2C_Direction_Receiver);
			Message.status = I2C_STATUS_REDATA;
		}
	}
	else if (SR1 & I2C_SR1_ADDR)//地址传输完成
	{
		SR2 = I2C1->SR2;

		if (Message.status == I2C_STATUS_ADDRESS)//发送寄存器地址
		{
			I2C_SendData(I2C1, Message.regAddress);//4 发送地址
		}
		if (Message.Length == 1)//只接受一个字节
		{
			if (Message.status == I2C_STATUS_REDATA)
			{
				I2C_AcknowledgeConfig(I2C1, DISABLE);
			}
		}

		I2C_ITConfig(I2C1, I2C_IT_BUF, ENABLE);    
	}
	else if (SR1 & I2C_SR1_BTF)
	{
		//4 上次传输完成

		if (SR1&I2C_SR1_TXE)//发送完成
		{
			if (Message.direction == i2cRead)//读数据
			{
				if (Message.status == I2C_STATUS_ADDRESS)//寄存器发送完
				{
					I2C1->CR1 = (I2C_CR1_START | I2C_CR1_PE);//
					Message.status = I2C_STATUS_START_R;//启动读数据
				}
			}
			else//写数据
			{
				I2C_SendData(I2C1, Message.buffer[Message.Index++]);
				if (Message.Index == Message.Length)
				{
					I2C_ITConfig(I2C1, I2C_IT_EVT | I2C_IT_BUF, DISABLE);//关闭中断
					I2C1->CR1 = (I2C_CR1_STOP | I2C_CR1_PE);//后续测试是否添加
					Message.status = I2C_STATUS_FINSIH;
				}
			}
		}
	}
	if (SR1 & I2C_SR1_RXNE) 
	{

		Message.buffer[Message.Index++] = I2C_ReceiveData(I2C1);

		if (Message.Index == Message.Length - 1)
		{
			I2C_AcknowledgeConfig(I2C1, DISABLE);//末尾数据禁止应答
		}

		if (Message.Index == Message.Length)
		{
			I2C1->CR1 = (I2C_CR1_STOP | I2C_CR1_PE);//后续测试是否添加
			I2C_ITConfig(I2C1, I2C_IT_EVT | I2C_IT_BUF, DISABLE);//接受结束
			Message.status = I2C_STATUS_FINSIH;
		}
	}
	else if (SR1 & I2C_SR1_TXE)
	{

	}
}

6、注意：

在整个读写操作中，发送结束位时作为数据收发成功信号，但此时停止位还没有开始发送。所以如果连续进行读写操作时请一点间隔时间，适当加点延时 ，延时5us左右即可。防止上一个的结束位和下一个的起始位间隔果断造成数据错误。