*                    This parameter can be:
*                     - UART0_DMAReq_Tx: Transmit DMA request
*                     - UART0_DMAReq_Rx: Receive DMA request
*                  - NewState: new state of the UART0抯 DMA request.
*                    This parameter can be: ENABLE or DISABLE.
* Output         : None
* Return         : None
*******************************************************************************/
void UART_DMACmd(u16 UART0_DMAReq, FunctionalState NewState)
{
  if(UART0_DMAReq == UART0_DMAReq_Tx)
  {
    if(NewState == ENABLE)
    {
      UART0->DMACR |=  UART0_DMAReq_Tx;
    }
    else
    {
      UART0->DMACR &= ~UART0_DMAReq_Tx;
    }
  }
  else
  {
    if(NewState == ENABLE)
    {
      UART0->DMACR |=  UART0_DMAReq_Rx;
    }
    else
    {
      UART0->DMACR &= ~UART0_DMAReq_Rx;
    }
  }
}

/*******************************************************************************
* Function Name  : UART_LoopBackConfig
* Description    : Enables or disables LoopBack mode in UARTx.
* Input          : - UARTx: where x can be 0,1 or 2 to select the UART peripheral
*                  - NewState: new state of the UARTx抯 LoopBack mode.
*                    This parameter can be: ENABLE or DISABLE.
* Output         : None
* Return         : None
*******************************************************************************/
void UART_LoopBackConfig(UART_TypeDef* UARTx, FunctionalState NewState)
{
  if (NewState == ENABLE)
  {
    /* Enable the LoopBack mode of the specified UART */
    UARTx->CR |= UART_LoopBack_Enable_Mask;
  }
  else
  {
    /* Disable the LoopBack mode of the specified UART */
    UARTx->CR &= UART_LoopBack_Disable_Mask;
  }
}

/*******************************************************************************
* Function Name  : UART_LINConfig
* Description    : Sets the LIN break length.
* Input          : - UARTx: where x can be 0,1 or 2 to select the UART peripheral.
*                  - UART_LINBreakLength: Break length value.
*                    This parameter can be:
*                         - UART_LINBreakLength_10: 10 low bits
*                         - UART_LINBreakLength_11: 11 low bits
*                         - UART_LINBreakLength_12: 12 low bits
*                         - UART_LINBreakLength_13: 13 low bits
*                         - UART_LINBreakLength_14: 14 low bits
*                         - UART_LINBreakLength_15: 15 low bits
*                         - UART_LINBreakLength_16: 16 low bits
*                         - UART_LINBreakLength_17: 17 low bits
*                         - UART_LINBreakLength_18: 18 low bits
*                         - UART_LINBreakLength_19: 19 low bits
*                         - UART_LINBreakLength_20: 20 low bits
* Output         : None
* Return         : None
*******************************************************************************/
void UART_LINConfig(UART_TypeDef* UARTx, u16 UART_LINBreakLength)
{
  /* Clear LBKLEN bits */
  UARTx->LCR &= UART_LINBreakLength_Mask;

  /* Set LBKLEN bits according to UART_LINBreakLength value */
  UARTx->LCR |= UART_LINBreakLength;
}

/*******************************************************************************
* Function Name  : UART_LINCmd
* Description    : Enables or disables LIN master mode in UARTx.
* Input          : - UARTx: where x can be 0,1 or 2 to select the UART peripheral
*                  - NewState: new state of the UARTx抯 LIN interface. 
*                    This parameter can be: ENABLE or DISABLE.
* Output         : None
* Return         : None
*******************************************************************************/
void UART_LINCmd(UART_TypeDef* UARTx, FunctionalState NewState)
{
  if(NewState == ENABLE)
  {
    /* Enable the LIN mode of the specified UART */
    UARTx->LCR |= UART_LIN_Enable_Mask;
  }
  else
  {
    /* Disable the LIN mode of the specified UART */
    UARTx->LCR &= UART_LIN_Disable_Mask;
  }
}

/*******************************************************************************
* Function Name  : UART_SendData
* Description    : Transmits a signle Byte of data through the UARTx peripheral.
* Input          : - UARTx: where x can be 0,1 or 2 to select the UART peripheral.
*                  - Data: the byte to transmit
* Output         : None
* Return         : None
*******************************************************************************/
void UART_SendData(UART_TypeDef* UARTx, u8 Data)
{
  /* Transmit one byte */
  UARTx->DR = Data;
}

/*******************************************************************************
* Function Name  : UART_ReceiveData
* Description    : Returns the most recent received Byte by the UARTx peripheral.
* Input          : UARTx: where x can be 0,1 or 2 to select the UART peripheral.
* Output         : None
* Return         : The received data
*******************************************************************************/
u8 UART_ReceiveData(UART_TypeDef* UARTx)
{
  /* Receive one byte */
  return ((u8)UARTx->DR);
}

/*******************************************************************************
* Function Name  : UART_SendBreak
* Description    : Transmits break characters.
* Input          : UARTx: where x can be 0,1 or 2 to select the UART peripheral.
* Output         : None
* Return         : None
*******************************************************************************/
void UART_SendBreak(UART_TypeDef* UARTx)
{
  /* Send break characters */
  UARTx->BKR |= UART_BreakChar_Mask;
}

