gabriel della-monica / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F0/stm32f0xx_hal_uart.c@445:9a3ffe6cfa19, 2015-01-14 (annotated)

Committer:
moirans2
Date:
Wed Jan 14 20:53:08 2015 +0000
Revision:
445:9a3ffe6cfa19
Parent:
441:d2c15dda23c1 
internal clock stm32L051

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 340:28d1f895c6fe 1 /**
mbed_official 340:28d1f895c6fe 2 ******************************************************************************
mbed_official 340:28d1f895c6fe 3 * @file stm32f0xx_hal_uart.c
mbed_official 340:28d1f895c6fe 4 * @author MCD Application Team
mbed_official 441:d2c15dda23c1 5 * @version V1.2.0
mbed_official 441:d2c15dda23c1 6 * @date 11-December-2014
mbed_official 340:28d1f895c6fe 7 * @brief UART HAL module driver.
mbed_official 340:28d1f895c6fe 8 * This file provides firmware functions to manage the following
mbed_official 340:28d1f895c6fe 9 * functionalities of the Universal Asynchronous Receiver Transmitter (UART) peripheral:
mbed_official 340:28d1f895c6fe 10 * + Initialization and de-initialization functions
mbed_official 340:28d1f895c6fe 11 * + IO operation functions
mbed_official 340:28d1f895c6fe 12 * + Peripheral Control functions
mbed_official 340:28d1f895c6fe 13 * + Peripheral State and Errors functions
mbed_official 340:28d1f895c6fe 14 @verbatim
mbed_official 340:28d1f895c6fe 15 ===============================================================================
mbed_official 340:28d1f895c6fe 16 ##### How to use this driver #####
mbed_official 340:28d1f895c6fe 17 ================================================================================
mbed_official 340:28d1f895c6fe 18 [..]
mbed_official 340:28d1f895c6fe 19 The UART HAL driver can be used as follows:
mbed_official 340:28d1f895c6fe 20
mbed_official 340:28d1f895c6fe 21 (#) Declare a UART_HandleTypeDef handle structure.
mbed_official 340:28d1f895c6fe 22
mbed_official 340:28d1f895c6fe 23 (#) Initialize the UART low level resources by implementing the HAL_UART_MspInit ()API:
mbed_official 340:28d1f895c6fe 24 (##) Enable the USARTx interface clock.
mbed_official 340:28d1f895c6fe 25 (##) UART pins configuration:
mbed_official 340:28d1f895c6fe 26 (+++) Enable the clock for the UART GPIOs.
mbed_official 340:28d1f895c6fe 27 (+++) Configure these UART pins as alternate function pull-up.
mbed_official 340:28d1f895c6fe 28 (##) NVIC configuration if you need to use interrupt process (HAL_UART_Transmit_IT()
mbed_official 340:28d1f895c6fe 29 and HAL_UART_Receive_IT() APIs):
mbed_official 340:28d1f895c6fe 30 (+++) Configure the USARTx interrupt priority.
mbed_official 340:28d1f895c6fe 31 (+++) Enable the NVIC USART IRQ handle.
mbed_official 340:28d1f895c6fe 32 (##) DMA Configuration if you need to use DMA process (HAL_UART_Transmit_DMA()
mbed_official 340:28d1f895c6fe 33 and HAL_UART_Receive_DMA() APIs):
mbed_official 340:28d1f895c6fe 34 (+++) Declare a DMA handle structure for the Tx/Rx channel.
mbed_official 340:28d1f895c6fe 35 (+++) Enable the DMAx interface clock.
mbed_official 340:28d1f895c6fe 36 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
mbed_official 340:28d1f895c6fe 37 (+++) Configure the DMA Tx/Rx channel.
mbed_official 340:28d1f895c6fe 38 (+++) Associate the initilalized DMA handle to the UART DMA Tx/Rx handle.
mbed_official 340:28d1f895c6fe 39 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
mbed_official 340:28d1f895c6fe 40
mbed_official 340:28d1f895c6fe 41 (#) Program the Baud Rate, Word Length , Stop Bit, Parity, Hardware
mbed_official 340:28d1f895c6fe 42 flow control and Mode(Receiver/Transmitter) in the huart Init structure.
mbed_official 340:28d1f895c6fe 43
mbed_official 340:28d1f895c6fe 44 (#) If required, program UART advanced features (TX/RX pins swap, auto Baud rate detection,...)
mbed_official 340:28d1f895c6fe 45 in the huart AdvancedInit structure.
mbed_official 340:28d1f895c6fe 46
mbed_official 340:28d1f895c6fe 47 (#) For the UART asynchronous mode, initialize the UART registers by calling
mbed_official 340:28d1f895c6fe 48 the HAL_UART_Init() API.
mbed_official 340:28d1f895c6fe 49
mbed_official 340:28d1f895c6fe 50 (#) For the UART Half duplex mode, initialize the UART registers by calling
mbed_official 340:28d1f895c6fe 51 the HAL_HalfDuplex_Init() API.
mbed_official 340:28d1f895c6fe 52
mbed_official 340:28d1f895c6fe 53 (#) For the UART Multiprocessor mode, initialize the UART registers
mbed_official 340:28d1f895c6fe 54 by calling the HAL_MultiProcessor_Init() API.
mbed_official 340:28d1f895c6fe 55
mbed_official 340:28d1f895c6fe 56 (#) For the UART RS485 Driver Enabled mode, initialize the UART registers
mbed_official 340:28d1f895c6fe 57 by calling the HAL_RS485Ex_Init() API.
mbed_official 340:28d1f895c6fe 58
mbed_official 340:28d1f895c6fe 59 [..]
mbed_official 340:28d1f895c6fe 60 (@) The specific UART interrupts (Transmission complete interrupt,
mbed_official 340:28d1f895c6fe 61 RXNE interrupt and Error Interrupts) will be managed using the macros
mbed_official 340:28d1f895c6fe 62 __HAL_UART_ENABLE_IT() and __HAL_UART_DISABLE_IT() inside the transmit and receive process.
mbed_official 340:28d1f895c6fe 63
mbed_official 340:28d1f895c6fe 64 [..]
mbed_official 340:28d1f895c6fe 65 (@) These APIs(HAL_UART_Init(), HAL_HalfDuplex_Init(), HAL_MultiProcessor_Init(),
mbed_official 340:28d1f895c6fe 66 also configure also the low level Hardware GPIO, CLOCK, CORTEX...etc) by
mbed_official 340:28d1f895c6fe 67 calling the customed HAL_UART_MspInit() API.
mbed_official 340:28d1f895c6fe 68
mbed_official 340:28d1f895c6fe 69 Three operation modes are available within this driver :
mbed_official 340:28d1f895c6fe 70
mbed_official 340:28d1f895c6fe 71 *** Polling mode IO operation ***
mbed_official 340:28d1f895c6fe 72 =================================
mbed_official 340:28d1f895c6fe 73 [..]
mbed_official 340:28d1f895c6fe 74 (+) Send an amount of data in blocking mode using HAL_UART_Transmit()
mbed_official 340:28d1f895c6fe 75 (+) Receive an amount of data in blocking mode using HAL_UART_Receive()
mbed_official 340:28d1f895c6fe 76
mbed_official 340:28d1f895c6fe 77 *** Interrupt mode IO operation ***
mbed_official 340:28d1f895c6fe 78 ===================================
mbed_official 340:28d1f895c6fe 79 [..]
mbed_official 340:28d1f895c6fe 80 (+) Send an amount of data in non blocking mode using HAL_UART_Transmit_IT()
mbed_official 340:28d1f895c6fe 81 (+) At transmission end of half transfer HAL_UART_TxHalfCpltCallback is executed and user can
mbed_official 340:28d1f895c6fe 82 add his own code by customization of function pointer HAL_UART_TxHalfCpltCallback
mbed_official 340:28d1f895c6fe 83 (+) At transmission end of transfer HAL_UART_TxCpltCallback is executed and user can
mbed_official 340:28d1f895c6fe 84 add his own code by customization of function pointer HAL_UART_TxCpltCallback
mbed_official 340:28d1f895c6fe 85 (+) Receive an amount of data in non blocking mode using HAL_UART_Receive_IT()
mbed_official 340:28d1f895c6fe 86 (+) At reception end of half transfer HAL_UART_RxHalfCpltCallback is executed and user can
mbed_official 340:28d1f895c6fe 87 add his own code by customization of function pointer HAL_UART_RxHalfCpltCallback
mbed_official 340:28d1f895c6fe 88 (+) At reception end of transfer HAL_UART_RxCpltCallback is executed and user can
mbed_official 340:28d1f895c6fe 89 add his own code by customization of function pointer HAL_UART_RxCpltCallback
mbed_official 340:28d1f895c6fe 90 (+) In case of transfer Error, HAL_UART_ErrorCallback() function is executed and user can
mbed_official 340:28d1f895c6fe 91 add his own code by customization of function pointer HAL_UART_ErrorCallback
mbed_official 340:28d1f895c6fe 92
mbed_official 340:28d1f895c6fe 93 *** DMA mode IO operation ***
mbed_official 340:28d1f895c6fe 94 ==============================
mbed_official 340:28d1f895c6fe 95 [..]
mbed_official 340:28d1f895c6fe 96 (+) Send an amount of data in non blocking mode (DMA) using HAL_UART_Transmit_DMA()
mbed_official 340:28d1f895c6fe 97 (+) At transmission end of half transfer HAL_UART_TxHalfCpltCallback is executed and user can
mbed_official 340:28d1f895c6fe 98 add his own code by customization of function pointer HAL_UART_TxHalfCpltCallback
mbed_official 340:28d1f895c6fe 99 (+) At transmission end of transfer HAL_UART_TxCpltCallback is executed and user can
mbed_official 340:28d1f895c6fe 100 add his own code by customization of function pointer HAL_UART_TxCpltCallback
mbed_official 340:28d1f895c6fe 101 (+) Receive an amount of data in non blocking mode (DMA) using HAL_UART_Receive_DMA()
mbed_official 340:28d1f895c6fe 102 (+) At reception end of half transfer HAL_UART_RxHalfCpltCallback is executed and user can
mbed_official 340:28d1f895c6fe 103 add his own code by customization of function pointer HAL_UART_RxHalfCpltCallback
mbed_official 340:28d1f895c6fe 104 (+) At reception end of transfer HAL_UART_RxCpltCallback is executed and user can
mbed_official 340:28d1f895c6fe 105 add his own code by customization of function pointer HAL_UART_RxCpltCallback
mbed_official 340:28d1f895c6fe 106 (+) In case of transfer Error, HAL_UART_ErrorCallback() function is executed and user can
mbed_official 340:28d1f895c6fe 107 add his own code by customization of function pointer HAL_UART_ErrorCallback
mbed_official 340:28d1f895c6fe 108 (+) Pause the DMA Transfer using HAL_UART_DMAPause()
mbed_official 340:28d1f895c6fe 109 (+) Resume the DMA Transfer using HAL_UART_DMAResume()
mbed_official 340:28d1f895c6fe 110 (+) Stop the DMA Transfer using HAL_UART_DMAStop()
mbed_official 340:28d1f895c6fe 111
mbed_official 340:28d1f895c6fe 112 *** UART HAL driver macros list ***
mbed_official 340:28d1f895c6fe 113 =============================================
mbed_official 340:28d1f895c6fe 114 [..]
mbed_official 340:28d1f895c6fe 115 Below the list of most used macros in UART HAL driver.
mbed_official 340:28d1f895c6fe 116
mbed_official 340:28d1f895c6fe 117 (+) __HAL_UART_ENABLE: Enable the UART peripheral
mbed_official 340:28d1f895c6fe 118 (+) __HAL_UART_DISABLE: Disable the UART peripheral
mbed_official 340:28d1f895c6fe 119 (+) __HAL_UART_GET_FLAG : Check whether the specified UART flag is set or not
mbed_official 340:28d1f895c6fe 120 (+) __HAL_UART_CLEAR_FLAG : Clear the specified UART pending flag
mbed_official 340:28d1f895c6fe 121 (+) __HAL_UART_ENABLE_IT: Enable the specified UART interrupt
mbed_official 340:28d1f895c6fe 122 (+) __HAL_UART_DISABLE_IT: Disable the specified UART interrupt
mbed_official 340:28d1f895c6fe 123
mbed_official 340:28d1f895c6fe 124 [..]
mbed_official 340:28d1f895c6fe 125 (@) You can refer to the UART HAL driver header file for more useful macros
mbed_official 340:28d1f895c6fe 126
mbed_official 340:28d1f895c6fe 127 @endverbatim
mbed_official 340:28d1f895c6fe 128 ******************************************************************************
mbed_official 340:28d1f895c6fe 129 * @attention
mbed_official 340:28d1f895c6fe 130 *
mbed_official 340:28d1f895c6fe 131 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 340:28d1f895c6fe 132 *
mbed_official 340:28d1f895c6fe 133 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 340:28d1f895c6fe 134 * are permitted provided that the following conditions are met:
mbed_official 340:28d1f895c6fe 135 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 340:28d1f895c6fe 136 * this list of conditions and the following disclaimer.
mbed_official 340:28d1f895c6fe 137 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 340:28d1f895c6fe 138 * this list of conditions and the following disclaimer in the documentation
mbed_official 340:28d1f895c6fe 139 * and/or other materials provided with the distribution.
mbed_official 340:28d1f895c6fe 140 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 340:28d1f895c6fe 141 * may be used to endorse or promote products derived from this software
mbed_official 340:28d1f895c6fe 142 * without specific prior written permission.
mbed_official 340:28d1f895c6fe 143 *
mbed_official 340:28d1f895c6fe 144 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 340:28d1f895c6fe 145 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 340:28d1f895c6fe 146 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 340:28d1f895c6fe 147 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 340:28d1f895c6fe 148 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 340:28d1f895c6fe 149 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 340:28d1f895c6fe 150 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 340:28d1f895c6fe 151 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 340:28d1f895c6fe 152 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 340:28d1f895c6fe 153 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 340:28d1f895c6fe 154 *
mbed_official 340:28d1f895c6fe 155 ******************************************************************************
mbed_official 340:28d1f895c6fe 156 */
mbed_official 340:28d1f895c6fe 157
mbed_official 340:28d1f895c6fe 158 /* Includes ------------------------------------------------------------------*/
mbed_official 340:28d1f895c6fe 159 #include "stm32f0xx_hal.h"
mbed_official 340:28d1f895c6fe 160
mbed_official 340:28d1f895c6fe 161 /** @addtogroup STM32F0xx_HAL_Driver
mbed_official 340:28d1f895c6fe 162 * @{
mbed_official 340:28d1f895c6fe 163 */
mbed_official 340:28d1f895c6fe 164
mbed_official 340:28d1f895c6fe 165 /** @defgroup UART UART HAL module driver
mbed_official 340:28d1f895c6fe 166 * @brief HAL UART module driver
mbed_official 340:28d1f895c6fe 167 * @{
mbed_official 340:28d1f895c6fe 168 */
mbed_official 340:28d1f895c6fe 169 #ifdef HAL_UART_MODULE_ENABLED
mbed_official 340:28d1f895c6fe 170
mbed_official 340:28d1f895c6fe 171 /* Private typedef -----------------------------------------------------------*/
mbed_official 340:28d1f895c6fe 172 /* Private define ------------------------------------------------------------*/
mbed_official 340:28d1f895c6fe 173 /** @defgroup UART_Private_Constants UART Private Constants
mbed_official 340:28d1f895c6fe 174 * @{
mbed_official 340:28d1f895c6fe 175 */
mbed_official 340:28d1f895c6fe 176 #define HAL_UART_TXDMA_TIMEOUTVALUE 22000
mbed_official 340:28d1f895c6fe 177 #define UART_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | \
mbed_official 340:28d1f895c6fe 178 USART_CR1_TE | USART_CR1_RE | USART_CR1_OVER8))
mbed_official 340:28d1f895c6fe 179 /**
mbed_official 340:28d1f895c6fe 180 * @}
mbed_official 340:28d1f895c6fe 181 */
mbed_official 340:28d1f895c6fe 182
mbed_official 340:28d1f895c6fe 183 /* Private macro -------------------------------------------------------------*/
mbed_official 340:28d1f895c6fe 184 /* Private variables ---------------------------------------------------------*/
mbed_official 340:28d1f895c6fe 185 /* Private function prototypes -----------------------------------------------*/
mbed_official 340:28d1f895c6fe 186 /** @addtogroup UART_Private_Functions UART Private Functions
mbed_official 340:28d1f895c6fe 187 * @{
mbed_official 340:28d1f895c6fe 188 */
mbed_official 340:28d1f895c6fe 189 static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma);
mbed_official 340:28d1f895c6fe 190 static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 340:28d1f895c6fe 191 static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
mbed_official 340:28d1f895c6fe 192 static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 340:28d1f895c6fe 193 static void UART_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 340:28d1f895c6fe 194 /**
mbed_official 340:28d1f895c6fe 195 * @}
mbed_official 340:28d1f895c6fe 196 */
mbed_official 340:28d1f895c6fe 197
mbed_official 340:28d1f895c6fe 198 /* Exported functions ---------------------------------------------------------*/
mbed_official 340:28d1f895c6fe 199
mbed_official 340:28d1f895c6fe 200 /** @defgroup UART_Exported_Functions UART Exported Functions
mbed_official 340:28d1f895c6fe 201 * @{
mbed_official 340:28d1f895c6fe 202 */
mbed_official 340:28d1f895c6fe 203
mbed_official 340:28d1f895c6fe 204 /** @defgroup UART_Exported_Functions_Group1 Initialization and de-initialization functions
mbed_official 340:28d1f895c6fe 205 * @brief Initialization and Configuration functions
mbed_official 340:28d1f895c6fe 206 *
mbed_official 340:28d1f895c6fe 207 @verbatim
mbed_official 340:28d1f895c6fe 208 ===============================================================================
mbed_official 340:28d1f895c6fe 209 ##### Initialization and Configuration functions #####
mbed_official 340:28d1f895c6fe 210 ===============================================================================
mbed_official 340:28d1f895c6fe 211 [..]
mbed_official 340:28d1f895c6fe 212 This subsection provides a set of functions allowing to initialize the USARTx or the UARTy
mbed_official 340:28d1f895c6fe 213 in asynchronous mode.
mbed_official 340:28d1f895c6fe 214 (+) For the asynchronous mode only these parameters can be configured:
mbed_official 340:28d1f895c6fe 215 (++) Baud Rate
mbed_official 340:28d1f895c6fe 216 (++) Word Length
mbed_official 340:28d1f895c6fe 217 (++) Stop Bit
mbed_official 340:28d1f895c6fe 218 (++) Parity: If the parity is enabled, then the MSB bit of the data written
mbed_official 340:28d1f895c6fe 219 in the data register is transmitted but is changed by the parity bit.
mbed_official 340:28d1f895c6fe 220 Depending on the frame length defined by the M bit (8-bits or 9-bits),
mbed_official 340:28d1f895c6fe 221 the possible UART frame formats are as listed in the following table:
mbed_official 340:28d1f895c6fe 222 |-----------|-----------|---------------------------------------|
mbed_official 340:28d1f895c6fe 223 | M1M0 bits | PCE bit | UART frame |
mbed_official 340:28d1f895c6fe 224 |-----------------------|---------------------------------------|
mbed_official 340:28d1f895c6fe 225 | 00 | 0 | | SB | 8-bit data | STB | |
mbed_official 340:28d1f895c6fe 226 |-----------|-----------|---------------------------------------|
mbed_official 340:28d1f895c6fe 227 | 00 | 1 | | SB | 7-bit data | PB | STB | |
mbed_official 340:28d1f895c6fe 228 |-----------|-----------|---------------------------------------|
mbed_official 340:28d1f895c6fe 229 | 01 | 0 | | SB | 9-bit data | STB | |
mbed_official 340:28d1f895c6fe 230 |-----------|-----------|---------------------------------------|
mbed_official 340:28d1f895c6fe 231 | 01 | 1 | | SB | 8-bit data | PB | STB | |
mbed_official 340:28d1f895c6fe 232 +---------------------------------------------------------------+
mbed_official 340:28d1f895c6fe 233 | 10 | 0 | | SB | 7-bit data | STB | |
mbed_official 340:28d1f895c6fe 234 |-----------|-----------|---------------------------------------|
mbed_official 340:28d1f895c6fe 235 | 10 | 1 | | SB | 6-bit data | PB | STB | |
mbed_official 340:28d1f895c6fe 236 +---------------------------------------------------------------+
mbed_official 340:28d1f895c6fe 237 (++) Hardware flow control
mbed_official 340:28d1f895c6fe 238 (++) Receiver/transmitter modes
mbed_official 340:28d1f895c6fe 239 (++) Over Sampling Method
mbed_official 340:28d1f895c6fe 240 (++) One-Bit Sampling Method
mbed_official 340:28d1f895c6fe 241 (+) For the asynchronous mode, the following advanced features can be configured as well:
mbed_official 340:28d1f895c6fe 242 (++) TX and/or RX pin level inversion
mbed_official 340:28d1f895c6fe 243 (++) data logical level inversion
mbed_official 340:28d1f895c6fe 244 (++) RX and TX pins swap
mbed_official 340:28d1f895c6fe 245 (++) RX overrun detection disabling
mbed_official 340:28d1f895c6fe 246 (++) DMA disabling on RX error
mbed_official 340:28d1f895c6fe 247 (++) MSB first on communication line
mbed_official 340:28d1f895c6fe 248 (++) auto Baud rate detection
mbed_official 340:28d1f895c6fe 249 [..]
mbed_official 340:28d1f895c6fe 250 The HAL_UART_Init(), HAL_HalfDuplex_Init() and HAL_MultiProcessor_Init()
mbed_official 340:28d1f895c6fe 251 API follow respectively the UART asynchronous, UART Half duplex and multiprocessor
mbed_official 340:28d1f895c6fe 252 configuration procedures (details for the procedures are available in reference manual).
mbed_official 340:28d1f895c6fe 253
mbed_official 340:28d1f895c6fe 254 @endverbatim
mbed_official 340:28d1f895c6fe 255 * @{
mbed_official 340:28d1f895c6fe 256 */
mbed_official 340:28d1f895c6fe 257
mbed_official 340:28d1f895c6fe 258 /**
mbed_official 340:28d1f895c6fe 259 * @brief Initializes the UART mode according to the specified
mbed_official 340:28d1f895c6fe 260 * parameters in the UART_InitTypeDef and creates the associated handle .
mbed_official 340:28d1f895c6fe 261 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 262 * @retval HAL status
mbed_official 340:28d1f895c6fe 263 */
mbed_official 340:28d1f895c6fe 264 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 265 {
mbed_official 340:28d1f895c6fe 266 /* Check the UART handle allocation */
mbed_official 441:d2c15dda23c1 267 if(huart == NULL)
mbed_official 340:28d1f895c6fe 268 {
mbed_official 340:28d1f895c6fe 269 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 270 }
mbed_official 340:28d1f895c6fe 271
mbed_official 340:28d1f895c6fe 272 if(huart->Init.HwFlowCtl != UART_HWCONTROL_NONE)
mbed_official 340:28d1f895c6fe 273 {
mbed_official 340:28d1f895c6fe 274 /* Check the parameters */
mbed_official 340:28d1f895c6fe 275 assert_param(IS_UART_HWFLOW_INSTANCE(huart->Instance));
mbed_official 340:28d1f895c6fe 276 }
mbed_official 340:28d1f895c6fe 277 else
mbed_official 340:28d1f895c6fe 278 {
mbed_official 340:28d1f895c6fe 279 /* Check the parameters */
mbed_official 340:28d1f895c6fe 280 assert_param(IS_UART_INSTANCE(huart->Instance));
mbed_official 340:28d1f895c6fe 281 }
mbed_official 340:28d1f895c6fe 282
mbed_official 340:28d1f895c6fe 283 if(huart->State == HAL_UART_STATE_RESET)
mbed_official 340:28d1f895c6fe 284 {
mbed_official 340:28d1f895c6fe 285 /* Init the low level hardware : GPIO, CLOCK */
mbed_official 340:28d1f895c6fe 286 HAL_UART_MspInit(huart);
mbed_official 340:28d1f895c6fe 287 }
mbed_official 340:28d1f895c6fe 288
mbed_official 340:28d1f895c6fe 289 huart->State = HAL_UART_STATE_BUSY;
mbed_official 340:28d1f895c6fe 290
mbed_official 340:28d1f895c6fe 291 /* Disable the Peripheral */
mbed_official 340:28d1f895c6fe 292 __HAL_UART_DISABLE(huart);
mbed_official 340:28d1f895c6fe 293
mbed_official 340:28d1f895c6fe 294 /* Set the UART Communication parameters */
mbed_official 340:28d1f895c6fe 295 if (UART_SetConfig(huart) == HAL_ERROR)
mbed_official 340:28d1f895c6fe 296 {
mbed_official 340:28d1f895c6fe 297 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 298 }
mbed_official 340:28d1f895c6fe 299
mbed_official 340:28d1f895c6fe 300 if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)
mbed_official 340:28d1f895c6fe 301 {
mbed_official 340:28d1f895c6fe 302 UART_AdvFeatureConfig(huart);
mbed_official 340:28d1f895c6fe 303 }
mbed_official 340:28d1f895c6fe 304
mbed_official 340:28d1f895c6fe 305 /* In asynchronous mode, the following bits must be kept cleared:
mbed_official 340:28d1f895c6fe 306 - LINEN and CLKEN bits in the USART_CR2 register,
mbed_official 340:28d1f895c6fe 307 - SCEN, HDSEL and IREN bits in the USART_CR3 register.*/
mbed_official 340:28d1f895c6fe 308 huart->Instance->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN);
mbed_official 340:28d1f895c6fe 309 huart->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN);
mbed_official 340:28d1f895c6fe 310
mbed_official 340:28d1f895c6fe 311 /* Enable the Peripheral */
mbed_official 340:28d1f895c6fe 312 __HAL_UART_ENABLE(huart);
mbed_official 340:28d1f895c6fe 313
mbed_official 340:28d1f895c6fe 314 /* TEACK and/or REACK to check before moving huart->State to Ready */
mbed_official 340:28d1f895c6fe 315 return (UART_CheckIdleState(huart));
mbed_official 340:28d1f895c6fe 316 }
mbed_official 340:28d1f895c6fe 317
mbed_official 340:28d1f895c6fe 318 /**
mbed_official 340:28d1f895c6fe 319 * @brief Initializes the half-duplex mode according to the specified
mbed_official 340:28d1f895c6fe 320 * parameters in the UART_InitTypeDef and creates the associated handle .
mbed_official 340:28d1f895c6fe 321 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 322 * @retval HAL status
mbed_official 340:28d1f895c6fe 323 */
mbed_official 340:28d1f895c6fe 324 HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 325 {
mbed_official 340:28d1f895c6fe 326 /* Check the UART handle allocation */
mbed_official 441:d2c15dda23c1 327 if(huart == NULL)
mbed_official 340:28d1f895c6fe 328 {
mbed_official 340:28d1f895c6fe 329 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 330 }
mbed_official 340:28d1f895c6fe 331
mbed_official 340:28d1f895c6fe 332 /* Check UART instance */
mbed_official 340:28d1f895c6fe 333 assert_param(IS_UART_HALFDUPLEX_INSTANCE(huart->Instance));
mbed_official 340:28d1f895c6fe 334
mbed_official 340:28d1f895c6fe 335 if(huart->State == HAL_UART_STATE_RESET)
mbed_official 340:28d1f895c6fe 336 {
mbed_official 340:28d1f895c6fe 337 /* Init the low level hardware : GPIO, CLOCK */
mbed_official 340:28d1f895c6fe 338 HAL_UART_MspInit(huart);
mbed_official 340:28d1f895c6fe 339 }
mbed_official 340:28d1f895c6fe 340
mbed_official 340:28d1f895c6fe 341 huart->State = HAL_UART_STATE_BUSY;
mbed_official 340:28d1f895c6fe 342
mbed_official 340:28d1f895c6fe 343 /* Disable the Peripheral */
mbed_official 340:28d1f895c6fe 344 __HAL_UART_DISABLE(huart);
mbed_official 340:28d1f895c6fe 345
mbed_official 340:28d1f895c6fe 346 /* Set the UART Communication parameters */
mbed_official 340:28d1f895c6fe 347 if (UART_SetConfig(huart) == HAL_ERROR)
mbed_official 340:28d1f895c6fe 348 {
mbed_official 340:28d1f895c6fe 349 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 350 }
mbed_official 340:28d1f895c6fe 351
mbed_official 340:28d1f895c6fe 352 if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)
mbed_official 340:28d1f895c6fe 353 {
mbed_official 340:28d1f895c6fe 354 UART_AdvFeatureConfig(huart);
mbed_official 340:28d1f895c6fe 355 }
mbed_official 340:28d1f895c6fe 356
mbed_official 340:28d1f895c6fe 357 /* In half-duplex mode, the following bits must be kept cleared:
mbed_official 340:28d1f895c6fe 358 - LINEN and CLKEN bits in the USART_CR2 register,
mbed_official 340:28d1f895c6fe 359 - SCEN and IREN bits in the USART_CR3 register.*/
mbed_official 340:28d1f895c6fe 360 huart->Instance->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN);
mbed_official 340:28d1f895c6fe 361 huart->Instance->CR3 &= ~(USART_CR3_IREN | USART_CR3_SCEN);
mbed_official 340:28d1f895c6fe 362
mbed_official 340:28d1f895c6fe 363 /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */
mbed_official 340:28d1f895c6fe 364 huart->Instance->CR3 |= USART_CR3_HDSEL;
mbed_official 340:28d1f895c6fe 365
mbed_official 340:28d1f895c6fe 366 /* Enable the Peripheral */
mbed_official 340:28d1f895c6fe 367 __HAL_UART_ENABLE(huart);
mbed_official 340:28d1f895c6fe 368
mbed_official 340:28d1f895c6fe 369 /* TEACK and/or REACK to check before moving huart->State to Ready */
mbed_official 340:28d1f895c6fe 370 return (UART_CheckIdleState(huart));
mbed_official 340:28d1f895c6fe 371 }
mbed_official 340:28d1f895c6fe 372
mbed_official 340:28d1f895c6fe 373
mbed_official 340:28d1f895c6fe 374 /**
mbed_official 340:28d1f895c6fe 375 * @brief Initializes the multiprocessor mode according to the specified
mbed_official 340:28d1f895c6fe 376 * parameters in the UART_InitTypeDef and creates the associated handle.
mbed_official 340:28d1f895c6fe 377 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 378 * @param Address: UART node address (4-, 6-, 7- or 8-bit long)
mbed_official 340:28d1f895c6fe 379 * @param WakeUpMethod: specifies the UART wakeup method.
mbed_official 340:28d1f895c6fe 380 * This parameter can be one of the following values:
mbed_official 340:28d1f895c6fe 381 * @arg UART_WAKEUPMETHOD_IDLELINE: WakeUp by an idle line detection
mbed_official 340:28d1f895c6fe 382 * @arg UART_WAKEUPMETHOD_ADDRESSMARK: WakeUp by an address mark
mbed_official 340:28d1f895c6fe 383 * @note If the user resorts to idle line detection wake up, the Address parameter
mbed_official 340:28d1f895c6fe 384 * is useless and ignored by the initialization function.
mbed_official 340:28d1f895c6fe 385 * @note If the user resorts to address mark wake up, the address length detection
mbed_official 340:28d1f895c6fe 386 * is configured by default to 4 bits only. For the UART to be able to
mbed_official 340:28d1f895c6fe 387 * manage 6-, 7- or 8-bit long addresses detection, the API
mbed_official 340:28d1f895c6fe 388 * HAL_MultiProcessorEx_AddressLength_Set() must be called after
mbed_official 340:28d1f895c6fe 389 * HAL_MultiProcessor_Init().
mbed_official 340:28d1f895c6fe 390 * @retval HAL status
mbed_official 340:28d1f895c6fe 391 */
mbed_official 340:28d1f895c6fe 392 HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod)
mbed_official 340:28d1f895c6fe 393 {
mbed_official 340:28d1f895c6fe 394 /* Check the UART handle allocation */
mbed_official 441:d2c15dda23c1 395 if(huart == NULL)
mbed_official 340:28d1f895c6fe 396 {
mbed_official 340:28d1f895c6fe 397 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 398 }
mbed_official 340:28d1f895c6fe 399
mbed_official 340:28d1f895c6fe 400 /* Check the wake up method parameter */
mbed_official 340:28d1f895c6fe 401 assert_param(IS_UART_WAKEUPMETHOD(WakeUpMethod));
mbed_official 340:28d1f895c6fe 402
mbed_official 340:28d1f895c6fe 403 if(huart->State == HAL_UART_STATE_RESET)
mbed_official 340:28d1f895c6fe 404 {
mbed_official 340:28d1f895c6fe 405 /* Init the low level hardware : GPIO, CLOCK */
mbed_official 340:28d1f895c6fe 406 HAL_UART_MspInit(huart);
mbed_official 340:28d1f895c6fe 407 }
mbed_official 340:28d1f895c6fe 408
mbed_official 340:28d1f895c6fe 409 huart->State = HAL_UART_STATE_BUSY;
mbed_official 340:28d1f895c6fe 410
mbed_official 340:28d1f895c6fe 411 /* Disable the Peripheral */
mbed_official 340:28d1f895c6fe 412 __HAL_UART_DISABLE(huart);
mbed_official 340:28d1f895c6fe 413
mbed_official 340:28d1f895c6fe 414 /* Set the UART Communication parameters */
mbed_official 340:28d1f895c6fe 415 if (UART_SetConfig(huart) == HAL_ERROR)
mbed_official 340:28d1f895c6fe 416 {
mbed_official 340:28d1f895c6fe 417 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 418 }
mbed_official 340:28d1f895c6fe 419
mbed_official 340:28d1f895c6fe 420 if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)
mbed_official 340:28d1f895c6fe 421 {
mbed_official 340:28d1f895c6fe 422 UART_AdvFeatureConfig(huart);
mbed_official 340:28d1f895c6fe 423 }
mbed_official 340:28d1f895c6fe 424
mbed_official 340:28d1f895c6fe 425 /* In multiprocessor mode, the following bits must be kept cleared:
mbed_official 340:28d1f895c6fe 426 - LINEN and CLKEN bits in the USART_CR2 register,
mbed_official 340:28d1f895c6fe 427 - SCEN, HDSEL and IREN bits in the USART_CR3 register. */
mbed_official 340:28d1f895c6fe 428 huart->Instance->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN);
mbed_official 340:28d1f895c6fe 429 huart->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN);
mbed_official 340:28d1f895c6fe 430
mbed_official 340:28d1f895c6fe 431 if (WakeUpMethod == UART_WAKEUPMETHOD_ADDRESSMARK)
mbed_official 340:28d1f895c6fe 432 {
mbed_official 340:28d1f895c6fe 433 /* If address mark wake up method is chosen, set the USART address node */
mbed_official 340:28d1f895c6fe 434 MODIFY_REG(huart->Instance->CR2, USART_CR2_ADD, ((uint32_t)Address << UART_CR2_ADDRESS_LSB_POS));
mbed_official 340:28d1f895c6fe 435 }
mbed_official 340:28d1f895c6fe 436
mbed_official 340:28d1f895c6fe 437 /* Set the wake up method by setting the WAKE bit in the CR1 register */
mbed_official 340:28d1f895c6fe 438 MODIFY_REG(huart->Instance->CR1, USART_CR1_WAKE, WakeUpMethod);
mbed_official 340:28d1f895c6fe 439
mbed_official 340:28d1f895c6fe 440 /* Enable the Peripheral */
mbed_official 340:28d1f895c6fe 441 __HAL_UART_ENABLE(huart);
mbed_official 340:28d1f895c6fe 442
mbed_official 340:28d1f895c6fe 443 /* TEACK and/or REACK to check before moving huart->State to Ready */
mbed_official 340:28d1f895c6fe 444 return (UART_CheckIdleState(huart));
mbed_official 340:28d1f895c6fe 445 }
mbed_official 340:28d1f895c6fe 446
mbed_official 340:28d1f895c6fe 447 /**
mbed_official 340:28d1f895c6fe 448 * @brief DeInitializes the UART peripheral
mbed_official 340:28d1f895c6fe 449 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 450 * @retval HAL status
mbed_official 340:28d1f895c6fe 451 */
mbed_official 340:28d1f895c6fe 452 HAL_StatusTypeDef HAL_UART_DeInit(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 453 {
mbed_official 340:28d1f895c6fe 454 /* Check the UART handle allocation */
mbed_official 441:d2c15dda23c1 455 if(huart == NULL)
mbed_official 340:28d1f895c6fe 456 {
mbed_official 340:28d1f895c6fe 457 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 458 }
mbed_official 340:28d1f895c6fe 459
mbed_official 340:28d1f895c6fe 460 /* Check the parameters */
mbed_official 340:28d1f895c6fe 461 assert_param(IS_UART_INSTANCE(huart->Instance));
mbed_official 340:28d1f895c6fe 462
mbed_official 340:28d1f895c6fe 463 huart->State = HAL_UART_STATE_BUSY;
mbed_official 340:28d1f895c6fe 464
mbed_official 340:28d1f895c6fe 465 /* Disable the Peripheral */
mbed_official 340:28d1f895c6fe 466 __HAL_UART_DISABLE(huart);
mbed_official 340:28d1f895c6fe 467
mbed_official 340:28d1f895c6fe 468 huart->Instance->CR1 = 0x0;
mbed_official 340:28d1f895c6fe 469 huart->Instance->CR2 = 0x0;
mbed_official 340:28d1f895c6fe 470 huart->Instance->CR3 = 0x0;
mbed_official 340:28d1f895c6fe 471
mbed_official 340:28d1f895c6fe 472 /* DeInit the low level hardware */
mbed_official 340:28d1f895c6fe 473 HAL_UART_MspDeInit(huart);
mbed_official 340:28d1f895c6fe 474
mbed_official 340:28d1f895c6fe 475 huart->ErrorCode = HAL_UART_ERROR_NONE;
mbed_official 340:28d1f895c6fe 476 huart->State = HAL_UART_STATE_RESET;
mbed_official 340:28d1f895c6fe 477
mbed_official 340:28d1f895c6fe 478 /* Process Unlock */
mbed_official 340:28d1f895c6fe 479 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 480
mbed_official 340:28d1f895c6fe 481 return HAL_OK;
mbed_official 340:28d1f895c6fe 482 }
mbed_official 340:28d1f895c6fe 483
mbed_official 340:28d1f895c6fe 484 /**
mbed_official 340:28d1f895c6fe 485 * @brief UART MSP Init
mbed_official 340:28d1f895c6fe 486 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 487 * @retval None
mbed_official 340:28d1f895c6fe 488 */
mbed_official 340:28d1f895c6fe 489 __weak void HAL_UART_MspInit(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 490 {
mbed_official 340:28d1f895c6fe 491 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 340:28d1f895c6fe 492 the HAL_UART_MspInit can be implemented in the user file
mbed_official 340:28d1f895c6fe 493 */
mbed_official 340:28d1f895c6fe 494 }
mbed_official 340:28d1f895c6fe 495
mbed_official 340:28d1f895c6fe 496 /**
mbed_official 340:28d1f895c6fe 497 * @brief UART MSP DeInit
mbed_official 340:28d1f895c6fe 498 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 499 * @retval None
mbed_official 340:28d1f895c6fe 500 */
mbed_official 340:28d1f895c6fe 501 __weak void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 502 {
mbed_official 340:28d1f895c6fe 503 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 340:28d1f895c6fe 504 the HAL_UART_MspDeInit could be implemented in the user file
mbed_official 340:28d1f895c6fe 505 */
mbed_official 340:28d1f895c6fe 506 }
mbed_official 340:28d1f895c6fe 507
mbed_official 340:28d1f895c6fe 508 /**
mbed_official 340:28d1f895c6fe 509 * @}
mbed_official 340:28d1f895c6fe 510 */
mbed_official 340:28d1f895c6fe 511
mbed_official 340:28d1f895c6fe 512 /** @defgroup UART_Exported_Functions_Group2 IO operation functions
mbed_official 340:28d1f895c6fe 513 * @brief UART Transmit and Receive functions
mbed_official 340:28d1f895c6fe 514 *
mbed_official 340:28d1f895c6fe 515 @verbatim
mbed_official 340:28d1f895c6fe 516 ==============================================================================
mbed_official 340:28d1f895c6fe 517 ##### IO operation functions #####
mbed_official 340:28d1f895c6fe 518 ==============================================================================
mbed_official 340:28d1f895c6fe 519 [..]
mbed_official 340:28d1f895c6fe 520 This subsection provides a set of functions allowing to manage the UART asynchronous
mbed_official 340:28d1f895c6fe 521 and Half duplex data transfers.
mbed_official 340:28d1f895c6fe 522
mbed_official 340:28d1f895c6fe 523 (#) There are two mode of transfer:
mbed_official 340:28d1f895c6fe 524 (++) Blocking mode: The communication is performed in polling mode.
mbed_official 340:28d1f895c6fe 525 The HAL status of all data processing is returned by the same function
mbed_official 340:28d1f895c6fe 526 after finishing transfer.
mbed_official 340:28d1f895c6fe 527 (++) No-Blocking mode: The communication is performed using Interrupts
mbed_official 340:28d1f895c6fe 528 or DMA, These APIs return the HAL status.
mbed_official 340:28d1f895c6fe 529 The end of the data processing will be indicated through the
mbed_official 340:28d1f895c6fe 530 dedicated UART IRQ when using Interrupt mode or the DMA IRQ when
mbed_official 340:28d1f895c6fe 531 using DMA mode.
mbed_official 340:28d1f895c6fe 532 The HAL_UART_TxCpltCallback(), HAL_UART_RxCpltCallback() user callbacks
mbed_official 340:28d1f895c6fe 533 will be executed respectivelly at the end of the transmit or Receive process
mbed_official 340:28d1f895c6fe 534 The HAL_UART_ErrorCallback()user callback will be executed when a communication error is detected
mbed_official 340:28d1f895c6fe 535
mbed_official 340:28d1f895c6fe 536 (#) Blocking mode APIs are :
mbed_official 340:28d1f895c6fe 537 (++) HAL_UART_Transmit()
mbed_official 340:28d1f895c6fe 538 (++) HAL_UART_Receive()
mbed_official 340:28d1f895c6fe 539
mbed_official 340:28d1f895c6fe 540 (#) Non Blocking mode APIs with Interrupt are :
mbed_official 340:28d1f895c6fe 541 (++) HAL_UART_Transmit_IT()
mbed_official 340:28d1f895c6fe 542 (++) HAL_UART_Receive_IT()
mbed_official 340:28d1f895c6fe 543 (++) HAL_UART_IRQHandler()
mbed_official 340:28d1f895c6fe 544 (++) UART_Transmit_IT()
mbed_official 340:28d1f895c6fe 545 (++) UART_Receive_IT()
mbed_official 340:28d1f895c6fe 546
mbed_official 340:28d1f895c6fe 547 (#) Non Blocking mode APIs with DMA are :
mbed_official 340:28d1f895c6fe 548 (++) HAL_UART_Transmit_DMA()
mbed_official 340:28d1f895c6fe 549 (++) HAL_UART_Receive_DMA()
mbed_official 340:28d1f895c6fe 550 (++) HAL_UART_DMAPause()
mbed_official 340:28d1f895c6fe 551 (++) HAL_UART_DMAResume()
mbed_official 340:28d1f895c6fe 552 (++) HAL_UART_DMAStop()
mbed_official 340:28d1f895c6fe 553
mbed_official 340:28d1f895c6fe 554 (#) A set of Transfer Complete Callbacks are provided in non blocking mode:
mbed_official 340:28d1f895c6fe 555 (++) HAL_UART_TxHalfCpltCallback()
mbed_official 340:28d1f895c6fe 556 (++) HAL_UART_TxCpltCallback()
mbed_official 340:28d1f895c6fe 557 (++) HAL_UART_RxHalfCpltCallback()
mbed_official 340:28d1f895c6fe 558 (++) HAL_UART_RxCpltCallback()
mbed_official 340:28d1f895c6fe 559 (++) HAL_UART_ErrorCallback()
mbed_official 340:28d1f895c6fe 560
mbed_official 340:28d1f895c6fe 561 [..]
mbed_official 340:28d1f895c6fe 562 (@) In the Half duplex communication, it is forbidden to run the transmit
mbed_official 340:28d1f895c6fe 563 and receive process in parallel, the UART state HAL_UART_STATE_BUSY_TX_RX can't be useful.
mbed_official 340:28d1f895c6fe 564
mbed_official 340:28d1f895c6fe 565 @endverbatim
mbed_official 340:28d1f895c6fe 566 * @{
mbed_official 340:28d1f895c6fe 567 */
mbed_official 340:28d1f895c6fe 568
mbed_official 340:28d1f895c6fe 569 /**
mbed_official 340:28d1f895c6fe 570 * @brief Send an amount of data in blocking mode
mbed_official 340:28d1f895c6fe 571 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 572 * @param pData: pointer to data buffer
mbed_official 340:28d1f895c6fe 573 * @param Size: amount of data to be sent
mbed_official 340:28d1f895c6fe 574 * @param Timeout : Timeout duration
mbed_official 340:28d1f895c6fe 575 * @retval HAL status
mbed_official 340:28d1f895c6fe 576 */
mbed_official 340:28d1f895c6fe 577 HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 340:28d1f895c6fe 578 {
mbed_official 340:28d1f895c6fe 579 uint16_t* tmp;
mbed_official 340:28d1f895c6fe 580
mbed_official 340:28d1f895c6fe 581 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_RX))
mbed_official 340:28d1f895c6fe 582 {
mbed_official 441:d2c15dda23c1 583 if((pData == NULL ) || (Size == 0))
mbed_official 340:28d1f895c6fe 584 {
mbed_official 340:28d1f895c6fe 585 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 586 }
mbed_official 340:28d1f895c6fe 587
mbed_official 340:28d1f895c6fe 588 /* Process Locked */
mbed_official 340:28d1f895c6fe 589 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 590
mbed_official 340:28d1f895c6fe 591 huart->ErrorCode = HAL_UART_ERROR_NONE;
mbed_official 340:28d1f895c6fe 592 /* Check if a non-blocking receive process is ongoing or not */
mbed_official 340:28d1f895c6fe 593 if(huart->State == HAL_UART_STATE_BUSY_RX)
mbed_official 340:28d1f895c6fe 594 {
mbed_official 340:28d1f895c6fe 595 huart->State = HAL_UART_STATE_BUSY_TX_RX;
mbed_official 340:28d1f895c6fe 596 }
mbed_official 340:28d1f895c6fe 597 else
mbed_official 340:28d1f895c6fe 598 {
mbed_official 340:28d1f895c6fe 599 huart->State = HAL_UART_STATE_BUSY_TX;
mbed_official 340:28d1f895c6fe 600 }
mbed_official 340:28d1f895c6fe 601
mbed_official 340:28d1f895c6fe 602 huart->TxXferSize = Size;
mbed_official 340:28d1f895c6fe 603 huart->TxXferCount = Size;
mbed_official 340:28d1f895c6fe 604 while(huart->TxXferCount > 0)
mbed_official 340:28d1f895c6fe 605 {
mbed_official 340:28d1f895c6fe 606 huart->TxXferCount--;
mbed_official 340:28d1f895c6fe 607 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, Timeout) != HAL_OK)
mbed_official 340:28d1f895c6fe 608 {
mbed_official 340:28d1f895c6fe 609 return HAL_TIMEOUT;
mbed_official 340:28d1f895c6fe 610 }
mbed_official 340:28d1f895c6fe 611 if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
mbed_official 340:28d1f895c6fe 612 {
mbed_official 340:28d1f895c6fe 613 tmp = (uint16_t*) pData;
mbed_official 340:28d1f895c6fe 614 huart->Instance->TDR = (*tmp & (uint16_t)0x01FF);
mbed_official 340:28d1f895c6fe 615 pData += 2;
mbed_official 340:28d1f895c6fe 616 }
mbed_official 340:28d1f895c6fe 617 else
mbed_official 340:28d1f895c6fe 618 {
mbed_official 340:28d1f895c6fe 619 huart->Instance->TDR = (*pData++ & (uint8_t)0xFF);
mbed_official 340:28d1f895c6fe 620 }
mbed_official 340:28d1f895c6fe 621 }
mbed_official 340:28d1f895c6fe 622 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, Timeout) != HAL_OK)
mbed_official 340:28d1f895c6fe 623 {
mbed_official 340:28d1f895c6fe 624 return HAL_TIMEOUT;
mbed_official 340:28d1f895c6fe 625 }
mbed_official 340:28d1f895c6fe 626 /* Check if a non-blocking receive Process is ongoing or not */
mbed_official 340:28d1f895c6fe 627 if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
mbed_official 340:28d1f895c6fe 628 {
mbed_official 340:28d1f895c6fe 629 huart->State = HAL_UART_STATE_BUSY_RX;
mbed_official 340:28d1f895c6fe 630 }
mbed_official 340:28d1f895c6fe 631 else
mbed_official 340:28d1f895c6fe 632 {
mbed_official 340:28d1f895c6fe 633 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 634 }
mbed_official 340:28d1f895c6fe 635
mbed_official 340:28d1f895c6fe 636 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 637 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 638
mbed_official 340:28d1f895c6fe 639 return HAL_OK;
mbed_official 340:28d1f895c6fe 640 }
mbed_official 340:28d1f895c6fe 641 else
mbed_official 340:28d1f895c6fe 642 {
mbed_official 340:28d1f895c6fe 643 return HAL_BUSY;
mbed_official 340:28d1f895c6fe 644 }
mbed_official 340:28d1f895c6fe 645 }
mbed_official 340:28d1f895c6fe 646
mbed_official 340:28d1f895c6fe 647 /**
mbed_official 340:28d1f895c6fe 648 * @brief Receive an amount of data in blocking mode
mbed_official 340:28d1f895c6fe 649 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 650 * @param pData: pointer to data buffer
mbed_official 340:28d1f895c6fe 651 * @param Size: amount of data to be received
mbed_official 340:28d1f895c6fe 652 * @param Timeout : Timeout duration
mbed_official 340:28d1f895c6fe 653 * @retval HAL status
mbed_official 340:28d1f895c6fe 654 */
mbed_official 340:28d1f895c6fe 655 HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
mbed_official 340:28d1f895c6fe 656 {
mbed_official 340:28d1f895c6fe 657 uint16_t* tmp;
mbed_official 340:28d1f895c6fe 658 uint16_t uhMask;
mbed_official 340:28d1f895c6fe 659
mbed_official 340:28d1f895c6fe 660 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_TX))
mbed_official 340:28d1f895c6fe 661 {
mbed_official 441:d2c15dda23c1 662 if((pData == NULL ) || (Size == 0))
mbed_official 340:28d1f895c6fe 663 {
mbed_official 340:28d1f895c6fe 664 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 665 }
mbed_official 340:28d1f895c6fe 666
mbed_official 340:28d1f895c6fe 667 /* Process Locked */
mbed_official 340:28d1f895c6fe 668 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 669
mbed_official 340:28d1f895c6fe 670 huart->ErrorCode = HAL_UART_ERROR_NONE;
mbed_official 340:28d1f895c6fe 671 /* Check if a non-blocking transmit process is ongoing or not */
mbed_official 340:28d1f895c6fe 672 if(huart->State == HAL_UART_STATE_BUSY_TX)
mbed_official 340:28d1f895c6fe 673 {
mbed_official 340:28d1f895c6fe 674 huart->State = HAL_UART_STATE_BUSY_TX_RX;
mbed_official 340:28d1f895c6fe 675 }
mbed_official 340:28d1f895c6fe 676 else
mbed_official 340:28d1f895c6fe 677 {
mbed_official 340:28d1f895c6fe 678 huart->State = HAL_UART_STATE_BUSY_RX;
mbed_official 340:28d1f895c6fe 679 }
mbed_official 340:28d1f895c6fe 680
mbed_official 340:28d1f895c6fe 681 huart->RxXferSize = Size;
mbed_official 340:28d1f895c6fe 682 huart->RxXferCount = Size;
mbed_official 340:28d1f895c6fe 683
mbed_official 340:28d1f895c6fe 684 /* Computation of UART mask to apply to RDR register */
mbed_official 340:28d1f895c6fe 685 __HAL_UART_MASK_COMPUTATION(huart);
mbed_official 340:28d1f895c6fe 686 uhMask = huart->Mask;
mbed_official 340:28d1f895c6fe 687
mbed_official 340:28d1f895c6fe 688 /* as long as data have to be received */
mbed_official 340:28d1f895c6fe 689 while(huart->RxXferCount > 0)
mbed_official 340:28d1f895c6fe 690 {
mbed_official 340:28d1f895c6fe 691 huart->RxXferCount--;
mbed_official 340:28d1f895c6fe 692 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_RXNE, RESET, Timeout) != HAL_OK)
mbed_official 340:28d1f895c6fe 693 {
mbed_official 340:28d1f895c6fe 694 return HAL_TIMEOUT;
mbed_official 340:28d1f895c6fe 695 }
mbed_official 340:28d1f895c6fe 696 if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
mbed_official 340:28d1f895c6fe 697 {
mbed_official 340:28d1f895c6fe 698 tmp = (uint16_t*) pData ;
mbed_official 340:28d1f895c6fe 699 *tmp = (uint16_t)(huart->Instance->RDR & uhMask);
mbed_official 340:28d1f895c6fe 700 pData +=2;
mbed_official 340:28d1f895c6fe 701 }
mbed_official 340:28d1f895c6fe 702 else
mbed_official 340:28d1f895c6fe 703 {
mbed_official 340:28d1f895c6fe 704 *pData++ = (uint8_t)(huart->Instance->RDR & (uint8_t)uhMask);
mbed_official 340:28d1f895c6fe 705 }
mbed_official 340:28d1f895c6fe 706 }
mbed_official 340:28d1f895c6fe 707
mbed_official 340:28d1f895c6fe 708 /* Check if a non-blocking transmit Process is ongoing or not */
mbed_official 340:28d1f895c6fe 709 if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
mbed_official 340:28d1f895c6fe 710 {
mbed_official 340:28d1f895c6fe 711 huart->State = HAL_UART_STATE_BUSY_TX;
mbed_official 340:28d1f895c6fe 712 }
mbed_official 340:28d1f895c6fe 713 else
mbed_official 340:28d1f895c6fe 714 {
mbed_official 340:28d1f895c6fe 715 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 716 }
mbed_official 340:28d1f895c6fe 717 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 718 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 719
mbed_official 340:28d1f895c6fe 720 return HAL_OK;
mbed_official 340:28d1f895c6fe 721 }
mbed_official 340:28d1f895c6fe 722 else
mbed_official 340:28d1f895c6fe 723 {
mbed_official 340:28d1f895c6fe 724 return HAL_BUSY;
mbed_official 340:28d1f895c6fe 725 }
mbed_official 340:28d1f895c6fe 726 }
mbed_official 340:28d1f895c6fe 727
mbed_official 340:28d1f895c6fe 728 /**
mbed_official 340:28d1f895c6fe 729 * @brief Send an amount of data in interrupt mode
mbed_official 340:28d1f895c6fe 730 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 731 * @param pData: pointer to data buffer
mbed_official 340:28d1f895c6fe 732 * @param Size: amount of data to be sent
mbed_official 340:28d1f895c6fe 733 * @retval HAL status
mbed_official 340:28d1f895c6fe 734 */
mbed_official 340:28d1f895c6fe 735 HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
mbed_official 340:28d1f895c6fe 736 {
mbed_official 340:28d1f895c6fe 737 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_RX))
mbed_official 340:28d1f895c6fe 738 {
mbed_official 441:d2c15dda23c1 739 if((pData == NULL ) || (Size == 0))
mbed_official 340:28d1f895c6fe 740 {
mbed_official 340:28d1f895c6fe 741 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 742 }
mbed_official 340:28d1f895c6fe 743
mbed_official 340:28d1f895c6fe 744 /* Process Locked */
mbed_official 340:28d1f895c6fe 745 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 746
mbed_official 340:28d1f895c6fe 747 huart->pTxBuffPtr = pData;
mbed_official 340:28d1f895c6fe 748 huart->TxXferSize = Size;
mbed_official 340:28d1f895c6fe 749 huart->TxXferCount = Size;
mbed_official 340:28d1f895c6fe 750
mbed_official 340:28d1f895c6fe 751 huart->ErrorCode = HAL_UART_ERROR_NONE;
mbed_official 340:28d1f895c6fe 752 /* Check if a receive process is ongoing or not */
mbed_official 340:28d1f895c6fe 753 if(huart->State == HAL_UART_STATE_BUSY_RX)
mbed_official 340:28d1f895c6fe 754 {
mbed_official 340:28d1f895c6fe 755 huart->State = HAL_UART_STATE_BUSY_TX_RX;
mbed_official 340:28d1f895c6fe 756 }
mbed_official 340:28d1f895c6fe 757 else
mbed_official 340:28d1f895c6fe 758 {
mbed_official 340:28d1f895c6fe 759 huart->State = HAL_UART_STATE_BUSY_TX;
mbed_official 340:28d1f895c6fe 760 }
mbed_official 340:28d1f895c6fe 761
mbed_official 340:28d1f895c6fe 762 /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 340:28d1f895c6fe 763 __HAL_UART_ENABLE_IT(huart, UART_IT_ERR);
mbed_official 340:28d1f895c6fe 764
mbed_official 340:28d1f895c6fe 765 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 766 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 767
mbed_official 340:28d1f895c6fe 768 /* Enable the UART Transmit Data Register Empty Interrupt */
mbed_official 340:28d1f895c6fe 769 __HAL_UART_ENABLE_IT(huart, UART_IT_TXE);
mbed_official 340:28d1f895c6fe 770
mbed_official 340:28d1f895c6fe 771 return HAL_OK;
mbed_official 340:28d1f895c6fe 772 }
mbed_official 340:28d1f895c6fe 773 else
mbed_official 340:28d1f895c6fe 774 {
mbed_official 340:28d1f895c6fe 775 return HAL_BUSY;
mbed_official 340:28d1f895c6fe 776 }
mbed_official 340:28d1f895c6fe 777 }
mbed_official 340:28d1f895c6fe 778
mbed_official 340:28d1f895c6fe 779 /**
mbed_official 340:28d1f895c6fe 780 * @brief Receive an amount of data in interrupt mode
mbed_official 340:28d1f895c6fe 781 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 782 * @param pData: pointer to data buffer
mbed_official 340:28d1f895c6fe 783 * @param Size: amount of data to be received
mbed_official 340:28d1f895c6fe 784 * @retval HAL status
mbed_official 340:28d1f895c6fe 785 */
mbed_official 340:28d1f895c6fe 786 HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
mbed_official 340:28d1f895c6fe 787 {
mbed_official 340:28d1f895c6fe 788 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_TX))
mbed_official 340:28d1f895c6fe 789 {
mbed_official 441:d2c15dda23c1 790 if((pData == NULL ) || (Size == 0))
mbed_official 340:28d1f895c6fe 791 {
mbed_official 340:28d1f895c6fe 792 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 793 }
mbed_official 340:28d1f895c6fe 794
mbed_official 340:28d1f895c6fe 795 /* Process Locked */
mbed_official 340:28d1f895c6fe 796 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 797
mbed_official 340:28d1f895c6fe 798 huart->pRxBuffPtr = pData;
mbed_official 340:28d1f895c6fe 799 huart->RxXferSize = Size;
mbed_official 340:28d1f895c6fe 800 huart->RxXferCount = Size;
mbed_official 340:28d1f895c6fe 801
mbed_official 340:28d1f895c6fe 802 /* Computation of UART mask to apply to RDR register */
mbed_official 340:28d1f895c6fe 803 __HAL_UART_MASK_COMPUTATION(huart);
mbed_official 340:28d1f895c6fe 804
mbed_official 340:28d1f895c6fe 805 huart->ErrorCode = HAL_UART_ERROR_NONE;
mbed_official 340:28d1f895c6fe 806 /* Check if a transmit process is ongoing or not */
mbed_official 340:28d1f895c6fe 807 if(huart->State == HAL_UART_STATE_BUSY_TX)
mbed_official 340:28d1f895c6fe 808 {
mbed_official 340:28d1f895c6fe 809 huart->State = HAL_UART_STATE_BUSY_TX_RX;
mbed_official 340:28d1f895c6fe 810 }
mbed_official 340:28d1f895c6fe 811 else
mbed_official 340:28d1f895c6fe 812 {
mbed_official 340:28d1f895c6fe 813 huart->State = HAL_UART_STATE_BUSY_RX;
mbed_official 340:28d1f895c6fe 814 }
mbed_official 340:28d1f895c6fe 815
mbed_official 340:28d1f895c6fe 816 /* Enable the UART Parity Error Interrupt */
mbed_official 340:28d1f895c6fe 817 __HAL_UART_ENABLE_IT(huart, UART_IT_PE);
mbed_official 340:28d1f895c6fe 818
mbed_official 340:28d1f895c6fe 819 /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 340:28d1f895c6fe 820 __HAL_UART_ENABLE_IT(huart, UART_IT_ERR);
mbed_official 340:28d1f895c6fe 821
mbed_official 340:28d1f895c6fe 822 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 823 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 824
mbed_official 340:28d1f895c6fe 825 /* Enable the UART Data Register not empty Interrupt */
mbed_official 340:28d1f895c6fe 826 __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
mbed_official 340:28d1f895c6fe 827
mbed_official 340:28d1f895c6fe 828 return HAL_OK;
mbed_official 340:28d1f895c6fe 829 }
mbed_official 340:28d1f895c6fe 830 else
mbed_official 340:28d1f895c6fe 831 {
mbed_official 340:28d1f895c6fe 832 return HAL_BUSY;
mbed_official 340:28d1f895c6fe 833 }
mbed_official 340:28d1f895c6fe 834 }
mbed_official 340:28d1f895c6fe 835
mbed_official 340:28d1f895c6fe 836 /**
mbed_official 340:28d1f895c6fe 837 * @brief Send an amount of data in DMA mode
mbed_official 340:28d1f895c6fe 838 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 839 * @param pData: pointer to data buffer
mbed_official 340:28d1f895c6fe 840 * @param Size: amount of data to be sent
mbed_official 340:28d1f895c6fe 841 * @retval HAL status
mbed_official 340:28d1f895c6fe 842 */
mbed_official 340:28d1f895c6fe 843 HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
mbed_official 340:28d1f895c6fe 844 {
mbed_official 340:28d1f895c6fe 845 uint32_t *tmp;
mbed_official 340:28d1f895c6fe 846
mbed_official 340:28d1f895c6fe 847 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_RX))
mbed_official 340:28d1f895c6fe 848 {
mbed_official 441:d2c15dda23c1 849 if((pData == NULL ) || (Size == 0))
mbed_official 340:28d1f895c6fe 850 {
mbed_official 340:28d1f895c6fe 851 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 852 }
mbed_official 340:28d1f895c6fe 853
mbed_official 340:28d1f895c6fe 854 /* Process Locked */
mbed_official 340:28d1f895c6fe 855 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 856
mbed_official 340:28d1f895c6fe 857 huart->pTxBuffPtr = pData;
mbed_official 340:28d1f895c6fe 858 huart->TxXferSize = Size;
mbed_official 340:28d1f895c6fe 859 huart->TxXferCount = Size;
mbed_official 340:28d1f895c6fe 860
mbed_official 340:28d1f895c6fe 861 huart->ErrorCode = HAL_UART_ERROR_NONE;
mbed_official 340:28d1f895c6fe 862 /* Check if a receive process is ongoing or not */
mbed_official 340:28d1f895c6fe 863 if(huart->State == HAL_UART_STATE_BUSY_RX)
mbed_official 340:28d1f895c6fe 864 {
mbed_official 340:28d1f895c6fe 865 huart->State = HAL_UART_STATE_BUSY_TX_RX;
mbed_official 340:28d1f895c6fe 866 }
mbed_official 340:28d1f895c6fe 867 else
mbed_official 340:28d1f895c6fe 868 {
mbed_official 340:28d1f895c6fe 869 huart->State = HAL_UART_STATE_BUSY_TX;
mbed_official 340:28d1f895c6fe 870 }
mbed_official 340:28d1f895c6fe 871
mbed_official 340:28d1f895c6fe 872 /* Set the UART DMA transfer complete callback */
mbed_official 340:28d1f895c6fe 873 huart->hdmatx->XferCpltCallback = UART_DMATransmitCplt;
mbed_official 340:28d1f895c6fe 874
mbed_official 340:28d1f895c6fe 875 /* Set the UART DMA Half transfer complete callback */
mbed_official 340:28d1f895c6fe 876 huart->hdmatx->XferHalfCpltCallback = UART_DMATxHalfCplt;
mbed_official 340:28d1f895c6fe 877
mbed_official 340:28d1f895c6fe 878 /* Set the DMA error callback */
mbed_official 340:28d1f895c6fe 879 huart->hdmatx->XferErrorCallback = UART_DMAError;
mbed_official 340:28d1f895c6fe 880
mbed_official 340:28d1f895c6fe 881 /* Enable the UART transmit DMA channel */
mbed_official 340:28d1f895c6fe 882 tmp = (uint32_t*)&pData;
mbed_official 340:28d1f895c6fe 883 HAL_DMA_Start_IT(huart->hdmatx, *(uint32_t*)tmp, (uint32_t)&huart->Instance->TDR, Size);
mbed_official 340:28d1f895c6fe 884
mbed_official 340:28d1f895c6fe 885 /* Enable the DMA transfer for transmit request by setting the DMAT bit
mbed_official 340:28d1f895c6fe 886 in the UART CR3 register */
mbed_official 340:28d1f895c6fe 887 huart->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 340:28d1f895c6fe 888
mbed_official 340:28d1f895c6fe 889 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 890 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 891
mbed_official 340:28d1f895c6fe 892 return HAL_OK;
mbed_official 340:28d1f895c6fe 893 }
mbed_official 340:28d1f895c6fe 894 else
mbed_official 340:28d1f895c6fe 895 {
mbed_official 340:28d1f895c6fe 896 return HAL_BUSY;
mbed_official 340:28d1f895c6fe 897 }
mbed_official 340:28d1f895c6fe 898 }
mbed_official 340:28d1f895c6fe 899
mbed_official 340:28d1f895c6fe 900 /**
mbed_official 340:28d1f895c6fe 901 * @brief Receive an amount of data in DMA mode
mbed_official 340:28d1f895c6fe 902 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 903 * @param pData: pointer to data buffer
mbed_official 340:28d1f895c6fe 904 * @param Size: amount of data to be received
mbed_official 340:28d1f895c6fe 905 * @note When the UART parity is enabled (PCE = 1), the received data contain
mbed_official 340:28d1f895c6fe 906 * the parity bit (MSB position)
mbed_official 340:28d1f895c6fe 907 * @retval HAL status
mbed_official 340:28d1f895c6fe 908 */
mbed_official 340:28d1f895c6fe 909 HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
mbed_official 340:28d1f895c6fe 910 {
mbed_official 340:28d1f895c6fe 911 uint32_t *tmp;
mbed_official 340:28d1f895c6fe 912
mbed_official 340:28d1f895c6fe 913 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_TX))
mbed_official 340:28d1f895c6fe 914 {
mbed_official 441:d2c15dda23c1 915 if((pData == NULL ) || (Size == 0))
mbed_official 340:28d1f895c6fe 916 {
mbed_official 340:28d1f895c6fe 917 return HAL_ERROR;
mbed_official 340:28d1f895c6fe 918 }
mbed_official 340:28d1f895c6fe 919
mbed_official 340:28d1f895c6fe 920 /* Process Locked */
mbed_official 340:28d1f895c6fe 921 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 922
mbed_official 340:28d1f895c6fe 923 huart->pRxBuffPtr = pData;
mbed_official 340:28d1f895c6fe 924 huart->RxXferSize = Size;
mbed_official 340:28d1f895c6fe 925
mbed_official 340:28d1f895c6fe 926 huart->ErrorCode = HAL_UART_ERROR_NONE;
mbed_official 340:28d1f895c6fe 927 /* Check if a transmit process is ongoing or not */
mbed_official 340:28d1f895c6fe 928 if(huart->State == HAL_UART_STATE_BUSY_TX)
mbed_official 340:28d1f895c6fe 929 {
mbed_official 340:28d1f895c6fe 930 huart->State = HAL_UART_STATE_BUSY_TX_RX;
mbed_official 340:28d1f895c6fe 931 }
mbed_official 340:28d1f895c6fe 932 else
mbed_official 340:28d1f895c6fe 933 {
mbed_official 340:28d1f895c6fe 934 huart->State = HAL_UART_STATE_BUSY_RX;
mbed_official 340:28d1f895c6fe 935 }
mbed_official 340:28d1f895c6fe 936
mbed_official 340:28d1f895c6fe 937 /* Set the UART DMA transfer complete callback */
mbed_official 340:28d1f895c6fe 938 huart->hdmarx->XferCpltCallback = UART_DMAReceiveCplt;
mbed_official 340:28d1f895c6fe 939
mbed_official 340:28d1f895c6fe 940 /* Set the UART DMA Half transfer complete callback */
mbed_official 340:28d1f895c6fe 941 huart->hdmarx->XferHalfCpltCallback = UART_DMARxHalfCplt;
mbed_official 340:28d1f895c6fe 942
mbed_official 340:28d1f895c6fe 943 /* Set the DMA error callback */
mbed_official 340:28d1f895c6fe 944 huart->hdmarx->XferErrorCallback = UART_DMAError;
mbed_official 340:28d1f895c6fe 945
mbed_official 340:28d1f895c6fe 946 /* Enable the DMA channel */
mbed_official 340:28d1f895c6fe 947 tmp = (uint32_t*)&pData;
mbed_official 340:28d1f895c6fe 948 HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->RDR, *(uint32_t*)tmp, Size);
mbed_official 340:28d1f895c6fe 949
mbed_official 340:28d1f895c6fe 950 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official 340:28d1f895c6fe 951 in the UART CR3 register */
mbed_official 340:28d1f895c6fe 952 huart->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 340:28d1f895c6fe 953
mbed_official 340:28d1f895c6fe 954 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 955 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 956
mbed_official 340:28d1f895c6fe 957 return HAL_OK;
mbed_official 340:28d1f895c6fe 958 }
mbed_official 340:28d1f895c6fe 959 else
mbed_official 340:28d1f895c6fe 960 {
mbed_official 340:28d1f895c6fe 961 return HAL_BUSY;
mbed_official 340:28d1f895c6fe 962 }
mbed_official 340:28d1f895c6fe 963 }
mbed_official 340:28d1f895c6fe 964
mbed_official 340:28d1f895c6fe 965 /**
mbed_official 340:28d1f895c6fe 966 * @brief Pauses the DMA Transfer.
mbed_official 340:28d1f895c6fe 967 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 968 * @retval None
mbed_official 340:28d1f895c6fe 969 */
mbed_official 340:28d1f895c6fe 970 HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 971 {
mbed_official 340:28d1f895c6fe 972 /* Process Locked */
mbed_official 340:28d1f895c6fe 973 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 974
mbed_official 340:28d1f895c6fe 975 if(huart->State == HAL_UART_STATE_BUSY_TX)
mbed_official 340:28d1f895c6fe 976 {
mbed_official 340:28d1f895c6fe 977 /* Disable the UART DMA Tx request */
mbed_official 340:28d1f895c6fe 978 huart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
mbed_official 340:28d1f895c6fe 979 }
mbed_official 340:28d1f895c6fe 980 else if(huart->State == HAL_UART_STATE_BUSY_RX)
mbed_official 340:28d1f895c6fe 981 {
mbed_official 340:28d1f895c6fe 982 /* Disable the UART DMA Rx request */
mbed_official 340:28d1f895c6fe 983 huart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
mbed_official 340:28d1f895c6fe 984 }
mbed_official 340:28d1f895c6fe 985 else if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
mbed_official 340:28d1f895c6fe 986 {
mbed_official 340:28d1f895c6fe 987 /* Disable the UART DMA Tx request */
mbed_official 340:28d1f895c6fe 988 huart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
mbed_official 340:28d1f895c6fe 989 /* Disable the UART DMA Rx request */
mbed_official 340:28d1f895c6fe 990 huart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
mbed_official 340:28d1f895c6fe 991 }
mbed_official 340:28d1f895c6fe 992
mbed_official 340:28d1f895c6fe 993 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 994 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 995
mbed_official 340:28d1f895c6fe 996 return HAL_OK;
mbed_official 340:28d1f895c6fe 997 }
mbed_official 340:28d1f895c6fe 998
mbed_official 340:28d1f895c6fe 999 /**
mbed_official 340:28d1f895c6fe 1000 * @brief Resumes the DMA Transfer.
mbed_official 340:28d1f895c6fe 1001 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 1002 * @retval None
mbed_official 340:28d1f895c6fe 1003 */
mbed_official 340:28d1f895c6fe 1004 HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1005 {
mbed_official 340:28d1f895c6fe 1006 /* Process Locked */
mbed_official 340:28d1f895c6fe 1007 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 1008
mbed_official 340:28d1f895c6fe 1009 if(huart->State == HAL_UART_STATE_BUSY_TX)
mbed_official 340:28d1f895c6fe 1010 {
mbed_official 340:28d1f895c6fe 1011 /* Enable the UART DMA Tx request */
mbed_official 340:28d1f895c6fe 1012 huart->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 340:28d1f895c6fe 1013 }
mbed_official 340:28d1f895c6fe 1014 else if(huart->State == HAL_UART_STATE_BUSY_RX)
mbed_official 340:28d1f895c6fe 1015 {
mbed_official 340:28d1f895c6fe 1016 /* Enable the UART DMA Rx request */
mbed_official 340:28d1f895c6fe 1017 huart->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 340:28d1f895c6fe 1018 }
mbed_official 340:28d1f895c6fe 1019 else if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
mbed_official 340:28d1f895c6fe 1020 {
mbed_official 340:28d1f895c6fe 1021 /* Enable the UART DMA Rx request before the DMA Tx request */
mbed_official 340:28d1f895c6fe 1022 huart->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 340:28d1f895c6fe 1023 /* Enable the UART DMA Tx request */
mbed_official 340:28d1f895c6fe 1024 huart->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 340:28d1f895c6fe 1025 }
mbed_official 340:28d1f895c6fe 1026
mbed_official 340:28d1f895c6fe 1027 /* If the UART peripheral is still not enabled, enable it */
mbed_official 340:28d1f895c6fe 1028 if ((huart->Instance->CR1 & USART_CR1_UE) == 0)
mbed_official 340:28d1f895c6fe 1029 {
mbed_official 340:28d1f895c6fe 1030 /* Enable UART peripheral */
mbed_official 340:28d1f895c6fe 1031 __HAL_UART_ENABLE(huart);
mbed_official 340:28d1f895c6fe 1032 }
mbed_official 340:28d1f895c6fe 1033
mbed_official 340:28d1f895c6fe 1034 /* TEACK and/or REACK to check before moving huart->State to Ready */
mbed_official 340:28d1f895c6fe 1035 return (UART_CheckIdleState(huart));
mbed_official 340:28d1f895c6fe 1036 }
mbed_official 340:28d1f895c6fe 1037
mbed_official 340:28d1f895c6fe 1038 /**
mbed_official 340:28d1f895c6fe 1039 * @brief Stops the DMA Transfer.
mbed_official 340:28d1f895c6fe 1040 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 1041 * @retval None
mbed_official 340:28d1f895c6fe 1042 */
mbed_official 340:28d1f895c6fe 1043 HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1044 {
mbed_official 340:28d1f895c6fe 1045 /* Process Locked */
mbed_official 340:28d1f895c6fe 1046 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 1047
mbed_official 340:28d1f895c6fe 1048 /* Disable the UART Tx/Rx DMA requests */
mbed_official 340:28d1f895c6fe 1049 huart->Instance->CR3 &= ~USART_CR3_DMAT;
mbed_official 340:28d1f895c6fe 1050 huart->Instance->CR3 &= ~USART_CR3_DMAR;
mbed_official 340:28d1f895c6fe 1051
mbed_official 340:28d1f895c6fe 1052 /* Abort the UART DMA tx channel */
mbed_official 441:d2c15dda23c1 1053 if(huart->hdmatx != NULL)
mbed_official 340:28d1f895c6fe 1054 {
mbed_official 340:28d1f895c6fe 1055 HAL_DMA_Abort(huart->hdmatx);
mbed_official 340:28d1f895c6fe 1056 }
mbed_official 340:28d1f895c6fe 1057 /* Abort the UART DMA rx channel */
mbed_official 441:d2c15dda23c1 1058 if(huart->hdmarx != NULL)
mbed_official 340:28d1f895c6fe 1059 {
mbed_official 340:28d1f895c6fe 1060 HAL_DMA_Abort(huart->hdmarx);
mbed_official 340:28d1f895c6fe 1061 }
mbed_official 340:28d1f895c6fe 1062
mbed_official 340:28d1f895c6fe 1063 /* Disable UART peripheral */
mbed_official 340:28d1f895c6fe 1064 __HAL_UART_DISABLE(huart);
mbed_official 340:28d1f895c6fe 1065
mbed_official 340:28d1f895c6fe 1066 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1067
mbed_official 340:28d1f895c6fe 1068 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 1069 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 1070
mbed_official 340:28d1f895c6fe 1071 return HAL_OK;
mbed_official 340:28d1f895c6fe 1072 }
mbed_official 340:28d1f895c6fe 1073
mbed_official 340:28d1f895c6fe 1074 /**
mbed_official 340:28d1f895c6fe 1075 * @brief Tx Transfer completed callbacks
mbed_official 340:28d1f895c6fe 1076 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 1077 * @retval None
mbed_official 340:28d1f895c6fe 1078 */
mbed_official 340:28d1f895c6fe 1079 __weak void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1080 {
mbed_official 340:28d1f895c6fe 1081 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 340:28d1f895c6fe 1082 the HAL_UART_TxCpltCallback can be implemented in the user file
mbed_official 340:28d1f895c6fe 1083 */
mbed_official 340:28d1f895c6fe 1084 }
mbed_official 340:28d1f895c6fe 1085
mbed_official 340:28d1f895c6fe 1086 /**
mbed_official 340:28d1f895c6fe 1087 * @brief Tx Half Transfer completed callbacks.
mbed_official 340:28d1f895c6fe 1088 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 1089 * @retval None
mbed_official 340:28d1f895c6fe 1090 */
mbed_official 340:28d1f895c6fe 1091 __weak void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1092 {
mbed_official 340:28d1f895c6fe 1093 /* NOTE: This function should not be modified, when the callback is needed,
mbed_official 340:28d1f895c6fe 1094 the HAL_UART_TxHalfCpltCallback can be implemented in the user file
mbed_official 340:28d1f895c6fe 1095 */
mbed_official 340:28d1f895c6fe 1096 }
mbed_official 340:28d1f895c6fe 1097
mbed_official 340:28d1f895c6fe 1098 /**
mbed_official 340:28d1f895c6fe 1099 * @brief Rx Transfer completed callbacks
mbed_official 340:28d1f895c6fe 1100 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 1101 * @retval None
mbed_official 340:28d1f895c6fe 1102 */
mbed_official 340:28d1f895c6fe 1103 __weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1104 {
mbed_official 340:28d1f895c6fe 1105 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 340:28d1f895c6fe 1106 the HAL_UART_RxCpltCallback can be implemented in the user file
mbed_official 340:28d1f895c6fe 1107 */
mbed_official 340:28d1f895c6fe 1108 }
mbed_official 340:28d1f895c6fe 1109
mbed_official 340:28d1f895c6fe 1110 /**
mbed_official 340:28d1f895c6fe 1111 * @brief Rx Half Transfer completed callbacks.
mbed_official 340:28d1f895c6fe 1112 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 1113 * @retval None
mbed_official 340:28d1f895c6fe 1114 */
mbed_official 340:28d1f895c6fe 1115 __weak void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1116 {
mbed_official 340:28d1f895c6fe 1117 /* NOTE: This function should not be modified, when the callback is needed,
mbed_official 340:28d1f895c6fe 1118 the HAL_UART_RxHalfCpltCallback can be implemented in the user file
mbed_official 340:28d1f895c6fe 1119 */
mbed_official 340:28d1f895c6fe 1120 }
mbed_official 340:28d1f895c6fe 1121
mbed_official 340:28d1f895c6fe 1122 /**
mbed_official 340:28d1f895c6fe 1123 * @brief UART error callbacks
mbed_official 340:28d1f895c6fe 1124 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 1125 * @retval None
mbed_official 340:28d1f895c6fe 1126 */
mbed_official 340:28d1f895c6fe 1127 __weak void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1128 {
mbed_official 340:28d1f895c6fe 1129 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 340:28d1f895c6fe 1130 the HAL_UART_ErrorCallback can be implemented in the user file
mbed_official 340:28d1f895c6fe 1131 */
mbed_official 340:28d1f895c6fe 1132 }
mbed_official 340:28d1f895c6fe 1133
mbed_official 340:28d1f895c6fe 1134 /**
mbed_official 340:28d1f895c6fe 1135 * @}
mbed_official 340:28d1f895c6fe 1136 */
mbed_official 340:28d1f895c6fe 1137
mbed_official 340:28d1f895c6fe 1138 /** @defgroup UART_Exported_Functions_Group3 Peripheral Control functions
mbed_official 340:28d1f895c6fe 1139 * @brief UART control functions
mbed_official 340:28d1f895c6fe 1140 *
mbed_official 340:28d1f895c6fe 1141 @verbatim
mbed_official 340:28d1f895c6fe 1142 ===============================================================================
mbed_official 340:28d1f895c6fe 1143 ##### Peripheral Control functions #####
mbed_official 340:28d1f895c6fe 1144 ===============================================================================
mbed_official 340:28d1f895c6fe 1145 [..]
mbed_official 340:28d1f895c6fe 1146 This subsection provides a set of functions allowing to control the UART.
mbed_official 340:28d1f895c6fe 1147 (+) HAL_UART_GetState() API is helpful to check in run-time the state of the UART peripheral.
mbed_official 340:28d1f895c6fe 1148 (+) HAL_MultiProcessor_EnableMuteMode() API enables mute mode
mbed_official 340:28d1f895c6fe 1149 (+) HAL_MultiProcessor_DisableMuteMode() API disables mute mode
mbed_official 340:28d1f895c6fe 1150 (+) HAL_MultiProcessor_EnterMuteMode() API enters mute mode
mbed_official 340:28d1f895c6fe 1151 (+) HAL_MultiProcessor_EnableMuteMode() API enables mute mode
mbed_official 340:28d1f895c6fe 1152 (+) HAL_UART_EnableStopMode() API enables the UART to wake up the MCU from stop mode
mbed_official 340:28d1f895c6fe 1153 (+) HAL_UART_DisableStopMode() API disables the above functionality
mbed_official 340:28d1f895c6fe 1154 (+) UART_SetConfig() API configures the UART peripheral
mbed_official 340:28d1f895c6fe 1155 (+) UART_AdvFeatureConfig() API optionally configures the UART advanced features
mbed_official 340:28d1f895c6fe 1156 (+) UART_CheckIdleState() API ensures that TEACK and/or REACK are set after initialization
mbed_official 340:28d1f895c6fe 1157 (+) UART_Wakeup_AddressConfig() API configures the wake-up from stop mode parameters
mbed_official 340:28d1f895c6fe 1158 (+) HAL_HalfDuplex_EnableTransmitter() API disables receiver and enables transmitter
mbed_official 340:28d1f895c6fe 1159 (+) HAL_HalfDuplex_EnableReceiver() API disables transmitter and enables receiver
mbed_official 340:28d1f895c6fe 1160 @endverbatim
mbed_official 340:28d1f895c6fe 1161 * @{
mbed_official 340:28d1f895c6fe 1162 */
mbed_official 340:28d1f895c6fe 1163
mbed_official 340:28d1f895c6fe 1164 /**
mbed_official 340:28d1f895c6fe 1165 * @brief Enable UART in mute mode (doesn't mean UART enters mute mode;
mbed_official 340:28d1f895c6fe 1166 * to enter mute mode, HAL_MultiProcessor_EnterMuteMode() API must be called)
mbed_official 340:28d1f895c6fe 1167 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 1168 * @retval HAL status
mbed_official 340:28d1f895c6fe 1169 */
mbed_official 340:28d1f895c6fe 1170 HAL_StatusTypeDef HAL_MultiProcessor_EnableMuteMode(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1171 {
mbed_official 340:28d1f895c6fe 1172 /* Process Locked */
mbed_official 340:28d1f895c6fe 1173 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 1174
mbed_official 340:28d1f895c6fe 1175 huart->State = HAL_UART_STATE_BUSY;
mbed_official 340:28d1f895c6fe 1176
mbed_official 340:28d1f895c6fe 1177 /* Enable USART mute mode by setting the MME bit in the CR1 register */
mbed_official 340:28d1f895c6fe 1178 huart->Instance->CR1 |= USART_CR1_MME;
mbed_official 340:28d1f895c6fe 1179
mbed_official 340:28d1f895c6fe 1180 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1181
mbed_official 340:28d1f895c6fe 1182 return (UART_CheckIdleState(huart));
mbed_official 340:28d1f895c6fe 1183 }
mbed_official 340:28d1f895c6fe 1184
mbed_official 340:28d1f895c6fe 1185 /**
mbed_official 340:28d1f895c6fe 1186 * @brief Disable UART mute mode (doesn't mean it actually wakes up the software,
mbed_official 340:28d1f895c6fe 1187 * as it may not have been in mute mode at this very moment).
mbed_official 340:28d1f895c6fe 1188 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 1189 * @retval HAL status
mbed_official 340:28d1f895c6fe 1190 */
mbed_official 340:28d1f895c6fe 1191 HAL_StatusTypeDef HAL_MultiProcessor_DisableMuteMode(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1192 {
mbed_official 340:28d1f895c6fe 1193 /* Process Locked */
mbed_official 340:28d1f895c6fe 1194 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 1195
mbed_official 340:28d1f895c6fe 1196 huart->State = HAL_UART_STATE_BUSY;
mbed_official 340:28d1f895c6fe 1197
mbed_official 340:28d1f895c6fe 1198 /* Disable USART mute mode by clearing the MME bit in the CR1 register */
mbed_official 340:28d1f895c6fe 1199 huart->Instance->CR1 &= ~(USART_CR1_MME);
mbed_official 340:28d1f895c6fe 1200
mbed_official 340:28d1f895c6fe 1201 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1202
mbed_official 340:28d1f895c6fe 1203 return (UART_CheckIdleState(huart));
mbed_official 340:28d1f895c6fe 1204 }
mbed_official 340:28d1f895c6fe 1205
mbed_official 340:28d1f895c6fe 1206 /**
mbed_official 340:28d1f895c6fe 1207 * @brief Enter UART mute mode (means UART actually enters mute mode).
mbed_official 340:28d1f895c6fe 1208 * To exit from mute mode, HAL_MultiProcessor_DisableMuteMode() API must be called.
mbed_official 340:28d1f895c6fe 1209 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 1210 * @retval HAL status
mbed_official 340:28d1f895c6fe 1211 */
mbed_official 340:28d1f895c6fe 1212 void HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1213 {
mbed_official 340:28d1f895c6fe 1214 __HAL_UART_SEND_REQ(huart, UART_MUTE_MODE_REQUEST);
mbed_official 340:28d1f895c6fe 1215 }
mbed_official 340:28d1f895c6fe 1216
mbed_official 340:28d1f895c6fe 1217 /**
mbed_official 340:28d1f895c6fe 1218 * @brief Enables the UART transmitter and disables the UART receiver.
mbed_official 340:28d1f895c6fe 1219 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 1220 * @retval HAL status
mbed_official 340:28d1f895c6fe 1221 * @retval None
mbed_official 340:28d1f895c6fe 1222 */
mbed_official 340:28d1f895c6fe 1223 HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1224 {
mbed_official 340:28d1f895c6fe 1225 /* Process Locked */
mbed_official 340:28d1f895c6fe 1226 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 1227 huart->State = HAL_UART_STATE_BUSY;
mbed_official 340:28d1f895c6fe 1228
mbed_official 340:28d1f895c6fe 1229 /* Clear TE and RE bits */
mbed_official 340:28d1f895c6fe 1230 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TE | USART_CR1_RE));
mbed_official 340:28d1f895c6fe 1231 /* Enable the USART's transmit interface by setting the TE bit in the USART CR1 register */
mbed_official 340:28d1f895c6fe 1232 SET_BIT(huart->Instance->CR1, USART_CR1_TE);
mbed_official 340:28d1f895c6fe 1233
mbed_official 340:28d1f895c6fe 1234 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1235 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 1236 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 1237
mbed_official 340:28d1f895c6fe 1238 return HAL_OK;
mbed_official 340:28d1f895c6fe 1239 }
mbed_official 340:28d1f895c6fe 1240
mbed_official 340:28d1f895c6fe 1241 /**
mbed_official 340:28d1f895c6fe 1242 * @brief Enables the UART receiver and disables the UART transmitter.
mbed_official 340:28d1f895c6fe 1243 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 1244 * @retval HAL status
mbed_official 340:28d1f895c6fe 1245 */
mbed_official 340:28d1f895c6fe 1246 HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1247 {
mbed_official 340:28d1f895c6fe 1248 /* Process Locked */
mbed_official 340:28d1f895c6fe 1249 __HAL_LOCK(huart);
mbed_official 340:28d1f895c6fe 1250 huart->State = HAL_UART_STATE_BUSY;
mbed_official 340:28d1f895c6fe 1251
mbed_official 340:28d1f895c6fe 1252 /* Clear TE and RE bits */
mbed_official 340:28d1f895c6fe 1253 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TE | USART_CR1_RE));
mbed_official 340:28d1f895c6fe 1254 /* Enable the USART's receive interface by setting the RE bit in the USART CR1 register */
mbed_official 340:28d1f895c6fe 1255 SET_BIT(huart->Instance->CR1, USART_CR1_RE);
mbed_official 340:28d1f895c6fe 1256
mbed_official 340:28d1f895c6fe 1257 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1258 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 1259 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 1260
mbed_official 340:28d1f895c6fe 1261 return HAL_OK;
mbed_official 340:28d1f895c6fe 1262 }
mbed_official 340:28d1f895c6fe 1263
mbed_official 340:28d1f895c6fe 1264 /**
mbed_official 340:28d1f895c6fe 1265 * @}
mbed_official 340:28d1f895c6fe 1266 */
mbed_official 340:28d1f895c6fe 1267
mbed_official 340:28d1f895c6fe 1268 /** @defgroup UART_Exported_Functions_Group4 Peripheral State and Errors functions
mbed_official 340:28d1f895c6fe 1269 * @{
mbed_official 340:28d1f895c6fe 1270 */
mbed_official 340:28d1f895c6fe 1271
mbed_official 340:28d1f895c6fe 1272 /**
mbed_official 340:28d1f895c6fe 1273 * @brief return the UART state
mbed_official 340:28d1f895c6fe 1274 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 1275 * @retval HAL state
mbed_official 340:28d1f895c6fe 1276 */
mbed_official 340:28d1f895c6fe 1277 HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1278 {
mbed_official 340:28d1f895c6fe 1279 return huart->State;
mbed_official 340:28d1f895c6fe 1280 }
mbed_official 340:28d1f895c6fe 1281
mbed_official 340:28d1f895c6fe 1282 /**
mbed_official 340:28d1f895c6fe 1283 * @brief Return the UART error code
mbed_official 340:28d1f895c6fe 1284 * @param huart : pointer to a UART_HandleTypeDef structure that contains
mbed_official 340:28d1f895c6fe 1285 * the configuration information for the specified UART.
mbed_official 340:28d1f895c6fe 1286 * @retval UART Error Code
mbed_official 340:28d1f895c6fe 1287 */
mbed_official 340:28d1f895c6fe 1288 uint32_t HAL_UART_GetError(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1289 {
mbed_official 340:28d1f895c6fe 1290 return huart->ErrorCode;
mbed_official 340:28d1f895c6fe 1291 }
mbed_official 340:28d1f895c6fe 1292
mbed_official 340:28d1f895c6fe 1293 /**
mbed_official 340:28d1f895c6fe 1294 * @}
mbed_official 340:28d1f895c6fe 1295 */
mbed_official 340:28d1f895c6fe 1296
mbed_official 340:28d1f895c6fe 1297 /**
mbed_official 340:28d1f895c6fe 1298 * @}
mbed_official 340:28d1f895c6fe 1299 */
mbed_official 340:28d1f895c6fe 1300
mbed_official 340:28d1f895c6fe 1301 /** @defgroup UART_Private_Functions UART Private Functions
mbed_official 340:28d1f895c6fe 1302 * @{
mbed_official 340:28d1f895c6fe 1303 */
mbed_official 340:28d1f895c6fe 1304
mbed_official 340:28d1f895c6fe 1305 /**
mbed_official 340:28d1f895c6fe 1306 * @brief Send an amount of data in interrupt mode
mbed_official 340:28d1f895c6fe 1307 * Function called under interruption only, once
mbed_official 340:28d1f895c6fe 1308 * interruptions have been enabled by HAL_UART_Transmit_IT()
mbed_official 340:28d1f895c6fe 1309 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 1310 * @retval HAL status
mbed_official 340:28d1f895c6fe 1311 */
mbed_official 340:28d1f895c6fe 1312 HAL_StatusTypeDef UART_Transmit_IT(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1313 {
mbed_official 340:28d1f895c6fe 1314 uint16_t* tmp;
mbed_official 340:28d1f895c6fe 1315
mbed_official 340:28d1f895c6fe 1316 if ((huart->State == HAL_UART_STATE_BUSY_TX) || (huart->State == HAL_UART_STATE_BUSY_TX_RX))
mbed_official 340:28d1f895c6fe 1317 {
mbed_official 340:28d1f895c6fe 1318
mbed_official 340:28d1f895c6fe 1319 if(huart->TxXferCount == 0)
mbed_official 340:28d1f895c6fe 1320 {
mbed_official 340:28d1f895c6fe 1321 /* Disable the UART Transmit Data Register Empty Interrupt */
mbed_official 340:28d1f895c6fe 1322 __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
mbed_official 340:28d1f895c6fe 1323
mbed_official 340:28d1f895c6fe 1324 /* Enable the UART Transmit Complete Interrupt */
mbed_official 340:28d1f895c6fe 1325 __HAL_UART_ENABLE_IT(huart, UART_IT_TC);
mbed_official 340:28d1f895c6fe 1326
mbed_official 340:28d1f895c6fe 1327 return HAL_OK;
mbed_official 340:28d1f895c6fe 1328 }
mbed_official 340:28d1f895c6fe 1329 else
mbed_official 340:28d1f895c6fe 1330 {
mbed_official 340:28d1f895c6fe 1331 if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
mbed_official 340:28d1f895c6fe 1332 {
mbed_official 340:28d1f895c6fe 1333 tmp = (uint16_t*) huart->pTxBuffPtr;
mbed_official 340:28d1f895c6fe 1334 huart->Instance->TDR = (*tmp & (uint16_t)0x01FF);
mbed_official 340:28d1f895c6fe 1335 huart->pTxBuffPtr += 2;
mbed_official 340:28d1f895c6fe 1336 }
mbed_official 340:28d1f895c6fe 1337 else
mbed_official 340:28d1f895c6fe 1338 {
mbed_official 340:28d1f895c6fe 1339 huart->Instance->TDR = (uint8_t)(*huart->pTxBuffPtr++ & (uint8_t)0xFF);
mbed_official 340:28d1f895c6fe 1340 }
mbed_official 340:28d1f895c6fe 1341
mbed_official 340:28d1f895c6fe 1342 huart->TxXferCount--;
mbed_official 340:28d1f895c6fe 1343
mbed_official 340:28d1f895c6fe 1344 return HAL_OK;
mbed_official 340:28d1f895c6fe 1345 }
mbed_official 340:28d1f895c6fe 1346 }
mbed_official 340:28d1f895c6fe 1347 else
mbed_official 340:28d1f895c6fe 1348 {
mbed_official 340:28d1f895c6fe 1349 return HAL_BUSY;
mbed_official 340:28d1f895c6fe 1350 }
mbed_official 340:28d1f895c6fe 1351 }
mbed_official 340:28d1f895c6fe 1352
mbed_official 340:28d1f895c6fe 1353 /**
mbed_official 340:28d1f895c6fe 1354 * @brief Receive an amount of data in interrupt mode
mbed_official 340:28d1f895c6fe 1355 * Function called under interruption only, once
mbed_official 340:28d1f895c6fe 1356 * interruptions have been enabled by HAL_UART_Receive_IT()
mbed_official 340:28d1f895c6fe 1357 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 1358 * @retval HAL status
mbed_official 340:28d1f895c6fe 1359 */
mbed_official 340:28d1f895c6fe 1360 HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1361 {
mbed_official 340:28d1f895c6fe 1362 uint16_t* tmp;
mbed_official 340:28d1f895c6fe 1363 uint16_t uhMask = huart->Mask;
mbed_official 340:28d1f895c6fe 1364
mbed_official 340:28d1f895c6fe 1365 if((huart->State == HAL_UART_STATE_BUSY_RX) || (huart->State == HAL_UART_STATE_BUSY_TX_RX))
mbed_official 340:28d1f895c6fe 1366 {
mbed_official 340:28d1f895c6fe 1367
mbed_official 340:28d1f895c6fe 1368 if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
mbed_official 340:28d1f895c6fe 1369 {
mbed_official 340:28d1f895c6fe 1370 tmp = (uint16_t*) huart->pRxBuffPtr ;
mbed_official 340:28d1f895c6fe 1371 *tmp = (uint16_t)(huart->Instance->RDR & uhMask);
mbed_official 340:28d1f895c6fe 1372 huart->pRxBuffPtr +=2;
mbed_official 340:28d1f895c6fe 1373 }
mbed_official 340:28d1f895c6fe 1374 else
mbed_official 340:28d1f895c6fe 1375 {
mbed_official 340:28d1f895c6fe 1376 *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->RDR & (uint8_t)uhMask);
mbed_official 340:28d1f895c6fe 1377 }
mbed_official 340:28d1f895c6fe 1378
mbed_official 340:28d1f895c6fe 1379 if(--huart->RxXferCount == 0)
mbed_official 340:28d1f895c6fe 1380 {
mbed_official 340:28d1f895c6fe 1381 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
mbed_official 340:28d1f895c6fe 1382
mbed_official 340:28d1f895c6fe 1383 /* Check if a transmit Process is ongoing or not */
mbed_official 340:28d1f895c6fe 1384 if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
mbed_official 340:28d1f895c6fe 1385 {
mbed_official 340:28d1f895c6fe 1386 huart->State = HAL_UART_STATE_BUSY_TX;
mbed_official 340:28d1f895c6fe 1387 }
mbed_official 340:28d1f895c6fe 1388 else
mbed_official 340:28d1f895c6fe 1389 {
mbed_official 340:28d1f895c6fe 1390 /* Disable the UART Parity Error Interrupt */
mbed_official 340:28d1f895c6fe 1391 __HAL_UART_DISABLE_IT(huart, UART_IT_PE);
mbed_official 340:28d1f895c6fe 1392
mbed_official 340:28d1f895c6fe 1393 /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 340:28d1f895c6fe 1394 __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
mbed_official 340:28d1f895c6fe 1395
mbed_official 340:28d1f895c6fe 1396 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1397 }
mbed_official 340:28d1f895c6fe 1398
mbed_official 340:28d1f895c6fe 1399 HAL_UART_RxCpltCallback(huart);
mbed_official 340:28d1f895c6fe 1400
mbed_official 340:28d1f895c6fe 1401 return HAL_OK;
mbed_official 340:28d1f895c6fe 1402 }
mbed_official 340:28d1f895c6fe 1403
mbed_official 340:28d1f895c6fe 1404 return HAL_OK;
mbed_official 340:28d1f895c6fe 1405 }
mbed_official 340:28d1f895c6fe 1406 else
mbed_official 340:28d1f895c6fe 1407 {
mbed_official 340:28d1f895c6fe 1408 return HAL_BUSY;
mbed_official 340:28d1f895c6fe 1409 }
mbed_official 340:28d1f895c6fe 1410 }
mbed_official 340:28d1f895c6fe 1411
mbed_official 340:28d1f895c6fe 1412 /**
mbed_official 340:28d1f895c6fe 1413 * @brief Check the UART Idle State
mbed_official 340:28d1f895c6fe 1414 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 1415 * @retval HAL status
mbed_official 340:28d1f895c6fe 1416 */
mbed_official 340:28d1f895c6fe 1417 HAL_StatusTypeDef UART_CheckIdleState(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1418 {
mbed_official 340:28d1f895c6fe 1419 /* Initialize the UART ErrorCode */
mbed_official 340:28d1f895c6fe 1420 huart->ErrorCode = HAL_UART_ERROR_NONE;
mbed_official 340:28d1f895c6fe 1421
mbed_official 340:28d1f895c6fe 1422 /* Check if the Transmitter is enabled */
mbed_official 340:28d1f895c6fe 1423 if((huart->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
mbed_official 340:28d1f895c6fe 1424 {
mbed_official 340:28d1f895c6fe 1425 /* Wait until TEACK flag is set */
mbed_official 340:28d1f895c6fe 1426 if(UART_WaitOnFlagUntilTimeout(huart, USART_ISR_TEACK, RESET, HAL_UART_TIMEOUT_VALUE) != HAL_OK)
mbed_official 340:28d1f895c6fe 1427 {
mbed_official 340:28d1f895c6fe 1428 /* Timeout Occured */
mbed_official 340:28d1f895c6fe 1429 return HAL_TIMEOUT;
mbed_official 340:28d1f895c6fe 1430 }
mbed_official 340:28d1f895c6fe 1431 }
mbed_official 340:28d1f895c6fe 1432 /* Check if the Receiver is enabled */
mbed_official 340:28d1f895c6fe 1433 if((huart->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
mbed_official 340:28d1f895c6fe 1434 {
mbed_official 340:28d1f895c6fe 1435 /* Wait until REACK flag is set */
mbed_official 340:28d1f895c6fe 1436 if(UART_WaitOnFlagUntilTimeout(huart, USART_ISR_REACK, RESET, HAL_UART_TIMEOUT_VALUE) != HAL_OK)
mbed_official 340:28d1f895c6fe 1437 {
mbed_official 340:28d1f895c6fe 1438 /* Timeout Occured */
mbed_official 340:28d1f895c6fe 1439 return HAL_TIMEOUT;
mbed_official 340:28d1f895c6fe 1440 }
mbed_official 340:28d1f895c6fe 1441 }
mbed_official 340:28d1f895c6fe 1442
mbed_official 340:28d1f895c6fe 1443 /* Initialize the UART State */
mbed_official 340:28d1f895c6fe 1444 huart->State= HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1445
mbed_official 340:28d1f895c6fe 1446 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 1447 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 1448
mbed_official 340:28d1f895c6fe 1449 return HAL_OK;
mbed_official 340:28d1f895c6fe 1450 }
mbed_official 340:28d1f895c6fe 1451
mbed_official 340:28d1f895c6fe 1452 /**
mbed_official 340:28d1f895c6fe 1453 * @brief This function handles UART Communication Timeout.
mbed_official 340:28d1f895c6fe 1454 * @param huart: UART handle
mbed_official 340:28d1f895c6fe 1455 * @param Flag: specifies the UART flag to check.
mbed_official 340:28d1f895c6fe 1456 * @param Status: The new Flag status (SET or RESET).
mbed_official 340:28d1f895c6fe 1457 * @param Timeout: Timeout duration
mbed_official 340:28d1f895c6fe 1458 * @retval HAL status
mbed_official 340:28d1f895c6fe 1459 */
mbed_official 340:28d1f895c6fe 1460 HAL_StatusTypeDef UART_WaitOnFlagUntilTimeout(UART_HandleTypeDef *huart, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
mbed_official 340:28d1f895c6fe 1461 {
mbed_official 340:28d1f895c6fe 1462 uint32_t tickstart = HAL_GetTick();
mbed_official 340:28d1f895c6fe 1463
mbed_official 340:28d1f895c6fe 1464 /* Wait until flag is set */
mbed_official 340:28d1f895c6fe 1465 if(Status == RESET)
mbed_official 340:28d1f895c6fe 1466 {
mbed_official 340:28d1f895c6fe 1467 while(__HAL_UART_GET_FLAG(huart, Flag) == RESET)
mbed_official 340:28d1f895c6fe 1468 {
mbed_official 340:28d1f895c6fe 1469 /* Check for the Timeout */
mbed_official 340:28d1f895c6fe 1470 if(Timeout != HAL_MAX_DELAY)
mbed_official 340:28d1f895c6fe 1471 {
mbed_official 340:28d1f895c6fe 1472 if((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
mbed_official 340:28d1f895c6fe 1473 {
mbed_official 340:28d1f895c6fe 1474 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 340:28d1f895c6fe 1475 __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
mbed_official 340:28d1f895c6fe 1476 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
mbed_official 340:28d1f895c6fe 1477 __HAL_UART_DISABLE_IT(huart, UART_IT_PE);
mbed_official 340:28d1f895c6fe 1478 __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
mbed_official 340:28d1f895c6fe 1479
mbed_official 441:d2c15dda23c1 1480 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1481
mbed_official 340:28d1f895c6fe 1482 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 1483 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 1484
mbed_official 340:28d1f895c6fe 1485 return HAL_TIMEOUT;
mbed_official 340:28d1f895c6fe 1486 }
mbed_official 340:28d1f895c6fe 1487 }
mbed_official 340:28d1f895c6fe 1488 }
mbed_official 340:28d1f895c6fe 1489 }
mbed_official 340:28d1f895c6fe 1490 else
mbed_official 340:28d1f895c6fe 1491 {
mbed_official 340:28d1f895c6fe 1492 while(__HAL_UART_GET_FLAG(huart, Flag) != RESET)
mbed_official 340:28d1f895c6fe 1493 {
mbed_official 340:28d1f895c6fe 1494 /* Check for the Timeout */
mbed_official 340:28d1f895c6fe 1495 if(Timeout != HAL_MAX_DELAY)
mbed_official 340:28d1f895c6fe 1496 {
mbed_official 340:28d1f895c6fe 1497 if((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
mbed_official 340:28d1f895c6fe 1498 {
mbed_official 340:28d1f895c6fe 1499 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 340:28d1f895c6fe 1500 __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
mbed_official 340:28d1f895c6fe 1501 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
mbed_official 340:28d1f895c6fe 1502 __HAL_UART_DISABLE_IT(huart, UART_IT_PE);
mbed_official 340:28d1f895c6fe 1503 __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
mbed_official 340:28d1f895c6fe 1504
mbed_official 441:d2c15dda23c1 1505 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1506
mbed_official 340:28d1f895c6fe 1507 /* Process Unlocked */
mbed_official 340:28d1f895c6fe 1508 __HAL_UNLOCK(huart);
mbed_official 340:28d1f895c6fe 1509
mbed_official 340:28d1f895c6fe 1510 return HAL_TIMEOUT;
mbed_official 340:28d1f895c6fe 1511 }
mbed_official 340:28d1f895c6fe 1512 }
mbed_official 340:28d1f895c6fe 1513 }
mbed_official 340:28d1f895c6fe 1514 }
mbed_official 340:28d1f895c6fe 1515 return HAL_OK;
mbed_official 340:28d1f895c6fe 1516 }
mbed_official 340:28d1f895c6fe 1517
mbed_official 340:28d1f895c6fe 1518 /**
mbed_official 340:28d1f895c6fe 1519 * @brief DMA UART transmit process complete callback
mbed_official 340:28d1f895c6fe 1520 * @param hdma: DMA handle
mbed_official 340:28d1f895c6fe 1521 * @retval None
mbed_official 340:28d1f895c6fe 1522 */
mbed_official 340:28d1f895c6fe 1523 static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official 340:28d1f895c6fe 1524 {
mbed_official 340:28d1f895c6fe 1525 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 340:28d1f895c6fe 1526 huart->TxXferCount = 0;
mbed_official 340:28d1f895c6fe 1527
mbed_official 340:28d1f895c6fe 1528 /* Disable the DMA transfer for transmit request by setting the DMAT bit
mbed_official 340:28d1f895c6fe 1529 in the UART CR3 register */
mbed_official 340:28d1f895c6fe 1530 huart->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DMAT);
mbed_official 340:28d1f895c6fe 1531
mbed_official 340:28d1f895c6fe 1532 /* Wait for UART TC Flag */
mbed_official 340:28d1f895c6fe 1533 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, HAL_UART_TXDMA_TIMEOUTVALUE) != HAL_OK)
mbed_official 340:28d1f895c6fe 1534 {
mbed_official 340:28d1f895c6fe 1535 /* Timeout Occured */
mbed_official 340:28d1f895c6fe 1536 huart->State = HAL_UART_STATE_TIMEOUT;
mbed_official 340:28d1f895c6fe 1537 HAL_UART_ErrorCallback(huart);
mbed_official 340:28d1f895c6fe 1538 }
mbed_official 340:28d1f895c6fe 1539 else
mbed_official 340:28d1f895c6fe 1540 {
mbed_official 340:28d1f895c6fe 1541 /* No Timeout */
mbed_official 340:28d1f895c6fe 1542 /* Check if a receive process is ongoing or not */
mbed_official 340:28d1f895c6fe 1543 if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
mbed_official 340:28d1f895c6fe 1544 {
mbed_official 340:28d1f895c6fe 1545 huart->State = HAL_UART_STATE_BUSY_RX;
mbed_official 340:28d1f895c6fe 1546 }
mbed_official 340:28d1f895c6fe 1547 else
mbed_official 340:28d1f895c6fe 1548 {
mbed_official 340:28d1f895c6fe 1549 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1550 }
mbed_official 340:28d1f895c6fe 1551 HAL_UART_TxCpltCallback(huart);
mbed_official 340:28d1f895c6fe 1552 }
mbed_official 340:28d1f895c6fe 1553 }
mbed_official 340:28d1f895c6fe 1554
mbed_official 340:28d1f895c6fe 1555 /**
mbed_official 340:28d1f895c6fe 1556 * @brief DMA UART transmit process half complete callback
mbed_official 340:28d1f895c6fe 1557 * @param hdma : DMA handle
mbed_official 340:28d1f895c6fe 1558 * @retval None
mbed_official 340:28d1f895c6fe 1559 */
mbed_official 340:28d1f895c6fe 1560 static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 340:28d1f895c6fe 1561 {
mbed_official 340:28d1f895c6fe 1562 UART_HandleTypeDef* huart = (UART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 340:28d1f895c6fe 1563
mbed_official 340:28d1f895c6fe 1564 HAL_UART_TxHalfCpltCallback(huart);
mbed_official 340:28d1f895c6fe 1565 }
mbed_official 340:28d1f895c6fe 1566
mbed_official 340:28d1f895c6fe 1567 /**
mbed_official 340:28d1f895c6fe 1568 * @brief DMA UART receive process complete callback
mbed_official 340:28d1f895c6fe 1569 * @param hdma: DMA handle
mbed_official 340:28d1f895c6fe 1570 * @retval None
mbed_official 340:28d1f895c6fe 1571 */
mbed_official 340:28d1f895c6fe 1572 static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official 340:28d1f895c6fe 1573 {
mbed_official 340:28d1f895c6fe 1574 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 340:28d1f895c6fe 1575 huart->RxXferCount = 0;
mbed_official 340:28d1f895c6fe 1576
mbed_official 340:28d1f895c6fe 1577 /* Disable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official 340:28d1f895c6fe 1578 in the UART CR3 register */
mbed_official 340:28d1f895c6fe 1579 huart->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DMAR);
mbed_official 340:28d1f895c6fe 1580
mbed_official 340:28d1f895c6fe 1581 /* Check if a transmit Process is ongoing or not */
mbed_official 340:28d1f895c6fe 1582 if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
mbed_official 340:28d1f895c6fe 1583 {
mbed_official 340:28d1f895c6fe 1584 huart->State = HAL_UART_STATE_BUSY_TX;
mbed_official 340:28d1f895c6fe 1585 }
mbed_official 340:28d1f895c6fe 1586 else
mbed_official 340:28d1f895c6fe 1587 {
mbed_official 340:28d1f895c6fe 1588 huart->State = HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1589 }
mbed_official 340:28d1f895c6fe 1590 HAL_UART_RxCpltCallback(huart);
mbed_official 340:28d1f895c6fe 1591 }
mbed_official 340:28d1f895c6fe 1592
mbed_official 340:28d1f895c6fe 1593 /**
mbed_official 340:28d1f895c6fe 1594 * @brief DMA UART receive process half complete callback
mbed_official 340:28d1f895c6fe 1595 * @param hdma : DMA handle
mbed_official 340:28d1f895c6fe 1596 * @retval None
mbed_official 340:28d1f895c6fe 1597 */
mbed_official 340:28d1f895c6fe 1598 static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 340:28d1f895c6fe 1599 {
mbed_official 340:28d1f895c6fe 1600 UART_HandleTypeDef* huart = (UART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 340:28d1f895c6fe 1601
mbed_official 340:28d1f895c6fe 1602 HAL_UART_RxHalfCpltCallback(huart);
mbed_official 340:28d1f895c6fe 1603 }
mbed_official 340:28d1f895c6fe 1604
mbed_official 340:28d1f895c6fe 1605 /**
mbed_official 340:28d1f895c6fe 1606 * @brief DMA UART communication error callback
mbed_official 340:28d1f895c6fe 1607 * @param hdma: DMA handle
mbed_official 340:28d1f895c6fe 1608 * @retval None
mbed_official 340:28d1f895c6fe 1609 */
mbed_official 340:28d1f895c6fe 1610 static void UART_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 340:28d1f895c6fe 1611 {
mbed_official 340:28d1f895c6fe 1612 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 340:28d1f895c6fe 1613 huart->RxXferCount = 0;
mbed_official 340:28d1f895c6fe 1614 huart->TxXferCount = 0;
mbed_official 340:28d1f895c6fe 1615 huart->State= HAL_UART_STATE_READY;
mbed_official 340:28d1f895c6fe 1616 huart->ErrorCode |= HAL_UART_ERROR_DMA;
mbed_official 340:28d1f895c6fe 1617 HAL_UART_ErrorCallback(huart);
mbed_official 340:28d1f895c6fe 1618 }
mbed_official 340:28d1f895c6fe 1619
mbed_official 340:28d1f895c6fe 1620 /**
mbed_official 340:28d1f895c6fe 1621 * @brief Configure the UART peripheral
mbed_official 340:28d1f895c6fe 1622 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 1623 * @retval None
mbed_official 340:28d1f895c6fe 1624 */
mbed_official 340:28d1f895c6fe 1625 HAL_StatusTypeDef UART_SetConfig(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1626 {
mbed_official 340:28d1f895c6fe 1627 uint32_t tmpreg = 0x00000000;
mbed_official 340:28d1f895c6fe 1628 UART_ClockSourceTypeDef clocksource = UART_CLOCKSOURCE_UNDEFINED;
mbed_official 340:28d1f895c6fe 1629 uint16_t brrtemp = 0x0000;
mbed_official 340:28d1f895c6fe 1630 uint16_t usartdiv = 0x0000;
mbed_official 340:28d1f895c6fe 1631 HAL_StatusTypeDef ret = HAL_OK;
mbed_official 340:28d1f895c6fe 1632
mbed_official 340:28d1f895c6fe 1633 /* Check the parameters */
mbed_official 340:28d1f895c6fe 1634 assert_param(IS_UART_BAUDRATE(huart->Init.BaudRate));
mbed_official 340:28d1f895c6fe 1635 assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));
mbed_official 340:28d1f895c6fe 1636 assert_param(IS_UART_STOPBITS(huart->Init.StopBits));
mbed_official 340:28d1f895c6fe 1637 assert_param(IS_UART_PARITY(huart->Init.Parity));
mbed_official 340:28d1f895c6fe 1638 assert_param(IS_UART_MODE(huart->Init.Mode));
mbed_official 340:28d1f895c6fe 1639 assert_param(IS_UART_HARDWARE_FLOW_CONTROL(huart->Init.HwFlowCtl));
mbed_official 340:28d1f895c6fe 1640 assert_param(IS_UART_ONEBIT_SAMPLING(huart->Init.OneBitSampling));
mbed_official 340:28d1f895c6fe 1641
mbed_official 340:28d1f895c6fe 1642
mbed_official 340:28d1f895c6fe 1643 /*-------------------------- USART CR1 Configuration -----------------------*/
mbed_official 340:28d1f895c6fe 1644 /* Clear M, PCE, PS, TE, RE and OVER8 bits and configure
mbed_official 340:28d1f895c6fe 1645 * the UART Word Length, Parity, Mode and oversampling:
mbed_official 340:28d1f895c6fe 1646 * set the M bits according to huart->Init.WordLength value
mbed_official 340:28d1f895c6fe 1647 * set PCE and PS bits according to huart->Init.Parity value
mbed_official 340:28d1f895c6fe 1648 * set TE and RE bits according to huart->Init.Mode value
mbed_official 340:28d1f895c6fe 1649 * set OVER8 bit according to huart->Init.OverSampling value */
mbed_official 340:28d1f895c6fe 1650 tmpreg = (uint32_t)huart->Init.WordLength | huart->Init.Parity | huart->Init.Mode | huart->Init.OverSampling ;
mbed_official 340:28d1f895c6fe 1651 MODIFY_REG(huart->Instance->CR1, UART_CR1_FIELDS, tmpreg);
mbed_official 340:28d1f895c6fe 1652
mbed_official 340:28d1f895c6fe 1653 /*-------------------------- USART CR2 Configuration -----------------------*/
mbed_official 340:28d1f895c6fe 1654 /* Configure the UART Stop Bits: Set STOP[13:12] bits according
mbed_official 340:28d1f895c6fe 1655 * to huart->Init.StopBits value */
mbed_official 340:28d1f895c6fe 1656 MODIFY_REG(huart->Instance->CR2, USART_CR2_STOP, huart->Init.StopBits);
mbed_official 340:28d1f895c6fe 1657
mbed_official 340:28d1f895c6fe 1658 /*-------------------------- USART CR3 Configuration -----------------------*/
mbed_official 340:28d1f895c6fe 1659 /* Configure
mbed_official 340:28d1f895c6fe 1660 * - UART HardWare Flow Control: set CTSE and RTSE bits according
mbed_official 340:28d1f895c6fe 1661 * to huart->Init.HwFlowCtl value
mbed_official 340:28d1f895c6fe 1662 * - one-bit sampling method versus three samples' majority rule according
mbed_official 340:28d1f895c6fe 1663 * to huart->Init.OneBitSampling */
mbed_official 340:28d1f895c6fe 1664 tmpreg = (uint32_t)huart->Init.HwFlowCtl | huart->Init.OneBitSampling ;
mbed_official 340:28d1f895c6fe 1665 MODIFY_REG(huart->Instance->CR3, (USART_CR3_RTSE | USART_CR3_CTSE | USART_CR3_ONEBIT), tmpreg);
mbed_official 340:28d1f895c6fe 1666
mbed_official 340:28d1f895c6fe 1667 /*-------------------------- USART BRR Configuration -----------------------*/
mbed_official 340:28d1f895c6fe 1668 __HAL_UART_GETCLOCKSOURCE(huart, clocksource);
mbed_official 340:28d1f895c6fe 1669
mbed_official 340:28d1f895c6fe 1670 /* Check the Over Sampling to set Baud Rate Register */
mbed_official 340:28d1f895c6fe 1671 if (huart->Init.OverSampling == UART_OVERSAMPLING_8)
mbed_official 340:28d1f895c6fe 1672 {
mbed_official 340:28d1f895c6fe 1673 switch (clocksource)
mbed_official 340:28d1f895c6fe 1674 {
mbed_official 340:28d1f895c6fe 1675 case UART_CLOCKSOURCE_PCLK1:
mbed_official 340:28d1f895c6fe 1676 usartdiv = (uint16_t)(__DIV_SAMPLING8(HAL_RCC_GetPCLK1Freq(), huart->Init.BaudRate));
mbed_official 340:28d1f895c6fe 1677 break;
mbed_official 340:28d1f895c6fe 1678 case UART_CLOCKSOURCE_HSI:
mbed_official 340:28d1f895c6fe 1679 usartdiv = (uint16_t)(__DIV_SAMPLING8(HSI_VALUE, huart->Init.BaudRate));
mbed_official 340:28d1f895c6fe 1680 break;
mbed_official 340:28d1f895c6fe 1681 case UART_CLOCKSOURCE_SYSCLK:
mbed_official 340:28d1f895c6fe 1682 usartdiv = (uint16_t)(__DIV_SAMPLING8(HAL_RCC_GetSysClockFreq(), huart->Init.BaudRate));
mbed_official 340:28d1f895c6fe 1683 break;
mbed_official 340:28d1f895c6fe 1684 case UART_CLOCKSOURCE_LSE:
mbed_official 340:28d1f895c6fe 1685 usartdiv = (uint16_t)(__DIV_SAMPLING8(LSE_VALUE, huart->Init.BaudRate));
mbed_official 340:28d1f895c6fe 1686 break;
mbed_official 340:28d1f895c6fe 1687 case UART_CLOCKSOURCE_UNDEFINED:
mbed_official 340:28d1f895c6fe 1688 default:
mbed_official 340:28d1f895c6fe 1689 ret = HAL_ERROR;
mbed_official 340:28d1f895c6fe 1690 break;
mbed_official 340:28d1f895c6fe 1691 }
mbed_official 340:28d1f895c6fe 1692
mbed_official 340:28d1f895c6fe 1693 brrtemp = usartdiv & 0xFFF0;
mbed_official 340:28d1f895c6fe 1694 brrtemp |= (uint16_t) ((usartdiv & (uint16_t)0x000F) >> 1U);
mbed_official 340:28d1f895c6fe 1695 huart->Instance->BRR = brrtemp;
mbed_official 340:28d1f895c6fe 1696 }
mbed_official 340:28d1f895c6fe 1697 else
mbed_official 340:28d1f895c6fe 1698 {
mbed_official 340:28d1f895c6fe 1699 switch (clocksource)
mbed_official 340:28d1f895c6fe 1700 {
mbed_official 340:28d1f895c6fe 1701 case UART_CLOCKSOURCE_PCLK1:
mbed_official 340:28d1f895c6fe 1702 huart->Instance->BRR = (uint16_t)(__DIV_SAMPLING16(HAL_RCC_GetPCLK1Freq(), huart->Init.BaudRate));
mbed_official 340:28d1f895c6fe 1703 break;
mbed_official 340:28d1f895c6fe 1704 case UART_CLOCKSOURCE_HSI:
mbed_official 340:28d1f895c6fe 1705 huart->Instance->BRR = (uint16_t)(__DIV_SAMPLING16(HSI_VALUE, huart->Init.BaudRate));
mbed_official 340:28d1f895c6fe 1706 break;
mbed_official 340:28d1f895c6fe 1707 case UART_CLOCKSOURCE_SYSCLK:
mbed_official 340:28d1f895c6fe 1708 huart->Instance->BRR = (uint16_t)(__DIV_SAMPLING16(HAL_RCC_GetSysClockFreq(), huart->Init.BaudRate));
mbed_official 340:28d1f895c6fe 1709 break;
mbed_official 340:28d1f895c6fe 1710 case UART_CLOCKSOURCE_LSE:
mbed_official 340:28d1f895c6fe 1711 huart->Instance->BRR = (uint16_t)(__DIV_SAMPLING16(LSE_VALUE, huart->Init.BaudRate));
mbed_official 340:28d1f895c6fe 1712 break;
mbed_official 340:28d1f895c6fe 1713 case UART_CLOCKSOURCE_UNDEFINED:
mbed_official 340:28d1f895c6fe 1714 default:
mbed_official 340:28d1f895c6fe 1715 ret = HAL_ERROR;
mbed_official 340:28d1f895c6fe 1716 break;
mbed_official 340:28d1f895c6fe 1717 }
mbed_official 340:28d1f895c6fe 1718 }
mbed_official 340:28d1f895c6fe 1719
mbed_official 340:28d1f895c6fe 1720 return ret;
mbed_official 340:28d1f895c6fe 1721
mbed_official 340:28d1f895c6fe 1722 }
mbed_official 340:28d1f895c6fe 1723
mbed_official 340:28d1f895c6fe 1724 /**
mbed_official 340:28d1f895c6fe 1725 * @brief Configure the UART peripheral advanced feautures
mbed_official 340:28d1f895c6fe 1726 * @param huart: uart handle
mbed_official 340:28d1f895c6fe 1727 * @retval None
mbed_official 340:28d1f895c6fe 1728 */
mbed_official 340:28d1f895c6fe 1729 void UART_AdvFeatureConfig(UART_HandleTypeDef *huart)
mbed_official 340:28d1f895c6fe 1730 {
mbed_official 340:28d1f895c6fe 1731 /* Check whether the set of advanced features to configure is properly set */
mbed_official 340:28d1f895c6fe 1732 assert_param(IS_UART_ADVFEATURE_INIT(huart->AdvancedInit.AdvFeatureInit));
mbed_official 340:28d1f895c6fe 1733
mbed_official 340:28d1f895c6fe 1734 /* if required, configure TX pin active level inversion */
mbed_official 340:28d1f895c6fe 1735 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_TXINVERT_INIT))
mbed_official 340:28d1f895c6fe 1736 {
mbed_official 340:28d1f895c6fe 1737 assert_param(IS_UART_ADVFEATURE_TXINV(huart->AdvancedInit.TxPinLevelInvert));
mbed_official 340:28d1f895c6fe 1738 MODIFY_REG(huart->Instance->CR2, USART_CR2_TXINV, huart->AdvancedInit.TxPinLevelInvert);
mbed_official 340:28d1f895c6fe 1739 }
mbed_official 340:28d1f895c6fe 1740
mbed_official 340:28d1f895c6fe 1741 /* if required, configure RX pin active level inversion */
mbed_official 340:28d1f895c6fe 1742 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_RXINVERT_INIT))
mbed_official 340:28d1f895c6fe 1743 {
mbed_official 340:28d1f895c6fe 1744 assert_param(IS_UART_ADVFEATURE_RXINV(huart->AdvancedInit.RxPinLevelInvert));
mbed_official 340:28d1f895c6fe 1745 MODIFY_REG(huart->Instance->CR2, USART_CR2_RXINV, huart->AdvancedInit.RxPinLevelInvert);
mbed_official 340:28d1f895c6fe 1746 }
mbed_official 340:28d1f895c6fe 1747
mbed_official 340:28d1f895c6fe 1748 /* if required, configure data inversion */
mbed_official 340:28d1f895c6fe 1749 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_DATAINVERT_INIT))
mbed_official 340:28d1f895c6fe 1750 {
mbed_official 340:28d1f895c6fe 1751 assert_param(IS_UART_ADVFEATURE_DATAINV(huart->AdvancedInit.DataInvert));
mbed_official 340:28d1f895c6fe 1752 MODIFY_REG(huart->Instance->CR2, USART_CR2_DATAINV, huart->AdvancedInit.DataInvert);
mbed_official 340:28d1f895c6fe 1753 }
mbed_official 340:28d1f895c6fe 1754
mbed_official 340:28d1f895c6fe 1755 /* if required, configure RX/TX pins swap */
mbed_official 340:28d1f895c6fe 1756 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_SWAP_INIT))
mbed_official 340:28d1f895c6fe 1757 {
mbed_official 340:28d1f895c6fe 1758 assert_param(IS_UART_ADVFEATURE_SWAP(huart->AdvancedInit.Swap));
mbed_official 340:28d1f895c6fe 1759 MODIFY_REG(huart->Instance->CR2, USART_CR2_SWAP, huart->AdvancedInit.Swap);
mbed_official 340:28d1f895c6fe 1760 }
mbed_official 340:28d1f895c6fe 1761
mbed_official 340:28d1f895c6fe 1762 /* if required, configure RX overrun detection disabling */
mbed_official 340:28d1f895c6fe 1763 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_RXOVERRUNDISABLE_INIT))
mbed_official 340:28d1f895c6fe 1764 {
mbed_official 340:28d1f895c6fe 1765 assert_param(IS_UART_OVERRUN(huart->AdvancedInit.OverrunDisable));
mbed_official 340:28d1f895c6fe 1766 MODIFY_REG(huart->Instance->CR3, USART_CR3_OVRDIS, huart->AdvancedInit.OverrunDisable);
mbed_official 340:28d1f895c6fe 1767 }
mbed_official 340:28d1f895c6fe 1768
mbed_official 340:28d1f895c6fe 1769 /* if required, configure DMA disabling on reception error */
mbed_official 340:28d1f895c6fe 1770 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_DMADISABLEONERROR_INIT))
mbed_official 340:28d1f895c6fe 1771 {
mbed_official 340:28d1f895c6fe 1772 assert_param(IS_UART_ADVFEATURE_DMAONRXERROR(huart->AdvancedInit.DMADisableonRxError));
mbed_official 340:28d1f895c6fe 1773 MODIFY_REG(huart->Instance->CR3, USART_CR3_DDRE, huart->AdvancedInit.DMADisableonRxError);
mbed_official 340:28d1f895c6fe 1774 }
mbed_official 340:28d1f895c6fe 1775
mbed_official 340:28d1f895c6fe 1776 /* if required, configure auto Baud rate detection scheme */
mbed_official 340:28d1f895c6fe 1777 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_AUTOBAUDRATE_INIT))
mbed_official 340:28d1f895c6fe 1778 {
mbed_official 340:28d1f895c6fe 1779 assert_param(IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(huart->Instance));
mbed_official 340:28d1f895c6fe 1780 assert_param(IS_UART_ADVFEATURE_AUTOBAUDRATE(huart->AdvancedInit.AutoBaudRateEnable));
mbed_official 340:28d1f895c6fe 1781 MODIFY_REG(huart->Instance->CR2, USART_CR2_ABREN, huart->AdvancedInit.AutoBaudRateEnable);
mbed_official 340:28d1f895c6fe 1782 /* set auto Baudrate detection parameters if detection is enabled */
mbed_official 340:28d1f895c6fe 1783 if (huart->AdvancedInit.AutoBaudRateEnable == UART_ADVFEATURE_AUTOBAUDRATE_ENABLE)
mbed_official 340:28d1f895c6fe 1784 {
mbed_official 340:28d1f895c6fe 1785 assert_param(IS_UART_ADVFEATURE_AUTOBAUDRATEMODE(huart->AdvancedInit.AutoBaudRateMode));
mbed_official 340:28d1f895c6fe 1786 MODIFY_REG(huart->Instance->CR2, USART_CR2_ABRMODE, huart->AdvancedInit.AutoBaudRateMode);
mbed_official 340:28d1f895c6fe 1787 }
mbed_official 340:28d1f895c6fe 1788 }
mbed_official 340:28d1f895c6fe 1789
mbed_official 340:28d1f895c6fe 1790 /* if required, configure MSB first on communication line */
mbed_official 340:28d1f895c6fe 1791 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_MSBFIRST_INIT))
mbed_official 340:28d1f895c6fe 1792 {
mbed_official 340:28d1f895c6fe 1793 assert_param(IS_UART_ADVFEATURE_MSBFIRST(huart->AdvancedInit.MSBFirst));
mbed_official 340:28d1f895c6fe 1794 MODIFY_REG(huart->Instance->CR2, USART_CR2_MSBFIRST, huart->AdvancedInit.MSBFirst);
mbed_official 340:28d1f895c6fe 1795 }
mbed_official 340:28d1f895c6fe 1796 }
mbed_official 340:28d1f895c6fe 1797
mbed_official 340:28d1f895c6fe 1798 /**
mbed_official 340:28d1f895c6fe 1799 * @}
mbed_official 340:28d1f895c6fe 1800 */
mbed_official 340:28d1f895c6fe 1801
mbed_official 340:28d1f895c6fe 1802 #endif /* HAL_UART_MODULE_ENABLED */
mbed_official 340:28d1f895c6fe 1803 /**
mbed_official 340:28d1f895c6fe 1804 * @}
mbed_official 340:28d1f895c6fe 1805 */
mbed_official 340:28d1f895c6fe 1806
mbed_official 340:28d1f895c6fe 1807 /**
mbed_official 340:28d1f895c6fe 1808 * @}
mbed_official 340:28d1f895c6fe 1809 */
mbed_official 340:28d1f895c6fe 1810
mbed_official 340:28d1f895c6fe 1811 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/