www.pudn.com > STM32F103C8T6-I0_LED.zip > stm32f10x_usart.c, change:2009-04-06,size:34930b


/** 
  ****************************************************************************** 
  * @file  stm32f10x_usart.c 
  * @author  MCD Application Team 
  * @version  V3.0.0 
  * @date  04/06/2009 
  * @brief  This file provides all the USART firmware functions. 
  ****************************************************************************** 
  * @copy 
  * 
  * THE PRESENT FIRMWARE 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 FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE 
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. 
  * 
  * <h2><center>© COPYRIGHT 2009 STMicroelectronics</center></h2> 
  */  
 
/* Includes ------------------------------------------------------------------*/ 
#include "stm32f10x_usart.h" 
#include "stm32f10x_rcc.h" 
 
/** @addtogroup StdPeriph_Driver 
  * @{ 
  */ 
 
/** @defgroup USART  
  * @brief USART driver modules 
  * @{ 
  */ 
 
/** @defgroup USART_Private_TypesDefinitions 
  * @{ 
  */ 
 
/** 
  * @} 
  */ 
 
/** @defgroup USART_Private_Defines 
  * @{ 
  */ 
 
/* USART UE Mask */ 
#define CR1_UE_Set                ((uint16_t)0x2000)  /* USART Enable Mask */ 
#define CR1_UE_Reset              ((uint16_t)0xDFFF)  /* USART Disable Mask */ 
 
/* USART WakeUp Method  */ 
#define CR1_WAKE_Mask             ((uint16_t)0xF7FF)  /* USART WakeUp Method Mask */ 
 
/* USART RWU Mask */ 
#define CR1_RWU_Set               ((uint16_t)0x0002)  /* USART mute mode Enable Mask */ 
#define CR1_RWU_Reset             ((uint16_t)0xFFFD)  /* USART mute mode Enable Mask */ 
#define CR1_SBK_Set               ((uint16_t)0x0001)  /* USART Break Character send Mask */ 
#define CR1_CLEAR_Mask            ((uint16_t)0xE9F3)  /* USART CR1 Mask */ 
#define CR2_Address_Mask          ((uint16_t)0xFFF0)  /* USART address Mask */ 
 
/* USART LIN Mask */ 
#define CR2_LINEN_Set              ((uint16_t)0x4000)  /* USART LIN Enable Mask */ 
#define CR2_LINEN_Reset            ((uint16_t)0xBFFF)  /* USART LIN Disable Mask */ 
 
/* USART LIN Break detection */ 
#define CR2_LBDL_Mask             ((uint16_t)0xFFDF)  /* USART LIN Break detection Mask */ 
#define CR2_STOP_CLEAR_Mask       ((uint16_t)0xCFFF)  /* USART CR2 STOP Bits Mask */ 
#define CR2_CLOCK_CLEAR_Mask      ((uint16_t)0xF0FF)  /* USART CR2 Clock Mask */ 
 
/* USART SC Mask */ 
#define CR3_SCEN_Set              ((uint16_t)0x0020)  /* USART SC Enable Mask */ 
#define CR3_SCEN_Reset            ((uint16_t)0xFFDF)  /* USART SC Disable Mask */ 
 
/* USART SC NACK Mask */ 
#define CR3_NACK_Set              ((uint16_t)0x0010)  /* USART SC NACK Enable Mask */ 
#define CR3_NACK_Reset            ((uint16_t)0xFFEF)  /* USART SC NACK Disable Mask */ 
 
/* USART Half-Duplex Mask */ 
#define CR3_HDSEL_Set             ((uint16_t)0x0008)  /* USART Half-Duplex Enable Mask */ 
#define CR3_HDSEL_Reset           ((uint16_t)0xFFF7)  /* USART Half-Duplex Disable Mask */ 
 
/* USART IrDA Mask */ 
#define CR3_IRLP_Mask             ((uint16_t)0xFFFB)  /* USART IrDA LowPower mode Mask */ 
#define CR3_CLEAR_Mask            ((uint16_t)0xFCFF)  /* USART CR3 Mask */ 
 
/* USART IrDA Mask */ 
#define CR3_IREN_Set              ((uint16_t)0x0002)  /* USART IrDA Enable Mask */ 
#define CR3_IREN_Reset            ((uint16_t)0xFFFD)  /* USART IrDA Disable Mask */ 
#define GTPR_LSB_Mask             ((uint16_t)0x00FF)  /* Guard Time Register LSB Mask */ 
#define GTPR_MSB_Mask             ((uint16_t)0xFF00)  /* Guard Time Register MSB Mask */ 
#define IT_Mask                   ((uint16_t)0x001F)  /* USART Interrupt Mask */ 
 
