2 ******************************************************************************
3 * @file stm32f30x_usart.c
4 * @author MCD Application Team
6 * @date 27-February-2014
7 * @brief This file provides firmware functions to manage the following
8 * functionalities of the Universal synchronous asynchronous receiver
10 * + Initialization and Configuration
14 * + Multi-Processor Communication
20 * + DMA transfers management
21 * + Interrupts and flags management
24 ===============================================================================
25 ##### How to use this driver #####
26 ===============================================================================
28 (#) Enable peripheral clock using RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE)
29 function for USART1 or using RCC_APB1PeriphClockCmd(RCC_APB1Periph_USARTx, ENABLE)
30 function for USART2, USART3, UART4 and UART5.
31 (#) According to the USART mode, enable the GPIO clocks using
32 RCC_AHBPeriphClockCmd() function. (The I/O can be TX, RX, CTS,
34 (#) Peripheral's alternate function:
35 (++) Connect the pin to the desired peripherals' Alternate
36 Function (AF) using GPIO_PinAFConfig() function.
37 (++) Configure the desired pin in alternate function by:
38 GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF.
39 (++) Select the type, pull-up/pull-down and output speed via
40 GPIO_PuPd, GPIO_OType and GPIO_Speed members.
41 (++) Call GPIO_Init() function.
42 (#) Program the Baud Rate, Word Length , Stop Bit, Parity, Hardware
43 flow control and Mode(Receiver/Transmitter) using the SPI_Init()
45 (#) For synchronous mode, enable the clock and program the polarity,
46 phase and last bit using the USART_ClockInit() function.
47 (#) Enable the USART using the USART_Cmd() function.
48 (#) Enable the NVIC and the corresponding interrupt using the function
49 USART_ITConfig() if you need to use interrupt mode.
50 (#) When using the DMA mode:
51 (++) Configure the DMA using DMA_Init() function.
52 (++) Activate the needed channel Request using USART_DMACmd() function.
53 (#) Enable the DMA using the DMA_Cmd() function, when using DMA mode.
55 Refer to Multi-Processor, LIN, half-duplex, Smartcard, IrDA sub-sections
60 ******************************************************************************
63 * <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
65 * Redistribution and use in source and binary forms, with or without modification,
66 * are permitted provided that the following conditions are met:
67 * 1. Redistributions of source code must retain the above copyright notice,
68 * this list of conditions and the following disclaimer.
69 * 2. Redistributions in binary form must reproduce the above copyright notice,
70 * this list of conditions and the following disclaimer in the documentation
71 * and/or other materials provided with the distribution.
72 * 3. Neither the name of STMicroelectronics nor the names of its contributors
73 * may be used to endorse or promote products derived from this software
74 * without specific prior written permission.
76 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
77 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
78 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
79 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
80 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
81 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
82 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
83 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
84 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
85 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
87 ******************************************************************************
90 /* Includes ------------------------------------------------------------------*/
91 #include "stm32f30x_usart.h"
92 #include "stm32f30x_rcc.h"
94 /** @addtogroup STM32F30x_StdPeriph_Driver
99 * @brief USART driver modules
103 /* Private typedef -----------------------------------------------------------*/
104 /* Private define ------------------------------------------------------------*/
106 /*!< USART CR1 register clear Mask ((~(uint32_t)0xFFFFE6F3)) */
107 #define CR1_CLEAR_MASK ((uint32_t)(USART_CR1_M | USART_CR1_PCE | \
108 USART_CR1_PS | USART_CR1_TE | \
111 /*!< USART CR2 register clock bits clear Mask ((~(uint32_t)0xFFFFF0FF)) */
112 #define CR2_CLOCK_CLEAR_MASK ((uint32_t)(USART_CR2_CLKEN | USART_CR2_CPOL | \
113 USART_CR2_CPHA | USART_CR2_LBCL))
115 /*!< USART CR3 register clear Mask ((~(uint32_t)0xFFFFFCFF)) */
116 #define CR3_CLEAR_MASK ((uint32_t)(USART_CR3_RTSE | USART_CR3_CTSE))
118 /*!< USART Interrupts mask */
119 #define IT_MASK ((uint32_t)0x000000FF)
121 /* Private macro -------------------------------------------------------------*/
122 /* Private variables ---------------------------------------------------------*/
123 /* Private function prototypes -----------------------------------------------*/
124 /* Private functions ---------------------------------------------------------*/
126 /** @defgroup USART_Private_Functions
130 /** @defgroup USART_Group1 Initialization and Configuration functions
131 * @brief Initialization and Configuration functions
134 ===============================================================================
135 ##### Initialization and Configuration functions #####
136 ===============================================================================
138 This subsection provides a set of functions allowing to initialize the USART
139 in asynchronous and in synchronous modes.
140 (+) For the asynchronous mode only these parameters can be configured:
144 (++) Parity: If the parity is enabled, then the MSB bit of the data written
145 in the data register is transmitted but is changed by the parity bit.
146 Depending on the frame length defined by the M bit (8-bits or 9-bits),
147 the possible USART frame formats are as listed in the following table:
149 +-------------------------------------------------------------+
150 | M bit | PCE bit | USART frame |
151 |---------------------|---------------------------------------|
152 | 0 | 0 | | SB | 8 bit data | STB | |
153 |---------|-----------|---------------------------------------|
154 | 0 | 1 | | SB | 7 bit data | PB | STB | |
155 |---------|-----------|---------------------------------------|
156 | 1 | 0 | | SB | 9 bit data | STB | |
157 |---------|-----------|---------------------------------------|
158 | 1 | 1 | | SB | 8 bit data | PB | STB | |
159 +-------------------------------------------------------------+
161 (++) Hardware flow control.
162 (++) Receiver/transmitter modes.
163 [..] The USART_Init() function follows the USART asynchronous configuration
164 procedure(details for the procedure are available in reference manual.
165 (+) For the synchronous mode in addition to the asynchronous mode parameters
166 these parameters should be also configured:
167 (++) USART Clock Enabled.
171 [..] These parameters can be configured using the USART_ClockInit() function.
178 * @brief Deinitializes the USARTx peripheral registers to their default reset values.
179 * @param USARTx: Select the USART peripheral. This parameter can be one of the
180 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
183 void USART_DeInit(USART_TypeDef* USARTx)
185 /* Check the parameters */
186 assert_param(IS_USART_ALL_PERIPH(USARTx));
188 if (USARTx == USART1)
190 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);
191 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE);
193 else if (USARTx == USART2)
195 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
196 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE);
198 else if (USARTx == USART3)
200 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE);
201 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, DISABLE);
203 else if (USARTx == UART4)
205 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE);
206 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, DISABLE);
212 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
213 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, DISABLE);
219 * @brief Initializes the USARTx peripheral according to the specified
220 * parameters in the USART_InitStruct .
221 * @param USARTx: Select the USART peripheral. This parameter can be one of the
222 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
223 * @param USART_InitStruct: pointer to a USART_InitTypeDef structure
224 * that contains the configuration information for the specified USART peripheral.
227 void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct)
229 uint32_t divider = 0, apbclock = 0, tmpreg = 0;
230 RCC_ClocksTypeDef RCC_ClocksStatus;
232 /* Check the parameters */
233 assert_param(IS_USART_ALL_PERIPH(USARTx));
234 assert_param(IS_USART_BAUDRATE(USART_InitStruct->USART_BaudRate));
235 assert_param(IS_USART_WORD_LENGTH(USART_InitStruct->USART_WordLength));
236 assert_param(IS_USART_STOPBITS(USART_InitStruct->USART_StopBits));
237 assert_param(IS_USART_PARITY(USART_InitStruct->USART_Parity));
238 assert_param(IS_USART_MODE(USART_InitStruct->USART_Mode));
239 assert_param(IS_USART_HARDWARE_FLOW_CONTROL(USART_InitStruct->USART_HardwareFlowControl));
242 USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_UE);
244 /*---------------------------- USART CR2 Configuration -----------------------*/
245 tmpreg = USARTx->CR2;
246 /* Clear STOP[13:12] bits */
247 tmpreg &= (uint32_t)~((uint32_t)USART_CR2_STOP);
249 /* Configure the USART Stop Bits, Clock, CPOL, CPHA and LastBit ------------*/
250 /* Set STOP[13:12] bits according to USART_StopBits value */
251 tmpreg |= (uint32_t)USART_InitStruct->USART_StopBits;
253 /* Write to USART CR2 */
254 USARTx->CR2 = tmpreg;
256 /*---------------------------- USART CR1 Configuration -----------------------*/
257 tmpreg = USARTx->CR1;
258 /* Clear M, PCE, PS, TE and RE bits */
259 tmpreg &= (uint32_t)~((uint32_t)CR1_CLEAR_MASK);
261 /* Configure the USART Word Length, Parity and mode ----------------------- */
262 /* Set the M bits according to USART_WordLength value */
263 /* Set PCE and PS bits according to USART_Parity value */
264 /* Set TE and RE bits according to USART_Mode value */
265 tmpreg |= (uint32_t)USART_InitStruct->USART_WordLength | USART_InitStruct->USART_Parity |
266 USART_InitStruct->USART_Mode;
268 /* Write to USART CR1 */
269 USARTx->CR1 = tmpreg;
271 /*---------------------------- USART CR3 Configuration -----------------------*/
272 tmpreg = USARTx->CR3;
273 /* Clear CTSE and RTSE bits */
274 tmpreg &= (uint32_t)~((uint32_t)CR3_CLEAR_MASK);
276 /* Configure the USART HFC -------------------------------------------------*/
277 /* Set CTSE and RTSE bits according to USART_HardwareFlowControl value */
278 tmpreg |= USART_InitStruct->USART_HardwareFlowControl;
280 /* Write to USART CR3 */
281 USARTx->CR3 = tmpreg;
283 /*---------------------------- USART BRR Configuration -----------------------*/
284 /* Configure the USART Baud Rate -------------------------------------------*/
285 RCC_GetClocksFreq(&RCC_ClocksStatus);
287 if (USARTx == USART1)
289 apbclock = RCC_ClocksStatus.USART1CLK_Frequency;
291 else if (USARTx == USART2)
293 apbclock = RCC_ClocksStatus.USART2CLK_Frequency;
295 else if (USARTx == USART3)
297 apbclock = RCC_ClocksStatus.USART3CLK_Frequency;
299 else if (USARTx == UART4)
301 apbclock = RCC_ClocksStatus.UART4CLK_Frequency;
305 apbclock = RCC_ClocksStatus.UART5CLK_Frequency;
308 /* Determine the integer part */
309 if ((USARTx->CR1 & USART_CR1_OVER8) != 0)
311 /* (divider * 10) computing in case Oversampling mode is 8 Samples */
312 divider = (uint32_t)((2 * apbclock) / (USART_InitStruct->USART_BaudRate));
313 tmpreg = (uint32_t)((2 * apbclock) % (USART_InitStruct->USART_BaudRate));
315 else /* if ((USARTx->CR1 & CR1_OVER8_Set) == 0) */
317 /* (divider * 10) computing in case Oversampling mode is 16 Samples */
318 divider = (uint32_t)((apbclock) / (USART_InitStruct->USART_BaudRate));
319 tmpreg = (uint32_t)((apbclock) % (USART_InitStruct->USART_BaudRate));
322 /* round the divider : if fractional part i greater than 0.5 increment divider */
323 if (tmpreg >= (USART_InitStruct->USART_BaudRate) / 2)
328 /* Implement the divider in case Oversampling mode is 8 Samples */
329 if ((USARTx->CR1 & USART_CR1_OVER8) != 0)
331 /* get the LSB of divider and shift it to the right by 1 bit */
332 tmpreg = (divider & (uint16_t)0x000F) >> 1;
334 /* update the divider value */
335 divider = (divider & (uint16_t)0xFFF0) | tmpreg;
338 /* Write to USART BRR */
339 USARTx->BRR = (uint16_t)divider;
343 * @brief Fills each USART_InitStruct member with its default value.
344 * @param USART_InitStruct: pointer to a USART_InitTypeDef structure
345 * which will be initialized.
348 void USART_StructInit(USART_InitTypeDef* USART_InitStruct)
350 /* USART_InitStruct members default value */
351 USART_InitStruct->USART_BaudRate = 9600;
352 USART_InitStruct->USART_WordLength = USART_WordLength_8b;
353 USART_InitStruct->USART_StopBits = USART_StopBits_1;
354 USART_InitStruct->USART_Parity = USART_Parity_No ;
355 USART_InitStruct->USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
356 USART_InitStruct->USART_HardwareFlowControl = USART_HardwareFlowControl_None;
360 * @brief Initializes the USARTx peripheral Clock according to the
361 * specified parameters in the USART_ClockInitStruct.
362 * @param USARTx: Select the USART peripheral. This parameter can be one of the
363 * following values: USART1 or USART2 or USART3.
364 * @param USART_ClockInitStruct: pointer to a USART_ClockInitTypeDef
365 * structure that contains the configuration information for the specified
369 void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct)
372 /* Check the parameters */
373 assert_param(IS_USART_123_PERIPH(USARTx));
374 assert_param(IS_USART_CLOCK(USART_ClockInitStruct->USART_Clock));
375 assert_param(IS_USART_CPOL(USART_ClockInitStruct->USART_CPOL));
376 assert_param(IS_USART_CPHA(USART_ClockInitStruct->USART_CPHA));
377 assert_param(IS_USART_LASTBIT(USART_ClockInitStruct->USART_LastBit));
378 /*---------------------------- USART CR2 Configuration -----------------------*/
379 tmpreg = USARTx->CR2;
380 /* Clear CLKEN, CPOL, CPHA, LBCL and SSM bits */
381 tmpreg &= (uint32_t)~((uint32_t)CR2_CLOCK_CLEAR_MASK);
382 /* Configure the USART Clock, CPOL, CPHA, LastBit and SSM ------------*/
383 /* Set CLKEN bit according to USART_Clock value */
384 /* Set CPOL bit according to USART_CPOL value */
385 /* Set CPHA bit according to USART_CPHA value */
386 /* Set LBCL bit according to USART_LastBit value */
387 tmpreg |= (uint32_t)(USART_ClockInitStruct->USART_Clock | USART_ClockInitStruct->USART_CPOL |
388 USART_ClockInitStruct->USART_CPHA | USART_ClockInitStruct->USART_LastBit);
389 /* Write to USART CR2 */
390 USARTx->CR2 = tmpreg;
394 * @brief Fills each USART_ClockInitStruct member with its default value.
395 * @param USART_ClockInitStruct: pointer to a USART_ClockInitTypeDef
396 * structure which will be initialized.
399 void USART_ClockStructInit(USART_ClockInitTypeDef* USART_ClockInitStruct)
401 /* USART_ClockInitStruct members default value */
402 USART_ClockInitStruct->USART_Clock = USART_Clock_Disable;
403 USART_ClockInitStruct->USART_CPOL = USART_CPOL_Low;
404 USART_ClockInitStruct->USART_CPHA = USART_CPHA_1Edge;
405 USART_ClockInitStruct->USART_LastBit = USART_LastBit_Disable;
409 * @brief Enables or disables the specified USART peripheral.
410 * @param USARTx: Select the USART peripheral. This parameter can be one of the
411 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
412 * @param NewState: new state of the USARTx peripheral.
413 * This parameter can be: ENABLE or DISABLE.
416 void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState)
418 /* Check the parameters */
419 assert_param(IS_USART_ALL_PERIPH(USARTx));
420 assert_param(IS_FUNCTIONAL_STATE(NewState));
422 if (NewState != DISABLE)
424 /* Enable the selected USART by setting the UE bit in the CR1 register */
425 USARTx->CR1 |= USART_CR1_UE;
429 /* Disable the selected USART by clearing the UE bit in the CR1 register */
430 USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_UE);
435 * @brief Enables or disables the USART's transmitter or receiver.
436 * @param USARTx: Select the USART peripheral. This parameter can be one of the
437 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
438 * @param USART_Direction: specifies the USART direction.
439 * This parameter can be any combination of the following values:
440 * @arg USART_Mode_Tx: USART Transmitter
441 * @arg USART_Mode_Rx: USART Receiver
442 * @param NewState: new state of the USART transfer direction.
443 * This parameter can be: ENABLE or DISABLE.
446 void USART_DirectionModeCmd(USART_TypeDef* USARTx, uint32_t USART_DirectionMode, FunctionalState NewState)
448 /* Check the parameters */
449 assert_param(IS_USART_ALL_PERIPH(USARTx));
450 assert_param(IS_USART_MODE(USART_DirectionMode));
451 assert_param(IS_FUNCTIONAL_STATE(NewState));
453 if (NewState != DISABLE)
455 /* Enable the USART's transfer interface by setting the TE and/or RE bits
456 in the USART CR1 register */
457 USARTx->CR1 |= USART_DirectionMode;
461 /* Disable the USART's transfer interface by clearing the TE and/or RE bits
462 in the USART CR3 register */
463 USARTx->CR1 &= (uint32_t)~USART_DirectionMode;
468 * @brief Enables or disables the USART's 8x oversampling mode.
469 * @param USARTx: Select the USART peripheral. This parameter can be one of the
470 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
471 * @param NewState: new state of the USART 8x oversampling mode.
472 * This parameter can be: ENABLE or DISABLE.
474 * This function has to be called before calling USART_Init()
475 * function in order to have correct baudrate Divider value.
478 void USART_OverSampling8Cmd(USART_TypeDef* USARTx, FunctionalState NewState)
480 /* Check the parameters */
481 assert_param(IS_USART_ALL_PERIPH(USARTx));
482 assert_param(IS_FUNCTIONAL_STATE(NewState));
484 if (NewState != DISABLE)
486 /* Enable the 8x Oversampling mode by setting the OVER8 bit in the CR1 register */
487 USARTx->CR1 |= USART_CR1_OVER8;
491 /* Disable the 8x Oversampling mode by clearing the OVER8 bit in the CR1 register */
492 USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_OVER8);
497 * @brief Enables or disables the USART's one bit sampling method.
498 * @param USARTx: Select the USART peripheral. This parameter can be one of the
499 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
500 * @param NewState: new state of the USART one bit sampling method.
501 * This parameter can be: ENABLE or DISABLE.
503 * This function has to be called before calling USART_Cmd() function.
506 void USART_OneBitMethodCmd(USART_TypeDef* USARTx, FunctionalState NewState)
508 /* Check the parameters */
509 assert_param(IS_USART_ALL_PERIPH(USARTx));
510 assert_param(IS_FUNCTIONAL_STATE(NewState));
512 if (NewState != DISABLE)
514 /* Enable the one bit method by setting the ONEBIT bit in the CR3 register */
515 USARTx->CR3 |= USART_CR3_ONEBIT;
519 /* Disable the one bit method by clearing the ONEBIT bit in the CR3 register */
520 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_ONEBIT);
525 * @brief Enables or disables the USART's most significant bit first
526 * transmitted/received following the start bit.
527 * @param USARTx: Select the USART peripheral. This parameter can be one of the
528 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
529 * @param NewState: new state of the USART most significant bit first
530 * transmitted/received following the start bit.
531 * This parameter can be: ENABLE or DISABLE.
533 * This function has to be called before calling USART_Cmd() function.
536 void USART_MSBFirstCmd(USART_TypeDef* USARTx, FunctionalState NewState)
538 /* Check the parameters */
539 assert_param(IS_USART_ALL_PERIPH(USARTx));
540 assert_param(IS_FUNCTIONAL_STATE(NewState));
542 if (NewState != DISABLE)
544 /* Enable the most significant bit first transmitted/received following the
545 start bit by setting the MSBFIRST bit in the CR2 register */
546 USARTx->CR2 |= USART_CR2_MSBFIRST;
550 /* Disable the most significant bit first transmitted/received following the
551 start bit by clearing the MSBFIRST bit in the CR2 register */
552 USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_MSBFIRST);
557 * @brief Enables or disables the binary data inversion.
558 * @param USARTx: Select the USART peripheral. This parameter can be one of the
559 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
560 * @param NewState: new defined levels for the USART data.
561 * This parameter can be: ENABLE or DISABLE.
562 * @arg ENABLE: Logical data from the data register are send/received in negative
563 * logic. (1=L, 0=H). The parity bit is also inverted.
564 * @arg DISABLE: Logical data from the data register are send/received in positive
567 * This function has to be called before calling USART_Cmd() function.
570 void USART_DataInvCmd(USART_TypeDef* USARTx, FunctionalState NewState)
572 /* Check the parameters */
573 assert_param(IS_USART_ALL_PERIPH(USARTx));
574 assert_param(IS_FUNCTIONAL_STATE(NewState));
576 if (NewState != DISABLE)
578 /* Enable the binary data inversion feature by setting the DATAINV bit in
580 USARTx->CR2 |= USART_CR2_DATAINV;
584 /* Disable the binary data inversion feature by clearing the DATAINV bit in
586 USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_DATAINV);
591 * @brief Enables or disables the Pin(s) active level inversion.
592 * @param USARTx: Select the USART peripheral. This parameter can be one of the
593 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
594 * @param USART_InvPin: specifies the USART pin(s) to invert.
595 * This parameter can be any combination of the following values:
596 * @arg USART_InvPin_Tx: USART Tx pin active level inversion.
597 * @arg USART_InvPin_Rx: USART Rx pin active level inversion.
598 * @param NewState: new active level status for the USART pin(s).
599 * This parameter can be: ENABLE or DISABLE.
600 * - ENABLE: pin(s) signal values are inverted (Vdd =0, Gnd =1).
601 * - DISABLE: pin(s) signal works using the standard logic levels (Vdd =1, Gnd =0).
603 * This function has to be called before calling USART_Cmd() function.
606 void USART_InvPinCmd(USART_TypeDef* USARTx, uint32_t USART_InvPin, FunctionalState NewState)
608 /* Check the parameters */
609 assert_param(IS_USART_ALL_PERIPH(USARTx));
610 assert_param(IS_USART_INVERSTION_PIN(USART_InvPin));
611 assert_param(IS_FUNCTIONAL_STATE(NewState));
613 if (NewState != DISABLE)
615 /* Enable the active level inversion for selected pins by setting the TXINV
616 and/or RXINV bits in the USART CR2 register */
617 USARTx->CR2 |= USART_InvPin;
621 /* Disable the active level inversion for selected requests by clearing the
622 TXINV and/or RXINV bits in the USART CR2 register */
623 USARTx->CR2 &= (uint32_t)~USART_InvPin;
628 * @brief Enables or disables the swap Tx/Rx pins.
629 * @param USARTx: Select the USART peripheral. This parameter can be one of the
630 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
631 * @param NewState: new state of the USARTx TX/RX pins pinout.
632 * This parameter can be: ENABLE or DISABLE.
633 * @arg ENABLE: The TX and RX pins functions are swapped.
634 * @arg DISABLE: TX/RX pins are used as defined in standard pinout
636 * This function has to be called before calling USART_Cmd() function.
639 void USART_SWAPPinCmd(USART_TypeDef* USARTx, FunctionalState NewState)
641 /* Check the parameters */
642 assert_param(IS_USART_ALL_PERIPH(USARTx));
643 assert_param(IS_FUNCTIONAL_STATE(NewState));
645 if (NewState != DISABLE)
647 /* Enable the SWAP feature by setting the SWAP bit in the CR2 register */
648 USARTx->CR2 |= USART_CR2_SWAP;
652 /* Disable the SWAP feature by clearing the SWAP bit in the CR2 register */
653 USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_SWAP);
658 * @brief Enables or disables the receiver Time Out feature.
659 * @param USARTx: Select the USART peripheral. This parameter can be one of the
660 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
661 * @param NewState: new state of the USARTx receiver Time Out.
662 * This parameter can be: ENABLE or DISABLE.
665 void USART_ReceiverTimeOutCmd(USART_TypeDef* USARTx, FunctionalState NewState)
667 /* Check the parameters */
668 assert_param(IS_USART_ALL_PERIPH(USARTx));
669 assert_param(IS_FUNCTIONAL_STATE(NewState));
671 if (NewState != DISABLE)
673 /* Enable the receiver time out feature by setting the RTOEN bit in the CR2
675 USARTx->CR2 |= USART_CR2_RTOEN;
679 /* Disable the receiver time out feature by clearing the RTOEN bit in the CR2
681 USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_RTOEN);
686 * @brief Sets the receiver Time Out value.
687 * @param USARTx: Select the USART peripheral. This parameter can be one of the
688 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
689 * @param USART_ReceiverTimeOut: specifies the Receiver Time Out value.
692 void USART_SetReceiverTimeOut(USART_TypeDef* USARTx, uint32_t USART_ReceiverTimeOut)
694 /* Check the parameters */
695 assert_param(IS_USART_ALL_PERIPH(USARTx));
696 assert_param(IS_USART_TIMEOUT(USART_ReceiverTimeOut));
698 /* Clear the receiver Time Out value by clearing the RTO[23:0] bits in the RTOR
700 USARTx->RTOR &= (uint32_t)~((uint32_t)USART_RTOR_RTO);
701 /* Set the receiver Time Out value by setting the RTO[23:0] bits in the RTOR
703 USARTx->RTOR |= USART_ReceiverTimeOut;
707 * @brief Sets the system clock prescaler.
708 * @param USARTx: Select the USART peripheral. This parameter can be one of the
709 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
710 * @param USART_Prescaler: specifies the prescaler clock.
712 * This function has to be called before calling USART_Cmd() function.
715 void USART_SetPrescaler(USART_TypeDef* USARTx, uint8_t USART_Prescaler)
717 /* Check the parameters */
718 assert_param(IS_USART_ALL_PERIPH(USARTx));
720 /* Clear the USART prescaler */
721 USARTx->GTPR &= USART_GTPR_GT;
722 /* Set the USART prescaler */
723 USARTx->GTPR |= USART_Prescaler;
731 /** @defgroup USART_Group2 STOP Mode functions
732 * @brief STOP Mode functions
735 ===============================================================================
736 ##### STOP Mode functions #####
737 ===============================================================================
738 [..] This subsection provides a set of functions allowing to manage
739 WakeUp from STOP mode.
741 [..] The USART is able to WakeUp from Stop Mode if USART clock is set to HSI
744 [..] The WakeUp source is configured by calling USART_StopModeWakeUpSourceConfig()
747 [..] After configuring the source of WakeUp and before entering in Stop Mode
748 USART_STOPModeCmd() function should be called to allow USART WakeUp.
755 * @brief Enables or disables the specified USART peripheral in STOP Mode.
756 * @param USARTx: Select the USART peripheral. This parameter can be one of the
757 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
758 * @param NewState: new state of the USARTx peripheral state in stop mode.
759 * This parameter can be: ENABLE or DISABLE.
761 * This function has to be called when USART clock is set to HSI or LSE.
764 void USART_STOPModeCmd(USART_TypeDef* USARTx, FunctionalState NewState)
766 /* Check the parameters */
767 assert_param(IS_USART_ALL_PERIPH(USARTx));
768 assert_param(IS_FUNCTIONAL_STATE(NewState));
770 if (NewState != DISABLE)
772 /* Enable the selected USART in STOP mode by setting the UESM bit in the CR1
774 USARTx->CR1 |= USART_CR1_UESM;
778 /* Disable the selected USART in STOP mode by clearing the UE bit in the CR1
780 USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_UESM);
785 * @brief Selects the USART WakeUp method form stop mode.
786 * @param USARTx: Select the USART peripheral. This parameter can be one of the
787 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
788 * @param USART_WakeUp: specifies the selected USART wakeup method.
789 * This parameter can be one of the following values:
790 * @arg USART_WakeUpSource_AddressMatch: WUF active on address match.
791 * @arg USART_WakeUpSource_StartBit: WUF active on Start bit detection.
792 * @arg USART_WakeUpSource_RXNE: WUF active on RXNE.
794 * This function has to be called before calling USART_Cmd() function.
797 void USART_StopModeWakeUpSourceConfig(USART_TypeDef* USARTx, uint32_t USART_WakeUpSource)
799 /* Check the parameters */
800 assert_param(IS_USART_ALL_PERIPH(USARTx));
801 assert_param(IS_USART_STOPMODE_WAKEUPSOURCE(USART_WakeUpSource));
803 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_WUS);
804 USARTx->CR3 |= USART_WakeUpSource;
812 /** @defgroup USART_Group3 AutoBaudRate functions
813 * @brief AutoBaudRate functions
816 ===============================================================================
817 ##### AutoBaudRate functions #####
818 ===============================================================================
819 [..] This subsection provides a set of functions allowing to manage
820 the AutoBaudRate detections.
822 [..] Before Enabling AutoBaudRate detection using USART_AutoBaudRateCmd ()
823 The character patterns used to calculate baudrate must be chosen by calling
824 USART_AutoBaudRateConfig() function. These function take as parameter :
825 (#)USART_AutoBaudRate_StartBit : any character starting with a bit 1.
826 (#)USART_AutoBaudRate_FallingEdge : any character starting with a 10xx bit pattern.
828 [..] At any later time, another request for AutoBaudRate detection can be performed
829 using USART_RequestCmd() function.
831 [..] The AutoBaudRate detection is monitored by the status of ABRF flag which indicate
832 that the AutoBaudRate detection is completed. In addition to ABRF flag, the ABRE flag
833 indicate that this procedure is completed without success. USART_GetFlagStatus ()
834 function should be used to monitor the status of these flags.
841 * @brief Enables or disables the Auto Baud Rate.
842 * @param USARTx: Select the USART peripheral. This parameter can be one of the
843 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
844 * @param NewState: new state of the USARTx auto baud rate.
845 * This parameter can be: ENABLE or DISABLE.
848 void USART_AutoBaudRateCmd(USART_TypeDef* USARTx, FunctionalState NewState)
850 /* Check the parameters */
851 assert_param(IS_USART_ALL_PERIPH(USARTx));
852 assert_param(IS_FUNCTIONAL_STATE(NewState));
854 if (NewState != DISABLE)
856 /* Enable the auto baud rate feature by setting the ABREN bit in the CR2
858 USARTx->CR2 |= USART_CR2_ABREN;
862 /* Disable the auto baud rate feature by clearing the ABREN bit in the CR2
864 USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ABREN);
869 * @brief Selects the USART auto baud rate method.
870 * @param USARTx: Select the USART peripheral. This parameter can be one of the
871 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
872 * @param USART_AutoBaudRate: specifies the selected USART auto baud rate method.
873 * This parameter can be one of the following values:
874 * @arg USART_AutoBaudRate_StartBit: Start Bit duration measurement.
875 * @arg USART_AutoBaudRate_FallingEdge: Falling edge to falling edge measurement.
876 * @arg USART_AutoBaudRate_0x7FFrame: 0x7F frame.
877 * @arg USART_AutoBaudRate_0x55Frame: 0x55 frame.
879 * This function has to be called before calling USART_Cmd() function.
882 void USART_AutoBaudRateConfig(USART_TypeDef* USARTx, uint32_t USART_AutoBaudRate)
884 /* Check the parameters */
885 assert_param(IS_USART_ALL_PERIPH(USARTx));
886 assert_param(IS_USART_AUTOBAUDRATE_MODE(USART_AutoBaudRate));
888 USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ABRMODE);
889 USARTx->CR2 |= USART_AutoBaudRate;
897 /** @defgroup USART_Group4 Data transfers functions
898 * @brief Data transfers functions
901 ===============================================================================
902 ##### Data transfers functions #####
903 ===============================================================================
904 [..] This subsection provides a set of functions allowing to manage
905 the USART data transfers.
906 [..] During an USART reception, data shifts in least significant bit first
907 through the RX pin. When a transmission is taking place, a write instruction to
908 the USART_TDR register stores the data in the shift register.
909 [..] The read access of the USART_RDR register can be done using
910 the USART_ReceiveData() function and returns the RDR value.
911 Whereas a write access to the USART_TDR can be done using USART_SendData()
912 function and stores the written data into TDR.
919 * @brief Transmits single data through the USARTx peripheral.
920 * @param USARTx: Select the USART peripheral. This parameter can be one of the
921 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
922 * @param Data: the data to transmit.
925 void USART_SendData(USART_TypeDef* USARTx, uint16_t Data)
927 /* Check the parameters */
928 assert_param(IS_USART_ALL_PERIPH(USARTx));
929 assert_param(IS_USART_DATA(Data));
932 USARTx->TDR = (Data & (uint16_t)0x01FF);
936 * @brief Returns the most recent received data by the USARTx peripheral.
937 * @param USARTx: Select the USART peripheral. This parameter can be one of the
938 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
939 * @retval The received data.
941 uint16_t USART_ReceiveData(USART_TypeDef* USARTx)
943 /* Check the parameters */
944 assert_param(IS_USART_ALL_PERIPH(USARTx));
947 return (uint16_t)(USARTx->RDR & (uint16_t)0x01FF);
954 /** @defgroup USART_Group5 MultiProcessor Communication functions
955 * @brief Multi-Processor Communication functions
958 ===============================================================================
959 ##### Multi-Processor Communication functions #####
960 ===============================================================================
961 [..] This subsection provides a set of functions allowing to manage the USART
962 multiprocessor communication.
963 [..] For instance one of the USARTs can be the master, its TX output is
964 connected to the RX input of the other USART. The others are slaves,
965 their respective TX outputs are logically ANDed together and connected
966 to the RX input of the master. USART multiprocessor communication is
967 possible through the following procedure:
968 (#) Program the Baud rate, Word length = 9 bits, Stop bits, Parity,
969 Mode transmitter or Mode receiver and hardware flow control values
970 using the USART_Init() function.
971 (#) Configures the USART address using the USART_SetAddress() function.
972 (#) Configures the wake up methode (USART_WakeUp_IdleLine or
973 USART_WakeUp_AddressMark) using USART_WakeUpConfig() function only
975 (#) Enable the USART using the USART_Cmd() function.
976 (#) Enter the USART slaves in mute mode using USART_ReceiverWakeUpCmd()
978 [..] The USART Slave exit from mute mode when receive the wake up condition.
985 * @brief Sets the address of the USART node.
986 * @param USARTx: Select the USART peripheral. This parameter can be one of the
987 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
988 * @param USART_Address: Indicates the address of the USART node.
991 void USART_SetAddress(USART_TypeDef* USARTx, uint8_t USART_Address)
993 /* Check the parameters */
994 assert_param(IS_USART_ALL_PERIPH(USARTx));
996 /* Clear the USART address */
997 USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ADD);
998 /* Set the USART address node */
999 USARTx->CR2 |=((uint32_t)USART_Address << (uint32_t)0x18);
1003 * @brief Enables or disables the USART's mute mode.
1004 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1005 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1006 * @param NewState: new state of the USART mute mode.
1007 * This parameter can be: ENABLE or DISABLE.
1010 void USART_MuteModeCmd(USART_TypeDef* USARTx, FunctionalState NewState)
1012 /* Check the parameters */
1013 assert_param(IS_USART_ALL_PERIPH(USARTx));
1014 assert_param(IS_FUNCTIONAL_STATE(NewState));
1016 if (NewState != DISABLE)
1018 /* Enable the USART mute mode by setting the MME bit in the CR1 register */
1019 USARTx->CR1 |= USART_CR1_MME;
1023 /* Disable the USART mute mode by clearing the MME bit in the CR1 register */
1024 USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_MME);
1029 * @brief Selects the USART WakeUp method from mute mode.
1030 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1031 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1032 * @param USART_WakeUp: specifies the USART wakeup method.
1033 * This parameter can be one of the following values:
1034 * @arg USART_WakeUp_IdleLine: WakeUp by an idle line detection
1035 * @arg USART_WakeUp_AddressMark: WakeUp by an address mark
1038 void USART_MuteModeWakeUpConfig(USART_TypeDef* USARTx, uint32_t USART_WakeUp)
1040 /* Check the parameters */
1041 assert_param(IS_USART_ALL_PERIPH(USARTx));
1042 assert_param(IS_USART_MUTEMODE_WAKEUP(USART_WakeUp));
1044 USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_WAKE);
1045 USARTx->CR1 |= USART_WakeUp;
1049 * @brief Configure the the USART Address detection length.
1050 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1051 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1052 * @param USART_AddressLength: specifies the USART address length detection.
1053 * This parameter can be one of the following values:
1054 * @arg USART_AddressLength_4b: 4-bit address length detection
1055 * @arg USART_AddressLength_7b: 7-bit address length detection
1058 void USART_AddressDetectionConfig(USART_TypeDef* USARTx, uint32_t USART_AddressLength)
1060 /* Check the parameters */
1061 assert_param(IS_USART_ALL_PERIPH(USARTx));
1062 assert_param(IS_USART_ADDRESS_DETECTION(USART_AddressLength));
1064 USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_ADDM7);
1065 USARTx->CR2 |= USART_AddressLength;
1072 /** @defgroup USART_Group6 LIN mode functions
1073 * @brief LIN mode functions
1076 ===============================================================================
1077 ##### LIN mode functions #####
1078 ===============================================================================
1079 [..] This subsection provides a set of functions allowing to manage the USART
1080 LIN Mode communication.
1081 [..] In LIN mode, 8-bit data format with 1 stop bit is required in accordance
1082 with the LIN standard.
1083 [..] Only this LIN Feature is supported by the USART IP:
1084 (+) LIN Master Synchronous Break send capability and LIN slave break
1085 detection capability : 13-bit break generation and 10/11 bit break
1087 [..] USART LIN Master transmitter communication is possible through the
1088 following procedure:
1089 (#) Program the Baud rate, Word length = 8bits, Stop bits = 1bit, Parity,
1090 Mode transmitter or Mode receiver and hardware flow control values
1091 using the USART_Init() function.
1092 (#) Enable the LIN mode using the USART_LINCmd() function.
1093 (#) Enable the USART using the USART_Cmd() function.
1094 (#) Send the break character using USART_SendBreak() function.
1095 [..] USART LIN Master receiver communication is possible through the
1096 following procedure:
1097 (#) Program the Baud rate, Word length = 8bits, Stop bits = 1bit, Parity,
1098 Mode transmitter or Mode receiver and hardware flow control values
1099 using the USART_Init() function.
1100 (#) Configures the break detection length
1101 using the USART_LINBreakDetectLengthConfig() function.
1102 (#) Enable the LIN mode using the USART_LINCmd() function.
1103 (#) Enable the USART using the USART_Cmd() function.
1105 (@) In LIN mode, the following bits must be kept cleared:
1106 (+@) CLKEN in the USART_CR2 register.
1107 (+@) STOP[1:0], SCEN, HDSEL and IREN in the USART_CR3 register.
1114 * @brief Sets the USART LIN Break detection length.
1115 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1116 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1117 * @param USART_LINBreakDetectLength: specifies the LIN break detection length.
1118 * This parameter can be one of the following values:
1119 * @arg USART_LINBreakDetectLength_10b: 10-bit break detection
1120 * @arg USART_LINBreakDetectLength_11b: 11-bit break detection
1123 void USART_LINBreakDetectLengthConfig(USART_TypeDef* USARTx, uint32_t USART_LINBreakDetectLength)
1125 /* Check the parameters */
1126 assert_param(IS_USART_ALL_PERIPH(USARTx));
1127 assert_param(IS_USART_LIN_BREAK_DETECT_LENGTH(USART_LINBreakDetectLength));
1129 USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_LBDL);
1130 USARTx->CR2 |= USART_LINBreakDetectLength;
1134 * @brief Enables or disables the USART's LIN mode.
1135 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1136 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1137 * @param NewState: new state of the USART LIN mode.
1138 * This parameter can be: ENABLE or DISABLE.
1141 void USART_LINCmd(USART_TypeDef* USARTx, FunctionalState NewState)
1143 /* Check the parameters */
1144 assert_param(IS_USART_ALL_PERIPH(USARTx));
1145 assert_param(IS_FUNCTIONAL_STATE(NewState));
1147 if (NewState != DISABLE)
1149 /* Enable the LIN mode by setting the LINEN bit in the CR2 register */
1150 USARTx->CR2 |= USART_CR2_LINEN;
1154 /* Disable the LIN mode by clearing the LINEN bit in the CR2 register */
1155 USARTx->CR2 &= (uint32_t)~((uint32_t)USART_CR2_LINEN);
1163 /** @defgroup USART_Group7 Halfduplex mode function
1164 * @brief Half-duplex mode function
1167 ===============================================================================
1168 ##### Half-duplex mode function #####
1169 ===============================================================================
1170 [..] This subsection provides a set of functions allowing to manage the USART
1171 Half-duplex communication.
1172 [..] The USART can be configured to follow a single-wire half-duplex protocol
1173 where the TX and RX lines are internally connected.
1174 [..] USART Half duplex communication is possible through the following procedure:
1175 (#) Program the Baud rate, Word length, Stop bits, Parity, Mode transmitter
1176 or Mode receiver and hardware flow control values using the USART_Init()
1178 (#) Configures the USART address using the USART_SetAddress() function.
1179 (#) Enable the half duplex mode using USART_HalfDuplexCmd() function.
1180 (#) Enable the USART using the USART_Cmd() function.
1182 (@) The RX pin is no longer used.
1183 (@) In Half-duplex mode the following bits must be kept cleared:
1184 (+@) LINEN and CLKEN bits in the USART_CR2 register.
1185 (+@) SCEN and IREN bits in the USART_CR3 register.
1192 * @brief Enables or disables the USART's Half Duplex communication.
1193 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1194 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1195 * @param NewState: new state of the USART Communication.
1196 * This parameter can be: ENABLE or DISABLE.
1199 void USART_HalfDuplexCmd(USART_TypeDef* USARTx, FunctionalState NewState)
1201 /* Check the parameters */
1202 assert_param(IS_USART_ALL_PERIPH(USARTx));
1203 assert_param(IS_FUNCTIONAL_STATE(NewState));
1205 if (NewState != DISABLE)
1207 /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */
1208 USARTx->CR3 |= USART_CR3_HDSEL;
1212 /* Disable the Half-Duplex mode by clearing the HDSEL bit in the CR3 register */
1213 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_HDSEL);
1222 /** @defgroup USART_Group8 Smartcard mode functions
1223 * @brief Smartcard mode functions
1226 ===============================================================================
1227 ##### Smartcard mode functions #####
1228 ===============================================================================
1229 [..] This subsection provides a set of functions allowing to manage the USART
1230 Smartcard communication.
1231 [..] The Smartcard interface is designed to support asynchronous protocol
1232 Smartcards as defined in the ISO 7816-3 standard. The USART can provide
1233 a clock to the smartcard through the SCLK output. In smartcard mode,
1234 SCLK is not associated to the communication but is simply derived from
1235 the internal peripheral input clock through a 5-bit prescaler.
1236 [..] Smartcard communication is possible through the following procedure:
1237 (#) Configures the Smartcard Prsecaler using the USART_SetPrescaler()
1239 (#) Configures the Smartcard Guard Time using the USART_SetGuardTime()
1241 (#) Program the USART clock using the USART_ClockInit() function as following:
1242 (++) USART Clock enabled.
1243 (++) USART CPOL Low.
1244 (++) USART CPHA on first edge.
1245 (++) USART Last Bit Clock Enabled.
1246 (#) Program the Smartcard interface using the USART_Init() function as
1248 (++) Word Length = 9 Bits.
1251 (++) BaudRate = 12096 baud.
1252 (++) Hardware flow control disabled (RTS and CTS signals).
1253 (++) Tx and Rx enabled
1254 (#) Optionally you can enable the parity error interrupt using
1255 the USART_ITConfig() function.
1256 (#) Enable the Smartcard NACK using the USART_SmartCardNACKCmd() function.
1257 (#) Enable the Smartcard interface using the USART_SmartCardCmd() function.
1258 (#) Enable the USART using the USART_Cmd() function.
1260 Please refer to the ISO 7816-3 specification for more details.
1262 (@) It is also possible to choose 0.5 stop bit for receiving but it is
1263 recommended to use 1.5 stop bits for both transmitting and receiving
1264 to avoid switching between the two configurations.
1265 (@) In smartcard mode, the following bits must be kept cleared:
1266 (+@) LINEN bit in the USART_CR2 register.
1267 (+@) HDSEL and IREN bits in the USART_CR3 register.
1274 * @brief Sets the specified USART guard time.
1275 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1276 * following values: USART1 or USART2 or USART3.
1277 * @param USART_GuardTime: specifies the guard time.
1280 void USART_SetGuardTime(USART_TypeDef* USARTx, uint8_t USART_GuardTime)
1282 /* Check the parameters */
1283 assert_param(IS_USART_123_PERIPH(USARTx));
1285 /* Clear the USART Guard time */
1286 USARTx->GTPR &= USART_GTPR_PSC;
1287 /* Set the USART guard time */
1288 USARTx->GTPR |= (uint16_t)((uint16_t)USART_GuardTime << 0x08);
1292 * @brief Enables or disables the USART's Smart Card mode.
1293 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1294 * following values: USART1 or USART2 or USART3.
1295 * @param NewState: new state of the Smart Card mode.
1296 * This parameter can be: ENABLE or DISABLE.
1299 void USART_SmartCardCmd(USART_TypeDef* USARTx, FunctionalState NewState)
1301 /* Check the parameters */
1302 assert_param(IS_USART_123_PERIPH(USARTx));
1303 assert_param(IS_FUNCTIONAL_STATE(NewState));
1304 if (NewState != DISABLE)
1306 /* Enable the SC mode by setting the SCEN bit in the CR3 register */
1307 USARTx->CR3 |= USART_CR3_SCEN;
1311 /* Disable the SC mode by clearing the SCEN bit in the CR3 register */
1312 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_SCEN);
1317 * @brief Enables or disables NACK transmission.
1318 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1319 * following values: USART1 or USART2 or USART3.
1320 * @param NewState: new state of the NACK transmission.
1321 * This parameter can be: ENABLE or DISABLE.
1324 void USART_SmartCardNACKCmd(USART_TypeDef* USARTx, FunctionalState NewState)
1326 /* Check the parameters */
1327 assert_param(IS_USART_123_PERIPH(USARTx));
1328 assert_param(IS_FUNCTIONAL_STATE(NewState));
1329 if (NewState != DISABLE)
1331 /* Enable the NACK transmission by setting the NACK bit in the CR3 register */
1332 USARTx->CR3 |= USART_CR3_NACK;
1336 /* Disable the NACK transmission by clearing the NACK bit in the CR3 register */
1337 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_NACK);
1342 * @brief Sets the Smart Card number of retries in transmit and receive.
1343 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1344 * following values: USART1 or USART2 or USART3.
1345 * @param USART_AutoCount: specifies the Smart Card auto retry count.
1348 void USART_SetAutoRetryCount(USART_TypeDef* USARTx, uint8_t USART_AutoCount)
1350 /* Check the parameters */
1351 assert_param(IS_USART_123_PERIPH(USARTx));
1352 assert_param(IS_USART_AUTO_RETRY_COUNTER(USART_AutoCount));
1353 /* Clear the USART auto retry count */
1354 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_SCARCNT);
1355 /* Set the USART auto retry count*/
1356 USARTx->CR3 |= (uint32_t)((uint32_t)USART_AutoCount << 0x11);
1360 * @brief Sets the Smart Card Block length.
1361 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1362 * following values: USART1 or USART2 or USART3.
1363 * @param USART_BlockLength: specifies the Smart Card block length.
1366 void USART_SetBlockLength(USART_TypeDef* USARTx, uint8_t USART_BlockLength)
1368 /* Check the parameters */
1369 assert_param(IS_USART_123_PERIPH(USARTx));
1371 /* Clear the Smart card block length */
1372 USARTx->RTOR &= (uint32_t)~((uint32_t)USART_RTOR_BLEN);
1373 /* Set the Smart Card block length */
1374 USARTx->RTOR |= (uint32_t)((uint32_t)USART_BlockLength << 0x18);
1381 /** @defgroup USART_Group9 IrDA mode functions
1382 * @brief IrDA mode functions
1385 ===============================================================================
1386 ##### IrDA mode functions #####
1387 ===============================================================================
1388 [..] This subsection provides a set of functions allowing to manage the USART
1390 [..] IrDA is a half duplex communication protocol. If the Transmitter is busy,
1391 any data on the IrDA receive line will be ignored by the IrDA decoder
1392 and if the Receiver is busy, data on the TX from the USART to IrDA will
1393 not be encoded by IrDA. While receiving data, transmission should be
1394 avoided as the data to be transmitted could be corrupted.
1395 [..] IrDA communication is possible through the following procedure:
1396 (#) Program the Baud rate, Word length = 8 bits, Stop bits, Parity,
1397 Transmitter/Receiver modes and hardware flow control values using
1398 the USART_Init() function.
1399 (#) Configures the IrDA pulse width by configuring the prescaler using
1400 the USART_SetPrescaler() function.
1401 (#) Configures the IrDA USART_IrDAMode_LowPower or USART_IrDAMode_Normal
1402 mode using the USART_IrDAConfig() function.
1403 (#) Enable the IrDA using the USART_IrDACmd() function.
1404 (#) Enable the USART using the USART_Cmd() function.
1406 (@) A pulse of width less than two and greater than one PSC period(s) may or
1407 may not be rejected.
1408 (@) The receiver set up time should be managed by software. The IrDA physical
1409 layer specification specifies a minimum of 10 ms delay between
1410 transmission and reception (IrDA is a half duplex protocol).
1411 (@) In IrDA mode, the following bits must be kept cleared:
1412 (+@) LINEN, STOP and CLKEN bits in the USART_CR2 register.
1413 (+@) SCEN and HDSEL bits in the USART_CR3 register.
1420 * @brief Configures the USART's IrDA interface.
1421 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1422 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1423 * @param USART_IrDAMode: specifies the IrDA mode.
1424 * This parameter can be one of the following values:
1425 * @arg USART_IrDAMode_LowPower
1426 * @arg USART_IrDAMode_Normal
1429 void USART_IrDAConfig(USART_TypeDef* USARTx, uint32_t USART_IrDAMode)
1431 /* Check the parameters */
1432 assert_param(IS_USART_ALL_PERIPH(USARTx));
1433 assert_param(IS_USART_IRDA_MODE(USART_IrDAMode));
1435 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_IRLP);
1436 USARTx->CR3 |= USART_IrDAMode;
1440 * @brief Enables or disables the USART's IrDA interface.
1441 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1442 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1443 * @param NewState: new state of the IrDA mode.
1444 * This parameter can be: ENABLE or DISABLE.
1447 void USART_IrDACmd(USART_TypeDef* USARTx, FunctionalState NewState)
1449 /* Check the parameters */
1450 assert_param(IS_USART_ALL_PERIPH(USARTx));
1451 assert_param(IS_FUNCTIONAL_STATE(NewState));
1453 if (NewState != DISABLE)
1455 /* Enable the IrDA mode by setting the IREN bit in the CR3 register */
1456 USARTx->CR3 |= USART_CR3_IREN;
1460 /* Disable the IrDA mode by clearing the IREN bit in the CR3 register */
1461 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_IREN);
1468 /** @defgroup USART_Group10 RS485 mode function
1469 * @brief RS485 mode function
1472 ===============================================================================
1473 ##### RS485 mode functions #####
1474 ===============================================================================
1475 [..] This subsection provides a set of functions allowing to manage the USART
1477 [..] RS485 flow control (Driver enable feature) handling is possible through
1478 the following procedure:
1479 (#) Program the Baud rate, Word length = 8 bits, Stop bits, Parity,
1480 Transmitter/Receiver modes and hardware flow control values using
1481 the USART_Init() function.
1482 (#) Enable the Driver Enable using the USART_DECmd() function.
1483 (#) Configures the Driver Enable polarity using the USART_DEPolarityConfig()
1485 (#) Configures the Driver Enable assertion time using USART_SetDEAssertionTime()
1486 function and deassertion time using the USART_SetDEDeassertionTime()
1488 (#) Enable the USART using the USART_Cmd() function.
1490 (@) The assertion and dessertion times are expressed in sample time units (1/8 or
1491 1/16 bit time, depending on the oversampling rate).
1498 * @brief Enables or disables the USART's DE functionality.
1499 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1500 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1501 * @param NewState: new state of the driver enable mode.
1502 * This parameter can be: ENABLE or DISABLE.
1505 void USART_DECmd(USART_TypeDef* USARTx, FunctionalState NewState)
1507 /* Check the parameters */
1508 assert_param(IS_USART_ALL_PERIPH(USARTx));
1509 assert_param(IS_FUNCTIONAL_STATE(NewState));
1510 if (NewState != DISABLE)
1512 /* Enable the DE functionality by setting the DEM bit in the CR3 register */
1513 USARTx->CR3 |= USART_CR3_DEM;
1517 /* Disable the DE functionality by clearing the DEM bit in the CR3 register */
1518 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DEM);
1523 * @brief Configures the USART's DE polarity
1524 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1525 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1526 * @param USART_DEPolarity: specifies the DE polarity.
1527 * This parameter can be one of the following values:
1528 * @arg USART_DEPolarity_Low
1529 * @arg USART_DEPolarity_High
1532 void USART_DEPolarityConfig(USART_TypeDef* USARTx, uint32_t USART_DEPolarity)
1534 /* Check the parameters */
1535 assert_param(IS_USART_ALL_PERIPH(USARTx));
1536 assert_param(IS_USART_DE_POLARITY(USART_DEPolarity));
1538 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DEP);
1539 USARTx->CR3 |= USART_DEPolarity;
1543 * @brief Sets the specified RS485 DE assertion time
1544 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1545 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1546 * @param USART_AssertionTime: specifies the time between the activation of the DE
1547 * signal and the beginning of the start bit
1550 void USART_SetDEAssertionTime(USART_TypeDef* USARTx, uint32_t USART_DEAssertionTime)
1552 /* Check the parameters */
1553 assert_param(IS_USART_ALL_PERIPH(USARTx));
1554 assert_param(IS_USART_DE_ASSERTION_DEASSERTION_TIME(USART_DEAssertionTime));
1556 /* Clear the DE assertion time */
1557 USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_DEAT);
1558 /* Set the new value for the DE assertion time */
1559 USARTx->CR1 |=((uint32_t)USART_DEAssertionTime << (uint32_t)0x15);
1563 * @brief Sets the specified RS485 DE deassertion time
1564 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1565 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1566 * @param USART_DeassertionTime: specifies the time between the middle of the last
1567 * stop bit in a transmitted message and the de-activation of the DE signal
1570 void USART_SetDEDeassertionTime(USART_TypeDef* USARTx, uint32_t USART_DEDeassertionTime)
1572 /* Check the parameters */
1573 assert_param(IS_USART_ALL_PERIPH(USARTx));
1574 assert_param(IS_USART_DE_ASSERTION_DEASSERTION_TIME(USART_DEDeassertionTime));
1576 /* Clear the DE deassertion time */
1577 USARTx->CR1 &= (uint32_t)~((uint32_t)USART_CR1_DEDT);
1578 /* Set the new value for the DE deassertion time */
1579 USARTx->CR1 |=((uint32_t)USART_DEDeassertionTime << (uint32_t)0x10);
1586 /** @defgroup USART_Group11 DMA transfers management functions
1587 * @brief DMA transfers management functions
1590 ===============================================================================
1591 ##### DMA transfers management functions #####
1592 ===============================================================================
1593 [..] This section provides two functions that can be used only in DMA mode.
1594 [..] In DMA Mode, the USART communication can be managed by 2 DMA Channel
1596 (#) USART_DMAReq_Tx: specifies the Tx buffer DMA transfer request.
1597 (#) USART_DMAReq_Rx: specifies the Rx buffer DMA transfer request.
1598 [..] In this Mode it is advised to use the following function:
1599 (+) void USART_DMACmd(USART_TypeDef* USARTx, uint16_t USART_DMAReq,
1600 FunctionalState NewState).
1606 * @brief Enables or disables the USART's DMA interface.
1607 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1608 * following values: USART1 or USART2 or USART3 or UART4.
1609 * @param USART_DMAReq: specifies the DMA request.
1610 * This parameter can be any combination of the following values:
1611 * @arg USART_DMAReq_Tx: USART DMA transmit request
1612 * @arg USART_DMAReq_Rx: USART DMA receive request
1613 * @param NewState: new state of the DMA Request sources.
1614 * This parameter can be: ENABLE or DISABLE.
1617 void USART_DMACmd(USART_TypeDef* USARTx, uint32_t USART_DMAReq, FunctionalState NewState)
1619 /* Check the parameters */
1620 assert_param(IS_USART_1234_PERIPH(USARTx));
1621 assert_param(IS_USART_DMAREQ(USART_DMAReq));
1622 assert_param(IS_FUNCTIONAL_STATE(NewState));
1624 if (NewState != DISABLE)
1626 /* Enable the DMA transfer for selected requests by setting the DMAT and/or
1627 DMAR bits in the USART CR3 register */
1628 USARTx->CR3 |= USART_DMAReq;
1632 /* Disable the DMA transfer for selected requests by clearing the DMAT and/or
1633 DMAR bits in the USART CR3 register */
1634 USARTx->CR3 &= (uint32_t)~USART_DMAReq;
1639 * @brief Enables or disables the USART's DMA interface when reception error occurs.
1640 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1641 * following values: USART1 or USART2 or USART3 or UART4.
1642 * @param USART_DMAOnError: specifies the DMA status in case of reception error.
1643 * This parameter can be any combination of the following values:
1644 * @arg USART_DMAOnError_Enable: DMA receive request enabled when the USART DMA
1645 * reception error is asserted.
1646 * @arg USART_DMAOnError_Disable: DMA receive request disabled when the USART DMA
1647 * reception error is asserted.
1650 void USART_DMAReceptionErrorConfig(USART_TypeDef* USARTx, uint32_t USART_DMAOnError)
1652 /* Check the parameters */
1653 assert_param(IS_USART_1234_PERIPH(USARTx));
1654 assert_param(IS_USART_DMAONERROR(USART_DMAOnError));
1656 /* Clear the DMA Reception error detection bit */
1657 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DDRE);
1658 /* Set the new value for the DMA Reception error detection bit */
1659 USARTx->CR3 |= USART_DMAOnError;
1666 /** @defgroup USART_Group12 Interrupts and flags management functions
1667 * @brief Interrupts and flags management functions
1670 ===============================================================================
1671 ##### Interrupts and flags management functions #####
1672 ===============================================================================
1673 [..] This subsection provides a set of functions allowing to configure the
1674 USART Interrupts sources, Requests and check or clear the flags or pending bits status.
1675 The user should identify which mode will be used in his application to
1676 manage the communication: Polling mode, Interrupt mode.
1678 *** Polling Mode ***
1679 ====================
1680 [..] In Polling Mode, the SPI communication can be managed by these flags:
1681 (#) USART_FLAG_REACK: to indicate the status of the Receive Enable
1683 (#) USART_FLAG_TEACK: to indicate the status of the Transmit Enable
1685 (#) USART_FLAG_WUF: to indicate the status of the Wake up flag.
1686 (#) USART_FLAG_RWU: to indicate the status of the Receive Wake up flag.
1687 (#) USART_FLAG_SBK: to indicate the status of the Send Break flag.
1688 (#) USART_FLAG_CMF: to indicate the status of the Character match flag.
1689 (#) USART_FLAG_BUSY: to indicate the status of the Busy flag.
1690 (#) USART_FLAG_ABRF: to indicate the status of the Auto baud rate flag.
1691 (#) USART_FLAG_ABRE: to indicate the status of the Auto baud rate error flag.
1692 (#) USART_FLAG_EOBF: to indicate the status of the End of block flag.
1693 (#) USART_FLAG_RTOF: to indicate the status of the Receive time out flag.
1694 (#) USART_FLAG_nCTSS: to indicate the status of the Inverted nCTS input
1696 (#) USART_FLAG_TXE: to indicate the status of the transmit buffer register.
1697 (#) USART_FLAG_RXNE: to indicate the status of the receive buffer register.
1698 (#) USART_FLAG_TC: to indicate the status of the transmit operation.
1699 (#) USART_FLAG_IDLE: to indicate the status of the Idle Line.
1700 (#) USART_FLAG_CTS: to indicate the status of the nCTS input.
1701 (#) USART_FLAG_LBD: to indicate the status of the LIN break detection.
1702 (#) USART_FLAG_NE: to indicate if a noise error occur.
1703 (#) USART_FLAG_FE: to indicate if a frame error occur.
1704 (#) USART_FLAG_PE: to indicate if a parity error occur.
1705 (#) USART_FLAG_ORE: to indicate if an Overrun error occur.
1706 [..] In this Mode it is advised to use the following functions:
1707 (+) FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG).
1708 (+) void USART_ClearFlag(USART_TypeDef* USARTx, uint16_t USART_FLAG).
1710 *** Interrupt Mode ***
1711 ======================
1712 [..] In Interrupt Mode, the USART communication can be managed by 8 interrupt
1713 sources and 10 pending bits:
1715 (##) USART_IT_WU: to indicate the status of the Wake up interrupt.
1716 (##) USART_IT_CM: to indicate the status of Character match interrupt.
1717 (##) USART_IT_EOB: to indicate the status of End of block interrupt.
1718 (##) USART_IT_RTO: to indicate the status of Receive time out interrupt.
1719 (##) USART_IT_CTS: to indicate the status of CTS change interrupt.
1720 (##) USART_IT_LBD: to indicate the status of LIN Break detection interrupt.
1721 (##) USART_IT_TC: to indicate the status of Transmission complete interrupt.
1722 (##) USART_IT_IDLE: to indicate the status of IDLE line detected interrupt.
1723 (##) USART_IT_ORE: to indicate the status of OverRun Error interrupt.
1724 (##) USART_IT_NE: to indicate the status of Noise Error interrupt.
1725 (##) USART_IT_FE: to indicate the status of Framing Error interrupt.
1726 (##) USART_IT_PE: to indicate the status of Parity Error interrupt.
1728 (+) Interrupt Source:
1729 (##) USART_IT_WU: specifies the interrupt source for Wake up interrupt.
1730 (##) USART_IT_CM: specifies the interrupt source for Character match
1732 (##) USART_IT_EOB: specifies the interrupt source for End of block
1734 (##) USART_IT_RTO: specifies the interrupt source for Receive time-out
1736 (##) USART_IT_CTS: specifies the interrupt source for CTS change interrupt.
1737 (##) USART_IT_LBD: specifies the interrupt source for LIN Break
1738 detection interrupt.
1739 (##) USART_IT_TXE: specifies the interrupt source for Tansmit Data
1740 Register empty interrupt.
1741 (##) USART_IT_TC: specifies the interrupt source for Transmission
1743 (##) USART_IT_RXNE: specifies the interrupt source for Receive Data
1744 register not empty interrupt.
1745 (##) USART_IT_IDLE: specifies the interrupt source for Idle line
1746 detection interrupt.
1747 (##) USART_IT_PE: specifies the interrupt source for Parity Error interrupt.
1748 (##) USART_IT_ERR: specifies the interrupt source for Error interrupt
1749 (Frame error, noise error, overrun error)
1750 -@@- Some parameters are coded in order to use them as interrupt
1751 source or as pending bits.
1752 [..] In this Mode it is advised to use the following functions:
1753 (+) void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState).
1754 (+) ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT).
1755 (+) void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT).
1762 * @brief Enables or disables the specified USART interrupts.
1763 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1764 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1765 * @param USART_IT: specifies the USART interrupt sources to be enabled or disabled.
1766 * This parameter can be one of the following values:
1767 * @arg USART_IT_WU: Wake up interrupt.
1768 * @arg USART_IT_CM: Character match interrupt.
1769 * @arg USART_IT_EOB: End of block interrupt.
1770 * @arg USART_IT_RTO: Receive time out interrupt.
1771 * @arg USART_IT_CTS: CTS change interrupt.
1772 * @arg USART_IT_LBD: LIN Break detection interrupt.
1773 * @arg USART_IT_TXE: Tansmit Data Register empty interrupt.
1774 * @arg USART_IT_TC: Transmission complete interrupt.
1775 * @arg USART_IT_RXNE: Receive Data register not empty interrupt.
1776 * @arg USART_IT_IDLE: Idle line detection interrupt.
1777 * @arg USART_IT_PE: Parity Error interrupt.
1778 * @arg USART_IT_ERR: Error interrupt(Frame error, noise error, overrun error)
1779 * @param NewState: new state of the specified USARTx interrupts.
1780 * This parameter can be: ENABLE or DISABLE.
1783 void USART_ITConfig(USART_TypeDef* USARTx, uint32_t USART_IT, FunctionalState NewState)
1785 uint32_t usartreg = 0, itpos = 0, itmask = 0;
1786 uint32_t usartxbase = 0;
1787 /* Check the parameters */
1788 assert_param(IS_USART_ALL_PERIPH(USARTx));
1789 assert_param(IS_USART_CONFIG_IT(USART_IT));
1790 assert_param(IS_FUNCTIONAL_STATE(NewState));
1792 usartxbase = (uint32_t)USARTx;
1794 /* Get the USART register index */
1795 usartreg = (((uint16_t)USART_IT) >> 0x08);
1797 /* Get the interrupt position */
1798 itpos = USART_IT & IT_MASK;
1799 itmask = (((uint32_t)0x01) << itpos);
1801 if (usartreg == 0x02) /* The IT is in CR2 register */
1805 else if (usartreg == 0x03) /* The IT is in CR3 register */
1809 else /* The IT is in CR1 register */
1812 if (NewState != DISABLE)
1814 *(__IO uint32_t*)usartxbase |= itmask;
1818 *(__IO uint32_t*)usartxbase &= ~itmask;
1823 * @brief Enables the specified USART's Request.
1824 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1825 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1826 * @param USART_Request: specifies the USART request.
1827 * This parameter can be any combination of the following values:
1828 * @arg USART_Request_TXFRQ: Transmit data flush ReQuest
1829 * @arg USART_Request_RXFRQ: Receive data flush ReQuest
1830 * @arg USART_Request_MMRQ: Mute Mode ReQuest
1831 * @arg USART_Request_SBKRQ: Send Break ReQuest
1832 * @arg USART_Request_ABRRQ: Auto Baud Rate ReQuest
1833 * @param NewState: new state of the DMA interface when reception error occurs.
1834 * This parameter can be: ENABLE or DISABLE.
1837 void USART_RequestCmd(USART_TypeDef* USARTx, uint32_t USART_Request, FunctionalState NewState)
1839 /* Check the parameters */
1840 assert_param(IS_USART_ALL_PERIPH(USARTx));
1841 assert_param(IS_USART_REQUEST(USART_Request));
1842 assert_param(IS_FUNCTIONAL_STATE(NewState));
1844 if (NewState != DISABLE)
1846 /* Enable the USART ReQuest by setting the dedicated request bit in the RQR
1848 USARTx->RQR |= USART_Request;
1852 /* Disable the USART ReQuest by clearing the dedicated request bit in the RQR
1854 USARTx->RQR &= (uint32_t)~USART_Request;
1859 * @brief Enables or disables the USART's Overrun detection.
1860 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1861 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1862 * @param USART_OVRDetection: specifies the OVR detection status in case of OVR error.
1863 * This parameter can be any combination of the following values:
1864 * @arg USART_OVRDetection_Enable: OVR error detection enabled when the USART OVR error
1866 * @arg USART_OVRDetection_Disable: OVR error detection disabled when the USART OVR error
1870 void USART_OverrunDetectionConfig(USART_TypeDef* USARTx, uint32_t USART_OVRDetection)
1872 /* Check the parameters */
1873 assert_param(IS_USART_ALL_PERIPH(USARTx));
1874 assert_param(IS_USART_OVRDETECTION(USART_OVRDetection));
1876 /* Clear the OVR detection bit */
1877 USARTx->CR3 &= (uint32_t)~((uint32_t)USART_CR3_OVRDIS);
1878 /* Set the new value for the OVR detection bit */
1879 USARTx->CR3 |= USART_OVRDetection;
1883 * @brief Checks whether the specified USART flag is set or not.
1884 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1885 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1886 * @param USART_FLAG: specifies the flag to check.
1887 * This parameter can be one of the following values:
1888 * @arg USART_FLAG_REACK: Receive Enable acknowledge flag.
1889 * @arg USART_FLAG_TEACK: Transmit Enable acknowledge flag.
1890 * @arg USART_FLAG_WUF: Wake up flag.
1891 * @arg USART_FLAG_RWU: Receive Wake up flag.
1892 * @arg USART_FLAG_SBK: Send Break flag.
1893 * @arg USART_FLAG_CMF: Character match flag.
1894 * @arg USART_FLAG_BUSY: Busy flag.
1895 * @arg USART_FLAG_ABRF: Auto baud rate flag.
1896 * @arg USART_FLAG_ABRE: Auto baud rate error flag.
1897 * @arg USART_FLAG_EOBF: End of block flag.
1898 * @arg USART_FLAG_RTOF: Receive time out flag.
1899 * @arg USART_FLAG_nCTSS: Inverted nCTS input bit status.
1900 * @arg USART_FLAG_CTS: CTS Change flag.
1901 * @arg USART_FLAG_LBD: LIN Break detection flag.
1902 * @arg USART_FLAG_TXE: Transmit data register empty flag.
1903 * @arg USART_FLAG_TC: Transmission Complete flag.
1904 * @arg USART_FLAG_RXNE: Receive data register not empty flag.
1905 * @arg USART_FLAG_IDLE: Idle Line detection flag.
1906 * @arg USART_FLAG_ORE: OverRun Error flag.
1907 * @arg USART_FLAG_NE: Noise Error flag.
1908 * @arg USART_FLAG_FE: Framing Error flag.
1909 * @arg USART_FLAG_PE: Parity Error flag.
1910 * @retval The new state of USART_FLAG (SET or RESET).
1912 FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint32_t USART_FLAG)
1914 FlagStatus bitstatus = RESET;
1915 /* Check the parameters */
1916 assert_param(IS_USART_ALL_PERIPH(USARTx));
1917 assert_param(IS_USART_FLAG(USART_FLAG));
1919 if ((USARTx->ISR & USART_FLAG) != (uint16_t)RESET)
1931 * @brief Clears the USARTx's pending flags.
1932 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1933 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1934 * @param USART_FLAG: specifies the flag to clear.
1935 * This parameter can be any combination of the following values:
1936 * @arg USART_FLAG_WUF: Wake up flag.
1937 * @arg USART_FLAG_CMF: Character match flag.
1938 * @arg USART_FLAG_EOBF: End of block flag.
1939 * @arg USART_FLAG_RTOF: Receive time out flag.
1940 * @arg USART_FLAG_CTS: CTS Change flag.
1941 * @arg USART_FLAG_LBD: LIN Break detection flag.
1942 * @arg USART_FLAG_TC: Transmission Complete flag.
1943 * @arg USART_FLAG_IDLE: IDLE line detected flag.
1944 * @arg USART_FLAG_ORE: OverRun Error flag.
1945 * @arg USART_FLAG_NE: Noise Error flag.
1946 * @arg USART_FLAG_FE: Framing Error flag.
1947 * @arg USART_FLAG_PE: Parity Errorflag.
1950 * - RXNE pending bit is cleared by a read to the USART_RDR register
1951 * (USART_ReceiveData()) or by writing 1 to the RXFRQ in the register USART_RQR
1952 * (USART_RequestCmd()).
1953 * - TC flag can be also cleared by software sequence: a read operation to
1954 * USART_SR register (USART_GetFlagStatus()) followed by a write operation
1955 * to USART_TDR register (USART_SendData()).
1956 * - TXE flag is cleared by a write to the USART_TDR register
1957 * (USART_SendData()) or by writing 1 to the TXFRQ in the register USART_RQR
1958 * (USART_RequestCmd()).
1959 * - SBKF flag is cleared by 1 to the SBKRQ in the register USART_RQR
1960 * (USART_RequestCmd()).
1963 void USART_ClearFlag(USART_TypeDef* USARTx, uint32_t USART_FLAG)
1965 /* Check the parameters */
1966 assert_param(IS_USART_ALL_PERIPH(USARTx));
1967 assert_param(IS_USART_CLEAR_FLAG(USART_FLAG));
1969 USARTx->ICR = USART_FLAG;
1973 * @brief Checks whether the specified USART interrupt has occurred or not.
1974 * @param USARTx: Select the USART peripheral. This parameter can be one of the
1975 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
1976 * @param USART_IT: specifies the USART interrupt source to check.
1977 * This parameter can be one of the following values:
1978 * @arg USART_IT_WU: Wake up interrupt.
1979 * @arg USART_IT_CM: Character match interrupt.
1980 * @arg USART_IT_EOB: End of block interrupt.
1981 * @arg USART_IT_RTO: Receive time out interrupt.
1982 * @arg USART_IT_CTS: CTS change interrupt.
1983 * @arg USART_IT_LBD: LIN Break detection interrupt.
1984 * @arg USART_IT_TXE: Tansmit Data Register empty interrupt.
1985 * @arg USART_IT_TC: Transmission complete interrupt.
1986 * @arg USART_IT_RXNE: Receive Data register not empty interrupt.
1987 * @arg USART_IT_IDLE: Idle line detection interrupt.
1988 * @arg USART_IT_ORE: OverRun Error interrupt.
1989 * @arg USART_IT_NE: Noise Error interrupt.
1990 * @arg USART_IT_FE: Framing Error interrupt.
1991 * @arg USART_IT_PE: Parity Error interrupt.
1992 * @retval The new state of USART_IT (SET or RESET).
1994 ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint32_t USART_IT)
1996 uint32_t bitpos = 0, itmask = 0, usartreg = 0;
1997 ITStatus bitstatus = RESET;
1998 /* Check the parameters */
1999 assert_param(IS_USART_ALL_PERIPH(USARTx));
2000 assert_param(IS_USART_GET_IT(USART_IT));
2002 /* Get the USART register index */
2003 usartreg = (((uint16_t)USART_IT) >> 0x08);
2004 /* Get the interrupt position */
2005 itmask = USART_IT & IT_MASK;
2006 itmask = (uint32_t)0x01 << itmask;
2008 if (usartreg == 0x01) /* The IT is in CR1 register */
2010 itmask &= USARTx->CR1;
2012 else if (usartreg == 0x02) /* The IT is in CR2 register */
2014 itmask &= USARTx->CR2;
2016 else /* The IT is in CR3 register */
2018 itmask &= USARTx->CR3;
2021 bitpos = USART_IT >> 0x10;
2022 bitpos = (uint32_t)0x01 << bitpos;
2023 bitpos &= USARTx->ISR;
2024 if ((itmask != (uint16_t)RESET)&&(bitpos != (uint16_t)RESET))
2037 * @brief Clears the USARTx's interrupt pending bits.
2038 * @param USARTx: Select the USART peripheral. This parameter can be one of the
2039 * following values: USART1 or USART2 or USART3 or UART4 or UART5.
2040 * @param USART_IT: specifies the interrupt pending bit to clear.
2041 * This parameter can be one of the following values:
2042 * @arg USART_IT_WU: Wake up interrupt.
2043 * @arg USART_IT_CM: Character match interrupt.
2044 * @arg USART_IT_EOB: End of block interrupt.
2045 * @arg USART_IT_RTO: Receive time out interrupt.
2046 * @arg USART_IT_CTS: CTS change interrupt.
2047 * @arg USART_IT_LBD: LIN Break detection interrupt.
2048 * @arg USART_IT_TC: Transmission complete interrupt.
2049 * @arg USART_IT_IDLE: IDLE line detected interrupt.
2050 * @arg USART_IT_ORE: OverRun Error interrupt.
2051 * @arg USART_IT_NE: Noise Error interrupt.
2052 * @arg USART_IT_FE: Framing Error interrupt.
2053 * @arg USART_IT_PE: Parity Error interrupt.
2055 * - RXNE pending bit is cleared by a read to the USART_RDR register
2056 * (USART_ReceiveData()) or by writing 1 to the RXFRQ in the register USART_RQR
2057 * (USART_RequestCmd()).
2058 * - TC pending bit can be also cleared by software sequence: a read
2059 * operation to USART_SR register (USART_GetITStatus()) followed by a write
2060 * operation to USART_TDR register (USART_SendData()).
2061 * - TXE pending bit is cleared by a write to the USART_TDR register
2062 * (USART_SendData()) or by writing 1 to the TXFRQ in the register USART_RQR
2063 * (USART_RequestCmd()).
2066 void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint32_t USART_IT)
2068 uint32_t bitpos = 0, itmask = 0;
2069 /* Check the parameters */
2070 assert_param(IS_USART_ALL_PERIPH(USARTx));
2071 assert_param(IS_USART_CLEAR_IT(USART_IT));
2073 bitpos = USART_IT >> 0x10;
2074 itmask = ((uint32_t)0x01 << (uint32_t)bitpos);
2075 USARTx->ICR = (uint32_t)itmask;
2094 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/