stm32f10x_i2c.c

中文固件库.rar

}

/**
  * @brief  Enables or disables the specified I2C dual addressing mode.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param NewState: new state of the I2C dual addressing mode.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void I2C_DualAddressCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  if (NewState != DISABLE)
  {
    /* Enable dual addressing mode */
    I2Cx->OAR2 |= OAR2_ENDUAL_Set;
  }
  else
  {
    /* Disable dual addressing mode */
    I2Cx->OAR2 &= OAR2_ENDUAL_Reset;
  }
}

/**
  * @brief  Enables or disables the specified I2C general call feature.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param NewState: new state of the I2C General call.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void I2C_GeneralCallCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  if (NewState != DISABLE)
  {
    /* Enable generall call */
    I2Cx->CR1 |= CR1_ENGC_Set;
  }
  else
  {
    /* Disable generall call */
    I2Cx->CR1 &= CR1_ENGC_Reset;
  }
}

/**
  * @brief  Enables or disables the specified I2C interrupts.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param I2C_IT: specifies the I2C interrupts sources to be enabled
  *   or disabled. 
  *   This parameter can be any combination of the following values:
  * @arg I2C_IT_BUF: Buffer interrupt mask
  * @arg I2C_IT_EVT: Event interrupt mask
  * @arg I2C_IT_ERR: Error interrupt mask
  * @param NewState: new state of the specified I2C interrupts.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void I2C_ITConfig(I2C_TypeDef* I2Cx, uint16_t I2C_IT, FunctionalState NewState)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  assert_param(IS_I2C_CONFIG_IT(I2C_IT));
  
  if (NewState != DISABLE)
  {
    /* Enable the selected I2C interrupts */
    I2Cx->CR2 |= I2C_IT;
  }
  else
  {
    /* Disable the selected I2C interrupts */
    I2Cx->CR2 &= (uint16_t)~I2C_IT;
  }
}

/**
  * @brief  Sends a data byte through the I2Cx peripheral.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param Data: Byte to be transmitted..
  * @retval : None
  */
void I2C_SendData(I2C_TypeDef* I2Cx, uint8_t Data)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  /* Write in the DR register the data to be sent */
  I2Cx->DR = Data;
}

/**
  * @brief  Returns the most recent received data by the I2Cx peripheral.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @retval : The value of the received data.
  */
uint8_t I2C_ReceiveData(I2C_TypeDef* I2Cx)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  /* Return the data in the DR register */
  return (uint8_t)I2Cx->DR;
}

/**
  * @brief  Transmits the address byte to select the slave device.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param Address: specifies the slave address which will be transmitted
  * @param I2C_Direction: specifies whether the I2C device will be a
  *   Transmitter or a Receiver. 
  *   This parameter can be one of the following values
  * @arg I2C_Direction_Transmitter: Transmitter mode
  * @arg I2C_Direction_Receiver: Receiver mode
  * @retval : None.
  */
void I2C_Send7bitAddress(I2C_TypeDef* I2Cx, uint8_t Address, uint8_t I2C_Direction)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_I2C_DIRECTION(I2C_Direction));
  /* Test on the direction to set/reset the read/write bit */
  if (I2C_Direction != I2C_Direction_Transmitter)
  {
    /* Set the address bit0 for read */
    Address |= OAR1_ADD0_Set;
  }
  else
  {
    /* Reset the address bit0 for write */
    Address &= OAR1_ADD0_Reset;
  }
  /* Send the address */
  I2Cx->DR = Address;
}

/**
  * @brief  Reads the specified I2C register and returns its value.
  * @param I2C_Register: specifies the register to read.
  *   This parameter can be one of the following values:
  * @arg I2C_Register_CR1:  CR1 register.
  * @arg I2C_Register_CR2:   CR2 register.
  * @arg I2C_Register_OAR1:  OAR1 register.
  * @arg I2C_Register_OAR2:  OAR2 register.
  * @arg I2C_Register_DR:    DR register.
  * @arg I2C_Register_SR1:   SR1 register.
  * @arg I2C_Register_SR2:   SR2 register.
  * @arg I2C_Register_CCR:   CCR register.
  * @arg I2C_Register_TRISE: TRISE register.
  * @retval : The value of the read register.
  */
uint16_t I2C_ReadRegister(I2C_TypeDef* I2Cx, uint8_t I2C_Register)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_I2C_REGISTER(I2C_Register));
  /* Return the selected register value */
  return (*(__IO uint16_t *)(*((__IO uint32_t *)&I2Cx) + I2C_Register));
}

/**
  * @brief  Enables or disables the specified I2C software reset.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param NewState: new state of the I2C software reset.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void I2C_SoftwareResetCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  if (NewState != DISABLE)
  {
    /* Peripheral under reset */
    I2Cx->CR1 |= CR1_SWRST_Set;
  }
  else
  {
    /* Peripheral not under reset */
    I2Cx->CR1 &= CR1_SWRST_Reset;
  }
}