/** 
  * @} 
  */ 
 
/** @defgroup USART_Private_Macros 
  * @{ 
  */ 
 
/** 
  * @} 
  */ 
 
/** @defgroup USART_Private_Variables 
  * @{ 
  */ 
 
/** 
  * @} 
  */ 
 
/** @defgroup USART_Private_FunctionPrototypes 
  * @{ 
  */ 
 
/** 
  * @} 
  */ 
 
/** @defgroup USART_Private_Functions 
  * @{ 
  */ 
 
/** 
  * @brief  Deinitializes the USARTx peripheral registers to their 
  *   default reset values. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @retval : None 
  */ 
void USART_DeInit(USART_TypeDef* USARTx) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  switch (*(uint32_t*)&USARTx) 
  { 
    case USART1_BASE: 
      RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE); 
      RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE); 
      break; 
    case USART2_BASE: 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE); 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE); 
      break; 
    case USART3_BASE: 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE); 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, DISABLE); 
      break; 
     
    case UART4_BASE: 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE); 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, DISABLE); 
      break; 
     
    case UART5_BASE: 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE); 
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, DISABLE); 
      break;             
    default: 
      break; 
  } 
} 
 
/** 
  * @brief  Initializes the USARTx peripheral according to the specified 
  *   parameters in the USART_InitStruct . 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_InitStruct: pointer to a USART_InitTypeDef structure 
  *   that contains the configuration information for the 
  *   specified USART peripheral. 
  * @retval : None 
  */ 
void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct) 
{ 
  uint32_t tmpreg = 0x00, apbclock = 0x00; 
  uint32_t integerdivider = 0x00; 
  uint32_t fractionaldivider = 0x00; 
  uint32_t usartxbase = 0; 
  RCC_ClocksTypeDef RCC_ClocksStatus; 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_BAUDRATE(USART_InitStruct->USART_BaudRate));   
  assert_param(IS_USART_WORD_LENGTH(USART_InitStruct->USART_WordLength)); 
  assert_param(IS_USART_STOPBITS(USART_InitStruct->USART_StopBits)); 
  assert_param(IS_USART_PARITY(USART_InitStruct->USART_Parity)); 
  assert_param(IS_USART_MODE(USART_InitStruct->USART_Mode)); 
  assert_param(IS_USART_HARDWARE_FLOW_CONTROL(USART_InitStruct->USART_HardwareFlowControl)); 
  /* The hardware flow control is available only for USART1, USART2 and USART3 */ 
  assert_param(IS_USART_PERIPH_HFC(USARTx, USART_InitStruct->USART_HardwareFlowControl)); 
 
  usartxbase = (*(uint32_t*)&USARTx); 
/*---------------------------- USART CR2 Configuration -----------------------*/ 
  tmpreg = USARTx->CR2; 
  /* Clear STOP[13:12] bits */ 
  tmpreg &= CR2_STOP_CLEAR_Mask; 
  /* Configure the USART Stop Bits, Clock, CPOL, CPHA and LastBit ------------*/ 
  /* Set STOP[13:12] bits according to USART_StopBits value */ 
  tmpreg |= (uint32_t)USART_InitStruct->USART_StopBits; 
   
  /* Write to USART CR2 */ 
  USARTx->CR2 = (uint16_t)tmpreg; 
/*---------------------------- USART CR1 Configuration -----------------------*/ 
  tmpreg = USARTx->CR1; 
  /* Clear M, PCE, PS, TE and RE bits */ 
  tmpreg &= CR1_CLEAR_Mask; 
  /* Configure the USART Word Length, Parity and mode ----------------------- */ 
  /* Set the M bits according to USART_WordLength value */ 
  /* Set PCE and PS bits according to USART_Parity value */ 
  /* Set TE and RE bits according to USART_Mode value */ 
  tmpreg |= (uint32_t)USART_InitStruct->USART_WordLength | USART_InitStruct->USART_Parity | 
            USART_InitStruct->USART_Mode; 
  /* Write to USART CR1 */ 
  USARTx->CR1 = (uint16_t)tmpreg; 
