| 0,0 → 1,615 |
|---|
| /******************** (C) COPYRIGHT 2008 STMicroelectronics ******************** |
| * File Name : 91x_i2c.c |
| * Author : MCD Application Team |
| * Version : V2.1 |
| * Date : 12/22/2008 |
| * Description : This file provides all the I2C firmware functions. |
| ******************************************************************************** |
| * THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS |
| * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. |
| * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT, |
| * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE |
| * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING |
| * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. |
| *******************************************************************************/ |
| |
| /* Includes ------------------------------------------------------------------*/ |
| #include "91x_i2c.h" |
| #include "91x_scu.h" |
| |
| /* Private typedef -----------------------------------------------------------*/ |
| /* Private define ------------------------------------------------------------*/ |
| |
| /* I2C IT enable */ |
| #define I2C_IT_Enable 0x01 |
| #define I2C_IT_Disable 0xFE |
| |
| /* I2C Peripheral Enable/Disable */ |
| #define I2C_PE_Set 0x20 |
| #define I2C_PE_Reset 0xDF |
| |
| /* Address direction bit */ |
| #define I2C_ADD0_Set 0x01 |
| #define I2C_ADD0_Reset 0xFE |
| |
| /* I2C START Enable/Disable */ |
| #define I2C_Start_Enable 0x08 |
| #define I2C_Start_Disable 0xF7 |
| |
| /* I2C STOP Enable/Disable */ |
| #define I2C_Stop_Enable 0x02 |
| #define I2C_Stop_Disable 0xFD |
| |
| /* I2C Masks */ |
| #define I2C_Frequency_Mask 0x1F |
| #define I2C_AddressHigh_Mask 0xF9 |
| #define I2C_OwnAddress_Mask 0x0300 |
| #define I2C_StandardMode_Mask 0x7f |
| #define I2C_FastMode_Mask 0x80 |
| #define I2C_Event_Mask 0x3FFF |
| #define I2C_HeaderSet_Mask 0xF1 |
| #define I2C_HeaderReset_Mask 0xFE |
| |
| /* Private macro -------------------------------------------------------------*/ |
| /* Private variables ---------------------------------------------------------*/ |
| /* Private function prototypes -----------------------------------------------*/ |
| /* Private functions ---------------------------------------------------------*/ |
| /******************************************************************************* |
| * Function Name : I2C_DeInit |
| * Description : Deinitializes the I2C peripheral registers to their default |
| * reset values. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * Output : None |
| * Return : None |
| *******************************************************************************/ |
| void I2C_DeInit(I2C_TypeDef* I2Cx) |
| { |
| if (I2Cx == I2C0) |
| { |
| /* Reset the I2C0 registers values */ |
| SCU_APBPeriphReset(__I2C0, ENABLE); |
| SCU_APBPeriphReset(__I2C0, DISABLE); |
| } |
| if (I2Cx == I2C1) |
| { |
| /* Reset the I2C1 registers values */ |
| SCU_APBPeriphReset(__I2C1, ENABLE); |
| SCU_APBPeriphReset(__I2C1, DISABLE); |
| } |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_Init |
| * Description : Initializes the I2C peripheral according to the specified |
| * parameters in the I2C_InitTypeDef structure. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * |
| * - I2C_InitStruct: pointer to an I2C_InitTypeDef structure that |
| * contains the configuration information for the specified I2C |
| * peripheral. |
| * Output : None |
| * Return : None |
| *******************************************************************************/ |
| void I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct) |
| { |
| u16 wResult = 0x0F; |
| u32 dPCLK = 25000000; |
| |
| /* Get PCLK frequency value */ |
| dPCLK = SCU_GetPCLKFreqValue()*1000; |
| /* Disable I2C peripheral to set FR[2:0] bits */ |
| I2C_Cmd (I2Cx, DISABLE); |
| /* Clear frequency FR[2:0] bits */ |
| I2Cx->OAR2 &= I2C_Frequency_Mask; |
| /* Set frequency bits depending on PCLK value */ |
| if ((dPCLK <1667000) & (dPCLK > 10000000)) |
| I2Cx->OAR2 |= 0x20; |
| else if (dPCLK < 26670000) |
| I2Cx->OAR2 |= 0x40; |
| else if (dPCLK < 40000000) |
| I2Cx->OAR2 |= 0x60; |
| else if (dPCLK < 53330000) |
| I2Cx->OAR2 |= 0x80; |
| else if (dPCLK < 66000000) |
| I2Cx->OAR2 |= 0xA0; |
| else if (dPCLK < 80000000) |
| I2Cx->OAR2 |= 0xC0; |
| else if (dPCLK < 100000000) |
| I2Cx->OAR2 |= 0xE0; |
| I2C_Cmd (I2Cx, ENABLE); |
| |
| /* Configure general call */ |
| if (I2C_InitStruct->I2C_GeneralCall == I2C_GeneralCall_Enable) |
| { |
| /* Enable general call */ |
| I2Cx->CR |= I2C_GeneralCall_Enable; |
| } |
| else |
| { |
| /* Disable general call */ |
| I2Cx->CR &= I2C_GeneralCall_Disable; |
| } |
| /* Configure acknowledgement */ |
| if (I2C_InitStruct->I2C_Ack == I2C_Ack_Enable) |
| { |
| /* Enable acknowledgement */ |
| I2Cx->CR |= I2C_Ack_Enable; |
| } |
| else |
| { |
| /* Disable acknowledgement */ |
| I2Cx->CR &= I2C_Ack_Disable; |
| } |
| |
| /* Configure LSB own address */ |
| I2Cx->OAR1 = I2C_InitStruct->I2C_OwnAddress; |
| /* Clear MSB own address ADD[9:8] bits */ |
| I2Cx->OAR2 &= I2C_AddressHigh_Mask; |
| /* Set MSB own address value */ |
| I2Cx->OAR2 |= (I2C_InitStruct->I2C_OwnAddress & I2C_OwnAddress_Mask)>>7; |
| |
| /* Configure speed in standard mode */ |
| if (I2C_InitStruct->I2C_CLKSpeed <= 100000) |
| { |
| /* Standard mode speed calculate */ |
| wResult = ((dPCLK/I2C_InitStruct->I2C_CLKSpeed)-7)/2; |
| /* Set speed value and clear FM/SM bit for standard mode in LSB clock divider */ |
| I2Cx->CCR = wResult & I2C_StandardMode_Mask; |
| } |
| /* Configure speed in fast mode */ |
| else if (I2C_InitStruct->I2C_CLKSpeed <= 400000) |
| { |
| /* Fast mode speed calculate */ |
| wResult = ((dPCLK/I2C_InitStruct->I2C_CLKSpeed)-9)/3; |
| /* Set speed value and set FM/SM bit for fast mode in LSB clock divider */ |
| I2Cx->CCR = wResult | I2C_FastMode_Mask; |
| } |
| /* Set speed in MSB clock divider */ |
| I2Cx->ECCR = wResult >>7; |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_StructInit |
| * Description : Initialize the I2C Init Structure parameters |
| * Input : - I2C_InitStruct: pointer to an I2C_InitTypeDef structure |
| which will be initialized. |
| * Output : None |
| * Return : None. |
| *******************************************************************************/ |
| void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct) |
| { |
| /* Initialize the I2C_CLKSpeed member */ |
| I2C_InitStruct->I2C_CLKSpeed = 5000; |
| |
| /* Initialize the I2C_OwnAddress member */ |
| I2C_InitStruct->I2C_OwnAddress = 0x0; |
| |
| /* Initialize the I2C_GeneralCall member */ |
| I2C_InitStruct->I2C_GeneralCall = I2C_GeneralCall_Disable; |
| |
| /* Initialize the I2C_Ack member */ |
| I2C_InitStruct->I2C_Ack = I2C_Ack_Disable; |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_Cmd |
| * Description : Enables or disables the specified I2C peripheral. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * - NewState: new state of the I2C peripheral. This parameter |
| * can be: ENABLE or DISABLE. |
| * Output : None |
| * Return : None. |
| *******************************************************************************/ |
| void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState) |
| { |
| if (NewState == ENABLE) |
| { |
| /* Enable the I2C peripheral by setting twice the PE bit on the CR register */ |
| I2Cx->CR |= I2C_PE_Set; |
| I2Cx->CR |= I2C_PE_Set; |
| } |
| else |
| { |
| /* Disable the I2C peripheral */ |
| I2Cx->CR &= I2C_PE_Reset; |
| } |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_GenerateSTART |
| * Description : Generates I2C communication START condition. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * |
| * - NewState: new state of the Start condition. This parameter |
| * can be: ENABLE or DISABLE. |
| * Output : None |
| * Return : None. |
| *******************************************************************************/ |
| void I2C_GenerateStart(I2C_TypeDef* I2Cx, FunctionalState NewState) |
| { |
| if (NewState == ENABLE) |
| { |
| /* Generate a START condition */ |
| I2Cx->CR |= I2C_Start_Enable; |
| } |
| else |
| { |
| /* Disable the START condition generation */ |
| I2Cx->CR &= I2C_Start_Disable; |
| } |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_GenerateSTOP |
| * Description : Generates I2C communication STOP condition. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * |
| * - NewState: new state of the Stop condition. This parameter |
| * can be: ENABLE or DISABLE. |
| * Output : None |
| * Return : None. |
| *******************************************************************************/ |
| void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState) |
| { |
| if (NewState == ENABLE) |
| { |
| /* Generate a SIOP condition */ |
| I2Cx->CR |= I2C_Stop_Enable; |
| } |
| else |
| { |
| /* Disable the STOP condition generation */ |
| I2Cx->CR &= I2C_Stop_Disable; |
| } |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_AcknowledgeConfig |
| * Description : Enables or disables I2C acknowledge feature. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * - NewState: new state of the Acknowledgement. This parameter |
| * can be: ENABLE or DISABLE. |
| * Output : None |
| * Return : None. |
| *******************************************************************************/ |
| void I2C_AcknowledgeConfig(I2C_TypeDef *I2Cx, FunctionalState NewState) |
| { |
| if (NewState == ENABLE) |
| { |
| /* Enable the acknowledgement */ |
| I2Cx->CR |= I2C_Ack_Enable; |
| } |
| else |
| { |
| /* Disable the acknowledgement */ |
| I2Cx->CR &= I2C_Ack_Disable; |
| } |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_ITConfig |
| * Description : Enables or disables I2C interrupt feature. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * - NewState: new state of the specified I2C interrupt. |
| * This parameter can be: ENABLE or DISABLE. |
| * Output : None |
| * Return : None. |
| *******************************************************************************/ |
| void I2C_ITConfig(I2C_TypeDef *I2Cx, FunctionalState NewState) |
| { |
| if (NewState == ENABLE) |
| { |
| /* Enable the I2C interrupt */ |
| I2Cx->CR |= I2C_IT_Enable; |
| } |
| else |
| { |
| /* Disable the I2C interrupt */ |
| I2Cx->CR &= I2C_IT_Disable; |
| } |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_ReadRegister |
| * Description : Reads any I2C register and returns its value. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * - I2C_Register: the I2C register to be read. This parameter |
| * can be one of the following values: |
| * - I2C_CR: CR register. |
| * - I2C_SR1: SR1 register. |
| * - I2C_SR2: SR2 register. |
| * - I2C_CCR: CCR register. |
| * - I2C_OAR1: OAR1 register. |
| * - I2C_OAR2: OAR2 register. |
| * - I2C_DR: DR register. |
| * - I2C_ECCR: ECCR register. |
| * Output : None |
| * Return : The value of the register passed as parameter |
| *******************************************************************************/ |
| u8 I2C_ReadRegister(I2C_TypeDef* I2Cx, u8 I2C_Register) |
| { |
| /* Return the selected register value */ |
| if (I2Cx == I2C0) |
| { |
| return (*(u8 *)(I2C0_BASE + I2C_Register)); |
| } |
| if (I2Cx == I2C1) |
| { |
| return (*(u8 *)(I2C1_BASE + I2C_Register)); |
| } |
| return 0; |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_GetFlagStatus |
| * Description : Checks whether the specified I2C flag is set or not. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * - I2C_FLAG: flag to check. This parameter can be one of the |
| * following values: |
| * - I2C_FLAG_SB: Start bit flag |
| * - I2C_FLAG_M_SL: Master/Slave flag |
| * - I2C_FLAG_ADSL: Adress matched flag |
| * - I2C_FLAG_BTF: Byte transfer finished flag |
| * - I2C_FLAG_BUSY: Bus busy flag |
| * - I2C_FLAG_TRA: Transmitter/Receiver flag |
| * - I2C_FLAG_ADD10: 10-bit addressing in Master mode flag |
| * - I2C_FLAG_EVF: Event flag |
| * - I2C_FLAG_GCAL: General call flag |
| * - I2C_FLAG_BERR: Bus error flag |
| * - I2C_FLAG_ARLO: Arbitration lost flag |
| * - I2C_FLAG_STOPF: Stop detection flag |
| * - I2C_FLAG_AF: Acknowledge failure flag |
| * - I2C_FLAG_ENDAD: End of address transmission flag |
| * - I2C_FLAG_ACK: Acknowledge enable flag |
| * Output : None |
| * Return : The NewState of the I2C_Flag (SET or RESET). |
| *******************************************************************************/ |
| FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, u16 I2C_FLAG) |
| { |
| u16 wFlag1=0, wFlag2=0, wTmp=0; |
| |
| wFlag1 = I2Cx->SR2; |
| wFlag1 = wFlag1<<8; |
| wFlag2 = I2Cx->CR & 0x04; |
| |
| /* Get all the I2C flags in a unique register*/ |
| wTmp = (((I2Cx->SR1 | (wFlag1)) & I2C_Event_Mask) | (wFlag2<<12)); |
| |
| /* Check the status of the specified I2C flag */ |
| if((wTmp & I2C_FLAG) != RESET) |
| { |
| /* Return SET if I2C_FLAG is set */ |
| return SET; |
| } |
| else |
| { |
| /* Return RESET if I2C_FLAG is reset */ |
| return RESET; |
| } |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_ClearFlag |
| * Description : Clears the I2C Flag passed as a parameter |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * - I2C_FLAG: flag to check. This parameter can be one of the |
| * following values: |
| * - I2C_FLAG_SB: Start bit flag |
| * - I2C_FLAG_M_SL: Master/Slave flag |
| * - I2C_FLAG_ADSL: Adress matched flag |
| * - I2C_FLAG_BTF: Byte transfer finished flag |
| * - I2C_FLAG_BUSY: Bus busy flag |
| * - I2C_FLAG_TRA: Transmitter/Receiver flag |
| * - I2C_FLAG_ADD10: 10-bit addressing in Master mode flag |
| * - I2C_FLAG_EVF: Event flag |
| * - I2C_FLAG_GCAL: General call flag |
| * - I2C_FLAG_BERR: Bus error flag |
| * - I2C_FLAG_ARLO: Arbitration lost flag |
| * - I2C_FLAG_STOPF: Stop detection flag |
| * - I2C_FLAG_AF: Acknowledge failure flag |
| * - I2C_FLAG_ENDAD: End of address transmission flag |
| * - I2C_FLAG_ACK: Acknowledge enable flag |
| * - parameter needed in the case that the flag to be cleared |
| * need a write in one register |
| * Output : None |
| * Return : None. |
| *******************************************************************************/ |
| void I2C_ClearFlag(I2C_TypeDef* I2Cx, u16 I2C_FLAG, ...) |
| { |
| u8 bTmp = (u8)*((u32 *) & I2C_FLAG + sizeof(I2C_FLAG)); |
| |
| /* flags that need a read of the SR2 register to be cleared */ |
| if ((I2C_FLAG==I2C_FLAG_ADD10) || (I2C_FLAG==I2C_FLAG_EVF) || (I2C_FLAG==I2C_FLAG_BERR) || (I2C_FLAG==I2C_FLAG_ARLO) | |
| (I2C_FLAG==I2C_FLAG_STOPF) ||(I2C_FLAG==I2C_FLAG_AF) || (I2C_FLAG==I2C_FLAG_ENDAD)) |
| { |
| /* Read the SR2 register */ |
| I2Cx->SR2; |
| |
| /* Two flags need a second step to be cleared */ |
| switch (I2C_FLAG) |
| { |
| case I2C_FLAG_ADD10: |
| /* Send the MSB 10bit address passed as second parameter */ |
| I2Cx->DR = bTmp; |
| break; |
| case I2C_FLAG_ENDAD: |
| /* Write to the I2C_CR register by setting PE bit */ |
| I2Cx->CR |= I2C_PE_Set; |
| break; |
| } |
| } |
| |
| /* flags that need a read of the SR1 register to be cleared */ |
| else if (I2C_FLAG==I2C_FLAG_SB || I2C_FLAG==I2C_FLAG_ADSL || I2C_FLAG==I2C_FLAG_BTF || I2C_FLAG==I2C_FLAG_TRA) |
| { |
| /* Read the SR1 register */ |
| (void)I2Cx->SR1; |
| |
| /* three flags need a second step to be cleared */ |
| if (I2C_FLAG == I2C_FLAG_SB) |
| { |
| /* Send the address byte passed as second parameter */ |
| I2Cx->DR = bTmp; |
| } |
| else if (I2C_FLAG==I2C_FLAG_BTF || I2C_FLAG==I2C_FLAG_TRA) |
| { |
| /* return the received byte in the variable passed as second parameter */ |
| bTmp=I2Cx->DR; |
| } |
| } |
| |
| /* flags that need to disable the I2C interface */ |
| else if ( I2C_FLAG==I2C_FLAG_M_SL || I2C_FLAG==I2C_FLAG_GCAL) |
| { |
| I2C_Cmd(I2Cx, DISABLE); |
| I2C_Cmd(I2Cx, ENABLE); |
| } |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_Send7bitAddress |
| * Description : Transmits the address byte to select the slave device. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * - Address: specifies the slave address which will be transmitted |
| * - Direction: specifies whether the I2C device will be a |
| * Transmitter or a Receiver. This parameter can be one of the |
| * following values |
| * - I2C_MODE_TRANSMITTER: Transmitter mode |
| * - I2C_MODE_RECEIVER: Receiver mode |
| * Output : None |
| * Return : None. |
| *******************************************************************************/ |
| void I2C_Send7bitAddress(I2C_TypeDef* I2Cx, u8 Address, u8 Direction) |
| { |
| /* Test on the direction to define the read/write bit */ |
| if (Direction == I2C_MODE_RECEIVER) |
| { |
| /* Set the address bit0 for read */ |
| Address |= I2C_ADD0_Set; |
| } |
| else |
| { |
| /* Reset the address bit0 for write */ |
| Address &= I2C_ADD0_Reset; |
| } |
| /* Send the address */ |
| I2Cx->DR = Address; |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_SendData |
| * Description : Send a data byte. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * - bData : the byte to be sent |
| * Output : None |
| * Return : None. |
| *******************************************************************************/ |
| void I2C_SendData(I2C_TypeDef* I2Cx, u8 bData) |
| { |
| /* Write in the DR register the byte to be sent */ |
| I2Cx->DR = bData; |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_ReceiveData |
| * Description : Read the received byte. |
| * Input : - I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * Output : None |
| * Return : The received byte |
| *******************************************************************************/ |
| u8 I2C_ReceiveData(I2C_TypeDef* I2Cx) |
| { |
| /* Return from the DR register the received byte */ |
| return I2Cx->DR; |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_GetLastEvent |
| * Description : Get the Last happened I2C Event. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * Output : None |
| * Return : The Last happened Event. |
| *******************************************************************************/ |
| u16 I2C_GetLastEvent(I2C_TypeDef* I2Cx) |
| { |
| u16 wFlag1=0, wFlag2 =0, wLastEvent=0; |
| wFlag2 = I2Cx->SR1; |
| wFlag1 = I2Cx->SR2; |
| wFlag1 = wFlag1<<8; |
| /* Get the last event value from I2C status register */ |
| wLastEvent = ((( wFlag2 | (wFlag1)) & I2C_Event_Mask)); |
| /* Return the last event */ |
| return wLastEvent; |
| } |
| |
| /******************************************************************************* |
| * Function Name : I2C_CheckEvent |
| * Description : Checks whether the Last I2C Event is equal to the one passed |
| * as parameter. |
| * Input :- I2Cx: I2C peripheral can be: |
| * - I2C0 |
| * - I2C1 |
| * - I2C_EVENT: the event to check. This parameter can be one of |
| * the following values: |
| * - I2C_EVENT_SLAVE_ADDRESS_MATCHED |
| * - I2C_EVENT_SLAVE_BYTE_RECEIVED |
| * - I2C_EVENT_SLAVE_BYTE_TRANSMITTED |
| * - I2C_EVENT_MASTER_MODE_SELECT |
| * - I2C_EVENT_MASTER_MODE_SELECTED |
| * - I2C_EVENT_MASTER_BYTE_RECEIVED |
| * - I2C_EVENT_MASTER_BYTE_TRANSMITTED |
| * - I2C_EVENT_MASTER_MODE_ADDRESS10 |
| * - I2C_EVENT_SLAVE_STOP_DETECTED |
| * - I2C_EVENT_SLAVE_ACK_FAILURE |
| - I2C_EV31 |
| * Output : None |
| * Return : An ErrorStatus enumuration value: |
| * - SUCCESS: Last event is equal to the I2C_Event |
| * - ERROR: Last event is different from the I2C_Event |
| *******************************************************************************/ |
| ErrorStatus I2C_CheckEvent(I2C_TypeDef* I2Cx,u16 I2C_EVENT) |
| { |
| u16 wLastEvent = I2C_GetLastEvent(I2Cx); |
| |
| /* Check whther the last event is equal to I2C_EVENT */ |
| if (wLastEvent == I2C_EVENT) |
| { |
| /* Return SUCCESS when last event is equal to I2C_EVENT */ |
| return SUCCESS; |
| } |
| else |
| { |
| /* Return ERROR when last event is different from I2C_EVENT */ |
| return ERROR; |
| } |
| } |
| |
| /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/ |