void I2C1_EV_IRQHandler (void) { if(I2C_GetITStatus(I2C1, I2C_IT_TX_EMPTY)) { I2C_ClearITPendingBit(I2C1, I2C_IT_TX_EMPTY); tx_flag = 1; } if(I2C_GetITStatus(I2C1, I2C_IT_RX_FULL)) { I2C_ClearITPendingBit(I2C1, I2C_IT_RX_FULL); rx_flag = 1; } }
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); }
void i2c_common(mal_i2c_s *handle) { // Check if transmission is complete if (I2C_GetITStatus(handle->stm_handle, I2C_IT_TC) == SET) { // Transmit complete, stop transfer, clear interrupt with stop I2C_GenerateSTOP(handle->stm_handle, ENABLE); // Make sure it was expected if (I2C_STATE_WAITING_TRANSFER_COMPLETE != handle->state) { // We are in error handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_ERROR; } else { // Next state handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_WAIT_STOP; } } // Check for stop if (I2C_GetITStatus(handle->stm_handle, I2C_IT_STOPF) == SET) { // Clear interrupt I2C_ClearITPendingBit(handle->stm_handle, I2C_IT_STOPF); // Notify mal_i2c_result_e i2c_result = MAL_I2C_SUCCESS; if (I2C_STATE_WAIT_STOP != handle->state) { i2c_result = MAL_I2C_BUS_ERROR; } handle->msg->callback(handle->msg->handle, &handle->msg->packet, i2c_result, &handle->msg); // Check if a new message can be started if (handle->msg != NULL) { i2c_start_transfer(handle); } else { handle->is_active = false; } } }
void i2c_interrupt_receive_handler(mal_i2c_s *handle) { // Common errors i2c_common_errors(handle); // Receiver status if (I2C_GetITStatus(handle->stm_handle, I2C_IT_RXNE) == SET) { // Make sure we are receiving if (I2C_STATE_RECEIVING != handle->state && I2C_STATE_START != handle->state) { // Clear interrupt I2C_ClearITPendingBit(handle->stm_handle, I2C_IT_RXNE); // Stop receiving I2C_GenerateSTOP(handle->stm_handle, ENABLE); // We are in error handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_ERROR; } else { // Read data, also clears interrupt handle->msg->packet.buffer[handle->data_ptr++] = I2C_ReceiveData(handle->stm_handle); // Check if data is complete if (handle->data_ptr >= handle->msg->packet.packet_size) { // Change state handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_WAITING_TRANSFER_COMPLETE; } else { handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_RECEIVING; } } } // Common states i2c_common(handle); }
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); } }
/******************************************************************************* * Function Name : I2C2_ER_IRQHandler * Description : This function handles I2C2 Error interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void I2C2_ER_IRQHandler(void) { /* Check on I2C2 AF flag and clear it */ if (I2C_GetITStatus(I2C2, I2C_IT_AF)) { I2C_ClearITPendingBit(I2C2, I2C_IT_AF); } }
void I2C1_ER_IRQHandler(void) { /* Check on I2C2 AF flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_AF)) { I2C_ClearITPendingBit(I2C1, I2C_IT_AF); I2C_ITConfig(I2C1, I2C_IT_EVT | I2C_IT_BUF | I2C_IT_ERR, DISABLE); } }
void i2c_common_errors(mal_i2c_s *handle) { // Bus error if (I2C_GetITStatus(handle->stm_handle, I2C_IT_BERR) == SET) { // Clear interrupt I2C_ClearITPendingBit(handle->stm_handle, I2C_IT_BERR); // Stop bus I2C_GenerateSTOP(handle->stm_handle, ENABLE); // Start or stop out of place switch to error state handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_ERROR; } // Arbitration loss error if (I2C_GetITStatus(handle->stm_handle, I2C_IT_ARLO) == SET) { // Clear interrupt I2C_ClearITPendingBit(handle->stm_handle, I2C_IT_ARLO); // Start or stop out of place switch to error state handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_ERROR; } }
void I2C1_EV_IRQHandler(void) { /* Address matched */ if (I2C_GetITStatus(I2C, I2C_IT_ADDRI)) { uprintf("ADDRI\r\n"); I2C_ClearITPendingBit(I2C, I2C_IT_ADDRI); } /* Received byte */ if (I2C_GetITStatus(I2C, I2C_IT_RXI)) { I2C_RX_Packets[I2C_RX_Index] = I2C_ReceiveData(I2C); uprintf("RXI: %i\r\n", I2C_RX_Packets[I2C_RX_Index]); if (I2C_RX_Index < I2C_RX_PACKET_BUFFER_LENGTH-1) { I2C_RX_Index++; } I2C_ClearITPendingBit(I2C, I2C_IT_RXI); } /* Stop condition detected */ if (I2C_GetITStatus(I2C, I2C_IT_STOPI)) { uprintf("STOPI\r\n"); I2C_ClearITPendingBit(I2C, I2C_IT_STOPI); I2C_ProcessCommand(I2C_RX_Packets, I2C_RX_Index+1); I2C_RX_Index = 0; } ///* Transmit interrupt status */ //if (I2C_GetITStatus(I2C, I2C_IT_TXI)) //{ // if (I2C_TX_Index > 0) // { // I2C_SendData(I2C, I2C_TX_Packets[I2C_TX_Index]); // I2C_TX_Index--; // uprintf("Transmitted packet\r\n"); // I2C_ClearITPendingBit(I2C, I2C_IT_TXI); // } //} //I2C_PrintInterruptStatus(); }
void I2C_IRQ_err(i2c_bus *bus) { bool err = FALSE; bus->phy_error = 0; if (I2C_GetITStatus(I2C_HW(bus), I2C_IT_SMBALERT )) { DBG(D_I2C, D_WARN, "i2c_err: SMBus Alert\n"); I2C_ClearITPendingBit(I2C_HW(bus), I2C_IT_SMBALERT ); bus->phy_error |= 1 << I2C_ERR_PHY_SMBUS_ALERT; err = TRUE; } if (I2C_GetITStatus(I2C_HW(bus), I2C_IT_TIMEOUT )) { DBG(D_I2C, D_WARN, "i2c_err: Timeout or Tlow error\n"); I2C_ClearITPendingBit(I2C_HW(bus), I2C_IT_TIMEOUT ); bus->phy_error |= 1 << I2C_ERR_PHY_TIMEOUT; err = TRUE; } if (I2C_GetITStatus(I2C_HW(bus), I2C_IT_ARLO )) { DBG(D_I2C, D_WARN, "i2c_err: Arbitration lost\n"); I2C_ClearITPendingBit(I2C_HW(bus), I2C_IT_ARLO ); bus->phy_error |= 1 << I2C_ERR_PHY_ARBITRATION_LOST; err = TRUE; } if (I2C_GetITStatus(I2C_HW(bus), I2C_IT_PECERR )) { DBG(D_I2C, D_WARN, "i2c_err: PEC error\n"); I2C_ClearITPendingBit(I2C_HW(bus), I2C_IT_PECERR ); bus->phy_error |= 1 << I2C_ERR_PHY_PEC_ERR; err = TRUE; } if (I2C_GetITStatus(I2C_HW(bus), I2C_IT_OVR )) { DBG(D_I2C, D_WARN, "i2c_err: Overrun/Underrun flag\n"); I2C_ClearITPendingBit(I2C_HW(bus), I2C_IT_OVR ); bus->phy_error |= 1 << I2C_ERR_PHY_OVER_UNDERRUN; err = TRUE; } if (I2C_GetITStatus(I2C_HW(bus), I2C_IT_AF )) { DBG(D_I2C, D_WARN, "i2c_err: Acknowledge failure\n"); I2C_ClearITPendingBit(I2C_HW(bus), I2C_IT_AF ); bus->phy_error |= 1 << I2C_ERR_PHY_ACK_FAIL; err = TRUE; } if (I2C_GetITStatus(I2C_HW(bus), I2C_IT_BERR )) { DBG(D_I2C, D_WARN, "i2c_err: Bus error\n"); I2C_ClearITPendingBit(I2C_HW(bus), I2C_IT_BERR ); bus->phy_error |= 1 << I2C_ERR_PHY_BUS_ERR; err = TRUE; } if (err) { I2C_LOG_ERR(bus, bus->phy_error); i2c_error(bus, I2C_ERR_PHY, bus->phy_error & ((1 << I2C_ERR_PHY_BUS_ERR) | (1 << I2C_ERR_PHY_ARBITRATION_LOST))); } }
static inline void i2c_error(struct i2c_periph *periph) { uint8_t err_nr = 0; periph->errors->er_irq_cnt; if (I2C_GetITStatus(periph->reg_addr, I2C_IT_AF)) { /* Acknowledge failure */ periph->errors->ack_fail_cnt++; I2C_ClearITPendingBit(periph->reg_addr, I2C_IT_AF); err_nr = 1; } if (I2C_GetITStatus(periph->reg_addr, I2C_IT_BERR)) { /* Misplaced Start or Stop condition */ periph->errors->miss_start_stop_cnt++; I2C_ClearITPendingBit(periph->reg_addr, I2C_IT_BERR); err_nr = 2; } if (I2C_GetITStatus(periph->reg_addr, I2C_IT_ARLO)) { /* Arbitration lost */ periph->errors->arb_lost_cnt++; I2C_ClearITPendingBit(periph->reg_addr, I2C_IT_ARLO); err_nr = 3; } if (I2C_GetITStatus(periph->reg_addr, I2C_IT_OVR)) { /* Overrun/Underrun */ periph->errors->over_under_cnt++; I2C_ClearITPendingBit(periph->reg_addr, I2C_IT_OVR); err_nr = 4; } if (I2C_GetITStatus(periph->reg_addr, I2C_IT_PECERR)) { /* PEC Error in reception */ periph->errors->pec_recep_cnt++; I2C_ClearITPendingBit(periph->reg_addr, I2C_IT_PECERR); err_nr = 5; } if (I2C_GetITStatus(periph->reg_addr, I2C_IT_TIMEOUT)) { /* Timeout or Tlow error */ periph->errors->timeout_tlow_cnt++; I2C_ClearITPendingBit(periph->reg_addr, I2C_IT_TIMEOUT); err_nr = 6; } if (I2C_GetITStatus(periph->reg_addr, I2C_IT_SMBALERT)) { /* SMBus alert */ periph->errors->smbus_alert_cnt++; I2C_ClearITPendingBit(periph->reg_addr, I2C_IT_SMBALERT); err_nr = 7; } #ifdef I2C_DEBUG_LED LED_ERROR(20, err_nr); #endif return; }
/**************************************************************************************************** * @fn I2C_Slave_Initialise * Call this function to set up the I2C slave to its initial standby state. * ***************************************************************************************************/ static void I2C_Slave_Initialise(void) { I2C_InitTypeDef I2C_InitStructure; /* Enable the bus */ I2C_Cmd(I2C_SLAVE_BUS, ENABLE); /* Configure the I2C interface */ I2C_InitStructure.I2C_Mode = I2C_Mode_I2C; I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2; I2C_InitStructure.I2C_OwnAddress1 = I2C_SLAVE_ADDR_8BIT; I2C_InitStructure.I2C_Ack = I2C_Ack_Enable; I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; I2C_InitStructure.I2C_ClockSpeed = I2C_SLAVE_BUS_CLOCK; I2C_Init(I2C_SLAVE_BUS, &I2C_InitStructure); /* Enable interrupts and clear flags */ I2C_ITConfig( I2C_SLAVE_BUS, (I2C_IT_EVT | I2C_IT_BUF | I2C_IT_ERR), ENABLE ); I2C_ClearITPendingBit( I2C_SLAVE_BUS, I2C_IT_SMBALERT | I2C_IT_TIMEOUT | I2C_IT_PECERR | I2C_IT_OVR | I2C_IT_AF | I2C_IT_ARLO | I2C_IT_BERR ); }
/**************************************************************************************************** * @fn I2C_Start_Transfer * Call this function to send a prepared data. Also include how many bytes that should be * sent/read including the address byte. The function will initiate the transfer and return * immediately (or return with error if previous transfer pending). User must wait for * transfer to complete by calling I2C_Wait_Completion * * @param //TODO * * @return none * ***************************************************************************************************/ uint8_t I2C_Start_Transfer( uint8_t slaveAddr, uint16_t regAddr, uint8_t *pData, uint8_t dataSize, I2C_SendMode_t sendMode ) { /* Check that no transfer is already pending*/ if (asyncXfer.i2c_txrx_status == I2C_TXRX_STATUS_ACTIVE) { D0_printf("I2C_Start_Transfer: A transfer is already pending\n\r"); return I2C_ERR_BUSY; } if ((sendMode == I2C_MASTER_READ) || (sendMode == I2C_MASTER_WRITE)) { /* Update the transfer descriptor */ asyncXfer.i2c_slave_addr = (slaveAddr << 1); asyncXfer.i2c_slave_reg = regAddr; asyncXfer.i2c_txrx_status = I2C_TXRX_STATUS_ACTIVE; asyncXfer.pData = pData; asyncXfer.num = dataSize; asyncXfer.byte_index = 0; asyncXfer.i2c_txrx_phase = 0; gSendMode = sendMode; /* Enable interrupts and clear flags */ I2C_ITConfig( I2C_SENSOR_BUS, I2C_IT_EVT | I2C_IT_BUF | I2C_IT_ERR, ENABLE ); I2C_ClearITPendingBit( I2C_SENSOR_BUS, I2C_IT_SMBALERT | I2C_IT_TIMEOUT | I2C_IT_PECERR | I2C_IT_OVR | I2C_IT_AF | I2C_IT_ARLO | I2C_IT_BERR ); /* Enable ACK as it is disabled in interrupt handler after each transaction */ I2C_SENSOR_BUS->CR1 |= CR1_ACK_Set; /* Initiate start */ I2C_GenerateSTART( I2C_SENSOR_BUS, ENABLE ); } else { return I2C_ERR_REQ; } return I2C_ERR_OK; }
/** * @brief This function handles I2C2 Error interrupt request. * @param None * @retval None */ void I2C1_ER_IRQHandler(void) { /* Check on I2C1 SMBALERT flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_SMBALERT)) { I2C_ClearITPendingBit(I2C1, I2C_IT_SMBALERT); SMbusAlertOccurred++; } /* Check on I2C1 Time out flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_TIMEOUT)) { I2C_ClearITPendingBit(I2C1, I2C_IT_TIMEOUT); } /* Check on I2C1 Arbitration Lost flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_ARLO)) { I2C_ClearITPendingBit(I2C1, I2C_IT_ARLO); } /* Check on I2C1 PEC error flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_PECERR)) { I2C_ClearITPendingBit(I2C1, I2C_IT_PECERR); } /* Check on I2C1 Overrun/Underrun error flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_OVR)) { I2C_ClearITPendingBit(I2C1, I2C_IT_OVR); } /* Check on I2C1 Acknowledge failure error flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_AF)) { I2C_ClearITPendingBit(I2C1, I2C_IT_AF); } /* Check on I2C1 Bus error flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_BERR)) { I2C_ClearITPendingBit(I2C1, I2C_IT_BERR); } }
/** * @brief This function handles I2C ERROR interrupt request. * @param None * @retval None */ void I2C1_ER_IRQHandler(void) { /* Check on I2C2 SMBALERT flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_SMBALERT)) { I2C_ClearITPendingBit(I2C1, I2C_IT_SMBALERT); } /* Check on I2C2 Time out flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_TIMEOUT)) { I2C_ClearITPendingBit(I2C1, I2C_IT_TIMEOUT); } /* Check on I2C2 Arbitration Lost flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_ARLO)) { I2C_ClearITPendingBit(I2C1, I2C_IT_ARLO); } /* Check on I2C2 PEC error flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_PECERR)) { I2C_ClearITPendingBit(I2C1, I2C_IT_PECERR); } /* Check on I2C2 Overrun/Underrun error flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_OVR)) { I2C_ClearITPendingBit(I2C1, I2C_IT_OVR); } /* Check on I2C2 Acknowledge failure error flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_AF)) { I2C_ClearITPendingBit(I2C1, I2C_IT_AF); } /* Check on I2C2 Bus error flag and clear it */ if (I2C_GetITStatus(I2C1, I2C_IT_BERR)) { I2C_ClearITPendingBit(I2C1, I2C_IT_BERR); } // Error_message("I2C Bus ERROR"); // LCD_PutStrig(20, 160, 0, "Push button OK for continue"); // while(EPM570_Read_Keys() != OK); // // LCD_SetTextColor(0x0000); // LCD_PutStrig(20, 160, 0, "Push button OK for continue"); // LCD_DrawGrid(&activeAreaGrid, DRAW); // перерисовываем сетку в области осциллограмм }
void i2c_interrupt_transmit_handler(mal_i2c_s *handle) { // Common errors i2c_common_errors(handle); // Nack event if (I2C_GetITStatus(handle->stm_handle, I2C_IT_NACKF) == SET) { // Clear interrupt I2C_ClearITPendingBit(handle->stm_handle, I2C_IT_NACKF); if (handle->state == I2C_STATE_TRANSMITTING) { mal_i2c_result_e result; // Check if write is complete if (handle->data_ptr >= handle->msg->packet.packet_size) { // Change state result = MAL_I2C_NACK_COMPLETE; } else { // Transfer is incomplete result = MAL_I2C_NACK_INCOMPLETE; } handle->msg->callback(handle->msg->handle, &handle->msg->packet, result, &handle->msg); // Next state handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_WAIT_STOP; } else { // Unknown sate for nack handle->msg->callback(handle->msg->handle, &handle->msg->packet, MAL_I2C_NACK_INCOMPLETE, &handle->msg); // Next state handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_WAIT_STOP; } } // Transmitter status if (I2C_GetITStatus(handle->stm_handle, I2C_IT_TXIS) == SET) { // Make sure we are transmitting if (I2C_STATE_TRANSMITTING != handle->state && I2C_STATE_START != handle->state) { // Stop receiving I2C_GenerateSTOP(handle->stm_handle, ENABLE); // We are in error handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_ERROR; // Clear interrupt by transmitting zero I2C_SendData(handle->stm_handle, 0); // Clear interrupt I2C_ClearITPendingBit(handle->stm_handle, I2C_IT_TXIS); } else { // Check if there still data to be sent if (handle->data_ptr >= handle->msg->packet.packet_size) { // Clear interrupt by transmitting zero I2C_SendData(handle->stm_handle, 0); // Clear interrupt I2C_ClearITPendingBit(handle->stm_handle, I2C_IT_TXIS); // Flag error handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_WAITING_TRANSFER_COMPLETE; } else { // Transmit next data I2C_SendData(handle->stm_handle, handle->msg->packet.buffer[handle->data_ptr++]); // Check if transmission should be complete if (handle->data_ptr >= handle->msg->packet.packet_size) { handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_WAITING_TRANSFER_COMPLETE; } else { handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_TRANSMITTING; } } } } // Common states i2c_common(handle); }
static void HAL_I2C_ER_InterruptHandler(HAL_I2C_Interface i2c) { /* Useful for debugging, diable to save time */ // DEBUG_D("ER:0x%04x\r\n",I2C_ReadRegister(i2cMap[i2c]->I2C_Peripheral, I2C_Register_SR1) & 0xFF00); #if 0 //Check whether specified I2C interrupt has occurred and clear IT pending bit. /* Check on I2C SMBus Alert flag and clear it */ if (I2C_GetITStatus(i2cMap[i2c]->I2C_Peripheral, I2C_IT_SMBALERT)) { I2C_ClearITPendingBit(i2cMap[i2c]->I2C_Peripheral, I2C_IT_SMBALERT); } /* Check on I2C PEC error flag and clear it */ if (I2C_GetITStatus(i2cMap[i2c]->I2C_Peripheral, I2C_IT_PECERR)) { I2C_ClearITPendingBit(i2cMap[i2c]->I2C_Peripheral, I2C_IT_PECERR); } /* Check on I2C Time out flag and clear it */ if (I2C_GetITStatus(i2cMap[i2c]->I2C_Peripheral, I2C_IT_TIMEOUT)) { I2C_ClearITPendingBit(i2cMap[i2c]->I2C_Peripheral, I2C_IT_TIMEOUT); } /* Check on I2C Arbitration Lost flag and clear it */ if (I2C_GetITStatus(i2cMap[i2c]->I2C_Peripheral, I2C_IT_ARLO)) { I2C_ClearITPendingBit(i2cMap[i2c]->I2C_Peripheral, I2C_IT_ARLO); } /* Check on I2C Overrun/Underrun error flag and clear it */ if (I2C_GetITStatus(i2cMap[i2c]->I2C_Peripheral, I2C_IT_OVR)) { I2C_ClearITPendingBit(i2cMap[i2c]->I2C_Peripheral, I2C_IT_OVR); } /* Check on I2C Bus error flag and clear it */ if (I2C_GetITStatus(i2cMap[i2c]->I2C_Peripheral, I2C_IT_BERR)) { I2C_ClearITPendingBit(i2cMap[i2c]->I2C_Peripheral, I2C_IT_BERR); } #else /* Save I2C Acknowledge failure error flag, then clear it */ if (I2C_GetITStatus(i2cMap[i2c]->I2C_Peripheral, I2C_IT_AF)) { i2cMap[i2c]->ackFailure = true; I2C_ClearITPendingBit(i2cMap[i2c]->I2C_Peripheral, I2C_IT_AF); } /* Now clear all remaining error pending bits without worrying about specific error * interrupt bit. This is faster than checking and clearing each one. */ /* Read SR1 register to get I2C error */ if ((I2C_ReadRegister(i2cMap[i2c]->I2C_Peripheral, I2C_Register_SR1) & 0xFF00) != 0x00) { /* Clear I2C error flags */ i2cMap[i2c]->I2C_Peripheral->SR1 &= 0x00FF; } #endif /* We could call I2C_SoftwareResetCmd() and/or I2C_GenerateStop() from this error handler, * but for now only ACK failure is handled in code. */ }
/** * @brief Main program * @param None * @retval None */ int main(void) { /*!< At this stage the microcontroller clock setting is already configured, this is done through SystemInit() function which is called from startup file (startup_stm32f10x_xx.s) before to branch to application main. To reconfigure the default setting of SystemInit() function, refer to system_stm32f10x.c file */ /* NVIC Configuration */ NVIC_Configuration(); /* Initialize the LCD */ #ifdef USE_STM32100E_EVAL STM32100E_LCD_Init(); #elif defined USE_STM3210E_EVAL STM3210E_LCD_Init(); #elif defined USE_STM32100B_EVAL STM32100B_LCD_Init(); #elif defined USE_STM3210B_EVAL STM3210B_LCD_Init(); #endif #ifdef USE_STM3210E_EVAL /* Disable FSMC only for STM32 High-density and XL-density devices */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, DISABLE); #endif /* USE_STM3210E_EVAL */ /* Initialize the Temperature Sensor */ LM75_Init(); if (LM75_GetStatus() == SUCCESS) { #ifdef USE_STM3210E_EVAL /* Enable FSMC */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE); #endif /* USE_STM3210E_EVAL */ /* Clear the LCD */ LCD_Clear(LCD_COLOR_WHITE); /* Set the Back Color */ LCD_SetBackColor(LCD_COLOR_BLUE); /* Set the Text Color */ LCD_SetTextColor(LCD_COLOR_GREEN); LCD_DisplayStringLine(LCD_LINE_0, " Temperature "); #ifdef USE_STM3210E_EVAL /* Disable FSMC */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, DISABLE); /* Initialize the Temperature Sensor */ LM75_Init(); #endif /* USE_STM3210E_EVAL */ /* Configure the Temperature sensor device STLM75: - Thermostat mode Interrupt - Fault tolerance: 00 */ LM75_WriteConfReg(0x02); /* Configure the THYS and TOS inorder to use the SMbus alert interrupt */ LM75_WriteReg(LM75_REG_THYS, TEMPERATURE_THYS << 8); /*31ÝC*/ LM75_WriteReg(LM75_REG_TOS, TEMPERATURE_TOS << 8); /*32ÝC*/ I2C_ClearITPendingBit(LM75_I2C, I2C_IT_SMBALERT); SMbusAlertOccurred = 0; /* Infinite Loop */ while (1) { #ifdef USE_STM3210E_EVAL /* Disable FSMC */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, DISABLE); /* Initialize the Temperature Sensor */ LM75_Init(); #endif /* USE_STM3210E_EVAL */ /* Get double of Temperature value */ TempValue = LM75_ReadTemp(); #ifdef USE_STM3210E_EVAL /* Enable FSMC */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE); #endif /* USE_STM3210E_EVAL */ if (TempValue <= 256) { /* Positive temperature measured */ TempCelsiusDisplay[7] = '+'; /* Initialize the temperature sensor value*/ TempValueCelsius = TempValue; } else { /* Negative temperature measured */ TempCelsiusDisplay[7] = '-'; /* Remove temperature value sign */ TempValueCelsius = 0x200 - TempValue; } /* Calculate temperature digits in ÝC */ if ((TempValueCelsius & 0x01) == 0x01) { TempCelsiusDisplay[12] = 0x05 + 0x30; TempFahrenheitDisplay[12] = 0x05 + 0x30; } else { TempCelsiusDisplay[12] = 0x00 + 0x30; TempFahrenheitDisplay[12] = 0x00 + 0x30; } TempValueCelsius >>= 1; TempCelsiusDisplay[8] = (TempValueCelsius / 100) + 0x30; TempCelsiusDisplay[9] = ((TempValueCelsius % 100) / 10) + 0x30; TempCelsiusDisplay[10] = ((TempValueCelsius % 100) % 10) + 0x30; if (TempValue > 256) { if (((9 * TempValueCelsius) / 5) <= 32) { /* Convert temperature ÝC to Fahrenheit */ TempValueFahrenheit = abs (32 - ((9 * TempValueCelsius) / 5)); /* Calculate temperature digits in ÝF */ TempFahrenheitDisplay[8] = (TempValueFahrenheit / 100) + 0x30; TempFahrenheitDisplay[9] = ((TempValueFahrenheit % 100) / 10) + 0x30; TempFahrenheitDisplay[10] = ((TempValueFahrenheit % 100) % 10) + 0x30; /* Positive temperature measured */ TempFahrenheitDisplay[7] = '+'; } else { /* Convert temperature ÝC to Fahrenheit */ TempValueFahrenheit = abs(((9 * TempValueCelsius) / 5) - 32); /* Calculate temperature digits in ÝF */ TempFahrenheitDisplay[8] = (TempValueFahrenheit / 100) + 0x30; TempFahrenheitDisplay[9] = ((TempValueFahrenheit % 100) / 10) + 0x30; TempFahrenheitDisplay[10] = ((TempValueFahrenheit % 100) % 10) + 0x30; /* Negative temperature measured */ TempFahrenheitDisplay[7] = '-'; } } else { /* Convert temperature ÝC to Fahrenheit */ TempValueFahrenheit = ((9 * TempValueCelsius) / 5) + 32; /* Calculate temperature digits in ÝF */ TempFahrenheitDisplay[8] = (TempValueFahrenheit / 100) + 0x30; TempFahrenheitDisplay[9] = ((TempValueFahrenheit % 100) / 10) + 0x30; TempFahrenheitDisplay[10] = ((TempValueFahrenheit % 100) % 10) + 0x30; /* Positive temperature measured */ TempFahrenheitDisplay[7] = '+'; } /* Display Fahrenheit value on LCD */ for (index = 0; index < 20; index++) { LCD_DisplayChar(LCD_LINE_6, (319 - (16 * index)), TempCelsiusDisplay[index]); LCD_DisplayChar(LCD_LINE_7, (319 - (16 * index)), TempFahrenheitDisplay[index]); } if (SMbusAlertOccurred == 1) { /* Set the Back Color */ LCD_SetBackColor(LCD_COLOR_BLUE); /* Set the Text Color */ LCD_SetTextColor(LCD_COLOR_RED); LCD_DisplayStringLine(LCD_LINE_2, "Warning: Temp exceed"); LCD_DisplayStringLine(LCD_LINE_3, " 32 C "); } if (SMbusAlertOccurred == 2) { /* Set the Back Color */ LCD_SetBackColor(LCD_COLOR_WHITE); /* Set the Text Color */ LCD_SetTextColor(LCD_COLOR_WHITE); LCD_ClearLine(LCD_LINE_2); LCD_ClearLine(LCD_LINE_3); SMbusAlertOccurred = 0; /* Set the Back Color */ LCD_SetBackColor(LCD_COLOR_BLUE); /* Set the Text Color */ LCD_SetTextColor(LCD_COLOR_GREEN); } } }
void i2c2_er_irq_handler(void) { /* Check on I2C2 AF flag and clear it */ if (I2C_GetITStatus(I2C2, I2C_IT_AF)) { I2C_ClearITPendingBit(I2C2, I2C_IT_AF); } }