/*---------------------------- USART CR3 Configuration -----------------------*/   
  tmpreg = USARTx->CR3; 
  /* Clear CTSE and RTSE bits */ 
  tmpreg &= CR3_CLEAR_Mask; 
  /* Configure the USART HFC -------------------------------------------------*/ 
  /* Set CTSE and RTSE bits according to USART_HardwareFlowControl value */ 
  tmpreg |= USART_InitStruct->USART_HardwareFlowControl; 
  /* Write to USART CR3 */ 
  USARTx->CR3 = (uint16_t)tmpreg; 
/*---------------------------- USART BRR Configuration -----------------------*/ 
  /* Configure the USART Baud Rate -------------------------------------------*/ 
  RCC_GetClocksFreq(&RCC_ClocksStatus); 
  if (usartxbase == USART1_BASE) 
  { 
    apbclock = RCC_ClocksStatus.PCLK2_Frequency; 
  } 
  else 
  { 
    apbclock = RCC_ClocksStatus.PCLK1_Frequency; 
  } 
  /* Determine the integer part */ 
  integerdivider = ((0x19 * apbclock) / (0x04 * (USART_InitStruct->USART_BaudRate))); 
  tmpreg = (integerdivider / 0x64) << 0x04; 
  /* Determine the fractional part */ 
  fractionaldivider = integerdivider - (0x64 * (tmpreg >> 0x04)); 
  tmpreg |= ((((fractionaldivider * 0x10) + 0x32) / 0x64)) & ((uint8_t)0x0F); 
  /* Write to USART BRR */ 
  USARTx->BRR = (uint16_t)tmpreg; 
} 
 
/** 
  * @brief  Fills each USART_InitStruct member with its default value. 
  * @param USART_InitStruct: pointer to a USART_InitTypeDef structure 
  *   which will be initialized. 
  * @retval : None 
  */ 
void USART_StructInit(USART_InitTypeDef* USART_InitStruct) 
{ 
  /* USART_InitStruct members default value */ 
  USART_InitStruct->USART_BaudRate = 9600; 
  USART_InitStruct->USART_WordLength = USART_WordLength_8b; 
  USART_InitStruct->USART_StopBits = USART_StopBits_1; 
  USART_InitStruct->USART_Parity = USART_Parity_No ; 
  USART_InitStruct->USART_Mode = USART_Mode_Rx | USART_Mode_Tx; 
  USART_InitStruct->USART_HardwareFlowControl = USART_HardwareFlowControl_None;   
} 
 
/** 
  * @brief  Initializes the USARTx peripheral Clock according to the  
  *   specified parameters in the USART_ClockInitStruct . 
  * @param USARTx: where x can be 1, 2, 3 to select the USART peripheral. 
  * @param USART_ClockInitStruct: pointer to a USART_ClockInitTypeDef 
  *   structure that contains the configuration information for the specified  
  *   USART peripheral.   
  * @note The Smart Card mode is not available for UART4 and UART5. 
  * @retval : None 
  */ 
void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct) 
{ 
  uint32_t tmpreg = 0x00; 
  /* Check the parameters */ 
  assert_param(IS_USART_123_PERIPH(USARTx)); 
  assert_param(IS_USART_CLOCK(USART_ClockInitStruct->USART_Clock)); 
  assert_param(IS_USART_CPOL(USART_ClockInitStruct->USART_CPOL)); 
  assert_param(IS_USART_CPHA(USART_ClockInitStruct->USART_CPHA)); 
  assert_param(IS_USART_LASTBIT(USART_ClockInitStruct->USART_LastBit)); 
   
/*---------------------------- USART CR2 Configuration -----------------------*/ 
  tmpreg = USARTx->CR2; 
  /* Clear CLKEN, CPOL, CPHA and LBCL bits */ 
  tmpreg &= CR2_CLOCK_CLEAR_Mask; 
  /* Configure the USART Clock, CPOL, CPHA and LastBit ------------*/ 
  /* Set CLKEN bit according to USART_Clock value */ 
  /* Set CPOL bit according to USART_CPOL value */ 
  /* Set CPHA bit according to USART_CPHA value */ 
  /* Set LBCL bit according to USART_LastBit value */ 
  tmpreg |= (uint32_t)USART_ClockInitStruct->USART_Clock | USART_ClockInitStruct->USART_CPOL |  
                 USART_ClockInitStruct->USART_CPHA | USART_ClockInitStruct->USART_LastBit; 
  /* Write to USART CR2 */ 
  USARTx->CR2 = (uint16_t)tmpreg; 
} 
 