/**
  * @brief  Drives the SMBusAlert pin high or low for the specified I2C.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param I2C_SMBusAlert: specifies SMBAlert pin level. 
  *   This parameter can be one of the following values:
  * @arg I2C_SMBusAlert_Low: SMBAlert pin driven low
  * @arg I2C_SMBusAlert_High: SMBAlert pin driven high
  * @retval : None
  */
void I2C_SMBusAlertConfig(I2C_TypeDef* I2Cx, uint16_t I2C_SMBusAlert)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_I2C_SMBUS_ALERT(I2C_SMBusAlert));
  if (I2C_SMBusAlert == I2C_SMBusAlert_Low)
  {
    /* Drive the SMBusAlert pin Low */
    I2Cx->CR1 |= I2C_SMBusAlert_Low;
  }
  else
  {
    /* Drive the SMBusAlert pin High  */
    I2Cx->CR1 &= I2C_SMBusAlert_High;
  }
}

/**
  * @brief  Enables or disables the specified I2C PEC transfer.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param NewState: new state of the I2C PEC transmission.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void I2C_TransmitPEC(I2C_TypeDef* I2Cx, FunctionalState NewState)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  if (NewState != DISABLE)
  {
    /* Enable the selected I2C PEC transmission */
    I2Cx->CR1 |= CR1_PEC_Set;
  }
  else
  {
    /* Disable the selected I2C PEC transmission */
    I2Cx->CR1 &= CR1_PEC_Reset;
  }
}

/**
  * @brief  Selects the specified I2C PEC position.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param I2C_PECPosition: specifies the PEC position. 
  *   This parameter can be one of the following values:
  * @arg I2C_PECPosition_Next: indicates that the next
  *   byte is PEC
  * @arg I2C_PECPosition_Current: indicates that current
  *   byte is PEC
  * @retval : None
  */
void I2C_PECPositionConfig(I2C_TypeDef* I2Cx, uint16_t I2C_PECPosition)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_I2C_PEC_POSITION(I2C_PECPosition));
  if (I2C_PECPosition == I2C_PECPosition_Next)
  {
    /* Next byte in shift register is PEC */
    I2Cx->CR1 |= I2C_PECPosition_Next;
  }
  else
  {
    /* Current byte in shift register is PEC */
    I2Cx->CR1 &= I2C_PECPosition_Current;
  }
}

/**
  * @brief  Enables or disables the PEC value calculation of the
  *   transfered bytes.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param NewState: new state of the I2Cx PEC value calculation.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void I2C_CalculatePEC(I2C_TypeDef* I2Cx, FunctionalState NewState)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  if (NewState != DISABLE)
  {
    /* Enable the selected I2C PEC calculation */
    I2Cx->CR1 |= CR1_ENPEC_Set;
  }
  else
  {
    /* Disable the selected I2C PEC calculation */
    I2Cx->CR1 &= CR1_ENPEC_Reset;
  }
}

/**
  * @brief  Returns the PEC value for the specified I2C.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @retval : The PEC value.
  */
uint8_t I2C_GetPEC(I2C_TypeDef* I2Cx)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  /* Return the selected I2C PEC value */
  return ((I2Cx->SR2) >> 8);
}

/**
  * @brief  Enables or disables the specified I2C ARP.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param NewState: new state of the I2Cx ARP. 
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void I2C_ARPCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  if (NewState != DISABLE)
  {
    /* Enable the selected I2C ARP */
    I2Cx->CR1 |= CR1_ENARP_Set;
  }
  else
  {
    /* Disable the selected I2C ARP */
    I2Cx->CR1 &= CR1_ENARP_Reset;
  }
}

/**
  * @brief  Enables or disables the specified I2C Clock stretching.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param NewState: new state of the I2Cx Clock stretching.
  *   This parameter can be: ENABLE or DISABLE.
  * @retval : None
  */
void I2C_StretchClockCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_FUNCTIONAL_STATE(NewState));
  if (NewState == DISABLE)
  {
    /* Enable the selected I2C Clock stretching */
    I2Cx->CR1 |= CR1_NOSTRETCH_Set;
  }
  else
  {
    /* Disable the selected I2C Clock stretching */
    I2Cx->CR1 &= CR1_NOSTRETCH_Reset;
  }
}

/**
  * @brief  Selects the specified I2C fast mode duty cycle.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param I2C_DutyCycle: specifies the fast mode duty cycle.
  *   This parameter can be one of the following values:
  * @arg I2C_DutyCycle_2: I2C fast mode Tlow/Thigh = 2
  * @arg I2C_DutyCycle_16_9: I2C fast mode Tlow/Thigh = 16/9
  * @retval : None
  */