/*******************************************************************************
* Function Name  : UART_RTSConfig
* Description    : Sets or Resets the RTS signal
* Input          : - UARTx: where x can be 0,1 or 2 to select the UART peripheral.
*                  - RTSState: new state of the RTS signal.
*                    This parameter can be: RTSSET or RTSRESET
* Output         : None
* Return         : None
*******************************************************************************/
void UART_RTSConfig(UART_TypeDef* UARTx, UART_RTSTypeDef RTSState)
{
  if(RTSState == RTSRESET)
  {
    UARTx->CR |= UART_RTSRESET_Mask;
  }
  else if(RTSState == RTSSET)
  {
    UARTx->CR &= UART_RTSSET_Mask;
  }
}

/*******************************************************************************
* Function Name  : UART_GetFlagStatus
* Description    : Checks whether the specified UART flag is set or not.
* Input          : - UARTx: where x can be 0,1 or 2 to select the UART peripheral
*                  - UART_FLAG: specifies the flag to check.
*                    This parameter can be one of the following values:
*                     - UART_FLAG_OverrunError: Overrun error flag
*                     - UART_FLAG_Break: break error flag
*                     - UART_FLAG_ParityError: parity error flag
*                     - UART_FLAG_FrameError: frame error flag
*                     - UART_FLAG_TxFIFOEmpty: Transmit FIFO Empty flag
*                     - UART_FLAG_RxFIFOFull: Receive FIFO Full flag
*                     - UART_FLAG_TxFIFOFull: Transmit FIFO Full flag
*                     - UART_FLAG_RxFIFOEmpty: Receive FIFO Empty flag
*                     - UART_FLAG_Busy: Busy flag
*                     - UART_FLAG_CTS: CTS flag
*                     - UART_RawIT_OverrunError: Overrun Error interrupt flag
*                     - UART_RawIT_BreakError: Break Error interrupt flag
*                     - UART_RawIT_ParityError: Parity Error interrupt flag
*                     - UART_RawIT_FrameError: Frame Error interrupt flag
*                     - UART_RawIT_ReceiveTimeOut: ReceiveTimeOut interrupt flag
*                     - UART_RawIT_Transmit: Transmit interrupt flag
*                     - UART_RawIT_Receive: Receive interrupt flag
*                     - UART_RawIT_CTS: CTS interrupt flag
* Output         : None
* Return         : The new state of UART_FLAG (SET or RESET).
*******************************************************************************/
FlagStatus UART_GetFlagStatus(UART_TypeDef* UARTx, u16 UART_FLAG)
{
  u32 UARTReg = 0, FlagPos = 0;
  u32 StatusReg = 0;

  /* Get the UART register index */
  UARTReg = UART_FLAG >> 5;

  /* Get the flag position */
  FlagPos = UART_FLAG & UART_FLAG_Mask;

  if(UARTReg == 1) /* The flag to check is in RSR register */
  {
    StatusReg = UARTx->RSR;
  }
  else if (UARTReg == 2) /* The flag to check is in FR register */
  {
    StatusReg = UARTx->FR;
  }
  else if(UARTReg == 3) /* The flag to check is in RIS register */
  {
    StatusReg = UARTx->RIS;
  }

  if((StatusReg & (1 << FlagPos))!= RESET)
  {
    return SET;
  }
  else
  {
    return RESET;
  }
}

/*******************************************************************************
* Function Name  : UART_ClearFlag
* Description    : Clears the UARTx抯 pending flags.
* Input          : - UARTx: where x can be 0,1or 2 to select the UART peripheral.
*                  - UART_FLAG: specifies the flag to clear.
*                    This parameter can be one of the following values:
*                       - UART_FLAG_OverrunError: Overrun error flag
*                       - UART_FLAG_Break: break error flag
*                       - UART_FLAG_ParityError: parity error flag
*                       - UART_FLAG_FrameError: frame error flag
* Output         : None
* Return         : None
*******************************************************************************/
void UART_ClearFlag(UART_TypeDef* UARTx, u16 UART_FLAG)
{
  u8 FlagPos = 0;

  /* Get the flag position */
  FlagPos = UART_FLAG & UART_FLAG_Mask;

  /* Clear the sepecified flag */
  UARTx->RSR &= ~(1 << FlagPos);
}

/*******************************************************************************
* Function Name  : UART_GetITStatus
* Description    : Checks whether the specified UART interrupt has occurred or not.
* Input          : - UARTx: where x can be 0,1or 2 to select the UART peripheral.
*                  - UART_IT: specifies the interrupt source to check.
*                    This parameter can be one of the following values:
*                       - UART_IT_OverrunError: Overrun Error interrupt 
*                       - UART_IT_BreakError: Break Error interrupt 
*                       - UART_IT_ParityError: Parity Error interrupt 
*                       - UART_IT_FrameError: Frame Error interrupt 
*                       - UART_IT_ReceiveTimeOut: Receive Time Out interrupt 
*                       - UART_IT_Transmit: Transmit interrupt 
*                       - UART_IT_Receive: Receive interrupt 
*                       - UART_IT_CTS: CTS interrupt 
* Output         : None
* Return         : The new state of UART_IT (SET or RESET).
*******************************************************************************/
ITStatus UART_GetITStatus(UART_TypeDef* UARTx, u16 UART_IT)
{
  if((UARTx->MIS & UART_IT) != RESET)
  {
    return SET;
  }
  else
  {
    return RESET;
  }
}

/*******************************************************************************
* Function Name  : UART_ClearITPendingBit
* Description    : Clears the UARTx抯 interrupt pending bits.
* Input          : - UARTx: where x can be 0,1or 2 to select the UART peripheral.
*                  - UART_IT: specifies the interrupt pending bit to clear.
*                    More than one interrupt can be cleared using the 搢