/** 
  * @brief  Fills each USART_ClockInitStruct member with its default value. 
  * @param USART_ClockInitStruct: pointer to a USART_ClockInitTypeDef 
  *   structure which will be initialized. 
  * @retval : None 
  */ 
void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct) 
{ 
  /* USART_ClockInitStruct members default value */ 
  USART_ClockInitStruct->USART_Clock = USART_Clock_Disable; 
  USART_ClockInitStruct->USART_CPOL = USART_CPOL_Low; 
  USART_ClockInitStruct->USART_CPHA = USART_CPHA_1Edge; 
  USART_ClockInitStruct->USART_LastBit = USART_LastBit_Disable; 
} 
 
/** 
  * @brief  Enables or disables the specified USART peripheral. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param NewState: new state of the USARTx peripheral. 
  *   This parameter can be: ENABLE or DISABLE. 
  * @retval : None 
  */ 
void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_FUNCTIONAL_STATE(NewState)); 
   
  if (NewState != DISABLE) 
  { 
    /* Enable the selected USART by setting the UE bit in the CR1 register */ 
    USARTx->CR1 |= CR1_UE_Set; 
  } 
  else 
  { 
    /* Disable the selected USART by clearing the UE bit in the CR1 register */ 
    USARTx->CR1 &= CR1_UE_Reset; 
  } 
} 
 
/** 
  * @brief  Enables or disables the specified USART interrupts. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_IT: specifies the USART interrupt sources to be 
  *   enabled or disabled. 
  *   This parameter can be one of the following values: 
  * @arg USART_IT_CTS:  CTS change interrupt (not available for 
  *   UART4 and UART5) 
  * @arg USART_IT_LBD:  LIN Break detection interrupt 
  * @arg USART_IT_TXE:  Tansmit Data Register empty interrupt 
  * @arg USART_IT_TC:   Transmission complete interrupt 
  * @arg USART_IT_RXNE: Receive Data register not empty  
  *   interrupt 
  * @arg USART_IT_IDLE: Idle line detection interrupt 
  * @arg USART_IT_PE:   Parity Error interrupt 
  * @arg USART_IT_ERR:  Error interrupt(Frame error, noise 
  *   error, overrun error) 
  * @param NewState: new state of the specified USARTx interrupts. 
  *   This parameter can be: ENABLE or DISABLE. 
  * @retval : None 
  */ 
void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState) 
{ 
  uint32_t usartreg = 0x00, itpos = 0x00, itmask = 0x00; 
  uint32_t usartxbase = 0x00; 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_CONFIG_IT(USART_IT)); 
  assert_param(IS_USART_PERIPH_IT(USARTx, USART_IT)); /* The CTS interrupt is not available for UART4 and UART5 */ 
  assert_param(IS_FUNCTIONAL_STATE(NewState)); 
  usartxbase = (*(uint32_t*)&(USARTx)); 
  /* Get the USART register index */ 
  usartreg = (((uint8_t)USART_IT) >> 0x05); 
  /* Get the interrupt position */ 
  itpos = USART_IT & IT_Mask; 
  itmask = (((uint32_t)0x01) << itpos); 
     
  if (usartreg == 0x01) /* The IT is in CR1 register */ 
  { 
    usartxbase += 0x0C; 
  } 
  else if (usartreg == 0x02) /* The IT is in CR2 register */ 
  { 
    usartxbase += 0x10; 
  } 
  else /* The IT is in CR3 register */ 
  { 
    usartxbase += 0x14;  
  } 
  if (NewState != DISABLE) 
  { 
    *(__IO uint32_t*)usartxbase  |= itmask; 
  } 
  else 
  { 
    *(__IO uint32_t*)usartxbase &= ~itmask; 
  } 
} 
 
/** 
  * @brief  Enables or disables the USARTís DMA interface. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3 or UART4.   
  * @param USART_DMAReq: specifies the DMA request. 
  *   This parameter can be any combination of the following values: 
  * @arg USART_DMAReq_Tx: USART DMA transmit request 
  * @arg USART_DMAReq_Rx: USART DMA receive request 
  * @param NewState: new state of the DMA Request sources. 
  *   This parameter can be: ENABLE or DISABLE. 
  * @note The DMA mode is not available for UART5.   
  * @retval : None 
  */ 