void I2C_FastModeDutyCycleConfig(I2C_TypeDef* I2Cx, uint16_t I2C_DutyCycle)
{
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_I2C_DUTY_CYCLE(I2C_DutyCycle));
  if (I2C_DutyCycle != I2C_DutyCycle_16_9)
  {
    /* I2C fast mode Tlow/Thigh=2 */
    I2Cx->CCR &= I2C_DutyCycle_2;
  }
  else
  {
    /* I2C fast mode Tlow/Thigh=16/9 */
    I2Cx->CCR |= I2C_DutyCycle_16_9;
  }
}

/**
  * @brief  Returns the last I2Cx Event.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @retval : The last event
  */
uint32_t I2C_GetLastEvent(I2C_TypeDef* I2Cx)
{
  uint32_t lastevent = 0;
  uint32_t flag1 = 0, flag2 = 0;
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  /* Read the I2Cx status register */
  flag1 = I2Cx->SR1;
  flag2 = I2Cx->SR2;
  flag2 = flag2 << 16;
  /* Get the last event value from I2C status register */
  lastevent = (flag1 | flag2) & FLAG_Mask;
  /* Return status */
  return lastevent;
}

/**
  * @brief  Checks whether the last I2Cx Event is equal to the one passed
  *   as parameter.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param I2C_EVENT: specifies the event to be checked. 
  *   This parameter can be one of the following values:
  * @arg I2C_EVENT_SLAVE_ADDRESS_MATCHED   : EV1
  * @arg I2C_EVENT_SLAVE_BYTE_RECEIVED     : EV2
  * @arg I2C_EVENT_SLAVE_BYTE_TRANSMITTED  : EV3
  * @arg I2C_EVENT_SLAVE_ACK_FAILURE       : EV3-2
  * @arg I2C_EVENT_MASTER_MODE_SELECT      : EV5
  * @arg I2C_EVENT_MASTER_MODE_SELECTED    : EV6
  * @arg I2C_EVENT_MASTER_BYTE_RECEIVED    : EV7
  * @arg I2C_EVENT_MASTER_BYTE_TRANSMITTED : EV8
  * @arg I2C_EVENT_MASTER_MODE_ADDRESS10   : EV9
  * @arg I2C_EVENT_SLAVE_STOP_DETECTED     : EV4
  * @retval : 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, uint32_t I2C_EVENT)
{
  uint32_t lastevent = 0;
  uint32_t flag1 = 0, flag2 = 0;
  ErrorStatus status = ERROR;
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_I2C_EVENT(I2C_EVENT));
  /* Read the I2Cx status register */
  flag1 = I2Cx->SR1;
  flag2 = I2Cx->SR2;
  flag2 = flag2 << 16;
  /* Get the last event value from I2C status register */
  lastevent = (flag1 | flag2) & FLAG_Mask;
  /* Check whether the last event is equal to I2C_EVENT */
  if (lastevent == I2C_EVENT )
  {
    /* SUCCESS: last event is equal to I2C_EVENT */
    status = SUCCESS;
  }
  else
  {
    /* ERROR: last event is different from I2C_EVENT */
    status = ERROR;
  }
  /* Return status */
  return status;
}

/**
  * @brief  Checks whether the specified I2C flag is set or not.
  * @param I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param I2C_FLAG: specifies the flag to check. 
  *   This parameter can be one of the following values:
  * @arg I2C_FLAG_DUALF: Dual flag (Slave mode)
  * @arg I2C_FLAG_SMBHOST: SMBus host header (Slave mode)
  * @arg I2C_FLAG_SMBDEFAULT: SMBus default header (Slave mode)
  * @arg I2C_FLAG_GENCALL: General call header flag (Slave mode)
  * @arg I2C_FLAG_TRA: Transmitter/Receiver flag
  * @arg I2C_FLAG_BUSY: Bus busy flag
  * @arg I2C_FLAG_MSL: Master/Slave flag
  * @arg I2C_FLAG_SMBALERT: SMBus Alert flag
  * @arg I2C_FLAG_TIMEOUT: Timeout or Tlow error flag
  * @arg I2C_FLAG_PECERR: PEC error in reception flag
  * @arg I2C_FLAG_OVR: Overrun/Underrun flag (Slave mode)
  * @arg I2C_FLAG_AF: Acknowledge failure flag
  * @arg I2C_FLAG_ARLO: Arbitration lost flag (Master mode)
  * @arg I2C_FLAG_BERR: Bus error flag
  * @arg I2C_FLAG_TXE: Data register empty flag (Transmitter)
  * @arg I2C_FLAG_RXNE: Data register not empty (Receiver) flag
  * @arg I2C_FLAG_STOPF: Stop detection flag (Slave mode)
  * @arg I2C_FLAG_ADD10: 10-bit header sent flag (Master mode)
  * @arg I2C_FLAG_BTF: Byte transfer finished flag
  * @arg I2C_FLAG_ADDR: Address sent flag (Master mode) 揂DSL