/******************** (C) COPYRIGHT 2008 STMicroelectronics ******************** | |
* File Name : stm32f10x_usart.c | |
* Author : MCD Application Team | |
* Version : V2.0.1 | |
* Date : 06/13/2008 | |
* Description : This file provides all the USART firmware functions. | |
******************************************************************************** | |
* 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. | |
*******************************************************************************/ | |
/* Includes ------------------------------------------------------------------*/ | |
#include "stm32f10x_usart.h" | |
#include "stm32f10x_rcc.h" | |
/* Private typedef -----------------------------------------------------------*/ | |
/* Private define ------------------------------------------------------------*/ | |
/* USART UE Mask */ | |
#define CR1_UE_Set ((u16)0x2000) /* USART Enable Mask */ | |
#define CR1_UE_Reset ((u16)0xDFFF) /* USART Disable Mask */ | |
/* USART WakeUp Method */ | |
#define CR1_WAKE_Mask ((u16)0xF7FF) /* USART WakeUp Method Mask */ | |
/* USART RWU Mask */ | |
#define CR1_RWU_Set ((u16)0x0002) /* USART mute mode Enable Mask */ | |
#define CR1_RWU_Reset ((u16)0xFFFD) /* USART mute mode Enable Mask */ | |
#define CR1_SBK_Set ((u16)0x0001) /* USART Break Character send Mask */ | |
#define CR1_CLEAR_Mask ((u16)0xE9F3) /* USART CR1 Mask */ | |
#define CR2_Address_Mask ((u16)0xFFF0) /* USART address Mask */ | |
/* USART LIN Mask */ | |
#define CR2_LINEN_Set ((u16)0x4000) /* USART LIN Enable Mask */ | |
#define CR2_LINEN_Reset ((u16)0xBFFF) /* USART LIN Disable Mask */ | |
/* USART LIN Break detection */ | |
#define CR2_LBDL_Mask ((u16)0xFFDF) /* USART LIN Break detection Mask */ | |
#define CR2_STOP_CLEAR_Mask ((u16)0xCFFF) /* USART CR2 STOP Bits Mask */ | |
#define CR2_CLOCK_CLEAR_Mask ((u16)0xF0FF) /* USART CR2 Clock Mask */ | |
/* USART SC Mask */ | |
#define CR3_SCEN_Set ((u16)0x0020) /* USART SC Enable Mask */ | |
#define CR3_SCEN_Reset ((u16)0xFFDF) /* USART SC Disable Mask */ | |
/* USART SC NACK Mask */ | |
#define CR3_NACK_Set ((u16)0x0010) /* USART SC NACK Enable Mask */ | |
#define CR3_NACK_Reset ((u16)0xFFEF) /* USART SC NACK Disable Mask */ | |
/* USART Half-Duplex Mask */ | |
#define CR3_HDSEL_Set ((u16)0x0008) /* USART Half-Duplex Enable Mask */ | |
#define CR3_HDSEL_Reset ((u16)0xFFF7) /* USART Half-Duplex Disable Mask */ | |
/* USART IrDA Mask */ | |
#define CR3_IRLP_Mask ((u16)0xFFFB) /* USART IrDA LowPower mode Mask */ | |
#define CR3_CLEAR_Mask ((u16)0xFCFF) /* USART CR3 Mask */ | |
/* USART IrDA Mask */ | |
#define CR3_IREN_Set ((u16)0x0002) /* USART IrDA Enable Mask */ | |
#define CR3_IREN_Reset ((u16)0xFFFD) /* USART IrDA Disable Mask */ | |
#define GTPR_LSB_Mask ((u16)0x00FF) /* Guard Time Register LSB Mask */ | |
#define GTPR_MSB_Mask ((u16)0xFF00) /* Guard Time Register MSB Mask */ | |
#define IT_Mask ((u16)0x001F) /* USART Interrupt Mask */ | |
/* Private macro -------------------------------------------------------------*/ | |
/* Private variables ---------------------------------------------------------*/ | |
/* Private function prototypes -----------------------------------------------*/ | |
/* Private functions ---------------------------------------------------------*/ | |
/******************************************************************************* | |
* Function Name : USART_DeInit | |
* Description : Deinitializes the USARTx peripheral registers to their | |
* default reset values. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_DeInit(USART_TypeDef* USARTx) | |
{ | |
/* Check the parameters */ | |
assert_param(IS_USART_ALL_PERIPH(USARTx)); | |
switch (*(u32*)&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; | |
} | |
} | |
/******************************************************************************* | |
* Function Name : USART_Init | |
* Description : Initializes the USARTx peripheral according to the specified | |
* parameters in the USART_InitStruct . | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - USART_InitStruct: pointer to a USART_InitTypeDef structure | |
* that contains the configuration information for the | |
* specified USART peripheral. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct) | |
{ | |
u32 tmpreg = 0x00, apbclock = 0x00; | |
u32 integerdivider = 0x00; | |
u32 fractionaldivider = 0x00; | |
u32 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 = (*(u32*)&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 |= (u32)USART_InitStruct->USART_StopBits; | |
/* Write to USART CR2 */ | |
USARTx->CR2 = (u16)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 |= (u32)USART_InitStruct->USART_WordLength | USART_InitStruct->USART_Parity | | |
USART_InitStruct->USART_Mode; | |
/* Write to USART CR1 */ | |
USARTx->CR1 = (u16)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 = (u16)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)) & ((u8)0x0F); | |
/* Write to USART BRR */ | |
USARTx->BRR = (u16)tmpreg; | |
} | |
/******************************************************************************* | |
* Function Name : USART_StructInit | |
* Description : Fills each USART_InitStruct member with its default value. | |
* Input : - USART_InitStruct: pointer to a USART_InitTypeDef structure | |
* which will be initialized. | |
* Output : None | |
* Return : 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; | |
} | |
/******************************************************************************* | |
* Function Name : USART_ClockInit | |
* Description : Initializes the USARTx peripheral Clock according to the | |
* specified parameters in the USART_ClockInitStruct . | |
* Input : - USARTx: where x can be 1, 2, 3 to select the USART peripheral. | |
* Note: The Smart Card mode is not available for UART4 and UART5. | |
* - USART_ClockInitStruct: pointer to a USART_ClockInitTypeDef | |
* structure that contains the configuration information for | |
* the specified USART peripheral. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct) | |
{ | |
u32 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 |= (u32)USART_ClockInitStruct->USART_Clock | USART_ClockInitStruct->USART_CPOL | | |
USART_ClockInitStruct->USART_CPHA | USART_ClockInitStruct->USART_LastBit; | |
/* Write to USART CR2 */ | |
USARTx->CR2 = (u16)tmpreg; | |
} | |
/******************************************************************************* | |
* Function Name : USART_ClockStructInit | |
* Description : Fills each USART_ClockInitStruct member with its default value. | |
* Input : - USART_ClockInitStruct: pointer to a USART_ClockInitTypeDef | |
* structure which will be initialized. | |
* Output : None | |
* Return : 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; | |
} | |
/******************************************************************************* | |
* Function Name : USART_Cmd | |
* Description : Enables or disables the specified USART peripheral. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* : - NewState: new state of the USARTx peripheral. | |
* This parameter can be: ENABLE or DISABLE. | |
* Output : None | |
* Return : 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; | |
} | |
} | |
/******************************************************************************* | |
* Function Name : USART_ITConfig | |
* Description : Enables or disables the specified USART interrupts. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - USART_IT: specifies the USART interrupt sources to be | |
* enabled or disabled. | |
* This parameter can be one of the following values: | |
* - USART_IT_CTS: CTS change interrupt (not available for | |
* UART4 and UART5) | |
* - USART_IT_LBD: LIN Break detection interrupt | |
* - USART_IT_TXE: Tansmit Data Register empty interrupt | |
* - USART_IT_TC: Transmission complete interrupt | |
* - USART_IT_RXNE: Receive Data register not empty | |
* interrupt | |
* - USART_IT_IDLE: Idle line detection interrupt | |
* - USART_IT_PE: Parity Error interrupt | |
* - USART_IT_ERR: Error interrupt(Frame error, noise | |
* error, overrun error) | |
* - NewState: new state of the specified USARTx interrupts. | |
* This parameter can be: ENABLE or DISABLE. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_ITConfig(USART_TypeDef* USARTx, u16 USART_IT, FunctionalState NewState) | |
{ | |
u32 usartreg = 0x00, itpos = 0x00, itmask = 0x00; | |
u32 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 = (*(u32*)&(USARTx)); | |
/* Get the USART register index */ | |
usartreg = (((u8)USART_IT) >> 0x05); | |
/* Get the interrupt position */ | |
itpos = USART_IT & IT_Mask; | |
itmask = (((u32)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) | |
{ | |
*(vu32*)usartxbase |= itmask; | |
} | |
else | |
{ | |
*(vu32*)usartxbase &= ~itmask; | |
} | |
} | |
/******************************************************************************* | |
* Function Name : USART_DMACmd | |
* Description : Enables or disables the USARTs DMA interface. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3 or UART4. | |
* Note: The DMA mode is not available for UART5. | |
* - USART_DMAReq: specifies the DMA request. | |
* This parameter can be any combination of the following values: | |
* - USART_DMAReq_Tx: USART DMA transmit request | |
* - USART_DMAReq_Rx: USART DMA receive request | |
* - NewState: new state of the DMA Request sources. | |
* This parameter can be: ENABLE or DISABLE. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_DMACmd(USART_TypeDef* USARTx, u16 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 &= (u16)~USART_DMAReq; | |
} | |
} | |
/******************************************************************************* | |
* Function Name : USART_SetAddress | |
* Description : Sets the address of the USART node. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - USART_Address: Indicates the address of the USART node. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_SetAddress(USART_TypeDef* USARTx, u8 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; | |
} | |
/******************************************************************************* | |
* Function Name : USART_WakeUpConfig | |
* Description : Selects the USART WakeUp method. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - USART_WakeUp: specifies the USART wakeup method. | |
* This parameter can be one of the following values: | |
* - USART_WakeUp_IdleLine: WakeUp by an idle line detection | |
* - USART_WakeUp_AddressMark: WakeUp by an address mark | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_WakeUpConfig(USART_TypeDef* USARTx, u16 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; | |
} | |
/******************************************************************************* | |
* Function Name : USART_ReceiverWakeUpCmd | |
* Description : Determines if the USART is in mute mode or not. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - NewState: new state of the USART mute mode. | |
* This parameter can be: ENABLE or DISABLE. | |
* Output : None | |
* Return : 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; | |
} | |
} | |
/******************************************************************************* | |
* Function Name : USART_LINBreakDetectLengthConfig | |
* Description : Sets the USART LIN Break detection length. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - USART_LINBreakDetectLength: specifies the LIN break | |
* detection length. | |
* This parameter can be one of the following values: | |
* - USART_LINBreakDetectLength_10b: 10-bit break detection | |
* - USART_LINBreakDetectLength_11b: 11-bit break detection | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, u16 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; | |
} | |
/******************************************************************************* | |
* Function Name : USART_LINCmd | |
* Description : Enables or disables the USARTs LIN mode. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - NewState: new state of the USART LIN mode. | |
* This parameter can be: ENABLE or DISABLE. | |
* Output : None | |
* Return : 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; | |
} | |
} | |
/******************************************************************************* | |
* Function Name : USART_SendData | |
* Description : Transmits single data through the USARTx peripheral. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - Data: the data to transmit. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_SendData(USART_TypeDef* USARTx, u16 Data) | |
{ | |
/* Check the parameters */ | |
assert_param(IS_USART_ALL_PERIPH(USARTx)); | |
assert_param(IS_USART_DATA(Data)); | |
/* Transmit Data */ | |
USARTx->DR = (Data & (u16)0x01FF); | |
} | |
/******************************************************************************* | |
* Function Name : USART_ReceiveData | |
* Description : Returns the most recent received data by the USARTx peripheral. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* Output : None | |
* Return : The received data. | |
*******************************************************************************/ | |
u16 USART_ReceiveData(USART_TypeDef* USARTx) | |
{ | |
/* Check the parameters */ | |
assert_param(IS_USART_ALL_PERIPH(USARTx)); | |
/* Receive Data */ | |
return (u16)(USARTx->DR & (u16)0x01FF); | |
} | |
/******************************************************************************* | |
* Function Name : USART_SendBreak | |
* Description : Transmits break characters. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* Output : None | |
* Return : 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; | |
} | |
/******************************************************************************* | |
* Function Name : USART_SetGuardTime | |
* Description : Sets the specified USART guard time. | |
* Input : - USARTx: where x can be 1, 2 or 3 to select the USART | |
* peripheral. | |
* Note: The guard time bits are not available for UART4 and UART5. | |
* - USART_GuardTime: specifies the guard time. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_SetGuardTime(USART_TypeDef* USARTx, u8 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 |= (u16)((u16)USART_GuardTime << 0x08); | |
} | |
/******************************************************************************* | |
* Function Name : USART_SetPrescaler | |
* Description : Sets the system clock prescaler. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* Note: The function is used for IrDA mode with UART4 and UART5. | |
* - USART_Prescaler: specifies the prescaler clock. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_SetPrescaler(USART_TypeDef* USARTx, u8 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; | |
} | |
/******************************************************************************* | |
* Function Name : USART_SmartCardCmd | |
* Description : Enables or disables the USARTs Smart Card mode. | |
* Input : - USARTx: where x can be 1, 2 or 3 to select the USART | |
* peripheral. | |
* Note: The Smart Card mode is not available for UART4 and UART5. | |
* - NewState: new state of the Smart Card mode. | |
* This parameter can be: ENABLE or DISABLE. | |
* Output : None | |
* Return : 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; | |
} | |
} | |
/******************************************************************************* | |
* Function Name : USART_SmartCardNACKCmd | |
* Description : Enables or disables NACK transmission. | |
* Input : - USARTx: where x can be 1, 2 or 3 to select the USART | |
* peripheral. | |
* Note: The Smart Card mode is not available for UART4 and UART5. | |
* - NewState: new state of the NACK transmission. | |
* This parameter can be: ENABLE or DISABLE. | |
* Output : None | |
* Return : 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; | |
} | |
} | |
/******************************************************************************* | |
* Function Name : USART_HalfDuplexCmd | |
* Description : Enables or disables the USARTs Half Duplex communication. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - NewState: new state of the USART Communication. | |
* This parameter can be: ENABLE or DISABLE. | |
* Output : None | |
* Return : 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; | |
} | |
} | |
/******************************************************************************* | |
* Function Name : USART_IrDAConfig | |
* Description : Configures the USARTs IrDA interface. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - USART_IrDAMode: specifies the IrDA mode. | |
* This parameter can be one of the following values: | |
* - USART_IrDAMode_LowPower | |
* - USART_IrDAMode_Normal | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_IrDAConfig(USART_TypeDef* USARTx, u16 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; | |
} | |
/******************************************************************************* | |
* Function Name : USART_IrDACmd | |
* Description : Enables or disables the USARTs IrDA interface. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - NewState: new state of the IrDA mode. | |
* This parameter can be: ENABLE or DISABLE. | |
* Output : None | |
* Return : 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; | |
} | |
} | |
/******************************************************************************* | |
* Function Name : USART_GetFlagStatus | |
* Description : Checks whether the specified USART flag is set or not. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - USART_FLAG: specifies the flag to check. | |
* This parameter can be one of the following values: | |
* - USART_FLAG_CTS: CTS Change flag (not available for | |
* UART4 and UART5) | |
* - USART_FLAG_LBD: LIN Break detection flag | |
* - USART_FLAG_TXE: Transmit data register empty flag | |
* - USART_FLAG_TC: Transmission Complete flag | |
* - USART_FLAG_RXNE: Receive data register not empty flag | |
* - USART_FLAG_IDLE: Idle Line detection flag | |
* - USART_FLAG_ORE: OverRun Error flag | |
* - USART_FLAG_NE: Noise Error flag | |
* - USART_FLAG_FE: Framing Error flag | |
* - USART_FLAG_PE: Parity Error flag | |
* Output : None | |
* Return : The new state of USART_FLAG (SET or RESET). | |
*******************************************************************************/ | |
FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, u16 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) != (u16)RESET) | |
{ | |
bitstatus = SET; | |
} | |
else | |
{ | |
bitstatus = RESET; | |
} | |
return bitstatus; | |
} | |
/******************************************************************************* | |
* Function Name : USART_ClearFlag | |
* Description : Clears the USARTx's pending flags. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - USART_FLAG: specifies the flag to clear. | |
* This parameter can be any combination of the following values: | |
* - USART_FLAG_CTS: CTS Change flag (not available for | |
* UART4 and UART5). | |
* - USART_FLAG_LBD: LIN Break detection flag. | |
* - USART_FLAG_TC: Transmission Complete flag. | |
* - USART_FLAG_RXNE: Receive data register not empty flag. | |
* - USART_FLAG_IDLE: Idle Line detection flag. | |
* - USART_FLAG_ORE: OverRun Error flag. | |
* - USART_FLAG_NE: Noise Error flag. | |
* - USART_FLAG_FE: Framing Error flag. | |
* - USART_FLAG_PE: Parity Error flag. | |
* | |
* Note: - For IDLE, ORE, NE, FE and PE flags user has to read | |
* the USART DR register after calling this function. | |
* - TXE flag can't be cleared by this function, it's | |
* cleared only by a write to the USART DR register. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_ClearFlag(USART_TypeDef* USARTx, u16 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 = (u16)~USART_FLAG; | |
} | |
/******************************************************************************* | |
* Function Name : USART_GetITStatus | |
* Description : Checks whether the specified USART interrupt has occurred or not. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - USART_IT: specifies the USART interrupt source to check. | |
* This parameter can be one of the following values: | |
* - USART_IT_CTS: CTS change interrupt (not available for | |
* UART4 and UART5) | |
* - USART_IT_LBD: LIN Break detection interrupt | |
* - USART_IT_TXE: Tansmit Data Register empty interrupt | |
* - USART_IT_TC: Transmission complete interrupt | |
* - USART_IT_RXNE: Receive Data register not empty | |
* interrupt | |
* - USART_IT_IDLE: Idle line detection interrupt | |
* - USART_IT_ORE: OverRun Error interrupt | |
* - USART_IT_NE: Noise Error interrupt | |
* - USART_IT_FE: Framing Error interrupt | |
* - USART_IT_PE: Parity Error interrupt | |
* Output : None | |
* Return : The new state of USART_IT (SET or RESET). | |
*******************************************************************************/ | |
ITStatus USART_GetITStatus(USART_TypeDef* USARTx, u16 USART_IT) | |
{ | |
u32 bitpos = 0x00, itmask = 0x00, usartreg = 0x00; | |
ITStatus bitstatus = RESET; | |
/* Check the parameters */ | |
assert_param(IS_USART_ALL_PERIPH(USARTx)); | |
assert_param(IS_USART_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 = (((u8)USART_IT) >> 0x05); | |
/* Get the interrupt position */ | |
itmask = USART_IT & IT_Mask; | |
itmask = (u32)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 = (u32)0x01 << bitpos; | |
bitpos &= USARTx->SR; | |
if ((itmask != (u16)RESET)&&(bitpos != (u16)RESET)) | |
{ | |
bitstatus = SET; | |
} | |
else | |
{ | |
bitstatus = RESET; | |
} | |
return bitstatus; | |
} | |
/******************************************************************************* | |
* Function Name : USART_ClearITPendingBit | |
* Description : Clears the USARTxs interrupt pending bits. | |
* Input : - USARTx: Select the USART or the UART peripheral. | |
* This parameter can be one of the following values: | |
* - USART1, USART2, USART3, UART4 or UART5. | |
* - USART_IT: specifies the interrupt pending bit to clear. | |
* This parameter can be one of the following values: | |
* - USART_IT_CTS: CTS change interrupt (not available for | |
* UART4 and UART5) | |
* - USART_IT_LBD: LIN Break detection interrupt | |
* - USART_IT_TC: Transmission complete interrupt. | |
* - USART_IT_RXNE: Receive Data register not empty interrupt. | |
* - USART_IT_IDLE: Idle line detection interrupt. | |
* - USART_IT_ORE: OverRun Error interrupt. | |
* - USART_IT_NE: Noise Error interrupt. | |
* - USART_IT_FE: Framing Error interrupt. | |
* - USART_IT_PE: Parity Error interrupt. | |
* | |
* Note: - For IDLE, ORE, NE, FE and PE pending bits user has to | |
* read the USART DR register after calling this function. | |
* - TXE pending bit can't be cleared by this function, it's | |
* cleared only by a write to the USART DR register. | |
* Output : None | |
* Return : None | |
*******************************************************************************/ | |
void USART_ClearITPendingBit(USART_TypeDef* USARTx, u16 USART_IT) | |
{ | |
u16 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 = (u16)((u16)0x01 << bitpos); | |
USARTx->SR = (u16)~itmask; | |
} | |
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/ |