void USART_DMACmd(USART_TypeDef* USARTx, uint16_t USART_DMAReq, FunctionalState NewState) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_1234_PERIPH(USARTx)); 
  assert_param(IS_USART_DMAREQ(USART_DMAReq));   
  assert_param(IS_FUNCTIONAL_STATE(NewState));  
  if (NewState != DISABLE) 
  { 
    /* Enable the DMA transfer for selected requests by setting the DMAT and/or 
       DMAR bits in the USART CR3 register */ 
    USARTx->CR3 |= USART_DMAReq; 
  } 
  else 
  { 
    /* Disable the DMA transfer for selected requests by clearing the DMAT and/or 
       DMAR bits in the USART CR3 register */ 
    USARTx->CR3 &= (uint16_t)~USART_DMAReq; 
  } 
} 
 
/** 
  * @brief  Sets the address of the USART node. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_Address: Indicates the address of the USART node. 
  * @retval : None 
  */ 
void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_ADDRESS(USART_Address));  
     
  /* Clear the USART address */ 
  USARTx->CR2 &= CR2_Address_Mask; 
  /* Set the USART address node */ 
  USARTx->CR2 |= USART_Address; 
} 
 
/** 
  * @brief  Selects the USART WakeUp method. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_WakeUp: specifies the USART wakeup method. 
  *   This parameter can be one of the following values: 
  * @arg USART_WakeUp_IdleLine: WakeUp by an idle line detection 
  * @arg USART_WakeUp_AddressMark: WakeUp by an address mark 
  * @retval : None 
  */ 
void USART_WakeUpConfig(USART_TypeDef* USARTx, uint16_t USART_WakeUp) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_WAKEUP(USART_WakeUp)); 
   
  USARTx->CR1 &= CR1_WAKE_Mask; 
  USARTx->CR1 |= USART_WakeUp; 
} 
 
/** 
  * @brief  Determines if the USART is in mute mode or not. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param NewState: new state of the USART mute mode. 
  *   This parameter can be: ENABLE or DISABLE. 
  * @retval : None 
  */ 
void USART_ReceiverWakeUpCmd(USART_TypeDef* USARTx, FunctionalState NewState) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_FUNCTIONAL_STATE(NewState));  
   
  if (NewState != DISABLE) 
  { 
    /* Enable the USART mute mode  by setting the RWU bit in the CR1 register */ 
    USARTx->CR1 |= CR1_RWU_Set; 
  } 
  else 
  { 
    /* Disable the USART mute mode by clearing the RWU bit in the CR1 register */ 
    USARTx->CR1 &= CR1_RWU_Reset; 
  } 
} 
 
/** 
  * @brief  Sets the USART LIN Break detection length. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_LINBreakDetectLength: specifies the LIN break 
  *   detection length. 
  *   This parameter can be one of the following values: 
  * @arg USART_LINBreakDetectLength_10b: 10-bit break detection 
  * @arg USART_LINBreakDetectLength_11b: 11-bit break detection 
  * @retval : None 
  */ 
void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint16_t USART_LINBreakDetectLength) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_LIN_BREAK_DETECT_LENGTH(USART_LINBreakDetectLength)); 
   
  USARTx->CR2 &= CR2_LBDL_Mask; 
  USARTx->CR2 |= USART_LINBreakDetectLength;   
} 
 
/** 
  * @brief  Enables or disables the USARTís LIN mode. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param NewState: new state of the USART LIN mode. 
  *   This parameter can be: ENABLE or DISABLE. 
  * @retval : None 
  */ 
void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_FUNCTIONAL_STATE(NewState)); 
   
  if (NewState != DISABLE) 
  { 
    /* Enable the LIN mode by setting the LINEN bit in the CR2 register */ 
    USARTx->CR2 |= CR2_LINEN_Set; 
  } 
  else 
  { 
    /* Disable the LIN mode by clearing the LINEN bit in the CR2 register */ 
    USARTx->CR2 &= CR2_LINEN_Reset; 
  } 
} 
 
/** 
  * @brief  Transmits single data through the USARTx peripheral. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param Data: the data to transmit. 
  * @retval : None 
  */ 
void USART_SendData(USART_TypeDef* USARTx, uint16_t Data) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_DATA(Data));  
     
  /* Transmit Data */ 
  USARTx->DR = (Data & (uint16_t)0x01FF); 
} 
 
/** 
  * @brief  Returns the most recent received data by the USARTx peripheral. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @retval : The received data. 
  */ 
