static void HAL_I2C_SoftwareReset(HAL_I2C_Interface i2c)
{
/* Disable the I2C peripheral */
I2C_Cmd(i2cMap[i2c]->I2C_Peripheral, DISABLE);
/* Reset all I2C registers */
I2C_SoftwareResetCmd(i2cMap[i2c]->I2C_Peripheral, ENABLE);
I2C_SoftwareResetCmd(i2cMap[i2c]->I2C_Peripheral, DISABLE);
/* Clear all I2C interrupt error flags, and re-enable them */
I2C_ClearITPendingBit(i2cMap[i2c]->I2C_Peripheral, I2C_IT_SMBALERT | I2C_IT_PECERR |
I2C_IT_TIMEOUT | I2C_IT_ARLO | I2C_IT_OVR | I2C_IT_BERR | I2C_IT_AF);
I2C_ITConfig(i2cMap[i2c]->I2C_Peripheral, I2C_IT_ERR, ENABLE);
/* Re-enable Event and Buffer interrupts in Slave mode */
if(i2cMap[i2c]->mode == I2C_MODE_SLAVE)
{
I2C_ITConfig(i2cMap[i2c]->I2C_Peripheral, I2C_IT_EVT | I2C_IT_BUF, ENABLE);
}
/* Enable the I2C peripheral */
I2C_Cmd(i2cMap[i2c]->I2C_Peripheral, ENABLE);
/* Apply I2C configuration after enabling it */
I2C_Init(i2cMap[i2c]->I2C_Peripheral, &i2cMap[i2c]->I2C_InitStructure);
}
static void i2c_er_handler(I2CDevice device) {
I2C_TypeDef *I2Cx;
I2Cx = i2cHardwareMap[device].dev;
i2cState_t *state;
state = &(i2cState[device]);
// Read the I2C1 status register
volatile uint32_t SR1Register = I2Cx->SR1;
if (SR1Register & 0x0F00) // an error
state->error = true;
// If AF, BERR or ARLO, abandon the current job and commence new if there are jobs
if (SR1Register & 0x0700) {
(void)I2Cx->SR2; // read second status register to clear ADDR if it is set (note that BTF will not be set after a NACK)
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // disable the RXNE/TXE interrupt - prevent the ISR tailchaining onto the ER (hopefully)
if (!(SR1Register & I2C_SR1_ARLO) && !(I2Cx->CR1 & I2C_CR1_STOP)) { // if we dont have an ARLO error, ensure sending of a stop
if (I2Cx->CR1 & I2C_CR1_START) { // We are currently trying to send a start, this is very bad as start, stop will hang the peripheral
while (I2Cx->CR1 & I2C_CR1_START) {; } // wait for any start to finish sending
I2C_GenerateSTOP(I2Cx, ENABLE); // send stop to finalise bus transaction
while (I2Cx->CR1 & I2C_CR1_STOP) {; } // wait for stop to finish sending
i2cInit(device); // reset and configure the hardware
}
else {
I2C_GenerateSTOP(I2Cx, ENABLE); // stop to free up the bus
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); // Disable EVT and ERR interrupts while bus inactive
}
}
}
I2Cx->SR1 &= ~0x0F00; // reset all the error bits to clear the interrupt
state->busy = 0;
}
/*********************************************************************************************
I2C 作为 主机部分
**********************************************************************************************/
I2C_Return I2C_Master_Transmitter(I2C_InformationSendAndRecerve * I2CPram)
{
I2C_Return retStat;
retStat=I2C_Ok;
ARC_SetI2C_Information(I2CPram); // 存储数据到缓冲变量
// I2C_InterruptBuff=I2CPram;
/* Enable EVT IT*/
I2C_ITConfig(I2C1, I2C_IT_EVT, ENABLE);
I2C_ITConfig(I2C1, I2C_IT_BUF, ENABLE); // 缓冲中断使能
/* wait for Bus is not busy */
CODECTimeout = CODEC_LONG_TIMEOUT;
while(I2C_GetFlagStatus(CODEC_I2C, I2C_FLAG_BUSY))
{
if((CODECTimeout--) == 0) return I2C_Error; // return this function
}
/* Start the config sequence */
I2C_GenerateSTART(CODEC_I2C, ENABLE);
/* Then to go to interrupt to deal */
// while()// 发送数据可以不等带 。。主机程序中必须 等待发送成功，，可以适当延时
while (I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY));
if(I2CPram->TX_Generate_stop == 0)
I2C_AcknowledgeConfig(I2C1, ENABLE);
return retStat;
}
static void i2c_er_handler(void)
{
volatile uint32_t SR1Register, SR2Register;
/* Read the I2C1 status register */
SR1Register = I2Cx->SR1;
if (SR1Register & 0x0F00) { //an error
error = true;
// I2C1error.error = ((SR1Register & 0x0F00) >> 8); //save error
// I2C1error.job = job; //the task
}
/* If AF, BERR or ARLO, abandon the current job and commence new if there are jobs */
if (SR1Register & 0x0700) {
SR2Register = I2Cx->SR2; //read second status register to clear ADDR if it is set (note that BTF will not be set after a NACK)
SR2Register = SR2Register;
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); //disable the RXNE/TXE interrupt - prevent the ISR tailchaining onto the ER (hopefully)
if (!(SR1Register & 0x0200) && !(I2Cx->CR1 & 0x0200)) { //if we dont have an ARLO error, ensure sending of a stop
if (I2Cx->CR1 & 0x0100) { //We are currently trying to send a start, this is very bad as start,stop will hang the peripheral
while (I2Cx->CR1 & 0x0100); //wait for any start to finish sending
I2C_GenerateSTOP(I2Cx, ENABLE); //send stop to finalise bus transaction
while (I2Cx->CR1 & 0x0200); //wait for stop to finish sending
i2cInit(I2Cx); //reset and configure the hardware
} else {
I2C_GenerateSTOP(I2Cx, ENABLE); //stop to free up the bus
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); //Disable EVT and ERR interrupts while bus inactive
}
}
}
I2Cx->SR1 &= ~0x0F00; //reset all the error bits to clear the interrupt
busy = 0;
}
static void i2c_er_handler(void)
{
// Read the I2Cx status register
uint32_t SR1Register = I2Cx->SR1;
if (SR1Register & 0x0F00) { // an error
error = true;
}
// If AF, BERR or ARLO, abandon the current job and commence new if there are jobs
if (SR1Register & 0x0700) {
(void)I2Cx->SR2; // read second status register to clear ADDR if it is set (note that BTF will not be set after a NACK)
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // disable the RXNE/TXE interrupt - prevent the ISR tailchaining onto the ER (hopefully)
if (!(SR1Register & 0x0200) && !(I2Cx->CR1 & 0x0200)) { // if we dont have an ARLO error, ensure sending of a stop
if (I2Cx->CR1 & 0x0100) { // We are currently trying to send a start, this is very bad as start, stop will hang the peripheral
// TODO - busy waiting in highest priority IRQ. Maybe only set flag and handle it from main loop
while (I2Cx->CR1 & 0x0100) { ; } // wait for any start to finish sending
I2C_GenerateSTOP(I2Cx, ENABLE); // send stop to finalise bus transaction
while (I2Cx->CR1 & 0x0200) { ; } // wait for stop to finish sending
i2cInit(I2Cx_index); // reset and configure the hardware
} else {
I2C_GenerateSTOP(I2Cx, ENABLE); // stop to free up the bus
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); // Disable EVT and ERR interrupts while bus inactive
}
}
}
I2Cx->SR1 &= ~0x0F00; // reset all the error bits to clear the interrupt
busy = 0;
}
void I2C_ER_Handler(void)
{
volatile uint32_t SR1Register, SR2Register;
SR1Register = I2Cx->SR1; // Read the I2Cx status register
if (SR1Register & (I2C_SR1_AF |
I2C_SR1_ARLO |
I2C_SR1_BERR )) // If AF, BERR or ARLO, abandon the current job and commence new if there are jobs
{
SR2Register = I2Cx->SR2; // Read second status register to clear ADDR if it is set (note that BTF will not be set after a NACK)
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // Disable the RXNE/TXE interrupt - prevent the ISR tailchaining onto the ER (hopefully)
if (!(SR1Register & I2C_SR1_ARLO) && !(I2Cx->CR1 & I2C_CR1_STOP)) // If we dont have an ARLO error, ensure sending of a stop
{
if (I2Cx->CR1 & I2C_CR1_START) // We are currently trying to send a start, this is very bad as start,stop will hang the peripheral
{
while (I2Cx->CR1 & I2C_CR1_START); // Wait for any start to finish sending
I2C_GenerateSTOP(I2Cx, ENABLE); // Send stop to finalise bus transaction
while (I2Cx->CR1 & I2C_CR1_STOP); // Wait for stop to finish sending
i2cInit(I2Cx); // Reset and configure the hardware
} else
{
I2C_GenerateSTOP(I2Cx, ENABLE); // Stop to free up the bus
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); // Disable EVT and ERR interrupts while bus inactive
}
}
}
I2Cx->SR1 &= ~(I2C_SR1_OVR |
I2C_SR1_AF |
I2C_SR1_ARLO |
I2C_SR1_BERR ); // Reset all the error bits to clear the interrupt
busy = 0;
}
void i2c_config()
{
// RCC
/* Enable GPIOB clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
// GPIO
GPIO_InitTypeDef GPIO_InitStructure;
/* Configure I2C1 pins: SCL and SDA */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Enable I2C1 reset state */
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
/* Release I2C1 from reset state */
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, DISABLE);
I2C_DeInit(I2C1);
// I2C
/* Enable I2C1 */
I2C_Cmd(I2C1, ENABLE);
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_OwnAddress1 = ID;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = ClockSpeed;
I2C_Init(I2C1, &I2C_InitStructure);
I2C_GeneralCallCmd(I2C1, ENABLE);
/* Enable Event IT needed for ADDR and STOPF events ITs */
I2C_ITConfig(I2C1, I2C_IT_EVT, ENABLE);
/* Enable Error IT */
I2C_ITConfig(I2C1, I2C_IT_ERR, ENABLE);
/* Enable Buffer IT (TXE and RXNE ITs) */
I2C_ITConfig(I2C1, I2C_IT_BUF, ENABLE);
// NVIC
/* 1 bit for pre-emption priority, 3 bits for subpriority */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
NVIC_SetPriority(I2C1_EV_IRQn, 0x00);
NVIC_EnableIRQ(I2C1_EV_IRQn);
NVIC_SetPriority(I2C1_ER_IRQn, 0x01);
NVIC_EnableIRQ(I2C1_ER_IRQn);
}
//______________________________________________________________________________________
void I2C1_EV_IRQHandler(void)
{
static
int n=0;
switch (I2C_GetLastEvent(I2C1)) {
case I2C_EVENT_MASTER_MODE_SELECT :
if(__i2c1->ntx)
I2C_Send7bitAddress(I2C1, (uint8_t)(__i2c1->addr)<<1, I2C_Direction_Transmitter);
else
I2C_Send7bitAddress(I2C1, (uint8_t)(__i2c1->addr)<<1, I2C_Direction_Receiver);
n=0;
break;
case I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED:
I2C_SendData(I2C1, __i2c1->txbuf[n++]);
break;
case I2C_EVENT_MASTER_BYTE_TRANSMITTING:
case I2C_EVENT_MASTER_BYTE_TRANSMITTED:
if (n == __i2c1->ntx) {
__i2c1->ntx=0;
if(__i2c1->nrx)
I2C_GenerateSTART(I2C1, ENABLE);
else {
I2C_GenerateSTOP(I2C1, ENABLE);
I2C_ITConfig(I2C1, I2C_IT_EVT | I2C_IT_BUF, DISABLE);
}
} else
I2C_SendData(I2C1, __i2c1->txbuf[n++]);
break;
case I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED:
if(__i2c1->nrx==1) {
I2C_AcknowledgeConfig(I2C1, DISABLE);
I2C_GenerateSTOP(I2C1, ENABLE);
}
break;
case I2C_EVENT_MASTER_BYTE_RECEIVED:
__i2c1->rxbuf[n++]=I2C_ReceiveData (I2C1);
if(n==__i2c1->nrx-1) {
I2C_AcknowledgeConfig(I2C1, DISABLE);
I2C_GenerateSTOP(I2C1, ENABLE);
}
if(n==__i2c1->nrx) {
I2C_ITConfig(I2C1, I2C_IT_EVT | I2C_IT_BUF, DISABLE);
I2C_AcknowledgeConfig(I2C1, ENABLE);
__i2c1->nrx=0;
}
break;
default:
break;
}
}
void i2cInit(I2CDevice index)
{
NVIC_InitTypeDef nvic;
I2C_InitTypeDef i2c;
if (index > I2CDEV_MAX)
index = I2CDEV_MAX;
// Turn on peripheral clock, save device and index
I2Cx = i2cHardwareMap[index].dev;
I2Cx_index = index;
RCC_APB1PeriphClockCmd(i2cHardwareMap[index].peripheral, ENABLE);
// diable I2C interrrupts first to avoid ER handler triggering
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE);
// clock out stuff to make sure slaves arent stuck
// This will also configure GPIO as AF_OD at the end
i2cUnstick();
// Init I2C peripheral
I2C_DeInit(I2Cx);
I2C_StructInit(&i2c);
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); // Disable EVT and ERR interrupts - they are enabled by the first request
i2c.I2C_Mode = I2C_Mode_I2C;
i2c.I2C_DutyCycle = I2C_DutyCycle_2;
i2c.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
// Overclocking i2c, test results
// Default speed, conform specs is 400000 (400 kHz)
// 2.0* : 800kHz - worked without errors
// 3.0* : 1200kHz - worked without errors
// 3.5* : 1400kHz - failed, hangup, bootpin recovery needed
// 4.0* : 1600kHz - failed, hangup, bootpin recovery needed
i2c.I2C_ClockSpeed = CLOCKSPEED;
I2C_Cmd(I2Cx, ENABLE);
I2C_Init(I2Cx, &i2c);
// I2C ER Interrupt
nvic.NVIC_IRQChannel = i2cHardwareMap[index].er_irq;
nvic.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_I2C_ER);
nvic.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_I2C_ER);
nvic.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&nvic);
// I2C EV Interrupt
nvic.NVIC_IRQChannel = i2cHardwareMap[index].ev_irq;
nvic.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_I2C_EV);
nvic.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_I2C_EV);
NVIC_Init(&nvic);
}
int I2C_Read(uint8_t addr,void *pbuffer,uint16_t len)
{
struct i2c_job_st i2c_job;
xSemaphoreTake(xSemaphoreI2C_Mutex,portMAX_DELAY);
if (I2C_isBusy())
{
i2c_error_flags = I2C_SR1_SB;
xSemaphoreGive(xSemaphoreI2C_Mutex);
return FALSE;
}
i2c_cntr = 0;
i2c_oper = I2C_Direction_Receiver;
job = &i2c_job;
i2c_addr = addr << 1;
i2c_job.buf = (uint8_t *)pbuffer;
i2c_job.len = len;
i2c_job.dir = I2C_Direction_Receiver;
i2c_job.last = TRUE;
i2c_done = i2c_err = FALSE;
// clear the semaphore
while (xSemaphoreTake(xSemaphoreI2C_Work,0));
if ((i2c_oper == I2C_Direction_Receiver) && (len == 2))
I2C_NACKPositionConfig(I2Cx,I2C_NACKPosition_Next);
else
I2C_NACKPositionConfig(I2Cx,I2C_NACKPosition_Current);
I2C_AcknowledgeConfig(I2Cx,ENABLE);
I2C_ITConfig(I2Cx,I2C_IT_BUF | I2C_IT_ERR | I2C_IT_EVT,ENABLE);
/* Send START condition */
I2C_GenerateSTART(I2Cx, ENABLE);
while (!i2c_done && !i2c_err)
{
if (!xSemaphoreTake(xSemaphoreI2C_Work,SEMA_DELAY))
{
I2C_Open(0);
i2c_err = TRUE;
break;
}
}
I2C_ITConfig(I2Cx,I2C_IT_BUF | I2C_IT_ERR | I2C_IT_EVT,DISABLE);
xSemaphoreGive(xSemaphoreI2C_Mutex);
return !i2c_err;
}
void i2cInit(I2CDevice index)
{
NVIC_InitTypeDef nvic;
I2C_InitTypeDef i2c;
if (index > I2CDEV_MAX)
index = I2CDEV_MAX;
// Turn on peripheral clock, save device and index
I2Cx = i2cHardwareMap[index].dev;
I2Cx_index = index;
RCC_APB1PeriphClockCmd(i2cHardwareMap[index].peripheral, ENABLE);
// diable I2C interrrupts first to avoid ER handler triggering
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE);
// clock out stuff to make sure slaves arent stuck
// This will also configure GPIO as AF_OD at the end
i2cUnstick();
// Init I2C peripheral
I2C_DeInit(I2Cx);
I2C_StructInit(&i2c);
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); // Disable EVT and ERR interrupts - they are enabled by the first request
i2c.I2C_Mode = I2C_Mode_I2C;
i2c.I2C_DutyCycle = I2C_DutyCycle_2;
i2c.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
if (i2cOverClock) {
i2c.I2C_ClockSpeed = 800000; // 800khz Maximum speed tested on various boards without issues
} else {
i2c.I2C_ClockSpeed = 400000; // 400khz Operation according specs
}
I2C_Cmd(I2Cx, ENABLE);
I2C_Init(I2Cx, &i2c);
// I2C ER Interrupt
nvic.NVIC_IRQChannel = i2cHardwareMap[index].er_irq;
nvic.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_I2C_ER);
nvic.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_I2C_ER);
nvic.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&nvic);
// I2C EV Interrupt
nvic.NVIC_IRQChannel = i2cHardwareMap[index].ev_irq;
nvic.NVIC_IRQChannelPreemptionPriority = NVIC_PRIORITY_BASE(NVIC_PRIO_I2C_EV);
nvic.NVIC_IRQChannelSubPriority = NVIC_PRIORITY_SUB(NVIC_PRIO_I2C_EV);
NVIC_Init(&nvic);
}
static void i2cdrvStartTransfer(I2cDrv *i2c)
{
if (i2c->txMessage.direction == i2cRead)
{
i2c->DMAStruct.DMA_BufferSize = i2c->txMessage.messageLength;
i2c->DMAStruct.DMA_Memory0BaseAddr = (uint32_t)i2c->txMessage.buffer;
DMA_Init(i2c->def->dmaRxStream, &i2c->DMAStruct);
DMA_Cmd(i2c->def->dmaRxStream, ENABLE);
}
I2C_ITConfig(i2c->def->i2cPort, I2C_IT_BUF, DISABLE);
I2C_ITConfig(i2c->def->i2cPort, I2C_IT_EVT, ENABLE);
i2c->def->i2cPort->CR1 = (I2C_CR1_START | I2C_CR1_PE);
}
static rt_err_t stm_i2c_init(struct rt_i2c_bus_device *bus, rt_uint32_t bitrate)
{
struct stm32_i2c_bus *stm32_i2c;
I2C_InitTypeDef I2C_InitStructure;
RT_ASSERT(bus != RT_NULL);
if(bitrate != 100000 && bitrate != 400000)
{
return RT_EIO;
}
stm32_i2c = (struct stm32_i2c_bus *) bus;
I2C_Cmd(stm32_i2c->I2C, DISABLE);
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_OwnAddress1 = I2CADDR;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = bitrate;
I2C_Init(stm32_i2c->I2C, &I2C_InitStructure);
I2C_Cmd(stm32_i2c->I2C, ENABLE);
I2C_ITConfig(stm32_i2c->I2C, I2C_IT_EVT | I2C_IT_BUF | I2C_IT_ERR, ENABLE);
stm32_i2c_nvic_Config(stm32_i2c->I2C);
return RT_EOK;
}
uint8_t i2cRead(I2C_TypeDef* I2Cx, I2C_context_t * context, uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t * buf)
{
uint32_t timeout = I2C_DEFAULT_TIMEOUT;
context->addr = addr_ << 1;
context->reg = reg_;
context->writing = 0;
context->reading = 1;
context->read_p = buf;
context->write_p = buf;
context->bytes = len;
context->busy = 1;
if (!(I2Cx->CR2 & I2C_IT_EVT)) //if we are restarting the driver
{
if (!(I2Cx->CR1 & 0x0100)) //ensure sending a start
{
while (I2Cx->CR1 & 0x0200) {;
} //wait for any stop to finish sending
I2C_GenerateSTART(I2Cx, ENABLE); //send the start for the new job
}
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, ENABLE); //allow the interrupts to fire off again
}
while (context->busy && --timeout > 0);
if (timeout == 0) {
context->i2cErrorCount++; // reinit peripheral + clock out garbage
i2c_init(I2Cx);
return 0;
}
return 1;
}
void I2C1_ER_IRQHandler(void) {
uint32_t sr1 = I2C1->SR1;
uint32_t sr2 = I2C1->SR2;
i2cErr = sr1 | (sr2 << 16);
I2C_ITConfig(I2C1, I2C_IT_ERR, DISABLE);
}
/* I2C Slave with Interrupt Init */
void I2C_SlaveWithInterrupt_Init(I2C_TypeDef* I2Cx, uint32_t freq, int SlaveAddr, pin_t scl, pin_t sda){
NVIC_InitTypeDef i2c_slave_nvic;
uint8_t _i2c_er_irq;
I2C_Master_Init(I2Cx, freq, scl, sda);
I2C_Slave_Mode(I2Cx, 1);
I2C_Slave_Address(I2Cx, SlaveAddr);
/* Configure the Priority Group to 1 bit */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
if(I2Cx == I2C1){
_i2c_er_irq = I2C1_ER_IRQn;
i2c_slave_nvic.NVIC_IRQChannel = I2C1_EV_IRQn;
}else if(I2Cx == I2C2){
_i2c_er_irq = I2C2_ER_IRQn;
i2c_slave_nvic.NVIC_IRQChannel = I2C2_EV_IRQn;
}
i2c_slave_nvic.NVIC_IRQChannelPreemptionPriority = 1;
i2c_slave_nvic.NVIC_IRQChannelSubPriority = 0;
i2c_slave_nvic.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&i2c_slave_nvic);
i2c_slave_nvic.NVIC_IRQChannel = _i2c_er_irq;
NVIC_Init(&i2c_slave_nvic);
/* Enable Error Interrupt */
I2C_ITConfig(I2Cx, (I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF), ENABLE);
}
bool i2cRead(I2C_TypeDef *I2C, uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t *buf)
{
uint32_t timeout = I2C_DEFAULT_TIMEOUT;
I2Cx = I2C;
addr = addr_ << 1;
reg = reg_;
writing = 0;
reading = 1;
read_p = buf;
write_p = buf;
bytes = len;
busy = 1;
if (!(I2Cx->CR2 & I2C_IT_EVT)) // If we are restarting the driver
{
if (!(I2Cx->CR1 & I2C_CR1_START)) // Ensure sending a start
{
while (I2Cx->CR1 & I2C_CR1_STOP) { ; } // Wait for any stop to finish sending
I2C_GenerateSTART(I2Cx, ENABLE); // Send the start for the new job
}
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, ENABLE); // Allow the interrupts to fire off again
}
while (busy && --timeout > 0);
if (timeout == 0) {
if (I2Cx == I2C1) i2c1ErrorCount++;
if (I2Cx == I2C2) i2c2ErrorCount++;
i2cInit(I2Cx); // Reinit peripheral + clock out garbage
return false;
}
return true;
}
bool i2cRead(uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t* buf)
{
uint32_t timeout = I2C_DEFAULT_TIMEOUT;
addr = addr_ << 1;
reg = reg_;
writing = 0;
reading = 1;
read_p = buf;
write_p = buf;
bytes = len;
busy = 1;
error = false;
if (!I2Cx)
return false;
if (!(I2Cx->CR2 & I2C_IT_EVT)) { // if we are restarting the driver
if (!(I2Cx->CR1 & 0x0100)) { // ensure sending a start
while (I2Cx->CR1 & 0x0200 && --timeout > 0) { ; } // wait for any stop to finish sending
if (timeout == 0)
return i2cHandleHardwareFailure();
I2C_GenerateSTART(I2Cx, ENABLE); // send the start for the new job
}
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, ENABLE); // allow the interrupts to fire off again
}
timeout = I2C_DEFAULT_TIMEOUT;
while (busy && --timeout > 0) { ; }
if (timeout == 0)
return i2cHandleHardwareFailure();
return !error;
}
//______________________________________________________________________________________
int writeI2C( _i2c *p, char *dBuffer, int length) {
static
int nrpt=3;
int to=__time__+25;
if(p) {
memcpy(p->txbuf,dBuffer,length);
p->ntx=length;
I2C_ITConfig(I2C1, (I2C_IT_EVT | I2C_IT_BUF), ENABLE);
I2C_GenerateSTART(I2C1, ENABLE);
while(p->ntx && __time__< to)
_proc_loop();
if(p->ntx) {
Reset_I2C(p);
if(--nrpt)
return writeI2C(p, dBuffer, length);
}
nrpt=3;
if(p->ntx) {
return(0);
}
}
_CLEAR_ERROR(pfm,PFM_I2C_ERR);
if(_DBG(pfm,_DBG_I2C_TX)) {
_io *io=_stdio(__dbug);
int i;
__print(":%04d",__time__ % 10000);
for(i=0;i<length;++i)
__print(" %02X",p->txbuf[i]);
__print("\r\n>");
_stdio(io);
}
return(-1);
}
void TwoWire::begin(uint8_t address) {
if (onBeginCallback)
onBeginCallback();
status = SLAVE_IDLE;
if (twi==I2C1)
{
RCC_I2CCLKConfig(RCC_I2C1CLK_HSI);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
pinMode(SDA, ALTERNATE);
pinMode(SCL, ALTERNATE);
}
I2C_DeInit(twi);
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_AnalogFilter = I2C_AnalogFilter_Enable;
I2C_InitStructure.I2C_DigitalFilter = 0x00;
I2C_InitStructure.I2C_OwnAddress1 = address;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_Timing = 0x00E0D3FF;
I2C_Init(twi, &I2C_InitStructure);
NVIC_SetPriority(I2C1_IRQn, 0);
NVIC_EnableIRQ(I2C1_IRQn);
I2C_Cmd(twi, ENABLE);
I2C_ITConfig(twi, I2C_IT_ADDRI, ENABLE);
}
void i2c1_hw_init(void) {
i2c1.reg_addr = I2C1;
i2c1.init_struct = &I2C1_InitStruct;
i2c1.scl_pin = GPIO_Pin_6;
i2c1.sda_pin = GPIO_Pin_7;
i2c1.errors = &i2c1_errors;
/* zeros error counter */
ZEROS_ERR_COUNTER(i2c1_errors);
// Extra
#ifdef I2C_DEBUG_LED
LED_INIT();
#else
/* reset peripheral to default state ( sometimes not achieved on reset :( ) */
//I2C_DeInit(I2C1);
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
NVIC_InitTypeDef NVIC_InitStructure;
/* Configure and enable I2C1 event interrupt --------------------------------*/
NVIC_InitStructure.NVIC_IRQChannel = I2C1_EV_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Configure and enable I2C1 err interrupt ----------------------------------*/
NVIC_InitStructure.NVIC_IRQChannel = I2C1_ER_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Enable peripheral clocks -------------------------------------------------*/
/* Enable I2C1 clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
/* Enable GPIOB clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = i2c1.scl_pin | i2c1.sda_pin;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
GPIO_Init(GPIOB, &GPIO_InitStructure);
I2C_DeInit(I2C1);
// enable peripheral
I2C_Cmd(I2C1, ENABLE);
I2C_Init(I2C1, i2c1.init_struct);
// enable error interrupts
I2C_ITConfig(I2C1, I2C_IT_ERR, ENABLE);
#endif
}
void SendDataBy_I2C1()
{
DMA_ConfigForI2C1Send();
I2C_AcknowledgeConfig(I2C1, ENABLE);
I2C_ITConfig(I2C1, I2C_IT_BUF , DISABLE);
while(I2C_GetFlagStatus(CODEC_I2C, I2C_FLAG_BUSY)) //wait for bus is not busy
{
}
/* Start the config sequence */
I2C_GenerateSTART(CODEC_I2C, ENABLE);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) // EV5
{
}
/* Transmit the slave address and enable writing operation */
I2C_Send7bitAddress(CODEC_I2C, CODEC_ADDRESS, I2C_Direction_Transmitter);
DMA_Cmd(DMA1_Stream6, ENABLE);
I2C_DMACmd(I2C2, ENABLE);
/* DMA1 Channel6 transfer complete test */
while(DMA_GetFlagStatus(DMA1_Stream6,DMA_FLAG_TCIF6)==RESET)
{
}
I2C_DMACmd(I2C1, DISABLE);
DMA_Cmd(DMA1_Stream6, DISABLE);
// wait until BTF
while (!(I2C1->SR1 & 0x04));
I2C_GenerateSTOP(I2C1, ENABLE);
// wait until BUSY clear
while (I2C1->SR2 & 0x02);
if(I2C1->CR1 & 0x200)
I2C1->CR1 &= 0xFDFF;
}
void i2cSetup(uint32_t speed) {
I2C_InitTypeDef i2cConfig;
// GPIO Init
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_I2C1);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_I2C1);
GPIO_Init(GPIOB, &(GPIO_InitTypeDef){GPIO_Pin_6, GPIO_Mode_AF, GPIO_Speed_50MHz, GPIO_OType_OD, GPIO_PuPd_NOPULL});
GPIO_Init(GPIOB, &(GPIO_InitTypeDef){GPIO_Pin_9, GPIO_Mode_AF, GPIO_Speed_50MHz, GPIO_OType_OD, GPIO_PuPd_NOPULL});
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
// I2C init
I2C_StructInit(&i2cConfig);
// TODO - Figure out why the speed isn't being set porperly
i2cConfig.I2C_ClockSpeed = speed;
i2cConfig.I2C_DutyCycle = I2C_DutyCycle_16_9;
I2C_DeInit(I2C1);
I2C_Init(I2C1, &i2cConfig);
I2C_ITConfig(I2C1, I2C_IT_ERR, ENABLE);
NVIC_EnableIRQ(I2C1_ER_IRQn);
I2C_Cmd(I2C1, ENABLE);
}
bool i2cRead(uint8_t addr_, uint8_t reg_, uint8_t len, uint8_t* buf)
{
uint32_t timeout = I2C_DEFAULT_TIMEOUT;
addr = addr_ << 1;
reg = reg_;
writing = 0;
reading = 1;
read_p = buf;
write_p = buf;
bytes = len;
busy = 1;
error = false;
if (!(I2Cx->CR2 & I2C_IT_EVT)) { //if we are restarting the driver
if (!(I2Cx->CR1 & 0x0100)) { // ensure sending a start
while (I2Cx->CR1 & 0x0200) { ; } //wait for any stop to finish sending
I2C_GenerateSTART(I2Cx, ENABLE); //send the start for the new job
}
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, ENABLE); //allow the interrupts to fire off again
}
while (busy && --timeout > 0);
if (timeout == 0) {
i2cErrorCount++;
// reinit peripheral + clock out garbage
i2cInit(I2Cx);
return false;
}
return !error;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
void main(void)
{
/* I2C clock Enable*/
CLK_PeripheralClockConfig(CLK_Peripheral_I2C, ENABLE);
/* system_clock / 1 */
CLK_MasterPrescalerConfig(CLK_MasterPrescaler_HSIDiv1);
/* Initialize LEDs mounted on the EVAL board */
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
I2C_DeInit();
/* Initialize I2C peripheral */
#ifdef I2C_slave_7Bits_Address
I2C_Init(100000, SLAVE_ADDRESS, I2C_DutyCycle_2, I2C_Ack_Enable,
I2C_AcknowledgedAddress_7bit);
#else
I2C_Init(100000, SLAVE_ADDRESS, I2C_DutyCycle_2, I2C_Ack_Enable,
I2C_AcknowledgedAddress_10bit);
#endif
/* Enable Error Interrupt*/
I2C_ITConfig((I2C_IT_TypeDef)(I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF), ENABLE);
/* Enable general interrupts */
enableInterrupts();
/*Main Loop */
while (1)
{
/* infinite loop */
}
}
void init_i2c(void) {
I2C_InitTypeDef I2C_InitStruct;
GPIO_InitTypeDef GPIO_InitStruct;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11; // SCL,SDA
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_OD;
GPIO_Init(GPIOB, &GPIO_InitStruct);
I2C_SoftwareResetCmd(I2C2, ENABLE);
I2C_ITConfig(I2C2,I2C_IT_ERR,ENABLE);
I2C_StructInit(&I2C_InitStruct);
I2C_DeInit(I2C2);
I2C_InitStruct.I2C_ClockSpeed = 100000;
I2C_InitStruct.I2C_Ack = I2C_Ack_Enable;
I2C_InitStruct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStruct.I2C_Mode = I2C_Mode_I2C;
I2C_InitStruct.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStruct.I2C_OwnAddress1 = 0x00;
I2C_Init(I2C2, &I2C_InitStruct);
I2C_Cmd(I2C2, ENABLE);
}
void i2c_init(i2c_dev *dev, uint16_t address, uint32_t speed)
{
I2C_InitTypeDef I2C_InitStructure;
i2c_lowLevel_init(dev);
/* I2C configuration */
I2C_StructInit(&I2C_InitStructure);
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_OwnAddress1 = address;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = speed;
I2C_ITConfig(dev->I2Cx, I2C_IT_EVT | I2C_IT_BUF | I2C_IT_ERR, DISABLE);
/* I2C Peripheral Enable */
I2C_Cmd(dev->I2Cx, ENABLE);
/* Apply I2C configuration after enabling it */
I2C_Init(dev->I2Cx, &I2C_InitStructure);
sEEAddress = sEE_HW_ADDRESS;
I2C_BLOCKED = 0;
}
void TwoWire::onService(void)
{
if (I2C_GetITStatus(twi, I2C_IT_ADDR) == SET)
{
I2C_ITConfig(twi, I2C_IT_RXI | I2C_IT_TXI | I2C_IT_STOPI, ENABLE);
srvBufferLength = 0;
srvBufferIndex = 0;
if (twi->ISR & (1 << 16)) {
status = SLAVE_SEND;
if (onRequestCallback)
onRequestCallback();
} else {
status = SLAVE_RECV;
}
I2C_ClearITPendingBit(twi, I2C_IT_ADDR);
}
if (I2C_GetITStatus(twi, I2C_IT_TXIS) == SET)
{
uint8_t c = 'x';
if (srvBufferIndex < srvBufferLength)
c = srvBuffer[srvBufferIndex++];
I2C_SendData(twi, c);
}
if (I2C_GetITStatus(twi, I2C_IT_RXNE) == SET)
{
if (srvBufferLength < BUFFER_LENGTH)
srvBuffer[srvBufferLength++] = I2C_ReceiveData(twi);
}
if (I2C_GetITStatus(twi, I2C_IT_STOPF) == SET)
{
if (status == SLAVE_RECV && onReceiveCallback) {
// Copy data into rxBuffer
// (allows to receive another packet while the
// user program reads actual data)
for (uint8_t i = 0; i < srvBufferLength; ++i)
rxBuffer[i] = srvBuffer[i];
rxBufferIndex = 0;
rxBufferLength = srvBufferLength;
// Alert calling program
onReceiveCallback( rxBufferLength);
}
I2C_ITConfig(twi, I2C_IT_ADDRI, ENABLE);
I2C_ITConfig(twi, I2C_IT_RXI | I2C_IT_TXI | I2C_IT_STOPI, DISABLE);
I2C_ClearITPendingBit(twi, I2C_IT_STOPF);
}
}
void arch_I2cStart(p_dev_i2c p)
{
I2C_TypeDef *pI2c = stm32_tblI2cId[p->parent->id];
I2C_GenerateSTART(pI2c, ENABLE);
I2C_AcknowledgeConfig(pI2c, ENABLE);
I2C_ITConfig(pI2c, I2C_IT_EVT | I2C_IT_BUF, ENABLE);
}
/*************************************************************************
* Function Name: I2C1_Init
* Parameters: none
*
* Return: none
*
* Description: Init I2C1 interface
*
*************************************************************************/
void I2C1_Init (void)
{
I2C_InitTypeDef I2C_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
s_I2C_NotUsed = TRUE;
// Enable clock
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_AHB1PeriphResetCmd(RCC_AHB1Periph_GPIOB, DISABLE);
I2C_DeInit(I2C1);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_I2C1);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_I2C1);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
RCC_APB1PeriphClockCmd( RCC_APB1Periph_I2C1, ENABLE);
// I2C configuration
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_OwnAddress1 = 0xAA;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = I2C1_SPEED;
// I2C Peripheral Enable
I2C_Cmd(I2C1, ENABLE);
// Apply I2C configuration after enabling it
I2C_Init(I2C1, &I2C_InitStructure);
// Enable the I2C1 Events Interrupt
NVIC_InitStructure.NVIC_IRQChannel = I2C1_EV_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = I2C1_INTR_PRIO;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = I2C1_INTR_SUBPRIO;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// Enable the I2C1 Errors Interrupt
NVIC_InitStructure.NVIC_IRQChannel = I2C1_ER_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = I2C1_INTR_PRIO;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = I2C1_INTR_SUBPRIO;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// Enable interrupts from I2C1 module
I2C_ITConfig(I2C1, I2C_IT_BUF | I2C_IT_EVT | I2C_IT_ERR, ENABLE);
}
