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左右即可。防止上一个的结束位和下一个的起始位间隔果断造成数据错误。