uint16_t USART_ReceiveData(USART_TypeDef* USARTx) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
   
  /* Receive Data */ 
  return (uint16_t)(USARTx->DR & (uint16_t)0x01FF); 
} 
 
/** 
  * @brief  Transmits break characters. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @retval : None 
  */ 
void USART_SendBreak(USART_TypeDef* USARTx) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
   
  /* Send break characters */ 
  USARTx->CR1 |= CR1_SBK_Set; 
} 
 
/** 
  * @brief  Sets the specified USART guard time. 
  * @param USARTx: where x can be 1, 2 or 3 to select the USART 
  *   peripheral. 
  * @param USART_GuardTime: specifies the guard time. 
  * @note The guard time bits are not available for UART4 and UART5.    
  * @retval : None 
  */ 
void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime) 
{     
  /* Check the parameters */ 
  assert_param(IS_USART_123_PERIPH(USARTx)); 
   
  /* Clear the USART Guard time */ 
  USARTx->GTPR &= GTPR_LSB_Mask; 
  /* Set the USART guard time */ 
  USARTx->GTPR |= (uint16_t)((uint16_t)USART_GuardTime << 0x08); 
} 
 
/** 
  * @brief  Sets the system clock prescaler. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_Prescaler: specifies the prescaler clock.   
  * @note The function is used for IrDA mode with UART4 and UART5. 
   * @retval : None 
  */ 
void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler) 
{  
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
   
  /* Clear the USART prescaler */ 
  USARTx->GTPR &= GTPR_MSB_Mask; 
  /* Set the USART prescaler */ 
  USARTx->GTPR |= USART_Prescaler; 
} 
 
/** 
  * @brief  Enables or disables the USARTís Smart Card mode. 
  * @param USARTx: where x can be 1, 2 or 3 to select the USART 
  *   peripheral. 
  * @param NewState: new state of the Smart Card mode. 
  *   This parameter can be: ENABLE or DISABLE.      
  * @note The Smart Card mode is not available for UART4 and UART5.  
  * @retval : None 
  */ 
void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_123_PERIPH(USARTx)); 
  assert_param(IS_FUNCTIONAL_STATE(NewState)); 
  if (NewState != DISABLE) 
  { 
    /* Enable the SC mode by setting the SCEN bit in the CR3 register */ 
    USARTx->CR3 |= CR3_SCEN_Set; 
  } 
  else 
  { 
    /* Disable the SC mode by clearing the SCEN bit in the CR3 register */ 
    USARTx->CR3 &= CR3_SCEN_Reset; 
  } 
} 
 
/** 
  * @brief  Enables or disables NACK transmission. 
  * @param USARTx: where x can be 1, 2 or 3 to select the USART 
  *   peripheral.  
  * @param NewState: new state of the NACK transmission. 
  *   This parameter can be: ENABLE or DISABLE.   
  * @note The Smart Card mode is not available for UART4 and UART5. 
  * @retval : None 
  */ 
void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_123_PERIPH(USARTx));   
  assert_param(IS_FUNCTIONAL_STATE(NewState)); 
  if (NewState != DISABLE) 
  { 
    /* Enable the NACK transmission by setting the NACK bit in the CR3 register */ 
    USARTx->CR3 |= CR3_NACK_Set; 
  } 
  else 
  { 
    /* Disable the NACK transmission by clearing the NACK bit in the CR3 register */ 
    USARTx->CR3 &= CR3_NACK_Reset; 
  } 
} 
 
/** 
  * @brief  Enables or disables the USARTís Half Duplex communication. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param NewState: new state of the USART Communication. 
  *   This parameter can be: ENABLE or DISABLE. 
  * @retval : None 
  */ 
void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_FUNCTIONAL_STATE(NewState)); 
   
  if (NewState != DISABLE) 
  { 
    /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */ 
    USARTx->CR3 |= CR3_HDSEL_Set; 
  } 
  else 
  { 
    /* Disable the Half-Duplex mode by clearing the HDSEL bit in the CR3 register */ 
    USARTx->CR3 &= CR3_HDSEL_Reset; 
  } 
} 
 
/** 
  * @brief  Configures the USARTís IrDA interface. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_IrDAMode: specifies the IrDA mode. 
  *   This parameter can be one of the following values: 
  * @arg USART_IrDAMode_LowPower 
  * @arg USART_IrDAMode_Normal 
  * @retval : None 
  */ 
