mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L0/stm32l0xx_hal_uart.c@387:643a59b3dbac, 2014-11-05 (annotated)

Committer:
mbed_official
Date:
Wed Nov 05 14:30:08 2014 +0000
Revision:
387:643a59b3dbac
Parent:
382:ee426a420dbb
Child:
489:119543c9f674
Synchronized with git revision cfeccf154f8f92c3ea9c0c881c577c154537aecc



Full URL: https://github.com/mbedmicro/mbed/commit/cfeccf154f8f92c3ea9c0c881c577c154537aecc/



Exporters: STM32L053R8 - IAR exporter

Who changed what in which revision?

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