void USART_IrDAConfig(USART_TypeDef* USARTx, uint16_t USART_IrDAMode) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_IRDA_MODE(USART_IrDAMode)); 
     
  USARTx->CR3 &= CR3_IRLP_Mask; 
  USARTx->CR3 |= USART_IrDAMode; 
} 
 
/** 
  * @brief  Enables or disables the USARTís IrDA interface. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param NewState: new state of the IrDA mode. 
  *   This parameter can be: ENABLE or DISABLE. 
  * @retval : None 
  */ 
void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_FUNCTIONAL_STATE(NewState)); 
     
  if (NewState != DISABLE) 
  { 
    /* Enable the IrDA mode by setting the IREN bit in the CR3 register */ 
    USARTx->CR3 |= CR3_IREN_Set; 
  } 
  else 
  { 
    /* Disable the IrDA mode by clearing the IREN bit in the CR3 register */ 
    USARTx->CR3 &= CR3_IREN_Reset; 
  } 
} 
 
/** 
  * @brief  Checks whether the specified USART flag is set or not. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_FLAG: specifies the flag to check. 
  *   This parameter can be one of the following values: 
  * @arg USART_FLAG_CTS:  CTS Change flag (not available for UART4 and UART5) 
  * @arg USART_FLAG_LBD:  LIN Break detection flag 
  * @arg USART_FLAG_TXE:  Transmit data register empty flag 
  * @arg USART_FLAG_TC:   Transmission Complete flag 
  * @arg USART_FLAG_RXNE: Receive data register not empty flag 
  * @arg USART_FLAG_IDLE: Idle Line detection flag 
  * @arg USART_FLAG_ORE:  OverRun Error flag 
  * @arg USART_FLAG_NE:   Noise Error flag 
  * @arg USART_FLAG_FE:   Framing Error flag 
  * @arg USART_FLAG_PE:   Parity Error flag 
  * @retval : The new state of USART_FLAG (SET or RESET). 
  */ 
FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG) 
{ 
  FlagStatus bitstatus = RESET; 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_FLAG(USART_FLAG)); 
  assert_param(IS_USART_PERIPH_FLAG(USARTx, USART_FLAG)); /* The CTS flag is not available for UART4 and UART5 */    
  if ((USARTx->SR & USART_FLAG) != (uint16_t)RESET) 
  { 
    bitstatus = SET; 
  } 
  else 
  { 
    bitstatus = RESET; 
  } 
  return bitstatus; 
} 
 
/** 
  * @brief  Clears the USARTx's pending flags. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_FLAG: specifies the flag to clear. 
  *   This parameter can be any combination of the following values: 
  * @arg USART_FLAG_CTS:  CTS Change flag (not available for UART4 and UART5). 
  * @arg USART_FLAG_LBD:  LIN Break detection flag. 
  * @arg USART_FLAG_TC:   Transmission Complete flag. 
  * @arg USART_FLAG_RXNE: Receive data register not empty flag. 
  *    
  * @note 
  *   - PE (Parity error), FE (Framing error), NE (Noise error), ORE (OverRun  
  *     error) and IDLE (Idle line detected) flags are cleared by software  
  *     sequence: a read operation to USART_SR register (USART_GetFlagStatus())  
  *     followed by a read operation to USART_DR register (USART_ReceiveData()). 
  *   - RXNE flag can be also cleared by a read to the USART_DR register  
  *     (USART_ReceiveData()). 
  *   - TC flag can be also cleared by software sequence: a read operation to  
  *     USART_SR register (USART_GetFlagStatus()) followed by a write operation 
  *     to USART_DR register (USART_SendData()). 
  *   - TXE flag is cleared only by a write to the USART_DR register  
  *     (USART_SendData()). 
  * @retval : None 
  */ 
void USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG) 
{ 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_CLEAR_FLAG(USART_FLAG)); 
  assert_param(IS_USART_PERIPH_FLAG(USARTx, USART_FLAG)); /* The CTS flag is not available for UART4 and UART5 */    
    
  USARTx->SR = (uint16_t)~USART_FLAG; 
} 
 
/** 
  * @brief  Checks whether the specified USART interrupt has occurred or not. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_IT: specifies the USART interrupt source to check. 
  *   This parameter can be one of the following values: 
  * @arg USART_IT_CTS:  CTS change interrupt (not available for UART4 and UART5) 
  * @arg USART_IT_LBD:  LIN Break detection interrupt 
  * @arg USART_IT_TXE:  Tansmit Data Register empty interrupt 
  * @arg USART_IT_TC:   Transmission complete interrupt 
  * @arg USART_IT_RXNE: Receive Data register not empty interrupt 
  * @arg USART_IT_IDLE: Idle line detection interrupt 
  * @arg USART_IT_ORE:  OverRun Error interrupt 
  * @arg USART_IT_NE:   Noise Error interrupt 
  * @arg USART_IT_FE:   Framing Error interrupt 
  * @arg USART_IT_PE:   Parity Error interrupt 
  * @retval : The new state of USART_IT (SET or RESET). 
  */ 
ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT) 
{ 
  uint32_t bitpos = 0x00, itmask = 0x00, usartreg = 0x00; 
  ITStatus bitstatus = RESET; 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_GET_IT(USART_IT)); 
  assert_param(IS_USART_PERIPH_IT(USARTx, USART_IT)); /* The CTS interrupt is not available for UART4 and UART5 */   
   
  /* Get the USART register index */ 
  usartreg = (((uint8_t)USART_IT) >> 0x05); 
  /* Get the interrupt position */ 
  itmask = USART_IT & IT_Mask; 
  itmask = (uint32_t)0x01 << itmask; 
   
  if (usartreg == 0x01) /* The IT  is in CR1 register */ 
  { 
    itmask &= USARTx->CR1; 
  } 
  else if (usartreg == 0x02) /* The IT  is in CR2 register */ 
  { 
    itmask &= USARTx->CR2; 
  } 
  else /* The IT  is in CR3 register */ 
  { 
    itmask &= USARTx->CR3; 
  } 
   
  bitpos = USART_IT >> 0x08; 
  bitpos = (uint32_t)0x01 << bitpos; 
  bitpos &= USARTx->SR; 
  if ((itmask != (uint16_t)RESET)&&(bitpos != (uint16_t)RESET)) 
  { 
    bitstatus = SET; 
  } 
  else 
  { 
    bitstatus = RESET; 
  } 
   
  return bitstatus;   
} 
 
/** 
  * @brief  Clears the USARTxís interrupt pending bits. 
  * @param USARTx: Select the USART or the UART peripheral.  
  *   This parameter can be one of the following values: 
  *   USART1, USART2, USART3, UART4 or UART5. 
  * @param USART_IT: specifies the interrupt pending bit to clear. 
  *   This parameter can be one of the following values: 
  * @arg USART_IT_CTS:  CTS change interrupt (not available for UART4 and UART5) 
  * @arg USART_IT_LBD:  LIN Break detection interrupt 
  * @arg USART_IT_TC:   Transmission complete interrupt.  
  * @arg USART_IT_RXNE: Receive Data register not empty interrupt. 
  *    
  * @note 
  *   - PE (Parity error), FE (Framing error), NE (Noise error), ORE (OverRun  
  *     error) and IDLE (Idle line detected) pending bits are cleared by  
  *     software sequence: a read operation to USART_SR register  
  *     (USART_GetITStatus()) followed by a read operation to USART_DR register  
  *     (USART_ReceiveData()). 
  *   - RXNE pending bit can be also cleared by a read to the USART_DR register  
  *     (USART_ReceiveData()). 
  *   - TC pending bit can be also cleared by software sequence: a read  
  *     operation to USART_SR register (USART_GetITStatus()) followed by a write  
  *     operation to USART_DR register (USART_SendData()). 
  *   - TXE pending bit is cleared only by a write to the USART_DR register  
  *     (USART_SendData()). 
  * @retval : None 
  */ 
void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT) 
{ 
  uint16_t bitpos = 0x00, itmask = 0x00; 
  /* Check the parameters */ 
  assert_param(IS_USART_ALL_PERIPH(USARTx)); 
  assert_param(IS_USART_CLEAR_IT(USART_IT)); 
  assert_param(IS_USART_PERIPH_IT(USARTx, USART_IT)); /* The CTS interrupt is not available for UART4 and UART5 */ 
   
  bitpos = USART_IT >> 0x08; 
  itmask = (uint16_t)((uint16_t)0x01 << bitpos); 
  USARTx->SR = (uint16_t)~itmask; 
} 
/** 
  * @} 
  */ 
 
/** 
  * @} 
  */ 
 
/** 
  * @} 
  */ 
 
/******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE****/