mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents:   Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32F1/device/stm32f1xx_hal_uart.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:
AnnaBridge
Date:
Wed Feb 20 22:31:08 2019 +0000
Revision:
189:f392fc9709a3
Parent:
187:0387e8f68319 
mbed library release version 165

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f1xx_hal_uart.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @brief UART HAL module driver.
AnnaBridge 187:0387e8f68319 6 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 7 * functionalities of the Universal Asynchronous Receiver Transmitter (UART) peripheral:
<> 144:ef7eb2e8f9f7 8 * + Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 9 * + IO operation functions
AnnaBridge 165:e614a9f1c9e2 10 * + Peripheral Control functions
AnnaBridge 165:e614a9f1c9e2 11 * + Peripheral State and Errors functions
<> 144:ef7eb2e8f9f7 12 @verbatim
<> 144:ef7eb2e8f9f7 13 ==============================================================================
<> 144:ef7eb2e8f9f7 14 ##### How to use this driver #####
<> 144:ef7eb2e8f9f7 15 ==============================================================================
<> 144:ef7eb2e8f9f7 16 [..]
<> 144:ef7eb2e8f9f7 17 The UART HAL driver can be used as follows:
AnnaBridge 165:e614a9f1c9e2 18
<> 144:ef7eb2e8f9f7 19 (#) Declare a UART_HandleTypeDef handle structure.
<> 144:ef7eb2e8f9f7 20 (#) Initialize the UART low level resources by implementing the HAL_UART_MspInit() API:
<> 144:ef7eb2e8f9f7 21 (##) Enable the USARTx interface clock.
<> 144:ef7eb2e8f9f7 22 (##) UART pins configuration:
<> 144:ef7eb2e8f9f7 23 (+++) Enable the clock for the UART GPIOs.
AnnaBridge 165:e614a9f1c9e2 24 (+++) Configure the UART pins (TX as alternate function pull-up, RX as alternate function Input).
<> 144:ef7eb2e8f9f7 25 (##) NVIC configuration if you need to use interrupt process (HAL_UART_Transmit_IT()
<> 144:ef7eb2e8f9f7 26 and HAL_UART_Receive_IT() APIs):
<> 144:ef7eb2e8f9f7 27 (+++) Configure the USARTx interrupt priority.
<> 144:ef7eb2e8f9f7 28 (+++) Enable the NVIC USART IRQ handle.
<> 144:ef7eb2e8f9f7 29 (##) DMA Configuration if you need to use DMA process (HAL_UART_Transmit_DMA()
<> 144:ef7eb2e8f9f7 30 and HAL_UART_Receive_DMA() APIs):
<> 144:ef7eb2e8f9f7 31 (+++) Declare a DMA handle structure for the Tx/Rx channel.
<> 144:ef7eb2e8f9f7 32 (+++) Enable the DMAx interface clock.
<> 144:ef7eb2e8f9f7 33 (+++) Configure the declared DMA handle structure with the required
<> 144:ef7eb2e8f9f7 34 Tx/Rx parameters.
<> 144:ef7eb2e8f9f7 35 (+++) Configure the DMA Tx/Rx channel.
<> 144:ef7eb2e8f9f7 36 (+++) Associate the initialized DMA handle to the UART DMA Tx/Rx handle.
<> 144:ef7eb2e8f9f7 37 (+++) Configure the priority and enable the NVIC for the transfer complete
<> 144:ef7eb2e8f9f7 38 interrupt on the DMA Tx/Rx channel.
<> 144:ef7eb2e8f9f7 39 (+++) Configure the USARTx interrupt priority and enable the NVIC USART IRQ handle
<> 144:ef7eb2e8f9f7 40 (used for last byte sending completion detection in DMA non circular mode)
<> 144:ef7eb2e8f9f7 41
<> 144:ef7eb2e8f9f7 42 (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware
<> 144:ef7eb2e8f9f7 43 flow control and Mode(Receiver/Transmitter) in the huart Init structure.
<> 144:ef7eb2e8f9f7 44
<> 144:ef7eb2e8f9f7 45 (#) For the UART asynchronous mode, initialize the UART registers by calling
<> 144:ef7eb2e8f9f7 46 the HAL_UART_Init() API.
<> 144:ef7eb2e8f9f7 47
<> 144:ef7eb2e8f9f7 48 (#) For the UART Half duplex mode, initialize the UART registers by calling
<> 144:ef7eb2e8f9f7 49 the HAL_HalfDuplex_Init() API.
<> 144:ef7eb2e8f9f7 50
<> 144:ef7eb2e8f9f7 51 (#) For the LIN mode, initialize the UART registers by calling the HAL_LIN_Init() API.
<> 144:ef7eb2e8f9f7 52
<> 144:ef7eb2e8f9f7 53 (#) For the Multi-Processor mode, initialize the UART registers by calling
<> 144:ef7eb2e8f9f7 54 the HAL_MultiProcessor_Init() API.
<> 144:ef7eb2e8f9f7 55
<> 144:ef7eb2e8f9f7 56 [..]
<> 144:ef7eb2e8f9f7 57 (@) The specific UART interrupts (Transmission complete interrupt,
<> 144:ef7eb2e8f9f7 58 RXNE interrupt and Error Interrupts) will be managed using the macros
<> 144:ef7eb2e8f9f7 59 __HAL_UART_ENABLE_IT() and __HAL_UART_DISABLE_IT() inside the transmit
<> 144:ef7eb2e8f9f7 60 and receive process.
<> 144:ef7eb2e8f9f7 61
<> 144:ef7eb2e8f9f7 62 [..]
<> 144:ef7eb2e8f9f7 63 (@) These APIs (HAL_UART_Init() and HAL_HalfDuplex_Init()) configure also the
AnnaBridge 165:e614a9f1c9e2 64 low level Hardware GPIO, CLOCK, CORTEX...etc) by calling the customized
<> 144:ef7eb2e8f9f7 65 HAL_UART_MspInit() API.
<> 144:ef7eb2e8f9f7 66
AnnaBridge 165:e614a9f1c9e2 67 [..]
AnnaBridge 165:e614a9f1c9e2 68 Three operation modes are available within this driver:
<> 144:ef7eb2e8f9f7 69
<> 144:ef7eb2e8f9f7 70 *** Polling mode IO operation ***
<> 144:ef7eb2e8f9f7 71 =================================
AnnaBridge 165:e614a9f1c9e2 72 [..]
AnnaBridge 165:e614a9f1c9e2 73 (+) Send an amount of data in blocking mode using HAL_UART_Transmit()
<> 144:ef7eb2e8f9f7 74 (+) Receive an amount of data in blocking mode using HAL_UART_Receive()
AnnaBridge 165:e614a9f1c9e2 75
<> 144:ef7eb2e8f9f7 76 *** Interrupt mode IO operation ***
<> 144:ef7eb2e8f9f7 77 ===================================
<> 144:ef7eb2e8f9f7 78 [..]
<> 144:ef7eb2e8f9f7 79 (+) Send an amount of data in non blocking mode using HAL_UART_Transmit_IT()
<> 144:ef7eb2e8f9f7 80 (+) At transmission end of transfer HAL_UART_TxCpltCallback is executed and user can
<> 144:ef7eb2e8f9f7 81 add his own code by customization of function pointer HAL_UART_TxCpltCallback
<> 144:ef7eb2e8f9f7 82 (+) Receive an amount of data in non blocking mode using HAL_UART_Receive_IT()
<> 144:ef7eb2e8f9f7 83 (+) At reception end of transfer HAL_UART_RxCpltCallback is executed and user can
<> 144:ef7eb2e8f9f7 84 add his own code by customization of function pointer HAL_UART_RxCpltCallback
<> 144:ef7eb2e8f9f7 85 (+) In case of transfer Error, HAL_UART_ErrorCallback() function is executed and user can
<> 144:ef7eb2e8f9f7 86 add his own code by customization of function pointer HAL_UART_ErrorCallback
<> 144:ef7eb2e8f9f7 87
<> 144:ef7eb2e8f9f7 88 *** DMA mode IO operation ***
<> 144:ef7eb2e8f9f7 89 ==============================
<> 144:ef7eb2e8f9f7 90 [..]
<> 144:ef7eb2e8f9f7 91 (+) Send an amount of data in non blocking mode (DMA) using HAL_UART_Transmit_DMA()
<> 144:ef7eb2e8f9f7 92 (+) At transmission end of half transfer HAL_UART_TxHalfCpltCallback is executed and user can
<> 144:ef7eb2e8f9f7 93 add his own code by customization of function pointer HAL_UART_TxHalfCpltCallback
<> 144:ef7eb2e8f9f7 94 (+) At transmission end of transfer HAL_UART_TxCpltCallback is executed and user can
<> 144:ef7eb2e8f9f7 95 add his own code by customization of function pointer HAL_UART_TxCpltCallback
<> 144:ef7eb2e8f9f7 96 (+) Receive an amount of data in non blocking mode (DMA) using HAL_UART_Receive_DMA()
<> 144:ef7eb2e8f9f7 97 (+) At reception end of half transfer HAL_UART_RxHalfCpltCallback is executed and user can
<> 144:ef7eb2e8f9f7 98 add his own code by customization of function pointer HAL_UART_RxHalfCpltCallback
<> 144:ef7eb2e8f9f7 99 (+) At reception end of transfer HAL_UART_RxCpltCallback is executed and user can
<> 144:ef7eb2e8f9f7 100 add his own code by customization of function pointer HAL_UART_RxCpltCallback
<> 144:ef7eb2e8f9f7 101 (+) In case of transfer Error, HAL_UART_ErrorCallback() function is executed and user can
<> 144:ef7eb2e8f9f7 102 add his own code by customization of function pointer HAL_UART_ErrorCallback
<> 144:ef7eb2e8f9f7 103 (+) Pause the DMA Transfer using HAL_UART_DMAPause()
<> 144:ef7eb2e8f9f7 104 (+) Resume the DMA Transfer using HAL_UART_DMAResume()
<> 144:ef7eb2e8f9f7 105 (+) Stop the DMA Transfer using HAL_UART_DMAStop()
<> 144:ef7eb2e8f9f7 106
<> 144:ef7eb2e8f9f7 107 *** UART HAL driver macros list ***
<> 144:ef7eb2e8f9f7 108 =============================================
<> 144:ef7eb2e8f9f7 109 [..]
<> 144:ef7eb2e8f9f7 110 Below the list of most used macros in UART HAL driver.
<> 144:ef7eb2e8f9f7 111
<> 144:ef7eb2e8f9f7 112 (+) __HAL_UART_ENABLE: Enable the UART peripheral
<> 144:ef7eb2e8f9f7 113 (+) __HAL_UART_DISABLE: Disable the UART peripheral
<> 144:ef7eb2e8f9f7 114 (+) __HAL_UART_GET_FLAG : Check whether the specified UART flag is set or not
<> 144:ef7eb2e8f9f7 115 (+) __HAL_UART_CLEAR_FLAG : Clear the specified UART pending flag
<> 144:ef7eb2e8f9f7 116 (+) __HAL_UART_ENABLE_IT: Enable the specified UART interrupt
<> 144:ef7eb2e8f9f7 117 (+) __HAL_UART_DISABLE_IT: Disable the specified UART interrupt
<> 144:ef7eb2e8f9f7 118 (+) __HAL_UART_GET_IT_SOURCE: Check whether the specified UART interrupt has occurred or not
<> 144:ef7eb2e8f9f7 119
<> 144:ef7eb2e8f9f7 120 [..]
<> 144:ef7eb2e8f9f7 121 (@) You can refer to the UART HAL driver header file for more useful macros
<> 144:ef7eb2e8f9f7 122 @endverbatim
AnnaBridge 165:e614a9f1c9e2 123 [..]
AnnaBridge 165:e614a9f1c9e2 124 (@) Additionnal remark: If the parity is enabled, then the MSB bit of the data written
AnnaBridge 165:e614a9f1c9e2 125 in the data register is transmitted but is changed by the parity bit.
AnnaBridge 165:e614a9f1c9e2 126 Depending on the frame length defined by the M bit (8-bits or 9-bits),
AnnaBridge 165:e614a9f1c9e2 127 the possible UART frame formats are as listed in the following table:
AnnaBridge 165:e614a9f1c9e2 128 +-------------------------------------------------------------+
AnnaBridge 165:e614a9f1c9e2 129 | M bit | PCE bit | UART frame |
AnnaBridge 165:e614a9f1c9e2 130 |---------------------|---------------------------------------|
AnnaBridge 165:e614a9f1c9e2 131 | 0 | 0 | | SB | 8 bit data | STB | |
AnnaBridge 165:e614a9f1c9e2 132 |---------|-----------|---------------------------------------|
AnnaBridge 165:e614a9f1c9e2 133 | 0 | 1 | | SB | 7 bit data | PB | STB | |
AnnaBridge 165:e614a9f1c9e2 134 |---------|-----------|---------------------------------------|
AnnaBridge 165:e614a9f1c9e2 135 | 1 | 0 | | SB | 9 bit data | STB | |
AnnaBridge 165:e614a9f1c9e2 136 |---------|-----------|---------------------------------------|
AnnaBridge 165:e614a9f1c9e2 137 | 1 | 1 | | SB | 8 bit data | PB | STB | |
AnnaBridge 165:e614a9f1c9e2 138 +-------------------------------------------------------------+
<> 144:ef7eb2e8f9f7 139 ******************************************************************************
<> 144:ef7eb2e8f9f7 140 * @attention
<> 144:ef7eb2e8f9f7 141 *
AnnaBridge 165:e614a9f1c9e2 142 * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 143 *
<> 144:ef7eb2e8f9f7 144 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 145 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 146 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 147 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 148 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 149 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 150 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 151 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 152 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 153 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 154 *
<> 144:ef7eb2e8f9f7 155 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 156 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 157 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 158 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 159 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 160 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 161 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 162 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 163 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 164 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 165 *
<> 144:ef7eb2e8f9f7 166 ******************************************************************************
<> 144:ef7eb2e8f9f7 167 */
<> 144:ef7eb2e8f9f7 168
<> 144:ef7eb2e8f9f7 169 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 170 #include "stm32f1xx_hal.h"
<> 144:ef7eb2e8f9f7 171
<> 144:ef7eb2e8f9f7 172 /** @addtogroup STM32F1xx_HAL_Driver
<> 144:ef7eb2e8f9f7 173 * @{
<> 144:ef7eb2e8f9f7 174 */
<> 144:ef7eb2e8f9f7 175
<> 144:ef7eb2e8f9f7 176 /** @defgroup UART UART
<> 144:ef7eb2e8f9f7 177 * @brief HAL UART module driver
<> 144:ef7eb2e8f9f7 178 * @{
<> 144:ef7eb2e8f9f7 179 */
<> 144:ef7eb2e8f9f7 180 #ifdef HAL_UART_MODULE_ENABLED
AnnaBridge 165:e614a9f1c9e2 181
<> 144:ef7eb2e8f9f7 182 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 183 /* Private define ------------------------------------------------------------*/
AnnaBridge 165:e614a9f1c9e2 184 /** @addtogroup UART_Private_Constants
AnnaBridge 165:e614a9f1c9e2 185 * @{
AnnaBridge 165:e614a9f1c9e2 186 */
AnnaBridge 165:e614a9f1c9e2 187 /**
AnnaBridge 165:e614a9f1c9e2 188 * @}
AnnaBridge 165:e614a9f1c9e2 189 */
AnnaBridge 165:e614a9f1c9e2 190 /* Private macro -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 191 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 192 /* Private function prototypes -----------------------------------------------*/
AnnaBridge 165:e614a9f1c9e2 193 /** @addtogroup UART_Private_Functions
<> 144:ef7eb2e8f9f7 194 * @{
<> 144:ef7eb2e8f9f7 195 */
AnnaBridge 165:e614a9f1c9e2 196 static void UART_EndTxTransfer(UART_HandleTypeDef *huart);
AnnaBridge 165:e614a9f1c9e2 197 static void UART_EndRxTransfer(UART_HandleTypeDef *huart);
AnnaBridge 165:e614a9f1c9e2 198 static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 199 static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 200 static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 201 static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 202 static void UART_DMAError(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 203 static void UART_DMAAbortOnError(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 204 static void UART_DMATxAbortCallback(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 205 static void UART_DMARxAbortCallback(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 206 static void UART_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
AnnaBridge 165:e614a9f1c9e2 207 static void UART_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma);
<> 144:ef7eb2e8f9f7 208 static HAL_StatusTypeDef UART_Transmit_IT(UART_HandleTypeDef *huart);
<> 144:ef7eb2e8f9f7 209 static HAL_StatusTypeDef UART_EndTransmit_IT(UART_HandleTypeDef *huart);
<> 144:ef7eb2e8f9f7 210 static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart);
AnnaBridge 165:e614a9f1c9e2 211 static HAL_StatusTypeDef UART_WaitOnFlagUntilTimeout(UART_HandleTypeDef *huart, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout);
AnnaBridge 165:e614a9f1c9e2 212 static void UART_SetConfig (UART_HandleTypeDef *huart);
<> 144:ef7eb2e8f9f7 213 /**
<> 144:ef7eb2e8f9f7 214 * @}
<> 144:ef7eb2e8f9f7 215 */
<> 144:ef7eb2e8f9f7 216 /* Exported functions ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 217 /** @defgroup UART_Exported_Functions UART Exported Functions
<> 144:ef7eb2e8f9f7 218 * @{
<> 144:ef7eb2e8f9f7 219 */
<> 144:ef7eb2e8f9f7 220
<> 144:ef7eb2e8f9f7 221 /** @defgroup UART_Exported_Functions_Group1 Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 222 * @brief Initialization and Configuration functions
<> 144:ef7eb2e8f9f7 223 *
<> 144:ef7eb2e8f9f7 224 @verbatim
AnnaBridge 165:e614a9f1c9e2 225 ==============================================================================
<> 144:ef7eb2e8f9f7 226 ##### Initialization and Configuration functions #####
AnnaBridge 165:e614a9f1c9e2 227 ==============================================================================
<> 144:ef7eb2e8f9f7 228 [..]
<> 144:ef7eb2e8f9f7 229 This subsection provides a set of functions allowing to initialize the USARTx or the UARTy
<> 144:ef7eb2e8f9f7 230 in asynchronous mode.
<> 144:ef7eb2e8f9f7 231 (+) For the asynchronous mode only these parameters can be configured:
<> 144:ef7eb2e8f9f7 232 (++) Baud Rate
<> 144:ef7eb2e8f9f7 233 (++) Word Length
<> 144:ef7eb2e8f9f7 234 (++) Stop Bit
AnnaBridge 165:e614a9f1c9e2 235 (++) Parity: If the parity is enabled, then the MSB bit of the data written
AnnaBridge 165:e614a9f1c9e2 236 in the data register is transmitted but is changed by the parity bit.
AnnaBridge 165:e614a9f1c9e2 237 Depending on the frame length defined by the M bit (8-bits or 9-bits),
AnnaBridge 165:e614a9f1c9e2 238 please refer to Reference manual for possible UART frame formats.
<> 144:ef7eb2e8f9f7 239 (++) Hardware flow control
<> 144:ef7eb2e8f9f7 240 (++) Receiver/transmitter modes
AnnaBridge 165:e614a9f1c9e2 241 (++) Over Sampling Method
<> 144:ef7eb2e8f9f7 242 [..]
<> 144:ef7eb2e8f9f7 243 The HAL_UART_Init(), HAL_HalfDuplex_Init(), HAL_LIN_Init() and HAL_MultiProcessor_Init() APIs
<> 144:ef7eb2e8f9f7 244 follow respectively the UART asynchronous, UART Half duplex, LIN and Multi-Processor
<> 144:ef7eb2e8f9f7 245 configuration procedures (details for the procedures are available in reference manuals
<> 144:ef7eb2e8f9f7 246 (RM0008 for STM32F10Xxx MCUs and RM0041 for STM32F100xx MCUs)).
<> 144:ef7eb2e8f9f7 247
<> 144:ef7eb2e8f9f7 248 @endverbatim
<> 144:ef7eb2e8f9f7 249 * @{
<> 144:ef7eb2e8f9f7 250 */
<> 144:ef7eb2e8f9f7 251
<> 144:ef7eb2e8f9f7 252 /**
<> 144:ef7eb2e8f9f7 253 * @brief Initializes the UART mode according to the specified parameters in
<> 144:ef7eb2e8f9f7 254 * the UART_InitTypeDef and create the associated handle.
AnnaBridge 165:e614a9f1c9e2 255 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 256 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 257 * @retval HAL status
<> 144:ef7eb2e8f9f7 258 */
<> 144:ef7eb2e8f9f7 259 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 260 {
<> 144:ef7eb2e8f9f7 261 /* Check the UART handle allocation */
<> 144:ef7eb2e8f9f7 262 if(huart == NULL)
<> 144:ef7eb2e8f9f7 263 {
<> 144:ef7eb2e8f9f7 264 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 265 }
<> 144:ef7eb2e8f9f7 266
<> 144:ef7eb2e8f9f7 267 /* Check the parameters */
<> 144:ef7eb2e8f9f7 268 if(huart->Init.HwFlowCtl != UART_HWCONTROL_NONE)
<> 144:ef7eb2e8f9f7 269 {
<> 144:ef7eb2e8f9f7 270 /* The hardware flow control is available only for USART1, USART2, USART3 */
<> 144:ef7eb2e8f9f7 271 assert_param(IS_UART_HWFLOW_INSTANCE(huart->Instance));
<> 144:ef7eb2e8f9f7 272 assert_param(IS_UART_HARDWARE_FLOW_CONTROL(huart->Init.HwFlowCtl));
<> 144:ef7eb2e8f9f7 273 }
<> 144:ef7eb2e8f9f7 274 else
<> 144:ef7eb2e8f9f7 275 {
<> 144:ef7eb2e8f9f7 276 assert_param(IS_UART_INSTANCE(huart->Instance));
<> 144:ef7eb2e8f9f7 277 }
<> 144:ef7eb2e8f9f7 278 assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));
AnnaBridge 165:e614a9f1c9e2 279 #if defined(USART_CR1_OVER8)
<> 144:ef7eb2e8f9f7 280 assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));
AnnaBridge 165:e614a9f1c9e2 281 #endif /* USART_CR1_OVER8 */
<> 144:ef7eb2e8f9f7 282
AnnaBridge 165:e614a9f1c9e2 283 if(huart->gState == HAL_UART_STATE_RESET)
<> 144:ef7eb2e8f9f7 284 {
<> 144:ef7eb2e8f9f7 285 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 286 huart->Lock = HAL_UNLOCKED;
AnnaBridge 165:e614a9f1c9e2 287
<> 144:ef7eb2e8f9f7 288 /* Init the low level hardware */
<> 144:ef7eb2e8f9f7 289 HAL_UART_MspInit(huart);
<> 144:ef7eb2e8f9f7 290 }
<> 144:ef7eb2e8f9f7 291
AnnaBridge 165:e614a9f1c9e2 292 huart->gState = HAL_UART_STATE_BUSY;
<> 144:ef7eb2e8f9f7 293
<> 144:ef7eb2e8f9f7 294 /* Disable the peripheral */
<> 144:ef7eb2e8f9f7 295 __HAL_UART_DISABLE(huart);
<> 144:ef7eb2e8f9f7 296
<> 144:ef7eb2e8f9f7 297 /* Set the UART Communication parameters */
<> 144:ef7eb2e8f9f7 298 UART_SetConfig(huart);
<> 144:ef7eb2e8f9f7 299
<> 144:ef7eb2e8f9f7 300 /* In asynchronous mode, the following bits must be kept cleared:
<> 144:ef7eb2e8f9f7 301 - LINEN and CLKEN bits in the USART_CR2 register,
<> 144:ef7eb2e8f9f7 302 - SCEN, HDSEL and IREN bits in the USART_CR3 register.*/
<> 144:ef7eb2e8f9f7 303 CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
<> 144:ef7eb2e8f9f7 304 CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));
<> 144:ef7eb2e8f9f7 305
<> 144:ef7eb2e8f9f7 306 /* Enable the peripheral */
<> 144:ef7eb2e8f9f7 307 __HAL_UART_ENABLE(huart);
<> 144:ef7eb2e8f9f7 308
<> 144:ef7eb2e8f9f7 309 /* Initialize the UART state */
<> 144:ef7eb2e8f9f7 310 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 311 huart->gState= HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 312 huart->RxState= HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 313
<> 144:ef7eb2e8f9f7 314 return HAL_OK;
<> 144:ef7eb2e8f9f7 315 }
<> 144:ef7eb2e8f9f7 316
<> 144:ef7eb2e8f9f7 317 /**
<> 144:ef7eb2e8f9f7 318 * @brief Initializes the half-duplex mode according to the specified
<> 144:ef7eb2e8f9f7 319 * parameters in the UART_InitTypeDef and create the associated handle.
AnnaBridge 165:e614a9f1c9e2 320 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 321 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 322 * @retval HAL status
<> 144:ef7eb2e8f9f7 323 */
<> 144:ef7eb2e8f9f7 324 HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 325 {
<> 144:ef7eb2e8f9f7 326 /* Check the UART handle allocation */
<> 144:ef7eb2e8f9f7 327 if(huart == NULL)
<> 144:ef7eb2e8f9f7 328 {
<> 144:ef7eb2e8f9f7 329 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 330 }
AnnaBridge 165:e614a9f1c9e2 331
AnnaBridge 165:e614a9f1c9e2 332 /* Check the parameters */
<> 144:ef7eb2e8f9f7 333 assert_param(IS_UART_HALFDUPLEX_INSTANCE(huart->Instance));
<> 144:ef7eb2e8f9f7 334 assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));
AnnaBridge 165:e614a9f1c9e2 335 #if defined(USART_CR1_OVER8)
<> 144:ef7eb2e8f9f7 336 assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));
AnnaBridge 165:e614a9f1c9e2 337 #endif /* USART_CR1_OVER8 */
AnnaBridge 165:e614a9f1c9e2 338 if(huart->gState == HAL_UART_STATE_RESET)
AnnaBridge 165:e614a9f1c9e2 339 {
<> 144:ef7eb2e8f9f7 340 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 341 huart->Lock = HAL_UNLOCKED;
<> 144:ef7eb2e8f9f7 342 /* Init the low level hardware */
<> 144:ef7eb2e8f9f7 343 HAL_UART_MspInit(huart);
<> 144:ef7eb2e8f9f7 344 }
<> 144:ef7eb2e8f9f7 345
AnnaBridge 165:e614a9f1c9e2 346 huart->gState = HAL_UART_STATE_BUSY;
<> 144:ef7eb2e8f9f7 347
<> 144:ef7eb2e8f9f7 348 /* Disable the peripheral */
<> 144:ef7eb2e8f9f7 349 __HAL_UART_DISABLE(huart);
<> 144:ef7eb2e8f9f7 350
<> 144:ef7eb2e8f9f7 351 /* Set the UART Communication parameters */
<> 144:ef7eb2e8f9f7 352 UART_SetConfig(huart);
<> 144:ef7eb2e8f9f7 353
AnnaBridge 165:e614a9f1c9e2 354 /* In half-duplex mode, the following bits must be kept cleared:
<> 144:ef7eb2e8f9f7 355 - LINEN and CLKEN bits in the USART_CR2 register,
<> 144:ef7eb2e8f9f7 356 - SCEN and IREN bits in the USART_CR3 register.*/
<> 144:ef7eb2e8f9f7 357 CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
<> 144:ef7eb2e8f9f7 358 CLEAR_BIT(huart->Instance->CR3, (USART_CR3_IREN | USART_CR3_SCEN));
<> 144:ef7eb2e8f9f7 359
<> 144:ef7eb2e8f9f7 360 /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */
<> 144:ef7eb2e8f9f7 361 SET_BIT(huart->Instance->CR3, USART_CR3_HDSEL);
<> 144:ef7eb2e8f9f7 362
<> 144:ef7eb2e8f9f7 363 /* Enable the peripheral */
<> 144:ef7eb2e8f9f7 364 __HAL_UART_ENABLE(huart);
<> 144:ef7eb2e8f9f7 365
<> 144:ef7eb2e8f9f7 366 /* Initialize the UART state*/
<> 144:ef7eb2e8f9f7 367 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 368 huart->gState= HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 369 huart->RxState= HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 370
<> 144:ef7eb2e8f9f7 371 return HAL_OK;
<> 144:ef7eb2e8f9f7 372 }
<> 144:ef7eb2e8f9f7 373
<> 144:ef7eb2e8f9f7 374 /**
<> 144:ef7eb2e8f9f7 375 * @brief Initializes the LIN mode according to the specified
<> 144:ef7eb2e8f9f7 376 * parameters in the UART_InitTypeDef and create the associated handle.
AnnaBridge 165:e614a9f1c9e2 377 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 378 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 379 * @param BreakDetectLength: Specifies the LIN break detection length.
<> 144:ef7eb2e8f9f7 380 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 381 * @arg UART_LINBREAKDETECTLENGTH_10B: 10-bit break detection
<> 144:ef7eb2e8f9f7 382 * @arg UART_LINBREAKDETECTLENGTH_11B: 11-bit break detection
<> 144:ef7eb2e8f9f7 383 * @retval HAL status
<> 144:ef7eb2e8f9f7 384 */
<> 144:ef7eb2e8f9f7 385 HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength)
<> 144:ef7eb2e8f9f7 386 {
<> 144:ef7eb2e8f9f7 387 /* Check the UART handle allocation */
<> 144:ef7eb2e8f9f7 388 if(huart == NULL)
<> 144:ef7eb2e8f9f7 389 {
<> 144:ef7eb2e8f9f7 390 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 391 }
<> 144:ef7eb2e8f9f7 392
<> 144:ef7eb2e8f9f7 393 /* Check the LIN UART instance */
<> 144:ef7eb2e8f9f7 394 assert_param(IS_UART_LIN_INSTANCE(huart->Instance));
<> 144:ef7eb2e8f9f7 395 /* Check the Break detection length parameter */
<> 144:ef7eb2e8f9f7 396 assert_param(IS_UART_LIN_BREAK_DETECT_LENGTH(BreakDetectLength));
<> 144:ef7eb2e8f9f7 397 assert_param(IS_UART_LIN_WORD_LENGTH(huart->Init.WordLength));
AnnaBridge 165:e614a9f1c9e2 398 #if defined(USART_CR1_OVER8)
<> 144:ef7eb2e8f9f7 399 assert_param(IS_UART_LIN_OVERSAMPLING(huart->Init.OverSampling));
AnnaBridge 165:e614a9f1c9e2 400 #endif /* USART_CR1_OVER8 */
<> 144:ef7eb2e8f9f7 401
AnnaBridge 165:e614a9f1c9e2 402 if(huart->gState == HAL_UART_STATE_RESET)
AnnaBridge 165:e614a9f1c9e2 403 {
<> 144:ef7eb2e8f9f7 404 /* Allocate lock resource and initialize it */
AnnaBridge 165:e614a9f1c9e2 405 huart->Lock = HAL_UNLOCKED;
<> 144:ef7eb2e8f9f7 406 /* Init the low level hardware */
<> 144:ef7eb2e8f9f7 407 HAL_UART_MspInit(huart);
<> 144:ef7eb2e8f9f7 408 }
<> 144:ef7eb2e8f9f7 409
AnnaBridge 165:e614a9f1c9e2 410 huart->gState = HAL_UART_STATE_BUSY;
<> 144:ef7eb2e8f9f7 411
<> 144:ef7eb2e8f9f7 412 /* Disable the peripheral */
<> 144:ef7eb2e8f9f7 413 __HAL_UART_DISABLE(huart);
<> 144:ef7eb2e8f9f7 414
<> 144:ef7eb2e8f9f7 415 /* Set the UART Communication parameters */
<> 144:ef7eb2e8f9f7 416 UART_SetConfig(huart);
<> 144:ef7eb2e8f9f7 417
<> 144:ef7eb2e8f9f7 418 /* In LIN mode, the following bits must be kept cleared:
<> 144:ef7eb2e8f9f7 419 - CLKEN bits in the USART_CR2 register,
<> 144:ef7eb2e8f9f7 420 - SCEN and IREN bits in the USART_CR3 register.*/
<> 144:ef7eb2e8f9f7 421 CLEAR_BIT(huart->Instance->CR2, USART_CR2_CLKEN);
<> 144:ef7eb2e8f9f7 422 CLEAR_BIT(huart->Instance->CR3, (USART_CR3_HDSEL | USART_CR3_IREN | USART_CR3_SCEN));
<> 144:ef7eb2e8f9f7 423
<> 144:ef7eb2e8f9f7 424 /* Enable the LIN mode by setting the LINEN bit in the CR2 register */
<> 144:ef7eb2e8f9f7 425 SET_BIT(huart->Instance->CR2, USART_CR2_LINEN);
<> 144:ef7eb2e8f9f7 426
<> 144:ef7eb2e8f9f7 427 /* Set the USART LIN Break detection length. */
<> 144:ef7eb2e8f9f7 428 MODIFY_REG(huart->Instance->CR2, USART_CR2_LBDL, BreakDetectLength);
<> 144:ef7eb2e8f9f7 429
<> 144:ef7eb2e8f9f7 430 /* Enable the peripheral */
<> 144:ef7eb2e8f9f7 431 __HAL_UART_ENABLE(huart);
<> 144:ef7eb2e8f9f7 432
<> 144:ef7eb2e8f9f7 433 /* Initialize the UART state*/
<> 144:ef7eb2e8f9f7 434 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 435 huart->gState= HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 436 huart->RxState= HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 437
<> 144:ef7eb2e8f9f7 438 return HAL_OK;
<> 144:ef7eb2e8f9f7 439 }
<> 144:ef7eb2e8f9f7 440
<> 144:ef7eb2e8f9f7 441 /**
<> 144:ef7eb2e8f9f7 442 * @brief Initializes the Multi-Processor mode according to the specified
<> 144:ef7eb2e8f9f7 443 * parameters in the UART_InitTypeDef and create the associated handle.
AnnaBridge 165:e614a9f1c9e2 444 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 445 * the configuration information for the specified UART module.
AnnaBridge 165:e614a9f1c9e2 446 * @param Address: USART address
AnnaBridge 165:e614a9f1c9e2 447 * @param WakeUpMethod: specifies the USART wake-up method.
<> 144:ef7eb2e8f9f7 448 * This parameter can be one of the following values:
AnnaBridge 165:e614a9f1c9e2 449 * @arg UART_WAKEUPMETHOD_IDLELINE: Wake-up by an idle line detection
AnnaBridge 165:e614a9f1c9e2 450 * @arg UART_WAKEUPMETHOD_ADDRESSMARK: Wake-up by an address mark
<> 144:ef7eb2e8f9f7 451 * @retval HAL status
<> 144:ef7eb2e8f9f7 452 */
<> 144:ef7eb2e8f9f7 453 HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod)
<> 144:ef7eb2e8f9f7 454 {
<> 144:ef7eb2e8f9f7 455 /* Check the UART handle allocation */
<> 144:ef7eb2e8f9f7 456 if(huart == NULL)
<> 144:ef7eb2e8f9f7 457 {
<> 144:ef7eb2e8f9f7 458 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 459 }
<> 144:ef7eb2e8f9f7 460
<> 144:ef7eb2e8f9f7 461 /* Check UART instance capabilities */
<> 144:ef7eb2e8f9f7 462 assert_param(IS_UART_MULTIPROCESSOR_INSTANCE(huart->Instance));
<> 144:ef7eb2e8f9f7 463
<> 144:ef7eb2e8f9f7 464 /* Check the Address & wake up method parameters */
<> 144:ef7eb2e8f9f7 465 assert_param(IS_UART_WAKEUPMETHOD(WakeUpMethod));
<> 144:ef7eb2e8f9f7 466 assert_param(IS_UART_ADDRESS(Address));
<> 144:ef7eb2e8f9f7 467 assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));
AnnaBridge 165:e614a9f1c9e2 468 #if defined(USART_CR1_OVER8)
<> 144:ef7eb2e8f9f7 469 assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling));
AnnaBridge 165:e614a9f1c9e2 470 #endif /* USART_CR1_OVER8 */
<> 144:ef7eb2e8f9f7 471
AnnaBridge 165:e614a9f1c9e2 472 if(huart->gState == HAL_UART_STATE_RESET)
AnnaBridge 165:e614a9f1c9e2 473 {
<> 144:ef7eb2e8f9f7 474 /* Allocate lock resource and initialize it */
<> 144:ef7eb2e8f9f7 475 huart->Lock = HAL_UNLOCKED;
<> 144:ef7eb2e8f9f7 476 /* Init the low level hardware */
<> 144:ef7eb2e8f9f7 477 HAL_UART_MspInit(huart);
<> 144:ef7eb2e8f9f7 478 }
<> 144:ef7eb2e8f9f7 479
AnnaBridge 165:e614a9f1c9e2 480 huart->gState = HAL_UART_STATE_BUSY;
<> 144:ef7eb2e8f9f7 481
<> 144:ef7eb2e8f9f7 482 /* Disable the peripheral */
<> 144:ef7eb2e8f9f7 483 __HAL_UART_DISABLE(huart);
<> 144:ef7eb2e8f9f7 484
<> 144:ef7eb2e8f9f7 485 /* Set the UART Communication parameters */
<> 144:ef7eb2e8f9f7 486 UART_SetConfig(huart);
<> 144:ef7eb2e8f9f7 487
<> 144:ef7eb2e8f9f7 488 /* In Multi-Processor mode, the following bits must be kept cleared:
<> 144:ef7eb2e8f9f7 489 - LINEN and CLKEN bits in the USART_CR2 register,
<> 144:ef7eb2e8f9f7 490 - SCEN, HDSEL and IREN bits in the USART_CR3 register */
<> 144:ef7eb2e8f9f7 491 CLEAR_BIT(huart->Instance->CR2, (USART_CR2_LINEN | USART_CR2_CLKEN));
<> 144:ef7eb2e8f9f7 492 CLEAR_BIT(huart->Instance->CR3, (USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN));
<> 144:ef7eb2e8f9f7 493
<> 144:ef7eb2e8f9f7 494 /* Set the USART address node */
<> 144:ef7eb2e8f9f7 495 MODIFY_REG(huart->Instance->CR2, USART_CR2_ADD, Address);
<> 144:ef7eb2e8f9f7 496
<> 144:ef7eb2e8f9f7 497 /* Set the wake up method by setting the WAKE bit in the CR1 register */
<> 144:ef7eb2e8f9f7 498 MODIFY_REG(huart->Instance->CR1, USART_CR1_WAKE, WakeUpMethod);
<> 144:ef7eb2e8f9f7 499
<> 144:ef7eb2e8f9f7 500 /* Enable the peripheral */
<> 144:ef7eb2e8f9f7 501 __HAL_UART_ENABLE(huart);
<> 144:ef7eb2e8f9f7 502
<> 144:ef7eb2e8f9f7 503 /* Initialize the UART state */
<> 144:ef7eb2e8f9f7 504 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 505 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 506 huart->RxState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 507
<> 144:ef7eb2e8f9f7 508 return HAL_OK;
<> 144:ef7eb2e8f9f7 509 }
<> 144:ef7eb2e8f9f7 510
<> 144:ef7eb2e8f9f7 511 /**
<> 144:ef7eb2e8f9f7 512 * @brief DeInitializes the UART peripheral.
AnnaBridge 165:e614a9f1c9e2 513 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 514 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 515 * @retval HAL status
<> 144:ef7eb2e8f9f7 516 */
<> 144:ef7eb2e8f9f7 517 HAL_StatusTypeDef HAL_UART_DeInit(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 518 {
<> 144:ef7eb2e8f9f7 519 /* Check the UART handle allocation */
<> 144:ef7eb2e8f9f7 520 if(huart == NULL)
<> 144:ef7eb2e8f9f7 521 {
<> 144:ef7eb2e8f9f7 522 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 523 }
AnnaBridge 165:e614a9f1c9e2 524
<> 144:ef7eb2e8f9f7 525 /* Check the parameters */
<> 144:ef7eb2e8f9f7 526 assert_param(IS_UART_INSTANCE(huart->Instance));
<> 144:ef7eb2e8f9f7 527
AnnaBridge 165:e614a9f1c9e2 528 huart->gState = HAL_UART_STATE_BUSY;
AnnaBridge 165:e614a9f1c9e2 529
<> 144:ef7eb2e8f9f7 530 /* DeInit the low level hardware */
<> 144:ef7eb2e8f9f7 531 HAL_UART_MspDeInit(huart);
<> 144:ef7eb2e8f9f7 532
<> 144:ef7eb2e8f9f7 533 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 534 huart->gState = HAL_UART_STATE_RESET;
AnnaBridge 165:e614a9f1c9e2 535 huart->RxState = HAL_UART_STATE_RESET;
<> 144:ef7eb2e8f9f7 536
<> 144:ef7eb2e8f9f7 537 /* Process Unlock */
<> 144:ef7eb2e8f9f7 538 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 539
<> 144:ef7eb2e8f9f7 540 return HAL_OK;
<> 144:ef7eb2e8f9f7 541 }
<> 144:ef7eb2e8f9f7 542
<> 144:ef7eb2e8f9f7 543 /**
<> 144:ef7eb2e8f9f7 544 * @brief UART MSP Init.
AnnaBridge 165:e614a9f1c9e2 545 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 546 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 547 * @retval None
<> 144:ef7eb2e8f9f7 548 */
AnnaBridge 165:e614a9f1c9e2 549 __weak void HAL_UART_MspInit(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 550 {
<> 144:ef7eb2e8f9f7 551 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 552 UNUSED(huart);
<> 144:ef7eb2e8f9f7 553 /* NOTE: This function should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 554 the HAL_UART_MspInit could be implemented in the user file
AnnaBridge 165:e614a9f1c9e2 555 */
<> 144:ef7eb2e8f9f7 556 }
<> 144:ef7eb2e8f9f7 557
<> 144:ef7eb2e8f9f7 558 /**
<> 144:ef7eb2e8f9f7 559 * @brief UART MSP DeInit.
AnnaBridge 165:e614a9f1c9e2 560 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 561 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 562 * @retval None
<> 144:ef7eb2e8f9f7 563 */
AnnaBridge 165:e614a9f1c9e2 564 __weak void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 565 {
<> 144:ef7eb2e8f9f7 566 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 567 UNUSED(huart);
<> 144:ef7eb2e8f9f7 568 /* NOTE: This function should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 569 the HAL_UART_MspDeInit could be implemented in the user file
AnnaBridge 165:e614a9f1c9e2 570 */
<> 144:ef7eb2e8f9f7 571 }
<> 144:ef7eb2e8f9f7 572
<> 144:ef7eb2e8f9f7 573 /**
<> 144:ef7eb2e8f9f7 574 * @}
<> 144:ef7eb2e8f9f7 575 */
<> 144:ef7eb2e8f9f7 576
<> 144:ef7eb2e8f9f7 577 /** @defgroup UART_Exported_Functions_Group2 IO operation functions
<> 144:ef7eb2e8f9f7 578 * @brief UART Transmit and Receive functions
<> 144:ef7eb2e8f9f7 579 *
<> 144:ef7eb2e8f9f7 580 @verbatim
<> 144:ef7eb2e8f9f7 581 ==============================================================================
<> 144:ef7eb2e8f9f7 582 ##### IO operation functions #####
AnnaBridge 165:e614a9f1c9e2 583 ==============================================================================
<> 144:ef7eb2e8f9f7 584 [..]
<> 144:ef7eb2e8f9f7 585 This subsection provides a set of functions allowing to manage the UART asynchronous
<> 144:ef7eb2e8f9f7 586 and Half duplex data transfers.
<> 144:ef7eb2e8f9f7 587
<> 144:ef7eb2e8f9f7 588 (#) There are two modes of transfer:
<> 144:ef7eb2e8f9f7 589 (++) Blocking mode: The communication is performed in polling mode.
<> 144:ef7eb2e8f9f7 590 The HAL status of all data processing is returned by the same function
<> 144:ef7eb2e8f9f7 591 after finishing transfer.
<> 144:ef7eb2e8f9f7 592 (++) Non blocking mode: The communication is performed using Interrupts
<> 144:ef7eb2e8f9f7 593 or DMA, these APIs return the HAL status.
<> 144:ef7eb2e8f9f7 594 The end of the data processing will be indicated through the
<> 144:ef7eb2e8f9f7 595 dedicated UART IRQ when using Interrupt mode or the DMA IRQ when
<> 144:ef7eb2e8f9f7 596 using DMA mode.
<> 144:ef7eb2e8f9f7 597 The HAL_UART_TxCpltCallback(), HAL_UART_RxCpltCallback() user callbacks
<> 144:ef7eb2e8f9f7 598 will be executed respectively at the end of the transmit or receive process.
<> 144:ef7eb2e8f9f7 599 The HAL_UART_ErrorCallback() user callback will be executed when
<> 144:ef7eb2e8f9f7 600 a communication error is detected.
<> 144:ef7eb2e8f9f7 601
<> 144:ef7eb2e8f9f7 602 (#) Blocking mode APIs are:
<> 144:ef7eb2e8f9f7 603 (++) HAL_UART_Transmit()
<> 144:ef7eb2e8f9f7 604 (++) HAL_UART_Receive()
<> 144:ef7eb2e8f9f7 605
<> 144:ef7eb2e8f9f7 606 (#) Non Blocking mode APIs with Interrupt are:
<> 144:ef7eb2e8f9f7 607 (++) HAL_UART_Transmit_IT()
<> 144:ef7eb2e8f9f7 608 (++) HAL_UART_Receive_IT()
<> 144:ef7eb2e8f9f7 609 (++) HAL_UART_IRQHandler()
<> 144:ef7eb2e8f9f7 610
<> 144:ef7eb2e8f9f7 611 (#) Non Blocking mode functions with DMA are:
<> 144:ef7eb2e8f9f7 612 (++) HAL_UART_Transmit_DMA()
<> 144:ef7eb2e8f9f7 613 (++) HAL_UART_Receive_DMA()
<> 144:ef7eb2e8f9f7 614 (++) HAL_UART_DMAPause()
<> 144:ef7eb2e8f9f7 615 (++) HAL_UART_DMAResume()
<> 144:ef7eb2e8f9f7 616 (++) HAL_UART_DMAStop()
<> 144:ef7eb2e8f9f7 617
<> 144:ef7eb2e8f9f7 618 (#) A set of Transfer Complete Callbacks are provided in non blocking mode:
<> 144:ef7eb2e8f9f7 619 (++) HAL_UART_TxHalfCpltCallback()
<> 144:ef7eb2e8f9f7 620 (++) HAL_UART_TxCpltCallback()
<> 144:ef7eb2e8f9f7 621 (++) HAL_UART_RxHalfCpltCallback()
<> 144:ef7eb2e8f9f7 622 (++) HAL_UART_RxCpltCallback()
<> 144:ef7eb2e8f9f7 623 (++) HAL_UART_ErrorCallback()
<> 144:ef7eb2e8f9f7 624
AnnaBridge 165:e614a9f1c9e2 625 [..]
<> 144:ef7eb2e8f9f7 626 (@) In the Half duplex communication, it is forbidden to run the transmit
AnnaBridge 165:e614a9f1c9e2 627 and receive process in parallel, the UART state HAL_UART_STATE_BUSY_TX_RX
<> 144:ef7eb2e8f9f7 628 can't be useful.
AnnaBridge 165:e614a9f1c9e2 629
<> 144:ef7eb2e8f9f7 630 @endverbatim
<> 144:ef7eb2e8f9f7 631 * @{
<> 144:ef7eb2e8f9f7 632 */
<> 144:ef7eb2e8f9f7 633
<> 144:ef7eb2e8f9f7 634 /**
AnnaBridge 165:e614a9f1c9e2 635 * @brief Sends an amount of data in blocking mode.
AnnaBridge 165:e614a9f1c9e2 636 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 637 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 638 * @param pData: Pointer to data buffer
<> 144:ef7eb2e8f9f7 639 * @param Size: Amount of data to be sent
<> 144:ef7eb2e8f9f7 640 * @param Timeout: Timeout duration
<> 144:ef7eb2e8f9f7 641 * @retval HAL status
<> 144:ef7eb2e8f9f7 642 */
<> 144:ef7eb2e8f9f7 643 HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 644 {
<> 144:ef7eb2e8f9f7 645 uint16_t* tmp;
AnnaBridge 165:e614a9f1c9e2 646 uint32_t tickstart = 0U;
<> 144:ef7eb2e8f9f7 647
AnnaBridge 165:e614a9f1c9e2 648 /* Check that a Tx process is not already ongoing */
AnnaBridge 165:e614a9f1c9e2 649 if(huart->gState == HAL_UART_STATE_READY)
<> 144:ef7eb2e8f9f7 650 {
AnnaBridge 165:e614a9f1c9e2 651 if((pData == NULL) || (Size == 0U))
<> 144:ef7eb2e8f9f7 652 {
<> 144:ef7eb2e8f9f7 653 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 654 }
<> 144:ef7eb2e8f9f7 655
<> 144:ef7eb2e8f9f7 656 /* Process Locked */
<> 144:ef7eb2e8f9f7 657 __HAL_LOCK(huart);
<> 144:ef7eb2e8f9f7 658
<> 144:ef7eb2e8f9f7 659 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 660 huart->gState = HAL_UART_STATE_BUSY_TX;
AnnaBridge 165:e614a9f1c9e2 661
AnnaBridge 165:e614a9f1c9e2 662 /* Init tickstart for timeout managment */
AnnaBridge 165:e614a9f1c9e2 663 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 664
<> 144:ef7eb2e8f9f7 665 huart->TxXferSize = Size;
<> 144:ef7eb2e8f9f7 666 huart->TxXferCount = Size;
AnnaBridge 165:e614a9f1c9e2 667 while(huart->TxXferCount > 0U)
<> 144:ef7eb2e8f9f7 668 {
<> 144:ef7eb2e8f9f7 669 huart->TxXferCount--;
<> 144:ef7eb2e8f9f7 670 if(huart->Init.WordLength == UART_WORDLENGTH_9B)
<> 144:ef7eb2e8f9f7 671 {
AnnaBridge 165:e614a9f1c9e2 672 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
<> 144:ef7eb2e8f9f7 673 {
<> 144:ef7eb2e8f9f7 674 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 675 }
<> 144:ef7eb2e8f9f7 676 tmp = (uint16_t*) pData;
<> 144:ef7eb2e8f9f7 677 huart->Instance->DR = (*tmp & (uint16_t)0x01FF);
<> 144:ef7eb2e8f9f7 678 if(huart->Init.Parity == UART_PARITY_NONE)
<> 144:ef7eb2e8f9f7 679 {
AnnaBridge 165:e614a9f1c9e2 680 pData +=2U;
<> 144:ef7eb2e8f9f7 681 }
<> 144:ef7eb2e8f9f7 682 else
AnnaBridge 165:e614a9f1c9e2 683 {
AnnaBridge 165:e614a9f1c9e2 684 pData +=1U;
<> 144:ef7eb2e8f9f7 685 }
AnnaBridge 165:e614a9f1c9e2 686 }
<> 144:ef7eb2e8f9f7 687 else
<> 144:ef7eb2e8f9f7 688 {
AnnaBridge 165:e614a9f1c9e2 689 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK)
<> 144:ef7eb2e8f9f7 690 {
<> 144:ef7eb2e8f9f7 691 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 692 }
<> 144:ef7eb2e8f9f7 693 huart->Instance->DR = (*pData++ & (uint8_t)0xFF);
<> 144:ef7eb2e8f9f7 694 }
<> 144:ef7eb2e8f9f7 695 }
<> 144:ef7eb2e8f9f7 696
AnnaBridge 165:e614a9f1c9e2 697 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 698 {
<> 144:ef7eb2e8f9f7 699 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 700 }
<> 144:ef7eb2e8f9f7 701
AnnaBridge 165:e614a9f1c9e2 702 /* At end of Tx process, restore huart->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 703 huart->gState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 704
<> 144:ef7eb2e8f9f7 705 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 706 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 707
<> 144:ef7eb2e8f9f7 708 return HAL_OK;
<> 144:ef7eb2e8f9f7 709 }
<> 144:ef7eb2e8f9f7 710 else
<> 144:ef7eb2e8f9f7 711 {
<> 144:ef7eb2e8f9f7 712 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 713 }
<> 144:ef7eb2e8f9f7 714 }
<> 144:ef7eb2e8f9f7 715
<> 144:ef7eb2e8f9f7 716 /**
AnnaBridge 165:e614a9f1c9e2 717 * @brief Receive an amount of data in blocking mode.
AnnaBridge 165:e614a9f1c9e2 718 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 719 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 720 * @param pData: Pointer to data buffer
<> 144:ef7eb2e8f9f7 721 * @param Size: Amount of data to be received
<> 144:ef7eb2e8f9f7 722 * @param Timeout: Timeout duration
<> 144:ef7eb2e8f9f7 723 * @retval HAL status
<> 144:ef7eb2e8f9f7 724 */
<> 144:ef7eb2e8f9f7 725 HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 726 {
<> 144:ef7eb2e8f9f7 727 uint16_t* tmp;
AnnaBridge 165:e614a9f1c9e2 728 uint32_t tickstart = 0U;
AnnaBridge 165:e614a9f1c9e2 729
AnnaBridge 165:e614a9f1c9e2 730 /* Check that a Rx process is not already ongoing */
AnnaBridge 165:e614a9f1c9e2 731 if(huart->RxState == HAL_UART_STATE_READY)
<> 144:ef7eb2e8f9f7 732 {
AnnaBridge 165:e614a9f1c9e2 733 if((pData == NULL) || (Size == 0U))
<> 144:ef7eb2e8f9f7 734 {
<> 144:ef7eb2e8f9f7 735 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 736 }
<> 144:ef7eb2e8f9f7 737
<> 144:ef7eb2e8f9f7 738 /* Process Locked */
<> 144:ef7eb2e8f9f7 739 __HAL_LOCK(huart);
AnnaBridge 165:e614a9f1c9e2 740
<> 144:ef7eb2e8f9f7 741 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 742 huart->RxState = HAL_UART_STATE_BUSY_RX;
AnnaBridge 165:e614a9f1c9e2 743
AnnaBridge 165:e614a9f1c9e2 744 /* Init tickstart for timeout managment */
AnnaBridge 165:e614a9f1c9e2 745 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 746
<> 144:ef7eb2e8f9f7 747 huart->RxXferSize = Size;
<> 144:ef7eb2e8f9f7 748 huart->RxXferCount = Size;
<> 144:ef7eb2e8f9f7 749
<> 144:ef7eb2e8f9f7 750 /* Check the remain data to be received */
AnnaBridge 165:e614a9f1c9e2 751 while(huart->RxXferCount > 0U)
<> 144:ef7eb2e8f9f7 752 {
<> 144:ef7eb2e8f9f7 753 huart->RxXferCount--;
<> 144:ef7eb2e8f9f7 754 if(huart->Init.WordLength == UART_WORDLENGTH_9B)
<> 144:ef7eb2e8f9f7 755 {
AnnaBridge 165:e614a9f1c9e2 756 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
<> 144:ef7eb2e8f9f7 757 {
<> 144:ef7eb2e8f9f7 758 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 759 }
AnnaBridge 165:e614a9f1c9e2 760 tmp = (uint16_t*)pData;
<> 144:ef7eb2e8f9f7 761 if(huart->Init.Parity == UART_PARITY_NONE)
<> 144:ef7eb2e8f9f7 762 {
<> 144:ef7eb2e8f9f7 763 *tmp = (uint16_t)(huart->Instance->DR & (uint16_t)0x01FF);
AnnaBridge 165:e614a9f1c9e2 764 pData +=2U;
<> 144:ef7eb2e8f9f7 765 }
<> 144:ef7eb2e8f9f7 766 else
<> 144:ef7eb2e8f9f7 767 {
<> 144:ef7eb2e8f9f7 768 *tmp = (uint16_t)(huart->Instance->DR & (uint16_t)0x00FF);
AnnaBridge 165:e614a9f1c9e2 769 pData +=1U;
<> 144:ef7eb2e8f9f7 770 }
<> 144:ef7eb2e8f9f7 771
AnnaBridge 165:e614a9f1c9e2 772 }
<> 144:ef7eb2e8f9f7 773 else
<> 144:ef7eb2e8f9f7 774 {
AnnaBridge 165:e614a9f1c9e2 775 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK)
<> 144:ef7eb2e8f9f7 776 {
<> 144:ef7eb2e8f9f7 777 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 778 }
<> 144:ef7eb2e8f9f7 779 if(huart->Init.Parity == UART_PARITY_NONE)
<> 144:ef7eb2e8f9f7 780 {
<> 144:ef7eb2e8f9f7 781 *pData++ = (uint8_t)(huart->Instance->DR & (uint8_t)0x00FF);
<> 144:ef7eb2e8f9f7 782 }
<> 144:ef7eb2e8f9f7 783 else
<> 144:ef7eb2e8f9f7 784 {
<> 144:ef7eb2e8f9f7 785 *pData++ = (uint8_t)(huart->Instance->DR & (uint8_t)0x007F);
<> 144:ef7eb2e8f9f7 786 }
<> 144:ef7eb2e8f9f7 787
<> 144:ef7eb2e8f9f7 788 }
<> 144:ef7eb2e8f9f7 789 }
<> 144:ef7eb2e8f9f7 790
AnnaBridge 165:e614a9f1c9e2 791 /* At end of Rx process, restore huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 792 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 793
<> 144:ef7eb2e8f9f7 794 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 795 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 796
<> 144:ef7eb2e8f9f7 797 return HAL_OK;
<> 144:ef7eb2e8f9f7 798 }
<> 144:ef7eb2e8f9f7 799 else
<> 144:ef7eb2e8f9f7 800 {
<> 144:ef7eb2e8f9f7 801 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 802 }
<> 144:ef7eb2e8f9f7 803 }
<> 144:ef7eb2e8f9f7 804
<> 144:ef7eb2e8f9f7 805 /**
<> 144:ef7eb2e8f9f7 806 * @brief Sends an amount of data in non blocking mode.
AnnaBridge 165:e614a9f1c9e2 807 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 808 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 809 * @param pData: Pointer to data buffer
<> 144:ef7eb2e8f9f7 810 * @param Size: Amount of data to be sent
<> 144:ef7eb2e8f9f7 811 * @retval HAL status
<> 144:ef7eb2e8f9f7 812 */
<> 144:ef7eb2e8f9f7 813 HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
<> 144:ef7eb2e8f9f7 814 {
AnnaBridge 165:e614a9f1c9e2 815 /* Check that a Tx process is not already ongoing */
AnnaBridge 165:e614a9f1c9e2 816 if(huart->gState == HAL_UART_STATE_READY)
<> 144:ef7eb2e8f9f7 817 {
AnnaBridge 165:e614a9f1c9e2 818 if((pData == NULL) || (Size == 0U))
<> 144:ef7eb2e8f9f7 819 {
<> 144:ef7eb2e8f9f7 820 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 821 }
<> 144:ef7eb2e8f9f7 822 /* Process Locked */
<> 144:ef7eb2e8f9f7 823 __HAL_LOCK(huart);
AnnaBridge 165:e614a9f1c9e2 824
<> 144:ef7eb2e8f9f7 825 huart->pTxBuffPtr = pData;
<> 144:ef7eb2e8f9f7 826 huart->TxXferSize = Size;
<> 144:ef7eb2e8f9f7 827 huart->TxXferCount = Size;
<> 144:ef7eb2e8f9f7 828
<> 144:ef7eb2e8f9f7 829 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 830 huart->gState = HAL_UART_STATE_BUSY_TX;
<> 144:ef7eb2e8f9f7 831
<> 144:ef7eb2e8f9f7 832 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 833 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 834
<> 144:ef7eb2e8f9f7 835 /* Enable the UART Transmit data register empty Interrupt */
<> 144:ef7eb2e8f9f7 836 __HAL_UART_ENABLE_IT(huart, UART_IT_TXE);
AnnaBridge 165:e614a9f1c9e2 837
<> 144:ef7eb2e8f9f7 838 return HAL_OK;
<> 144:ef7eb2e8f9f7 839 }
<> 144:ef7eb2e8f9f7 840 else
<> 144:ef7eb2e8f9f7 841 {
<> 144:ef7eb2e8f9f7 842 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 843 }
<> 144:ef7eb2e8f9f7 844 }
<> 144:ef7eb2e8f9f7 845
<> 144:ef7eb2e8f9f7 846 /**
AnnaBridge 165:e614a9f1c9e2 847 * @brief Receives an amount of data in non blocking mode.
AnnaBridge 165:e614a9f1c9e2 848 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 849 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 850 * @param pData: Pointer to data buffer
<> 144:ef7eb2e8f9f7 851 * @param Size: Amount of data to be received
<> 144:ef7eb2e8f9f7 852 * @retval HAL status
<> 144:ef7eb2e8f9f7 853 */
<> 144:ef7eb2e8f9f7 854 HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
<> 144:ef7eb2e8f9f7 855 {
AnnaBridge 165:e614a9f1c9e2 856 /* Check that a Rx process is not already ongoing */
AnnaBridge 165:e614a9f1c9e2 857 if(huart->RxState == HAL_UART_STATE_READY)
<> 144:ef7eb2e8f9f7 858 {
AnnaBridge 165:e614a9f1c9e2 859 if((pData == NULL) || (Size == 0U))
<> 144:ef7eb2e8f9f7 860 {
<> 144:ef7eb2e8f9f7 861 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 862 }
<> 144:ef7eb2e8f9f7 863
<> 144:ef7eb2e8f9f7 864 /* Process Locked */
<> 144:ef7eb2e8f9f7 865 __HAL_LOCK(huart);
<> 144:ef7eb2e8f9f7 866
<> 144:ef7eb2e8f9f7 867 huart->pRxBuffPtr = pData;
<> 144:ef7eb2e8f9f7 868 huart->RxXferSize = Size;
<> 144:ef7eb2e8f9f7 869 huart->RxXferCount = Size;
<> 144:ef7eb2e8f9f7 870
<> 144:ef7eb2e8f9f7 871 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 872 huart->RxState = HAL_UART_STATE_BUSY_RX;
AnnaBridge 165:e614a9f1c9e2 873
<> 144:ef7eb2e8f9f7 874 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 875 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 876
<> 144:ef7eb2e8f9f7 877 /* Enable the UART Parity Error Interrupt */
<> 144:ef7eb2e8f9f7 878 __HAL_UART_ENABLE_IT(huart, UART_IT_PE);
<> 144:ef7eb2e8f9f7 879
<> 144:ef7eb2e8f9f7 880 /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
<> 144:ef7eb2e8f9f7 881 __HAL_UART_ENABLE_IT(huart, UART_IT_ERR);
<> 144:ef7eb2e8f9f7 882
<> 144:ef7eb2e8f9f7 883 /* Enable the UART Data Register not empty Interrupt */
<> 144:ef7eb2e8f9f7 884 __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
<> 144:ef7eb2e8f9f7 885
<> 144:ef7eb2e8f9f7 886 return HAL_OK;
<> 144:ef7eb2e8f9f7 887 }
<> 144:ef7eb2e8f9f7 888 else
<> 144:ef7eb2e8f9f7 889 {
<> 144:ef7eb2e8f9f7 890 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 891 }
<> 144:ef7eb2e8f9f7 892 }
<> 144:ef7eb2e8f9f7 893
<> 144:ef7eb2e8f9f7 894 /**
<> 144:ef7eb2e8f9f7 895 * @brief Sends an amount of data in non blocking mode.
AnnaBridge 165:e614a9f1c9e2 896 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 897 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 898 * @param pData: Pointer to data buffer
<> 144:ef7eb2e8f9f7 899 * @param Size: Amount of data to be sent
<> 144:ef7eb2e8f9f7 900 * @retval HAL status
<> 144:ef7eb2e8f9f7 901 */
<> 144:ef7eb2e8f9f7 902 HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
<> 144:ef7eb2e8f9f7 903 {
<> 144:ef7eb2e8f9f7 904 uint32_t *tmp;
AnnaBridge 165:e614a9f1c9e2 905
AnnaBridge 165:e614a9f1c9e2 906 /* Check that a Tx process is not already ongoing */
AnnaBridge 165:e614a9f1c9e2 907 if(huart->gState == HAL_UART_STATE_READY)
<> 144:ef7eb2e8f9f7 908 {
AnnaBridge 165:e614a9f1c9e2 909 if((pData == NULL) || (Size == 0U))
<> 144:ef7eb2e8f9f7 910 {
<> 144:ef7eb2e8f9f7 911 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 912 }
<> 144:ef7eb2e8f9f7 913
<> 144:ef7eb2e8f9f7 914 /* Process Locked */
<> 144:ef7eb2e8f9f7 915 __HAL_LOCK(huart);
<> 144:ef7eb2e8f9f7 916
<> 144:ef7eb2e8f9f7 917 huart->pTxBuffPtr = pData;
<> 144:ef7eb2e8f9f7 918 huart->TxXferSize = Size;
<> 144:ef7eb2e8f9f7 919 huart->TxXferCount = Size;
<> 144:ef7eb2e8f9f7 920
<> 144:ef7eb2e8f9f7 921 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 922 huart->gState = HAL_UART_STATE_BUSY_TX;
<> 144:ef7eb2e8f9f7 923
<> 144:ef7eb2e8f9f7 924 /* Set the UART DMA transfer complete callback */
<> 144:ef7eb2e8f9f7 925 huart->hdmatx->XferCpltCallback = UART_DMATransmitCplt;
<> 144:ef7eb2e8f9f7 926
<> 144:ef7eb2e8f9f7 927 /* Set the UART DMA Half transfer complete callback */
<> 144:ef7eb2e8f9f7 928 huart->hdmatx->XferHalfCpltCallback = UART_DMATxHalfCplt;
<> 144:ef7eb2e8f9f7 929
<> 144:ef7eb2e8f9f7 930 /* Set the DMA error callback */
<> 144:ef7eb2e8f9f7 931 huart->hdmatx->XferErrorCallback = UART_DMAError;
<> 144:ef7eb2e8f9f7 932
AnnaBridge 165:e614a9f1c9e2 933 /* Set the DMA abort callback */
AnnaBridge 165:e614a9f1c9e2 934 huart->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 935
<> 144:ef7eb2e8f9f7 936 /* Enable the UART transmit DMA channel */
<> 144:ef7eb2e8f9f7 937 tmp = (uint32_t*)&pData;
<> 144:ef7eb2e8f9f7 938 HAL_DMA_Start_IT(huart->hdmatx, *(uint32_t*)tmp, (uint32_t)&huart->Instance->DR, Size);
<> 144:ef7eb2e8f9f7 939
<> 144:ef7eb2e8f9f7 940 /* Clear the TC flag in the SR register by writing 0 to it */
<> 144:ef7eb2e8f9f7 941 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);
<> 144:ef7eb2e8f9f7 942
AnnaBridge 165:e614a9f1c9e2 943 /* Process Unlocked */
AnnaBridge 165:e614a9f1c9e2 944 __HAL_UNLOCK(huart);
AnnaBridge 165:e614a9f1c9e2 945
<> 144:ef7eb2e8f9f7 946 /* Enable the DMA transfer for transmit request by setting the DMAT bit
<> 144:ef7eb2e8f9f7 947 in the UART CR3 register */
<> 144:ef7eb2e8f9f7 948 SET_BIT(huart->Instance->CR3, USART_CR3_DMAT);
<> 144:ef7eb2e8f9f7 949
<> 144:ef7eb2e8f9f7 950 return HAL_OK;
<> 144:ef7eb2e8f9f7 951 }
<> 144:ef7eb2e8f9f7 952 else
<> 144:ef7eb2e8f9f7 953 {
<> 144:ef7eb2e8f9f7 954 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 955 }
<> 144:ef7eb2e8f9f7 956 }
<> 144:ef7eb2e8f9f7 957
<> 144:ef7eb2e8f9f7 958 /**
<> 144:ef7eb2e8f9f7 959 * @brief Receives an amount of data in non blocking mode.
AnnaBridge 165:e614a9f1c9e2 960 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 961 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 962 * @param pData: Pointer to data buffer
<> 144:ef7eb2e8f9f7 963 * @param Size: Amount of data to be received
AnnaBridge 165:e614a9f1c9e2 964 * @note When the UART parity is enabled (PCE = 1) the data received contain the parity bit.
<> 144:ef7eb2e8f9f7 965 * @retval HAL status
<> 144:ef7eb2e8f9f7 966 */
<> 144:ef7eb2e8f9f7 967 HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
<> 144:ef7eb2e8f9f7 968 {
<> 144:ef7eb2e8f9f7 969 uint32_t *tmp;
AnnaBridge 165:e614a9f1c9e2 970
AnnaBridge 165:e614a9f1c9e2 971 /* Check that a Rx process is not already ongoing */
AnnaBridge 165:e614a9f1c9e2 972 if(huart->RxState == HAL_UART_STATE_READY)
<> 144:ef7eb2e8f9f7 973 {
AnnaBridge 165:e614a9f1c9e2 974 if((pData == NULL) || (Size == 0U))
<> 144:ef7eb2e8f9f7 975 {
<> 144:ef7eb2e8f9f7 976 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 977 }
<> 144:ef7eb2e8f9f7 978
<> 144:ef7eb2e8f9f7 979 /* Process Locked */
<> 144:ef7eb2e8f9f7 980 __HAL_LOCK(huart);
<> 144:ef7eb2e8f9f7 981
<> 144:ef7eb2e8f9f7 982 huart->pRxBuffPtr = pData;
<> 144:ef7eb2e8f9f7 983 huart->RxXferSize = Size;
<> 144:ef7eb2e8f9f7 984
<> 144:ef7eb2e8f9f7 985 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 986 huart->RxState = HAL_UART_STATE_BUSY_RX;
<> 144:ef7eb2e8f9f7 987
<> 144:ef7eb2e8f9f7 988 /* Set the UART DMA transfer complete callback */
<> 144:ef7eb2e8f9f7 989 huart->hdmarx->XferCpltCallback = UART_DMAReceiveCplt;
<> 144:ef7eb2e8f9f7 990
<> 144:ef7eb2e8f9f7 991 /* Set the UART DMA Half transfer complete callback */
<> 144:ef7eb2e8f9f7 992 huart->hdmarx->XferHalfCpltCallback = UART_DMARxHalfCplt;
<> 144:ef7eb2e8f9f7 993
<> 144:ef7eb2e8f9f7 994 /* Set the DMA error callback */
<> 144:ef7eb2e8f9f7 995 huart->hdmarx->XferErrorCallback = UART_DMAError;
<> 144:ef7eb2e8f9f7 996
AnnaBridge 165:e614a9f1c9e2 997 /* Set the DMA abort callback */
AnnaBridge 165:e614a9f1c9e2 998 huart->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 999
<> 144:ef7eb2e8f9f7 1000 /* Enable the DMA channel */
<> 144:ef7eb2e8f9f7 1001 tmp = (uint32_t*)&pData;
<> 144:ef7eb2e8f9f7 1002 HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->DR, *(uint32_t*)tmp, Size);
<> 144:ef7eb2e8f9f7 1003
AnnaBridge 165:e614a9f1c9e2 1004 /* Clear the Overrun flag just before enabling the DMA Rx request: can be mandatory for the second transfer */
AnnaBridge 165:e614a9f1c9e2 1005 __HAL_UART_CLEAR_OREFLAG(huart);
<> 144:ef7eb2e8f9f7 1006
<> 144:ef7eb2e8f9f7 1007 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1008 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 1009
AnnaBridge 165:e614a9f1c9e2 1010 /* Enable the UART Parity Error Interrupt */
AnnaBridge 165:e614a9f1c9e2 1011 SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 165:e614a9f1c9e2 1012
AnnaBridge 165:e614a9f1c9e2 1013 /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
AnnaBridge 165:e614a9f1c9e2 1014 SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 1015
AnnaBridge 165:e614a9f1c9e2 1016 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
AnnaBridge 165:e614a9f1c9e2 1017 in the UART CR3 register */
AnnaBridge 165:e614a9f1c9e2 1018 SET_BIT(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1019
<> 144:ef7eb2e8f9f7 1020 return HAL_OK;
<> 144:ef7eb2e8f9f7 1021 }
<> 144:ef7eb2e8f9f7 1022 else
<> 144:ef7eb2e8f9f7 1023 {
<> 144:ef7eb2e8f9f7 1024 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 1025 }
<> 144:ef7eb2e8f9f7 1026 }
AnnaBridge 165:e614a9f1c9e2 1027
<> 144:ef7eb2e8f9f7 1028 /**
<> 144:ef7eb2e8f9f7 1029 * @brief Pauses the DMA Transfer.
AnnaBridge 165:e614a9f1c9e2 1030 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1031 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1032 * @retval HAL status
<> 144:ef7eb2e8f9f7 1033 */
<> 144:ef7eb2e8f9f7 1034 HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1035 {
AnnaBridge 165:e614a9f1c9e2 1036 uint32_t dmarequest = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1037
<> 144:ef7eb2e8f9f7 1038 /* Process Locked */
<> 144:ef7eb2e8f9f7 1039 __HAL_LOCK(huart);
AnnaBridge 165:e614a9f1c9e2 1040
AnnaBridge 165:e614a9f1c9e2 1041 dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 1042 if((huart->gState == HAL_UART_STATE_BUSY_TX) && dmarequest)
<> 144:ef7eb2e8f9f7 1043 {
<> 144:ef7eb2e8f9f7 1044 /* Disable the UART DMA Tx request */
<> 144:ef7eb2e8f9f7 1045 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);
<> 144:ef7eb2e8f9f7 1046 }
AnnaBridge 165:e614a9f1c9e2 1047
AnnaBridge 165:e614a9f1c9e2 1048 dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1049 if((huart->RxState == HAL_UART_STATE_BUSY_RX) && dmarequest)
<> 144:ef7eb2e8f9f7 1050 {
AnnaBridge 165:e614a9f1c9e2 1051 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 1052 CLEAR_BIT(huart->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 165:e614a9f1c9e2 1053 CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 1054
<> 144:ef7eb2e8f9f7 1055 /* Disable the UART DMA Rx request */
<> 144:ef7eb2e8f9f7 1056 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
<> 144:ef7eb2e8f9f7 1057 }
AnnaBridge 165:e614a9f1c9e2 1058
<> 144:ef7eb2e8f9f7 1059 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1060 __HAL_UNLOCK(huart);
AnnaBridge 165:e614a9f1c9e2 1061
AnnaBridge 165:e614a9f1c9e2 1062 return HAL_OK;
<> 144:ef7eb2e8f9f7 1063 }
<> 144:ef7eb2e8f9f7 1064
<> 144:ef7eb2e8f9f7 1065 /**
<> 144:ef7eb2e8f9f7 1066 * @brief Resumes the DMA Transfer.
AnnaBridge 165:e614a9f1c9e2 1067 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1068 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1069 * @retval HAL status
<> 144:ef7eb2e8f9f7 1070 */
<> 144:ef7eb2e8f9f7 1071 HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1072 {
<> 144:ef7eb2e8f9f7 1073 /* Process Locked */
<> 144:ef7eb2e8f9f7 1074 __HAL_LOCK(huart);
AnnaBridge 165:e614a9f1c9e2 1075
AnnaBridge 165:e614a9f1c9e2 1076 if(huart->gState == HAL_UART_STATE_BUSY_TX)
<> 144:ef7eb2e8f9f7 1077 {
<> 144:ef7eb2e8f9f7 1078 /* Enable the UART DMA Tx request */
<> 144:ef7eb2e8f9f7 1079 SET_BIT(huart->Instance->CR3, USART_CR3_DMAT);
<> 144:ef7eb2e8f9f7 1080 }
AnnaBridge 165:e614a9f1c9e2 1081
AnnaBridge 165:e614a9f1c9e2 1082 if(huart->RxState == HAL_UART_STATE_BUSY_RX)
<> 144:ef7eb2e8f9f7 1083 {
AnnaBridge 165:e614a9f1c9e2 1084 /* Clear the Overrun flag before resuming the Rx transfer*/
<> 144:ef7eb2e8f9f7 1085 __HAL_UART_CLEAR_OREFLAG(huart);
AnnaBridge 165:e614a9f1c9e2 1086
AnnaBridge 165:e614a9f1c9e2 1087 /* Reenable PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 1088 SET_BIT(huart->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 165:e614a9f1c9e2 1089 SET_BIT(huart->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 1090
<> 144:ef7eb2e8f9f7 1091 /* Enable the UART DMA Rx request */
<> 144:ef7eb2e8f9f7 1092 SET_BIT(huart->Instance->CR3, USART_CR3_DMAR);
<> 144:ef7eb2e8f9f7 1093 }
<> 144:ef7eb2e8f9f7 1094
<> 144:ef7eb2e8f9f7 1095 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1096 __HAL_UNLOCK(huart);
AnnaBridge 165:e614a9f1c9e2 1097
AnnaBridge 165:e614a9f1c9e2 1098 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 1099 }
AnnaBridge 165:e614a9f1c9e2 1100
AnnaBridge 165:e614a9f1c9e2 1101 /**
AnnaBridge 165:e614a9f1c9e2 1102 * @brief Stops the DMA Transfer.
AnnaBridge 165:e614a9f1c9e2 1103 * @param huart: pointer to a UART_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 1104 * the configuration information for the specified UART module.
AnnaBridge 165:e614a9f1c9e2 1105 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 1106 */
AnnaBridge 165:e614a9f1c9e2 1107 HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 1108 {
AnnaBridge 165:e614a9f1c9e2 1109 uint32_t dmarequest = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1110 /* The Lock is not implemented on this API to allow the user application
AnnaBridge 165:e614a9f1c9e2 1111 to call the HAL UART API under callbacks HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback():
AnnaBridge 165:e614a9f1c9e2 1112 when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
AnnaBridge 165:e614a9f1c9e2 1113 and the correspond call back is executed HAL_UART_TxCpltCallback() / HAL_UART_RxCpltCallback()
AnnaBridge 165:e614a9f1c9e2 1114 */
AnnaBridge 165:e614a9f1c9e2 1115
AnnaBridge 165:e614a9f1c9e2 1116 /* Stop UART DMA Tx request if ongoing */
AnnaBridge 165:e614a9f1c9e2 1117 dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 1118 if((huart->gState == HAL_UART_STATE_BUSY_TX) && dmarequest)
AnnaBridge 165:e614a9f1c9e2 1119 {
AnnaBridge 165:e614a9f1c9e2 1120 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 1121
AnnaBridge 165:e614a9f1c9e2 1122 /* Abort the UART DMA Tx channel */
AnnaBridge 165:e614a9f1c9e2 1123 if(huart->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 1124 {
AnnaBridge 165:e614a9f1c9e2 1125 HAL_DMA_Abort(huart->hdmatx);
AnnaBridge 165:e614a9f1c9e2 1126 }
AnnaBridge 165:e614a9f1c9e2 1127 UART_EndTxTransfer(huart);
AnnaBridge 165:e614a9f1c9e2 1128 }
AnnaBridge 165:e614a9f1c9e2 1129
AnnaBridge 165:e614a9f1c9e2 1130 /* Stop UART DMA Rx request if ongoing */
AnnaBridge 165:e614a9f1c9e2 1131 dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1132 if((huart->RxState == HAL_UART_STATE_BUSY_RX) && dmarequest)
AnnaBridge 165:e614a9f1c9e2 1133 {
AnnaBridge 165:e614a9f1c9e2 1134 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1135
AnnaBridge 165:e614a9f1c9e2 1136 /* Abort the UART DMA Rx channel */
AnnaBridge 165:e614a9f1c9e2 1137 if(huart->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 1138 {
AnnaBridge 165:e614a9f1c9e2 1139 HAL_DMA_Abort(huart->hdmarx);
AnnaBridge 165:e614a9f1c9e2 1140 }
AnnaBridge 165:e614a9f1c9e2 1141 UART_EndRxTransfer(huart);
AnnaBridge 165:e614a9f1c9e2 1142 }
AnnaBridge 165:e614a9f1c9e2 1143
AnnaBridge 165:e614a9f1c9e2 1144 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 1145 }
AnnaBridge 165:e614a9f1c9e2 1146
AnnaBridge 165:e614a9f1c9e2 1147 /**
AnnaBridge 165:e614a9f1c9e2 1148 * @brief Abort ongoing transfers (blocking mode).
AnnaBridge 165:e614a9f1c9e2 1149 * @param huart UART handle.
AnnaBridge 165:e614a9f1c9e2 1150 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 1151 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 1152 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 1153 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 1154 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 1155 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 1156 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
AnnaBridge 165:e614a9f1c9e2 1157 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 1158 */
AnnaBridge 165:e614a9f1c9e2 1159 HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 1160 {
AnnaBridge 165:e614a9f1c9e2 1161 /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 1162 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 165:e614a9f1c9e2 1163 CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 1164
AnnaBridge 165:e614a9f1c9e2 1165 /* Disable the UART DMA Tx request if enabled */
AnnaBridge 165:e614a9f1c9e2 1166 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 165:e614a9f1c9e2 1167 {
AnnaBridge 165:e614a9f1c9e2 1168 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 1169
AnnaBridge 165:e614a9f1c9e2 1170 /* Abort the UART DMA Tx channel: use blocking DMA Abort API (no callback) */
AnnaBridge 165:e614a9f1c9e2 1171 if(huart->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 1172 {
AnnaBridge 165:e614a9f1c9e2 1173 /* Set the UART DMA Abort callback to Null.
AnnaBridge 165:e614a9f1c9e2 1174 No call back execution at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1175 huart->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1176
AnnaBridge 165:e614a9f1c9e2 1177 HAL_DMA_Abort(huart->hdmatx);
AnnaBridge 165:e614a9f1c9e2 1178 }
AnnaBridge 165:e614a9f1c9e2 1179 }
AnnaBridge 165:e614a9f1c9e2 1180
AnnaBridge 165:e614a9f1c9e2 1181 /* Disable the UART DMA Rx request if enabled */
AnnaBridge 165:e614a9f1c9e2 1182 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 1183 {
AnnaBridge 165:e614a9f1c9e2 1184 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1185
AnnaBridge 165:e614a9f1c9e2 1186 /* Abort the UART DMA Rx channel: use blocking DMA Abort API (no callback) */
AnnaBridge 165:e614a9f1c9e2 1187 if(huart->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 1188 {
AnnaBridge 165:e614a9f1c9e2 1189 /* Set the UART DMA Abort callback to Null.
AnnaBridge 165:e614a9f1c9e2 1190 No call back execution at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1191 huart->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1192
AnnaBridge 165:e614a9f1c9e2 1193 HAL_DMA_Abort(huart->hdmarx);
AnnaBridge 165:e614a9f1c9e2 1194 }
AnnaBridge 165:e614a9f1c9e2 1195 }
AnnaBridge 165:e614a9f1c9e2 1196
AnnaBridge 165:e614a9f1c9e2 1197 /* Reset Tx and Rx transfer counters */
AnnaBridge 165:e614a9f1c9e2 1198 huart->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1199 huart->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1200
AnnaBridge 165:e614a9f1c9e2 1201 /* Reset ErrorCode */
AnnaBridge 165:e614a9f1c9e2 1202 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 1203
AnnaBridge 165:e614a9f1c9e2 1204 /* Restore huart->RxState and huart->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 1205 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1206 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1207
AnnaBridge 165:e614a9f1c9e2 1208 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 1209 }
AnnaBridge 165:e614a9f1c9e2 1210
AnnaBridge 165:e614a9f1c9e2 1211 /**
AnnaBridge 165:e614a9f1c9e2 1212 * @brief Abort ongoing Transmit transfer (blocking mode).
AnnaBridge 165:e614a9f1c9e2 1213 * @param huart UART handle.
AnnaBridge 165:e614a9f1c9e2 1214 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 1215 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 1216 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 1217 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 1218 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 1219 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 1220 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
AnnaBridge 165:e614a9f1c9e2 1221 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 1222 */
AnnaBridge 165:e614a9f1c9e2 1223 HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 1224 {
AnnaBridge 165:e614a9f1c9e2 1225 /* Disable TXEIE and TCIE interrupts */
AnnaBridge 165:e614a9f1c9e2 1226 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 165:e614a9f1c9e2 1227
AnnaBridge 165:e614a9f1c9e2 1228 /* Disable the UART DMA Tx request if enabled */
AnnaBridge 165:e614a9f1c9e2 1229 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 165:e614a9f1c9e2 1230 {
AnnaBridge 165:e614a9f1c9e2 1231 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 1232
AnnaBridge 165:e614a9f1c9e2 1233 /* Abort the UART DMA Tx channel : use blocking DMA Abort API (no callback) */
AnnaBridge 165:e614a9f1c9e2 1234 if(huart->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 1235 {
AnnaBridge 165:e614a9f1c9e2 1236 /* Set the UART DMA Abort callback to Null.
AnnaBridge 165:e614a9f1c9e2 1237 No call back execution at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1238 huart->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1239
AnnaBridge 165:e614a9f1c9e2 1240 HAL_DMA_Abort(huart->hdmatx);
AnnaBridge 165:e614a9f1c9e2 1241 }
AnnaBridge 165:e614a9f1c9e2 1242 }
AnnaBridge 165:e614a9f1c9e2 1243
AnnaBridge 165:e614a9f1c9e2 1244 /* Reset Tx transfer counter */
AnnaBridge 165:e614a9f1c9e2 1245 huart->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1246
AnnaBridge 165:e614a9f1c9e2 1247 /* Restore huart->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 1248 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1249
AnnaBridge 165:e614a9f1c9e2 1250 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 1251 }
AnnaBridge 165:e614a9f1c9e2 1252
AnnaBridge 165:e614a9f1c9e2 1253 /**
AnnaBridge 165:e614a9f1c9e2 1254 * @brief Abort ongoing Receive transfer (blocking mode).
AnnaBridge 165:e614a9f1c9e2 1255 * @param huart UART handle.
AnnaBridge 165:e614a9f1c9e2 1256 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 1257 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 1258 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 1259 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 1260 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 1261 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 1262 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed.
AnnaBridge 165:e614a9f1c9e2 1263 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 1264 */
AnnaBridge 165:e614a9f1c9e2 1265 HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 1266 {
AnnaBridge 165:e614a9f1c9e2 1267 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 1268 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
AnnaBridge 165:e614a9f1c9e2 1269 CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 1270
AnnaBridge 165:e614a9f1c9e2 1271 /* Disable the UART DMA Rx request if enabled */
AnnaBridge 165:e614a9f1c9e2 1272 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 1273 {
AnnaBridge 165:e614a9f1c9e2 1274 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1275
AnnaBridge 165:e614a9f1c9e2 1276 /* Abort the UART DMA Rx channel : use blocking DMA Abort API (no callback) */
AnnaBridge 165:e614a9f1c9e2 1277 if(huart->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 1278 {
AnnaBridge 165:e614a9f1c9e2 1279 /* Set the UART DMA Abort callback to Null.
AnnaBridge 165:e614a9f1c9e2 1280 No call back execution at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1281 huart->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1282
AnnaBridge 165:e614a9f1c9e2 1283 HAL_DMA_Abort(huart->hdmarx);
AnnaBridge 165:e614a9f1c9e2 1284 }
AnnaBridge 165:e614a9f1c9e2 1285 }
AnnaBridge 165:e614a9f1c9e2 1286
AnnaBridge 165:e614a9f1c9e2 1287 /* Reset Rx transfer counter */
AnnaBridge 165:e614a9f1c9e2 1288 huart->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1289
AnnaBridge 165:e614a9f1c9e2 1290 /* Restore huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1291 huart->RxState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 1292
<> 144:ef7eb2e8f9f7 1293 return HAL_OK;
<> 144:ef7eb2e8f9f7 1294 }
<> 144:ef7eb2e8f9f7 1295
<> 144:ef7eb2e8f9f7 1296 /**
AnnaBridge 165:e614a9f1c9e2 1297 * @brief Abort ongoing transfers (Interrupt mode).
AnnaBridge 165:e614a9f1c9e2 1298 * @param huart UART handle.
AnnaBridge 165:e614a9f1c9e2 1299 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 1300 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 1301 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 1302 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 1303 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 1304 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 1305 * - At abort completion, call user abort complete callback
AnnaBridge 165:e614a9f1c9e2 1306 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
AnnaBridge 165:e614a9f1c9e2 1307 * considered as completed only when user abort complete callback is executed (not when exiting function).
<> 144:ef7eb2e8f9f7 1308 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 1309 */
AnnaBridge 165:e614a9f1c9e2 1310 HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1311 {
AnnaBridge 165:e614a9f1c9e2 1312 uint32_t AbortCplt = 0x01U;
AnnaBridge 165:e614a9f1c9e2 1313
AnnaBridge 165:e614a9f1c9e2 1314 /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 1315 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 165:e614a9f1c9e2 1316 CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 1317
AnnaBridge 165:e614a9f1c9e2 1318 /* If DMA Tx and/or DMA Rx Handles are associated to UART Handle, DMA Abort complete callbacks should be initialised
AnnaBridge 165:e614a9f1c9e2 1319 before any call to DMA Abort functions */
AnnaBridge 165:e614a9f1c9e2 1320 /* DMA Tx Handle is valid */
<> 144:ef7eb2e8f9f7 1321 if(huart->hdmatx != NULL)
<> 144:ef7eb2e8f9f7 1322 {
AnnaBridge 165:e614a9f1c9e2 1323 /* Set DMA Abort Complete callback if UART DMA Tx request if enabled.
AnnaBridge 165:e614a9f1c9e2 1324 Otherwise, set it to NULL */
AnnaBridge 165:e614a9f1c9e2 1325 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 165:e614a9f1c9e2 1326 {
AnnaBridge 165:e614a9f1c9e2 1327 huart->hdmatx->XferAbortCallback = UART_DMATxAbortCallback;
AnnaBridge 165:e614a9f1c9e2 1328 }
AnnaBridge 165:e614a9f1c9e2 1329 else
AnnaBridge 165:e614a9f1c9e2 1330 {
AnnaBridge 165:e614a9f1c9e2 1331 huart->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1332 }
<> 144:ef7eb2e8f9f7 1333 }
AnnaBridge 165:e614a9f1c9e2 1334 /* DMA Rx Handle is valid */
<> 144:ef7eb2e8f9f7 1335 if(huart->hdmarx != NULL)
<> 144:ef7eb2e8f9f7 1336 {
AnnaBridge 165:e614a9f1c9e2 1337 /* Set DMA Abort Complete callback if UART DMA Rx request if enabled.
AnnaBridge 165:e614a9f1c9e2 1338 Otherwise, set it to NULL */
AnnaBridge 165:e614a9f1c9e2 1339 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 1340 {
AnnaBridge 165:e614a9f1c9e2 1341 huart->hdmarx->XferAbortCallback = UART_DMARxAbortCallback;
AnnaBridge 165:e614a9f1c9e2 1342 }
AnnaBridge 165:e614a9f1c9e2 1343 else
AnnaBridge 165:e614a9f1c9e2 1344 {
AnnaBridge 165:e614a9f1c9e2 1345 huart->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1346 }
AnnaBridge 165:e614a9f1c9e2 1347 }
AnnaBridge 165:e614a9f1c9e2 1348
AnnaBridge 165:e614a9f1c9e2 1349 /* Disable the UART DMA Tx request if enabled */
AnnaBridge 165:e614a9f1c9e2 1350 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 165:e614a9f1c9e2 1351 {
AnnaBridge 165:e614a9f1c9e2 1352 /* Disable DMA Tx at UART level */
AnnaBridge 165:e614a9f1c9e2 1353 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 1354
AnnaBridge 165:e614a9f1c9e2 1355 /* Abort the UART DMA Tx channel : use non blocking DMA Abort API (callback) */
AnnaBridge 165:e614a9f1c9e2 1356 if(huart->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 1357 {
AnnaBridge 165:e614a9f1c9e2 1358 /* UART Tx DMA Abort callback has already been initialised :
AnnaBridge 165:e614a9f1c9e2 1359 will lead to call HAL_UART_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1360
AnnaBridge 165:e614a9f1c9e2 1361 /* Abort DMA TX */
AnnaBridge 165:e614a9f1c9e2 1362 if(HAL_DMA_Abort_IT(huart->hdmatx) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 1363 {
AnnaBridge 165:e614a9f1c9e2 1364 huart->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1365 }
AnnaBridge 165:e614a9f1c9e2 1366 else
AnnaBridge 165:e614a9f1c9e2 1367 {
AnnaBridge 165:e614a9f1c9e2 1368 AbortCplt = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1369 }
AnnaBridge 165:e614a9f1c9e2 1370 }
AnnaBridge 165:e614a9f1c9e2 1371 }
AnnaBridge 165:e614a9f1c9e2 1372
AnnaBridge 165:e614a9f1c9e2 1373 /* Disable the UART DMA Rx request if enabled */
AnnaBridge 165:e614a9f1c9e2 1374 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 1375 {
AnnaBridge 165:e614a9f1c9e2 1376 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1377
AnnaBridge 165:e614a9f1c9e2 1378 /* Abort the UART DMA Rx channel : use non blocking DMA Abort API (callback) */
AnnaBridge 165:e614a9f1c9e2 1379 if(huart->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 1380 {
AnnaBridge 165:e614a9f1c9e2 1381 /* UART Rx DMA Abort callback has already been initialised :
AnnaBridge 165:e614a9f1c9e2 1382 will lead to call HAL_UART_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1383
AnnaBridge 165:e614a9f1c9e2 1384 /* Abort DMA RX */
AnnaBridge 165:e614a9f1c9e2 1385 if(HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 1386 {
AnnaBridge 165:e614a9f1c9e2 1387 huart->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 1388 AbortCplt = 0x01U;
AnnaBridge 165:e614a9f1c9e2 1389 }
AnnaBridge 165:e614a9f1c9e2 1390 else
AnnaBridge 165:e614a9f1c9e2 1391 {
AnnaBridge 165:e614a9f1c9e2 1392 AbortCplt = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1393 }
AnnaBridge 165:e614a9f1c9e2 1394 }
AnnaBridge 165:e614a9f1c9e2 1395 }
AnnaBridge 165:e614a9f1c9e2 1396
AnnaBridge 165:e614a9f1c9e2 1397 /* if no DMA abort complete callback execution is required => call user Abort Complete callback */
AnnaBridge 165:e614a9f1c9e2 1398 if(AbortCplt == 0x01U)
AnnaBridge 165:e614a9f1c9e2 1399 {
AnnaBridge 165:e614a9f1c9e2 1400 /* Reset Tx and Rx transfer counters */
AnnaBridge 165:e614a9f1c9e2 1401 huart->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1402 huart->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1403
AnnaBridge 165:e614a9f1c9e2 1404 /* Reset ErrorCode */
AnnaBridge 165:e614a9f1c9e2 1405 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 1406
AnnaBridge 165:e614a9f1c9e2 1407 /* Restore huart->gState and huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1408 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1409 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1410
AnnaBridge 165:e614a9f1c9e2 1411 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1412 HAL_UART_AbortCpltCallback(huart);
<> 144:ef7eb2e8f9f7 1413 }
AnnaBridge 165:e614a9f1c9e2 1414
AnnaBridge 165:e614a9f1c9e2 1415 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 1416 }
AnnaBridge 165:e614a9f1c9e2 1417
AnnaBridge 165:e614a9f1c9e2 1418 /**
AnnaBridge 165:e614a9f1c9e2 1419 * @brief Abort ongoing Transmit transfer (Interrupt mode).
AnnaBridge 165:e614a9f1c9e2 1420 * @param huart UART handle.
AnnaBridge 165:e614a9f1c9e2 1421 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 1422 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 1423 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 1424 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 1425 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 1426 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 1427 * - At abort completion, call user abort complete callback
AnnaBridge 165:e614a9f1c9e2 1428 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
AnnaBridge 165:e614a9f1c9e2 1429 * considered as completed only when user abort complete callback is executed (not when exiting function).
AnnaBridge 165:e614a9f1c9e2 1430 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 1431 */
AnnaBridge 165:e614a9f1c9e2 1432 HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 1433 {
AnnaBridge 165:e614a9f1c9e2 1434 /* Disable TXEIE and TCIE interrupts */
AnnaBridge 165:e614a9f1c9e2 1435 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 165:e614a9f1c9e2 1436
AnnaBridge 165:e614a9f1c9e2 1437 /* Disable the UART DMA Tx request if enabled */
AnnaBridge 165:e614a9f1c9e2 1438 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT))
AnnaBridge 165:e614a9f1c9e2 1439 {
AnnaBridge 165:e614a9f1c9e2 1440 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 1441
AnnaBridge 165:e614a9f1c9e2 1442 /* Abort the UART DMA Tx channel : use blocking DMA Abort API (no callback) */
AnnaBridge 165:e614a9f1c9e2 1443 if(huart->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 1444 {
AnnaBridge 165:e614a9f1c9e2 1445 /* Set the UART DMA Abort callback :
AnnaBridge 165:e614a9f1c9e2 1446 will lead to call HAL_UART_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1447 huart->hdmatx->XferAbortCallback = UART_DMATxOnlyAbortCallback;
AnnaBridge 165:e614a9f1c9e2 1448
AnnaBridge 165:e614a9f1c9e2 1449 /* Abort DMA TX */
AnnaBridge 165:e614a9f1c9e2 1450 if(HAL_DMA_Abort_IT(huart->hdmatx) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 1451 {
AnnaBridge 165:e614a9f1c9e2 1452 /* Call Directly huart->hdmatx->XferAbortCallback function in case of error */
AnnaBridge 165:e614a9f1c9e2 1453 huart->hdmatx->XferAbortCallback(huart->hdmatx);
AnnaBridge 165:e614a9f1c9e2 1454 }
AnnaBridge 165:e614a9f1c9e2 1455 }
AnnaBridge 165:e614a9f1c9e2 1456 else
AnnaBridge 165:e614a9f1c9e2 1457 {
AnnaBridge 165:e614a9f1c9e2 1458 /* Reset Tx transfer counter */
AnnaBridge 165:e614a9f1c9e2 1459 huart->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1460
AnnaBridge 165:e614a9f1c9e2 1461 /* Restore huart->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 1462 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1463
AnnaBridge 165:e614a9f1c9e2 1464 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1465 HAL_UART_AbortTransmitCpltCallback(huart);
AnnaBridge 165:e614a9f1c9e2 1466 }
AnnaBridge 165:e614a9f1c9e2 1467 }
AnnaBridge 165:e614a9f1c9e2 1468 else
AnnaBridge 165:e614a9f1c9e2 1469 {
AnnaBridge 165:e614a9f1c9e2 1470 /* Reset Tx transfer counter */
AnnaBridge 165:e614a9f1c9e2 1471 huart->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1472
AnnaBridge 165:e614a9f1c9e2 1473 /* Restore huart->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 1474 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1475
AnnaBridge 165:e614a9f1c9e2 1476 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1477 HAL_UART_AbortTransmitCpltCallback(huart);
AnnaBridge 165:e614a9f1c9e2 1478 }
AnnaBridge 165:e614a9f1c9e2 1479
AnnaBridge 165:e614a9f1c9e2 1480 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 1481 }
AnnaBridge 165:e614a9f1c9e2 1482
AnnaBridge 165:e614a9f1c9e2 1483 /**
AnnaBridge 165:e614a9f1c9e2 1484 * @brief Abort ongoing Receive transfer (Interrupt mode).
AnnaBridge 165:e614a9f1c9e2 1485 * @param huart UART handle.
AnnaBridge 165:e614a9f1c9e2 1486 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode.
AnnaBridge 165:e614a9f1c9e2 1487 * This procedure performs following operations :
AnnaBridge 165:e614a9f1c9e2 1488 * - Disable PPP Interrupts
AnnaBridge 165:e614a9f1c9e2 1489 * - Disable the DMA transfer in the peripheral register (if enabled)
AnnaBridge 165:e614a9f1c9e2 1490 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode)
AnnaBridge 165:e614a9f1c9e2 1491 * - Set handle State to READY
AnnaBridge 165:e614a9f1c9e2 1492 * - At abort completion, call user abort complete callback
AnnaBridge 165:e614a9f1c9e2 1493 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be
AnnaBridge 165:e614a9f1c9e2 1494 * considered as completed only when user abort complete callback is executed (not when exiting function).
AnnaBridge 165:e614a9f1c9e2 1495 * @retval HAL status
AnnaBridge 165:e614a9f1c9e2 1496 */
AnnaBridge 165:e614a9f1c9e2 1497 HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 1498 {
AnnaBridge 165:e614a9f1c9e2 1499 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 1500 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
AnnaBridge 165:e614a9f1c9e2 1501 CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 1502
AnnaBridge 165:e614a9f1c9e2 1503 /* Disable the UART DMA Rx request if enabled */
AnnaBridge 165:e614a9f1c9e2 1504 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 1505 {
AnnaBridge 165:e614a9f1c9e2 1506 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1507
AnnaBridge 165:e614a9f1c9e2 1508 /* Abort the UART DMA Rx channel : use blocking DMA Abort API (no callback) */
AnnaBridge 165:e614a9f1c9e2 1509 if(huart->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 1510 {
AnnaBridge 165:e614a9f1c9e2 1511 /* Set the UART DMA Abort callback :
AnnaBridge 165:e614a9f1c9e2 1512 will lead to call HAL_UART_AbortCpltCallback() at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1513 huart->hdmarx->XferAbortCallback = UART_DMARxOnlyAbortCallback;
AnnaBridge 165:e614a9f1c9e2 1514
AnnaBridge 165:e614a9f1c9e2 1515 /* Abort DMA RX */
AnnaBridge 165:e614a9f1c9e2 1516 if(HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 1517 {
AnnaBridge 165:e614a9f1c9e2 1518 /* Call Directly huart->hdmarx->XferAbortCallback function in case of error */
AnnaBridge 165:e614a9f1c9e2 1519 huart->hdmarx->XferAbortCallback(huart->hdmarx);
AnnaBridge 165:e614a9f1c9e2 1520 }
AnnaBridge 165:e614a9f1c9e2 1521 }
AnnaBridge 165:e614a9f1c9e2 1522 else
AnnaBridge 165:e614a9f1c9e2 1523 {
AnnaBridge 165:e614a9f1c9e2 1524 /* Reset Rx transfer counter */
AnnaBridge 165:e614a9f1c9e2 1525 huart->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1526
AnnaBridge 165:e614a9f1c9e2 1527 /* Restore huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1528 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1529
AnnaBridge 165:e614a9f1c9e2 1530 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1531 HAL_UART_AbortReceiveCpltCallback(huart);
AnnaBridge 165:e614a9f1c9e2 1532 }
AnnaBridge 165:e614a9f1c9e2 1533 }
AnnaBridge 165:e614a9f1c9e2 1534 else
AnnaBridge 165:e614a9f1c9e2 1535 {
AnnaBridge 165:e614a9f1c9e2 1536 /* Reset Rx transfer counter */
AnnaBridge 165:e614a9f1c9e2 1537 huart->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1538
AnnaBridge 165:e614a9f1c9e2 1539 /* Restore huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 1540 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1541
AnnaBridge 165:e614a9f1c9e2 1542 /* As no DMA to be aborted, call directly user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 1543 HAL_UART_AbortReceiveCpltCallback(huart);
AnnaBridge 165:e614a9f1c9e2 1544 }
AnnaBridge 165:e614a9f1c9e2 1545
<> 144:ef7eb2e8f9f7 1546 return HAL_OK;
<> 144:ef7eb2e8f9f7 1547 }
<> 144:ef7eb2e8f9f7 1548
<> 144:ef7eb2e8f9f7 1549 /**
<> 144:ef7eb2e8f9f7 1550 * @brief This function handles UART interrupt request.
AnnaBridge 165:e614a9f1c9e2 1551 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1552 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1553 * @retval None
<> 144:ef7eb2e8f9f7 1554 */
<> 144:ef7eb2e8f9f7 1555 void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1556 {
AnnaBridge 165:e614a9f1c9e2 1557 uint32_t isrflags = READ_REG(huart->Instance->SR);
AnnaBridge 165:e614a9f1c9e2 1558 uint32_t cr1its = READ_REG(huart->Instance->CR1);
AnnaBridge 165:e614a9f1c9e2 1559 uint32_t cr3its = READ_REG(huart->Instance->CR3);
AnnaBridge 165:e614a9f1c9e2 1560 uint32_t errorflags = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1561 uint32_t dmarequest = 0x00U;
<> 144:ef7eb2e8f9f7 1562
AnnaBridge 165:e614a9f1c9e2 1563 /* If no error occurs */
AnnaBridge 165:e614a9f1c9e2 1564 errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
AnnaBridge 165:e614a9f1c9e2 1565 if(errorflags == RESET)
AnnaBridge 165:e614a9f1c9e2 1566 {
AnnaBridge 165:e614a9f1c9e2 1567 /* UART in mode Receiver -------------------------------------------------*/
AnnaBridge 165:e614a9f1c9e2 1568 if(((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1569 {
AnnaBridge 165:e614a9f1c9e2 1570 UART_Receive_IT(huart);
AnnaBridge 165:e614a9f1c9e2 1571 return;
AnnaBridge 165:e614a9f1c9e2 1572 }
<> 144:ef7eb2e8f9f7 1573 }
AnnaBridge 165:e614a9f1c9e2 1574
AnnaBridge 165:e614a9f1c9e2 1575 /* If some errors occur */
AnnaBridge 165:e614a9f1c9e2 1576 if((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
AnnaBridge 165:e614a9f1c9e2 1577 {
AnnaBridge 165:e614a9f1c9e2 1578 /* UART parity error interrupt occurred ----------------------------------*/
AnnaBridge 165:e614a9f1c9e2 1579 if(((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1580 {
AnnaBridge 165:e614a9f1c9e2 1581 huart->ErrorCode |= HAL_UART_ERROR_PE;
AnnaBridge 165:e614a9f1c9e2 1582 }
AnnaBridge 165:e614a9f1c9e2 1583
AnnaBridge 165:e614a9f1c9e2 1584 /* UART noise error interrupt occurred -----------------------------------*/
AnnaBridge 165:e614a9f1c9e2 1585 if(((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1586 {
AnnaBridge 165:e614a9f1c9e2 1587 huart->ErrorCode |= HAL_UART_ERROR_NE;
AnnaBridge 165:e614a9f1c9e2 1588 }
AnnaBridge 165:e614a9f1c9e2 1589
AnnaBridge 165:e614a9f1c9e2 1590 /* UART frame error interrupt occurred -----------------------------------*/
AnnaBridge 165:e614a9f1c9e2 1591 if(((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1592 {
AnnaBridge 165:e614a9f1c9e2 1593 huart->ErrorCode |= HAL_UART_ERROR_FE;
AnnaBridge 165:e614a9f1c9e2 1594 }
AnnaBridge 165:e614a9f1c9e2 1595
AnnaBridge 165:e614a9f1c9e2 1596 /* UART Over-Run interrupt occurred --------------------------------------*/
AnnaBridge 165:e614a9f1c9e2 1597 if(((isrflags & USART_SR_ORE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1598 {
AnnaBridge 165:e614a9f1c9e2 1599 huart->ErrorCode |= HAL_UART_ERROR_ORE;
AnnaBridge 165:e614a9f1c9e2 1600 }
AnnaBridge 165:e614a9f1c9e2 1601
AnnaBridge 165:e614a9f1c9e2 1602 /* Call UART Error Call back function if need be --------------------------*/
AnnaBridge 165:e614a9f1c9e2 1603 if(huart->ErrorCode != HAL_UART_ERROR_NONE)
AnnaBridge 165:e614a9f1c9e2 1604 {
AnnaBridge 165:e614a9f1c9e2 1605 /* UART in mode Receiver -----------------------------------------------*/
AnnaBridge 165:e614a9f1c9e2 1606 if(((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1607 {
AnnaBridge 165:e614a9f1c9e2 1608 UART_Receive_IT(huart);
AnnaBridge 165:e614a9f1c9e2 1609 }
AnnaBridge 165:e614a9f1c9e2 1610
AnnaBridge 165:e614a9f1c9e2 1611 /* If Overrun error occurs, or if any error occurs in DMA mode reception,
AnnaBridge 165:e614a9f1c9e2 1612 consider error as blocking */
AnnaBridge 165:e614a9f1c9e2 1613 dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1614 if(((huart->ErrorCode & HAL_UART_ERROR_ORE) != RESET) || dmarequest)
AnnaBridge 165:e614a9f1c9e2 1615 {
AnnaBridge 165:e614a9f1c9e2 1616 /* Blocking error : transfer is aborted
AnnaBridge 165:e614a9f1c9e2 1617 Set the UART state ready to be able to start again the process,
AnnaBridge 165:e614a9f1c9e2 1618 Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
AnnaBridge 165:e614a9f1c9e2 1619 UART_EndRxTransfer(huart);
AnnaBridge 165:e614a9f1c9e2 1620
AnnaBridge 165:e614a9f1c9e2 1621 /* Disable the UART DMA Rx request if enabled */
AnnaBridge 165:e614a9f1c9e2 1622 if(HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
AnnaBridge 165:e614a9f1c9e2 1623 {
AnnaBridge 165:e614a9f1c9e2 1624 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 1625
AnnaBridge 165:e614a9f1c9e2 1626 /* Abort the UART DMA Rx channel */
AnnaBridge 165:e614a9f1c9e2 1627 if(huart->hdmarx != NULL)
AnnaBridge 165:e614a9f1c9e2 1628 {
AnnaBridge 165:e614a9f1c9e2 1629 /* Set the UART DMA Abort callback :
AnnaBridge 165:e614a9f1c9e2 1630 will lead to call HAL_UART_ErrorCallback() at end of DMA abort procedure */
AnnaBridge 165:e614a9f1c9e2 1631 huart->hdmarx->XferAbortCallback = UART_DMAAbortOnError;
AnnaBridge 165:e614a9f1c9e2 1632 if(HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)
AnnaBridge 165:e614a9f1c9e2 1633 {
AnnaBridge 165:e614a9f1c9e2 1634 /* Call Directly XferAbortCallback function in case of error */
AnnaBridge 165:e614a9f1c9e2 1635 huart->hdmarx->XferAbortCallback(huart->hdmarx);
AnnaBridge 165:e614a9f1c9e2 1636 }
AnnaBridge 165:e614a9f1c9e2 1637 }
AnnaBridge 165:e614a9f1c9e2 1638 else
AnnaBridge 165:e614a9f1c9e2 1639 {
AnnaBridge 165:e614a9f1c9e2 1640 /* Call user error callback */
AnnaBridge 165:e614a9f1c9e2 1641 HAL_UART_ErrorCallback(huart);
AnnaBridge 165:e614a9f1c9e2 1642 }
AnnaBridge 165:e614a9f1c9e2 1643 }
AnnaBridge 165:e614a9f1c9e2 1644 else
AnnaBridge 165:e614a9f1c9e2 1645 {
AnnaBridge 165:e614a9f1c9e2 1646 /* Call user error callback */
AnnaBridge 165:e614a9f1c9e2 1647 HAL_UART_ErrorCallback(huart);
AnnaBridge 165:e614a9f1c9e2 1648 }
AnnaBridge 165:e614a9f1c9e2 1649 }
AnnaBridge 165:e614a9f1c9e2 1650 else
AnnaBridge 165:e614a9f1c9e2 1651 {
AnnaBridge 165:e614a9f1c9e2 1652 /* Non Blocking error : transfer could go on.
AnnaBridge 165:e614a9f1c9e2 1653 Error is notified to user through user error callback */
AnnaBridge 165:e614a9f1c9e2 1654 HAL_UART_ErrorCallback(huart);
AnnaBridge 165:e614a9f1c9e2 1655 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 1656 }
AnnaBridge 165:e614a9f1c9e2 1657 }
AnnaBridge 165:e614a9f1c9e2 1658 return;
AnnaBridge 165:e614a9f1c9e2 1659 } /* End if some error occurs */
AnnaBridge 165:e614a9f1c9e2 1660
AnnaBridge 165:e614a9f1c9e2 1661 /* UART in mode Transmitter ------------------------------------------------*/
AnnaBridge 165:e614a9f1c9e2 1662 if(((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
AnnaBridge 165:e614a9f1c9e2 1663 {
AnnaBridge 165:e614a9f1c9e2 1664 UART_Transmit_IT(huart);
AnnaBridge 165:e614a9f1c9e2 1665 return;
<> 144:ef7eb2e8f9f7 1666 }
<> 144:ef7eb2e8f9f7 1667
<> 144:ef7eb2e8f9f7 1668 /* UART in mode Transmitter end --------------------------------------------*/
AnnaBridge 165:e614a9f1c9e2 1669 if(((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
<> 144:ef7eb2e8f9f7 1670 {
<> 144:ef7eb2e8f9f7 1671 UART_EndTransmit_IT(huart);
AnnaBridge 165:e614a9f1c9e2 1672 return;
AnnaBridge 165:e614a9f1c9e2 1673 }
<> 144:ef7eb2e8f9f7 1674 }
<> 144:ef7eb2e8f9f7 1675
<> 144:ef7eb2e8f9f7 1676 /**
<> 144:ef7eb2e8f9f7 1677 * @brief Tx Transfer completed callbacks.
AnnaBridge 165:e614a9f1c9e2 1678 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1679 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1680 * @retval None
<> 144:ef7eb2e8f9f7 1681 */
<> 144:ef7eb2e8f9f7 1682 __weak void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1683 {
<> 144:ef7eb2e8f9f7 1684 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1685 UNUSED(huart);
AnnaBridge 165:e614a9f1c9e2 1686 /* NOTE: This function Should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1687 the HAL_UART_TxCpltCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1688 */
<> 144:ef7eb2e8f9f7 1689 }
<> 144:ef7eb2e8f9f7 1690
<> 144:ef7eb2e8f9f7 1691 /**
<> 144:ef7eb2e8f9f7 1692 * @brief Tx Half Transfer completed callbacks.
AnnaBridge 165:e614a9f1c9e2 1693 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1694 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1695 * @retval None
<> 144:ef7eb2e8f9f7 1696 */
<> 144:ef7eb2e8f9f7 1697 __weak void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1698 {
<> 144:ef7eb2e8f9f7 1699 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1700 UNUSED(huart);
AnnaBridge 165:e614a9f1c9e2 1701 /* NOTE: This function Should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1702 the HAL_UART_TxHalfCpltCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1703 */
<> 144:ef7eb2e8f9f7 1704 }
<> 144:ef7eb2e8f9f7 1705
<> 144:ef7eb2e8f9f7 1706 /**
<> 144:ef7eb2e8f9f7 1707 * @brief Rx Transfer completed callbacks.
AnnaBridge 165:e614a9f1c9e2 1708 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1709 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1710 * @retval None
<> 144:ef7eb2e8f9f7 1711 */
<> 144:ef7eb2e8f9f7 1712 __weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1713 {
<> 144:ef7eb2e8f9f7 1714 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1715 UNUSED(huart);
AnnaBridge 165:e614a9f1c9e2 1716 /* NOTE: This function Should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1717 the HAL_UART_RxCpltCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1718 */
<> 144:ef7eb2e8f9f7 1719 }
<> 144:ef7eb2e8f9f7 1720
<> 144:ef7eb2e8f9f7 1721 /**
<> 144:ef7eb2e8f9f7 1722 * @brief Rx Half Transfer completed callbacks.
AnnaBridge 165:e614a9f1c9e2 1723 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1724 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1725 * @retval None
<> 144:ef7eb2e8f9f7 1726 */
<> 144:ef7eb2e8f9f7 1727 __weak void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1728 {
<> 144:ef7eb2e8f9f7 1729 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1730 UNUSED(huart);
AnnaBridge 165:e614a9f1c9e2 1731 /* NOTE: This function Should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1732 the HAL_UART_RxHalfCpltCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 1733 */
<> 144:ef7eb2e8f9f7 1734 }
<> 144:ef7eb2e8f9f7 1735
<> 144:ef7eb2e8f9f7 1736 /**
<> 144:ef7eb2e8f9f7 1737 * @brief UART error callbacks.
AnnaBridge 165:e614a9f1c9e2 1738 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1739 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1740 * @retval None
<> 144:ef7eb2e8f9f7 1741 */
<> 144:ef7eb2e8f9f7 1742 __weak void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1743 {
<> 144:ef7eb2e8f9f7 1744 /* Prevent unused argument(s) compilation warning */
AnnaBridge 165:e614a9f1c9e2 1745 UNUSED(huart);
AnnaBridge 165:e614a9f1c9e2 1746 /* NOTE: This function Should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1747 the HAL_UART_ErrorCallback could be implemented in the user file
AnnaBridge 165:e614a9f1c9e2 1748 */
AnnaBridge 165:e614a9f1c9e2 1749 }
AnnaBridge 165:e614a9f1c9e2 1750
AnnaBridge 165:e614a9f1c9e2 1751 /**
AnnaBridge 165:e614a9f1c9e2 1752 * @brief UART Abort Complete callback.
AnnaBridge 165:e614a9f1c9e2 1753 * @param huart UART handle.
AnnaBridge 165:e614a9f1c9e2 1754 * @retval None
AnnaBridge 165:e614a9f1c9e2 1755 */
AnnaBridge 165:e614a9f1c9e2 1756 __weak void HAL_UART_AbortCpltCallback (UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 1757 {
AnnaBridge 165:e614a9f1c9e2 1758 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 1759 UNUSED(huart);
AnnaBridge 165:e614a9f1c9e2 1760
AnnaBridge 165:e614a9f1c9e2 1761 /* NOTE : This function should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1762 the HAL_UART_AbortCpltCallback can be implemented in the user file.
AnnaBridge 165:e614a9f1c9e2 1763 */
AnnaBridge 165:e614a9f1c9e2 1764 }
AnnaBridge 165:e614a9f1c9e2 1765 /**
AnnaBridge 165:e614a9f1c9e2 1766 * @brief UART Abort Complete callback.
AnnaBridge 165:e614a9f1c9e2 1767 * @param huart UART handle.
AnnaBridge 165:e614a9f1c9e2 1768 * @retval None
AnnaBridge 165:e614a9f1c9e2 1769 */
AnnaBridge 165:e614a9f1c9e2 1770 __weak void HAL_UART_AbortTransmitCpltCallback (UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 1771 {
AnnaBridge 165:e614a9f1c9e2 1772 /* Prevent unused argument(s) compilation warning */
AnnaBridge 165:e614a9f1c9e2 1773 UNUSED(huart);
AnnaBridge 165:e614a9f1c9e2 1774
AnnaBridge 165:e614a9f1c9e2 1775 /* NOTE : This function should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1776 the HAL_UART_AbortTransmitCpltCallback can be implemented in the user file.
AnnaBridge 165:e614a9f1c9e2 1777 */
AnnaBridge 165:e614a9f1c9e2 1778 }
AnnaBridge 165:e614a9f1c9e2 1779
AnnaBridge 165:e614a9f1c9e2 1780 /**
AnnaBridge 165:e614a9f1c9e2 1781 * @brief UART Abort Receive Complete callback.
AnnaBridge 165:e614a9f1c9e2 1782 * @param huart UART handle.
AnnaBridge 165:e614a9f1c9e2 1783 * @retval None
AnnaBridge 165:e614a9f1c9e2 1784 */
AnnaBridge 165:e614a9f1c9e2 1785 __weak void HAL_UART_AbortReceiveCpltCallback (UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 1786 {
AnnaBridge 165:e614a9f1c9e2 1787 /* Prevent unused argument(s) compilation warning */
AnnaBridge 165:e614a9f1c9e2 1788 UNUSED(huart);
AnnaBridge 165:e614a9f1c9e2 1789
AnnaBridge 165:e614a9f1c9e2 1790 /* NOTE : This function should not be modified, when the callback is needed,
AnnaBridge 165:e614a9f1c9e2 1791 the HAL_UART_AbortReceiveCpltCallback can be implemented in the user file.
AnnaBridge 165:e614a9f1c9e2 1792 */
<> 144:ef7eb2e8f9f7 1793 }
<> 144:ef7eb2e8f9f7 1794
<> 144:ef7eb2e8f9f7 1795 /**
<> 144:ef7eb2e8f9f7 1796 * @}
<> 144:ef7eb2e8f9f7 1797 */
<> 144:ef7eb2e8f9f7 1798
<> 144:ef7eb2e8f9f7 1799 /** @defgroup UART_Exported_Functions_Group3 Peripheral Control functions
<> 144:ef7eb2e8f9f7 1800 * @brief UART control functions
<> 144:ef7eb2e8f9f7 1801 *
<> 144:ef7eb2e8f9f7 1802 @verbatim
<> 144:ef7eb2e8f9f7 1803 ==============================================================================
<> 144:ef7eb2e8f9f7 1804 ##### Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 1805 ==============================================================================
<> 144:ef7eb2e8f9f7 1806 [..]
<> 144:ef7eb2e8f9f7 1807 This subsection provides a set of functions allowing to control the UART:
<> 144:ef7eb2e8f9f7 1808 (+) HAL_LIN_SendBreak() API can be helpful to transmit the break character.
<> 144:ef7eb2e8f9f7 1809 (+) HAL_MultiProcessor_EnterMuteMode() API can be helpful to enter the UART in mute mode.
<> 144:ef7eb2e8f9f7 1810 (+) HAL_MultiProcessor_ExitMuteMode() API can be helpful to exit the UART mute mode by software.
<> 144:ef7eb2e8f9f7 1811 (+) HAL_HalfDuplex_EnableTransmitter() API to enable the UART transmitter and disables the UART receiver in Half Duplex mode
<> 144:ef7eb2e8f9f7 1812 (+) HAL_HalfDuplex_EnableReceiver() API to enable the UART receiver and disables the UART transmitter in Half Duplex mode
<> 144:ef7eb2e8f9f7 1813
<> 144:ef7eb2e8f9f7 1814 @endverbatim
<> 144:ef7eb2e8f9f7 1815 * @{
<> 144:ef7eb2e8f9f7 1816 */
<> 144:ef7eb2e8f9f7 1817
<> 144:ef7eb2e8f9f7 1818 /**
<> 144:ef7eb2e8f9f7 1819 * @brief Transmits break characters.
AnnaBridge 165:e614a9f1c9e2 1820 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1821 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1822 * @retval HAL status
<> 144:ef7eb2e8f9f7 1823 */
<> 144:ef7eb2e8f9f7 1824 HAL_StatusTypeDef HAL_LIN_SendBreak(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1825 {
<> 144:ef7eb2e8f9f7 1826 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1827 assert_param(IS_UART_INSTANCE(huart->Instance));
<> 144:ef7eb2e8f9f7 1828
<> 144:ef7eb2e8f9f7 1829 /* Process Locked */
<> 144:ef7eb2e8f9f7 1830 __HAL_LOCK(huart);
<> 144:ef7eb2e8f9f7 1831
AnnaBridge 165:e614a9f1c9e2 1832 huart->gState = HAL_UART_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1833
<> 144:ef7eb2e8f9f7 1834 /* Send break characters */
<> 144:ef7eb2e8f9f7 1835 SET_BIT(huart->Instance->CR1, USART_CR1_SBK);
<> 144:ef7eb2e8f9f7 1836
AnnaBridge 165:e614a9f1c9e2 1837 huart->gState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 1838
<> 144:ef7eb2e8f9f7 1839 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1840 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 1841
<> 144:ef7eb2e8f9f7 1842 return HAL_OK;
<> 144:ef7eb2e8f9f7 1843 }
<> 144:ef7eb2e8f9f7 1844
<> 144:ef7eb2e8f9f7 1845 /**
<> 144:ef7eb2e8f9f7 1846 * @brief Enters the UART in mute mode.
AnnaBridge 165:e614a9f1c9e2 1847 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1848 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1849 * @retval HAL status
<> 144:ef7eb2e8f9f7 1850 */
<> 144:ef7eb2e8f9f7 1851 HAL_StatusTypeDef HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1852 {
<> 144:ef7eb2e8f9f7 1853 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1854 assert_param(IS_UART_INSTANCE(huart->Instance));
<> 144:ef7eb2e8f9f7 1855
<> 144:ef7eb2e8f9f7 1856 /* Process Locked */
<> 144:ef7eb2e8f9f7 1857 __HAL_LOCK(huart);
<> 144:ef7eb2e8f9f7 1858
AnnaBridge 165:e614a9f1c9e2 1859 huart->gState = HAL_UART_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1860
<> 144:ef7eb2e8f9f7 1861 /* Enable the USART mute mode by setting the RWU bit in the CR1 register */
<> 144:ef7eb2e8f9f7 1862 SET_BIT(huart->Instance->CR1, USART_CR1_RWU);
<> 144:ef7eb2e8f9f7 1863
AnnaBridge 165:e614a9f1c9e2 1864 huart->gState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 1865
<> 144:ef7eb2e8f9f7 1866 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1867 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 1868
<> 144:ef7eb2e8f9f7 1869 return HAL_OK;
<> 144:ef7eb2e8f9f7 1870 }
<> 144:ef7eb2e8f9f7 1871
<> 144:ef7eb2e8f9f7 1872 /**
<> 144:ef7eb2e8f9f7 1873 * @brief Exits the UART mute mode: wake up software.
AnnaBridge 165:e614a9f1c9e2 1874 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1875 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1876 * @retval HAL status
<> 144:ef7eb2e8f9f7 1877 */
<> 144:ef7eb2e8f9f7 1878 HAL_StatusTypeDef HAL_MultiProcessor_ExitMuteMode(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1879 {
<> 144:ef7eb2e8f9f7 1880 /* Check the parameters */
<> 144:ef7eb2e8f9f7 1881 assert_param(IS_UART_INSTANCE(huart->Instance));
<> 144:ef7eb2e8f9f7 1882
<> 144:ef7eb2e8f9f7 1883 /* Process Locked */
<> 144:ef7eb2e8f9f7 1884 __HAL_LOCK(huart);
<> 144:ef7eb2e8f9f7 1885
AnnaBridge 165:e614a9f1c9e2 1886 huart->gState = HAL_UART_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1887
<> 144:ef7eb2e8f9f7 1888 /* Disable the USART mute mode by clearing the RWU bit in the CR1 register */
<> 144:ef7eb2e8f9f7 1889 CLEAR_BIT(huart->Instance->CR1, USART_CR1_RWU);
<> 144:ef7eb2e8f9f7 1890
AnnaBridge 165:e614a9f1c9e2 1891 huart->gState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 1892
<> 144:ef7eb2e8f9f7 1893 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1894 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 1895
<> 144:ef7eb2e8f9f7 1896 return HAL_OK;
<> 144:ef7eb2e8f9f7 1897 }
<> 144:ef7eb2e8f9f7 1898
<> 144:ef7eb2e8f9f7 1899 /**
<> 144:ef7eb2e8f9f7 1900 * @brief Enables the UART transmitter and disables the UART receiver.
AnnaBridge 165:e614a9f1c9e2 1901 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1902 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1903 * @retval HAL status
<> 144:ef7eb2e8f9f7 1904 */
<> 144:ef7eb2e8f9f7 1905 HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1906 {
AnnaBridge 165:e614a9f1c9e2 1907 uint32_t tmpreg = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1908
<> 144:ef7eb2e8f9f7 1909 /* Process Locked */
<> 144:ef7eb2e8f9f7 1910 __HAL_LOCK(huart);
<> 144:ef7eb2e8f9f7 1911
AnnaBridge 165:e614a9f1c9e2 1912 huart->gState = HAL_UART_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1913
<> 144:ef7eb2e8f9f7 1914 /*-------------------------- USART CR1 Configuration -----------------------*/
AnnaBridge 165:e614a9f1c9e2 1915 tmpreg = huart->Instance->CR1;
AnnaBridge 165:e614a9f1c9e2 1916
<> 144:ef7eb2e8f9f7 1917 /* Clear TE and RE bits */
AnnaBridge 165:e614a9f1c9e2 1918 tmpreg &= (uint32_t)~((uint32_t)(USART_CR1_TE | USART_CR1_RE));
AnnaBridge 165:e614a9f1c9e2 1919
<> 144:ef7eb2e8f9f7 1920 /* Enable the USART's transmit interface by setting the TE bit in the USART CR1 register */
AnnaBridge 165:e614a9f1c9e2 1921 tmpreg |= (uint32_t)USART_CR1_TE;
AnnaBridge 165:e614a9f1c9e2 1922
AnnaBridge 165:e614a9f1c9e2 1923 /* Write to USART CR1 */
AnnaBridge 165:e614a9f1c9e2 1924 WRITE_REG(huart->Instance->CR1, (uint32_t)tmpreg);
AnnaBridge 165:e614a9f1c9e2 1925
AnnaBridge 165:e614a9f1c9e2 1926 huart->gState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 1927
<> 144:ef7eb2e8f9f7 1928 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1929 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 1930
<> 144:ef7eb2e8f9f7 1931 return HAL_OK;
<> 144:ef7eb2e8f9f7 1932 }
<> 144:ef7eb2e8f9f7 1933
<> 144:ef7eb2e8f9f7 1934 /**
<> 144:ef7eb2e8f9f7 1935 * @brief Enables the UART receiver and disables the UART transmitter.
AnnaBridge 165:e614a9f1c9e2 1936 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1937 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1938 * @retval HAL status
<> 144:ef7eb2e8f9f7 1939 */
<> 144:ef7eb2e8f9f7 1940 HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1941 {
AnnaBridge 165:e614a9f1c9e2 1942 uint32_t tmpreg = 0x00U;
AnnaBridge 165:e614a9f1c9e2 1943
<> 144:ef7eb2e8f9f7 1944 /* Process Locked */
<> 144:ef7eb2e8f9f7 1945 __HAL_LOCK(huart);
AnnaBridge 165:e614a9f1c9e2 1946
AnnaBridge 165:e614a9f1c9e2 1947 huart->gState = HAL_UART_STATE_BUSY;
<> 144:ef7eb2e8f9f7 1948
<> 144:ef7eb2e8f9f7 1949 /*-------------------------- USART CR1 Configuration -----------------------*/
AnnaBridge 165:e614a9f1c9e2 1950 tmpreg = huart->Instance->CR1;
AnnaBridge 165:e614a9f1c9e2 1951
<> 144:ef7eb2e8f9f7 1952 /* Clear TE and RE bits */
AnnaBridge 165:e614a9f1c9e2 1953 tmpreg &= (uint32_t)~((uint32_t)(USART_CR1_TE | USART_CR1_RE));
AnnaBridge 165:e614a9f1c9e2 1954
<> 144:ef7eb2e8f9f7 1955 /* Enable the USART's receive interface by setting the RE bit in the USART CR1 register */
AnnaBridge 165:e614a9f1c9e2 1956 tmpreg |= (uint32_t)USART_CR1_RE;
AnnaBridge 165:e614a9f1c9e2 1957
AnnaBridge 165:e614a9f1c9e2 1958 /* Write to USART CR1 */
AnnaBridge 165:e614a9f1c9e2 1959 WRITE_REG(huart->Instance->CR1, (uint32_t)tmpreg);
AnnaBridge 165:e614a9f1c9e2 1960
AnnaBridge 165:e614a9f1c9e2 1961 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 1962
<> 144:ef7eb2e8f9f7 1963 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 1964 __HAL_UNLOCK(huart);
<> 144:ef7eb2e8f9f7 1965
<> 144:ef7eb2e8f9f7 1966 return HAL_OK;
<> 144:ef7eb2e8f9f7 1967 }
<> 144:ef7eb2e8f9f7 1968
<> 144:ef7eb2e8f9f7 1969 /**
<> 144:ef7eb2e8f9f7 1970 * @}
<> 144:ef7eb2e8f9f7 1971 */
<> 144:ef7eb2e8f9f7 1972
<> 144:ef7eb2e8f9f7 1973 /** @defgroup UART_Exported_Functions_Group4 Peripheral State and Errors functions
<> 144:ef7eb2e8f9f7 1974 * @brief UART State and Errors functions
<> 144:ef7eb2e8f9f7 1975 *
<> 144:ef7eb2e8f9f7 1976 @verbatim
<> 144:ef7eb2e8f9f7 1977 ==============================================================================
<> 144:ef7eb2e8f9f7 1978 ##### Peripheral State and Errors functions #####
<> 144:ef7eb2e8f9f7 1979 ==============================================================================
<> 144:ef7eb2e8f9f7 1980 [..]
<> 144:ef7eb2e8f9f7 1981 This subsection provides a set of functions allowing to return the State of
<> 144:ef7eb2e8f9f7 1982 UART communication process, return Peripheral Errors occurred during communication
<> 144:ef7eb2e8f9f7 1983 process
<> 144:ef7eb2e8f9f7 1984 (+) HAL_UART_GetState() API can be helpful to check in run-time the state of the UART peripheral.
<> 144:ef7eb2e8f9f7 1985 (+) HAL_UART_GetError() check in run-time errors that could be occurred during communication.
<> 144:ef7eb2e8f9f7 1986
<> 144:ef7eb2e8f9f7 1987 @endverbatim
<> 144:ef7eb2e8f9f7 1988 * @{
<> 144:ef7eb2e8f9f7 1989 */
<> 144:ef7eb2e8f9f7 1990
<> 144:ef7eb2e8f9f7 1991 /**
<> 144:ef7eb2e8f9f7 1992 * @brief Returns the UART state.
AnnaBridge 165:e614a9f1c9e2 1993 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 1994 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 1995 * @retval HAL state
<> 144:ef7eb2e8f9f7 1996 */
<> 144:ef7eb2e8f9f7 1997 HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 1998 {
AnnaBridge 165:e614a9f1c9e2 1999 uint32_t temp1= 0x00U, temp2 = 0x00U;
AnnaBridge 165:e614a9f1c9e2 2000 temp1 = huart->gState;
AnnaBridge 165:e614a9f1c9e2 2001 temp2 = huart->RxState;
AnnaBridge 165:e614a9f1c9e2 2002
AnnaBridge 165:e614a9f1c9e2 2003 return (HAL_UART_StateTypeDef)(temp1 | temp2);
<> 144:ef7eb2e8f9f7 2004 }
<> 144:ef7eb2e8f9f7 2005
<> 144:ef7eb2e8f9f7 2006 /**
AnnaBridge 165:e614a9f1c9e2 2007 * @brief Return the UART error code
AnnaBridge 165:e614a9f1c9e2 2008 * @param huart : pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2009 * the configuration information for the specified UART.
AnnaBridge 165:e614a9f1c9e2 2010 * @retval UART Error Code
AnnaBridge 165:e614a9f1c9e2 2011 */
<> 144:ef7eb2e8f9f7 2012 uint32_t HAL_UART_GetError(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 2013 {
<> 144:ef7eb2e8f9f7 2014 return huart->ErrorCode;
<> 144:ef7eb2e8f9f7 2015 }
<> 144:ef7eb2e8f9f7 2016
<> 144:ef7eb2e8f9f7 2017 /**
<> 144:ef7eb2e8f9f7 2018 * @}
<> 144:ef7eb2e8f9f7 2019 */
<> 144:ef7eb2e8f9f7 2020
<> 144:ef7eb2e8f9f7 2021 /**
<> 144:ef7eb2e8f9f7 2022 * @brief DMA UART transmit process complete callback.
AnnaBridge 165:e614a9f1c9e2 2023 * @param hdma: DMA handle
<> 144:ef7eb2e8f9f7 2024 * @retval None
<> 144:ef7eb2e8f9f7 2025 */
AnnaBridge 165:e614a9f1c9e2 2026 static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 2027 {
<> 144:ef7eb2e8f9f7 2028 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
<> 144:ef7eb2e8f9f7 2029 /* DMA Normal mode*/
AnnaBridge 165:e614a9f1c9e2 2030 if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
<> 144:ef7eb2e8f9f7 2031 {
AnnaBridge 165:e614a9f1c9e2 2032 huart->TxXferCount = 0U;
<> 144:ef7eb2e8f9f7 2033
<> 144:ef7eb2e8f9f7 2034 /* Disable the DMA transfer for transmit request by setting the DMAT bit
<> 144:ef7eb2e8f9f7 2035 in the UART CR3 register */
<> 144:ef7eb2e8f9f7 2036 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAT);
<> 144:ef7eb2e8f9f7 2037
AnnaBridge 165:e614a9f1c9e2 2038 /* Enable the UART Transmit Complete Interrupt */
AnnaBridge 165:e614a9f1c9e2 2039 SET_BIT(huart->Instance->CR1, USART_CR1_TCIE);
AnnaBridge 165:e614a9f1c9e2 2040
<> 144:ef7eb2e8f9f7 2041 }
<> 144:ef7eb2e8f9f7 2042 /* DMA Circular mode */
<> 144:ef7eb2e8f9f7 2043 else
<> 144:ef7eb2e8f9f7 2044 {
<> 144:ef7eb2e8f9f7 2045 HAL_UART_TxCpltCallback(huart);
<> 144:ef7eb2e8f9f7 2046 }
<> 144:ef7eb2e8f9f7 2047 }
<> 144:ef7eb2e8f9f7 2048
<> 144:ef7eb2e8f9f7 2049 /**
<> 144:ef7eb2e8f9f7 2050 * @brief DMA UART transmit process half complete callback
AnnaBridge 165:e614a9f1c9e2 2051 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 2052 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 2053 * @retval None
<> 144:ef7eb2e8f9f7 2054 */
<> 144:ef7eb2e8f9f7 2055 static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 2056 {
<> 144:ef7eb2e8f9f7 2057 UART_HandleTypeDef* huart = (UART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
<> 144:ef7eb2e8f9f7 2058
<> 144:ef7eb2e8f9f7 2059 HAL_UART_TxHalfCpltCallback(huart);
<> 144:ef7eb2e8f9f7 2060 }
<> 144:ef7eb2e8f9f7 2061
<> 144:ef7eb2e8f9f7 2062 /**
<> 144:ef7eb2e8f9f7 2063 * @brief DMA UART receive process complete callback.
AnnaBridge 165:e614a9f1c9e2 2064 * @param hdma: DMA handle
<> 144:ef7eb2e8f9f7 2065 * @retval None
<> 144:ef7eb2e8f9f7 2066 */
AnnaBridge 165:e614a9f1c9e2 2067 static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 2068 {
<> 144:ef7eb2e8f9f7 2069 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
<> 144:ef7eb2e8f9f7 2070 /* DMA Normal mode*/
AnnaBridge 165:e614a9f1c9e2 2071 if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0U)
<> 144:ef7eb2e8f9f7 2072 {
AnnaBridge 165:e614a9f1c9e2 2073 huart->RxXferCount = 0U;
<> 144:ef7eb2e8f9f7 2074
AnnaBridge 165:e614a9f1c9e2 2075 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 2076 CLEAR_BIT(huart->Instance->CR1, USART_CR1_PEIE);
AnnaBridge 165:e614a9f1c9e2 2077 CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 2078
<> 144:ef7eb2e8f9f7 2079 /* Disable the DMA transfer for the receiver request by setting the DMAR bit
<> 144:ef7eb2e8f9f7 2080 in the UART CR3 register */
<> 144:ef7eb2e8f9f7 2081 CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
<> 144:ef7eb2e8f9f7 2082
AnnaBridge 165:e614a9f1c9e2 2083 /* At end of Rx process, restore huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 2084 huart->RxState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 2085 }
<> 144:ef7eb2e8f9f7 2086 HAL_UART_RxCpltCallback(huart);
<> 144:ef7eb2e8f9f7 2087 }
<> 144:ef7eb2e8f9f7 2088
<> 144:ef7eb2e8f9f7 2089 /**
<> 144:ef7eb2e8f9f7 2090 * @brief DMA UART receive process half complete callback
AnnaBridge 165:e614a9f1c9e2 2091 * @param hdma: pointer to a DMA_HandleTypeDef structure that contains
AnnaBridge 165:e614a9f1c9e2 2092 * the configuration information for the specified DMA module.
<> 144:ef7eb2e8f9f7 2093 * @retval None
<> 144:ef7eb2e8f9f7 2094 */
<> 144:ef7eb2e8f9f7 2095 static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 2096 {
<> 144:ef7eb2e8f9f7 2097 UART_HandleTypeDef* huart = (UART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
<> 144:ef7eb2e8f9f7 2098 HAL_UART_RxHalfCpltCallback(huart);
<> 144:ef7eb2e8f9f7 2099 }
<> 144:ef7eb2e8f9f7 2100
<> 144:ef7eb2e8f9f7 2101 /**
<> 144:ef7eb2e8f9f7 2102 * @brief DMA UART communication error callback.
AnnaBridge 165:e614a9f1c9e2 2103 * @param hdma: DMA handle
<> 144:ef7eb2e8f9f7 2104 * @retval None
<> 144:ef7eb2e8f9f7 2105 */
AnnaBridge 165:e614a9f1c9e2 2106 static void UART_DMAError(DMA_HandleTypeDef *hdma)
<> 144:ef7eb2e8f9f7 2107 {
AnnaBridge 165:e614a9f1c9e2 2108 uint32_t dmarequest = 0x00U;
<> 144:ef7eb2e8f9f7 2109 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
AnnaBridge 165:e614a9f1c9e2 2110
AnnaBridge 165:e614a9f1c9e2 2111 /* Stop UART DMA Tx request if ongoing */
AnnaBridge 165:e614a9f1c9e2 2112 dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAT);
AnnaBridge 165:e614a9f1c9e2 2113 if((huart->gState == HAL_UART_STATE_BUSY_TX) && dmarequest)
AnnaBridge 165:e614a9f1c9e2 2114 {
AnnaBridge 165:e614a9f1c9e2 2115 huart->TxXferCount = 0U;
AnnaBridge 165:e614a9f1c9e2 2116 UART_EndTxTransfer(huart);
AnnaBridge 165:e614a9f1c9e2 2117 }
AnnaBridge 165:e614a9f1c9e2 2118
AnnaBridge 165:e614a9f1c9e2 2119 /* Stop UART DMA Rx request if ongoing */
AnnaBridge 165:e614a9f1c9e2 2120 dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
AnnaBridge 165:e614a9f1c9e2 2121 if((huart->RxState == HAL_UART_STATE_BUSY_RX) && dmarequest)
AnnaBridge 165:e614a9f1c9e2 2122 {
AnnaBridge 165:e614a9f1c9e2 2123 huart->RxXferCount = 0U;
AnnaBridge 165:e614a9f1c9e2 2124 UART_EndRxTransfer(huart);
AnnaBridge 165:e614a9f1c9e2 2125 }
AnnaBridge 165:e614a9f1c9e2 2126
<> 144:ef7eb2e8f9f7 2127 huart->ErrorCode |= HAL_UART_ERROR_DMA;
<> 144:ef7eb2e8f9f7 2128 HAL_UART_ErrorCallback(huart);
<> 144:ef7eb2e8f9f7 2129 }
<> 144:ef7eb2e8f9f7 2130
<> 144:ef7eb2e8f9f7 2131 /**
<> 144:ef7eb2e8f9f7 2132 * @brief This function handles UART Communication Timeout.
AnnaBridge 165:e614a9f1c9e2 2133 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2134 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 2135 * @param Flag: specifies the UART flag to check.
<> 144:ef7eb2e8f9f7 2136 * @param Status: The new Flag status (SET or RESET).
AnnaBridge 165:e614a9f1c9e2 2137 * @param Tickstart Tick start value
<> 144:ef7eb2e8f9f7 2138 * @param Timeout: Timeout duration
<> 144:ef7eb2e8f9f7 2139 * @retval HAL status
<> 144:ef7eb2e8f9f7 2140 */
AnnaBridge 165:e614a9f1c9e2 2141 static HAL_StatusTypeDef UART_WaitOnFlagUntilTimeout(UART_HandleTypeDef *huart, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 2142 {
<> 144:ef7eb2e8f9f7 2143 /* Wait until flag is set */
AnnaBridge 165:e614a9f1c9e2 2144 while((__HAL_UART_GET_FLAG(huart, Flag) ? SET : RESET) == Status)
<> 144:ef7eb2e8f9f7 2145 {
AnnaBridge 165:e614a9f1c9e2 2146 /* Check for the Timeout */
AnnaBridge 165:e614a9f1c9e2 2147 if(Timeout != HAL_MAX_DELAY)
<> 144:ef7eb2e8f9f7 2148 {
AnnaBridge 165:e614a9f1c9e2 2149 if((Timeout == 0U)||((HAL_GetTick() - Tickstart ) > Timeout))
<> 144:ef7eb2e8f9f7 2150 {
AnnaBridge 165:e614a9f1c9e2 2151 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
AnnaBridge 165:e614a9f1c9e2 2152 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE));
AnnaBridge 165:e614a9f1c9e2 2153 CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 2154
AnnaBridge 165:e614a9f1c9e2 2155 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2156 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2157
AnnaBridge 165:e614a9f1c9e2 2158 /* Process Unlocked */
AnnaBridge 165:e614a9f1c9e2 2159 __HAL_UNLOCK(huart);
AnnaBridge 165:e614a9f1c9e2 2160
AnnaBridge 165:e614a9f1c9e2 2161 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 2162 }
<> 144:ef7eb2e8f9f7 2163 }
<> 144:ef7eb2e8f9f7 2164 }
AnnaBridge 165:e614a9f1c9e2 2165
AnnaBridge 165:e614a9f1c9e2 2166 return HAL_OK;
AnnaBridge 165:e614a9f1c9e2 2167 }
AnnaBridge 165:e614a9f1c9e2 2168
AnnaBridge 165:e614a9f1c9e2 2169 /**
AnnaBridge 165:e614a9f1c9e2 2170 * @brief End ongoing Tx transfer on UART peripheral (following error detection or Transmit completion).
AnnaBridge 165:e614a9f1c9e2 2171 * @param huart: UART handle.
AnnaBridge 165:e614a9f1c9e2 2172 * @retval None
AnnaBridge 165:e614a9f1c9e2 2173 */
AnnaBridge 165:e614a9f1c9e2 2174 static void UART_EndTxTransfer(UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 2175 {
AnnaBridge 165:e614a9f1c9e2 2176 /* Disable TXEIE and TCIE interrupts */
AnnaBridge 165:e614a9f1c9e2 2177 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TXEIE | USART_CR1_TCIE));
AnnaBridge 165:e614a9f1c9e2 2178
AnnaBridge 165:e614a9f1c9e2 2179 /* At end of Tx process, restore huart->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 2180 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2181 }
AnnaBridge 165:e614a9f1c9e2 2182
AnnaBridge 165:e614a9f1c9e2 2183 /**
AnnaBridge 165:e614a9f1c9e2 2184 * @brief End ongoing Rx transfer on UART peripheral (following error detection or Reception completion).
AnnaBridge 165:e614a9f1c9e2 2185 * @param huart: UART handle.
AnnaBridge 165:e614a9f1c9e2 2186 * @retval None
AnnaBridge 165:e614a9f1c9e2 2187 */
AnnaBridge 165:e614a9f1c9e2 2188 static void UART_EndRxTransfer(UART_HandleTypeDef *huart)
AnnaBridge 165:e614a9f1c9e2 2189 {
AnnaBridge 165:e614a9f1c9e2 2190 /* Disable RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */
AnnaBridge 165:e614a9f1c9e2 2191 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE));
AnnaBridge 165:e614a9f1c9e2 2192 CLEAR_BIT(huart->Instance->CR3, USART_CR3_EIE);
AnnaBridge 165:e614a9f1c9e2 2193
AnnaBridge 165:e614a9f1c9e2 2194 /* At end of Rx process, restore huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 2195 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2196 }
AnnaBridge 165:e614a9f1c9e2 2197
AnnaBridge 165:e614a9f1c9e2 2198 /**
AnnaBridge 165:e614a9f1c9e2 2199 * @brief DMA UART communication abort callback, when initiated by HAL services on Error
AnnaBridge 165:e614a9f1c9e2 2200 * (To be called at end of DMA Abort procedure following error occurrence).
AnnaBridge 165:e614a9f1c9e2 2201 * @param hdma DMA handle.
AnnaBridge 165:e614a9f1c9e2 2202 * @retval None
AnnaBridge 165:e614a9f1c9e2 2203 */
AnnaBridge 165:e614a9f1c9e2 2204 static void UART_DMAAbortOnError(DMA_HandleTypeDef *hdma)
AnnaBridge 165:e614a9f1c9e2 2205 {
AnnaBridge 165:e614a9f1c9e2 2206 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
AnnaBridge 165:e614a9f1c9e2 2207 huart->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 2208 huart->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 2209
AnnaBridge 165:e614a9f1c9e2 2210 HAL_UART_ErrorCallback(huart);
AnnaBridge 165:e614a9f1c9e2 2211 }
AnnaBridge 165:e614a9f1c9e2 2212
AnnaBridge 165:e614a9f1c9e2 2213 /**
AnnaBridge 165:e614a9f1c9e2 2214 * @brief DMA UART Tx communication abort callback, when initiated by user
AnnaBridge 165:e614a9f1c9e2 2215 * (To be called at end of DMA Tx Abort procedure following user abort request).
AnnaBridge 165:e614a9f1c9e2 2216 * @note When this callback is executed, User Abort complete call back is called only if no
AnnaBridge 165:e614a9f1c9e2 2217 * Abort still ongoing for Rx DMA Handle.
AnnaBridge 165:e614a9f1c9e2 2218 * @param hdma DMA handle.
AnnaBridge 165:e614a9f1c9e2 2219 * @retval None
AnnaBridge 165:e614a9f1c9e2 2220 */
AnnaBridge 165:e614a9f1c9e2 2221 static void UART_DMATxAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 165:e614a9f1c9e2 2222 {
AnnaBridge 165:e614a9f1c9e2 2223 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
AnnaBridge 165:e614a9f1c9e2 2224
AnnaBridge 165:e614a9f1c9e2 2225 huart->hdmatx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 2226
AnnaBridge 165:e614a9f1c9e2 2227 /* Check if an Abort process is still ongoing */
AnnaBridge 165:e614a9f1c9e2 2228 if(huart->hdmarx != NULL)
<> 144:ef7eb2e8f9f7 2229 {
AnnaBridge 165:e614a9f1c9e2 2230 if(huart->hdmarx->XferAbortCallback != NULL)
<> 144:ef7eb2e8f9f7 2231 {
AnnaBridge 165:e614a9f1c9e2 2232 return;
<> 144:ef7eb2e8f9f7 2233 }
<> 144:ef7eb2e8f9f7 2234 }
AnnaBridge 165:e614a9f1c9e2 2235
AnnaBridge 165:e614a9f1c9e2 2236 /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
AnnaBridge 165:e614a9f1c9e2 2237 huart->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 2238 huart->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 2239
AnnaBridge 165:e614a9f1c9e2 2240 /* Reset ErrorCode */
AnnaBridge 165:e614a9f1c9e2 2241 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 2242
AnnaBridge 165:e614a9f1c9e2 2243 /* Restore huart->gState and huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 2244 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2245 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2246
AnnaBridge 165:e614a9f1c9e2 2247 /* Call user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 2248 HAL_UART_AbortCpltCallback(huart);
AnnaBridge 165:e614a9f1c9e2 2249 }
AnnaBridge 165:e614a9f1c9e2 2250
AnnaBridge 165:e614a9f1c9e2 2251 /**
AnnaBridge 165:e614a9f1c9e2 2252 * @brief DMA UART Rx communication abort callback, when initiated by user
AnnaBridge 165:e614a9f1c9e2 2253 * (To be called at end of DMA Rx Abort procedure following user abort request).
AnnaBridge 165:e614a9f1c9e2 2254 * @note When this callback is executed, User Abort complete call back is called only if no
AnnaBridge 165:e614a9f1c9e2 2255 * Abort still ongoing for Tx DMA Handle.
AnnaBridge 165:e614a9f1c9e2 2256 * @param hdma DMA handle.
AnnaBridge 165:e614a9f1c9e2 2257 * @retval None
AnnaBridge 165:e614a9f1c9e2 2258 */
AnnaBridge 165:e614a9f1c9e2 2259 static void UART_DMARxAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 165:e614a9f1c9e2 2260 {
AnnaBridge 165:e614a9f1c9e2 2261 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
AnnaBridge 165:e614a9f1c9e2 2262
AnnaBridge 165:e614a9f1c9e2 2263 huart->hdmarx->XferAbortCallback = NULL;
AnnaBridge 165:e614a9f1c9e2 2264
AnnaBridge 165:e614a9f1c9e2 2265 /* Check if an Abort process is still ongoing */
AnnaBridge 165:e614a9f1c9e2 2266 if(huart->hdmatx != NULL)
AnnaBridge 165:e614a9f1c9e2 2267 {
AnnaBridge 165:e614a9f1c9e2 2268 if(huart->hdmatx->XferAbortCallback != NULL)
AnnaBridge 165:e614a9f1c9e2 2269 {
AnnaBridge 165:e614a9f1c9e2 2270 return;
AnnaBridge 165:e614a9f1c9e2 2271 }
AnnaBridge 165:e614a9f1c9e2 2272 }
AnnaBridge 165:e614a9f1c9e2 2273
AnnaBridge 165:e614a9f1c9e2 2274 /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */
AnnaBridge 165:e614a9f1c9e2 2275 huart->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 2276 huart->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 2277
AnnaBridge 165:e614a9f1c9e2 2278 /* Reset ErrorCode */
AnnaBridge 165:e614a9f1c9e2 2279 huart->ErrorCode = HAL_UART_ERROR_NONE;
AnnaBridge 165:e614a9f1c9e2 2280
AnnaBridge 165:e614a9f1c9e2 2281 /* Restore huart->gState and huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 2282 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2283 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2284
AnnaBridge 165:e614a9f1c9e2 2285 /* Call user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 2286 HAL_UART_AbortCpltCallback(huart);
AnnaBridge 165:e614a9f1c9e2 2287 }
AnnaBridge 165:e614a9f1c9e2 2288
AnnaBridge 165:e614a9f1c9e2 2289 /**
AnnaBridge 165:e614a9f1c9e2 2290 * @brief DMA UART Tx communication abort callback, when initiated by user by a call to
AnnaBridge 165:e614a9f1c9e2 2291 * HAL_UART_AbortTransmit_IT API (Abort only Tx transfer)
AnnaBridge 165:e614a9f1c9e2 2292 * (This callback is executed at end of DMA Tx Abort procedure following user abort request,
AnnaBridge 165:e614a9f1c9e2 2293 * and leads to user Tx Abort Complete callback execution).
AnnaBridge 165:e614a9f1c9e2 2294 * @param hdma DMA handle.
AnnaBridge 165:e614a9f1c9e2 2295 * @retval None
AnnaBridge 165:e614a9f1c9e2 2296 */
AnnaBridge 165:e614a9f1c9e2 2297 static void UART_DMATxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 165:e614a9f1c9e2 2298 {
AnnaBridge 165:e614a9f1c9e2 2299 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
AnnaBridge 165:e614a9f1c9e2 2300
AnnaBridge 165:e614a9f1c9e2 2301 huart->TxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 2302
AnnaBridge 165:e614a9f1c9e2 2303 /* Restore huart->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 2304 huart->gState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2305
AnnaBridge 165:e614a9f1c9e2 2306 /* Call user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 2307 HAL_UART_AbortTransmitCpltCallback(huart);
AnnaBridge 165:e614a9f1c9e2 2308 }
AnnaBridge 165:e614a9f1c9e2 2309
AnnaBridge 165:e614a9f1c9e2 2310 /**
AnnaBridge 165:e614a9f1c9e2 2311 * @brief DMA UART Rx communication abort callback, when initiated by user by a call to
AnnaBridge 165:e614a9f1c9e2 2312 * HAL_UART_AbortReceive_IT API (Abort only Rx transfer)
AnnaBridge 165:e614a9f1c9e2 2313 * (This callback is executed at end of DMA Rx Abort procedure following user abort request,
AnnaBridge 165:e614a9f1c9e2 2314 * and leads to user Rx Abort Complete callback execution).
AnnaBridge 165:e614a9f1c9e2 2315 * @param hdma DMA handle.
AnnaBridge 165:e614a9f1c9e2 2316 * @retval None
AnnaBridge 165:e614a9f1c9e2 2317 */
AnnaBridge 165:e614a9f1c9e2 2318 static void UART_DMARxOnlyAbortCallback(DMA_HandleTypeDef *hdma)
AnnaBridge 165:e614a9f1c9e2 2319 {
AnnaBridge 165:e614a9f1c9e2 2320 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
AnnaBridge 165:e614a9f1c9e2 2321
AnnaBridge 165:e614a9f1c9e2 2322 huart->RxXferCount = 0x00U;
AnnaBridge 165:e614a9f1c9e2 2323
AnnaBridge 165:e614a9f1c9e2 2324 /* Restore huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 2325 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2326
AnnaBridge 165:e614a9f1c9e2 2327 /* Call user Abort complete callback */
AnnaBridge 165:e614a9f1c9e2 2328 HAL_UART_AbortReceiveCpltCallback(huart);
<> 144:ef7eb2e8f9f7 2329 }
<> 144:ef7eb2e8f9f7 2330
<> 144:ef7eb2e8f9f7 2331 /**
<> 144:ef7eb2e8f9f7 2332 * @brief Sends an amount of data in non blocking mode.
<> 144:ef7eb2e8f9f7 2333 * @param huart: Pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2334 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 2335 * @retval HAL status
<> 144:ef7eb2e8f9f7 2336 */
<> 144:ef7eb2e8f9f7 2337 static HAL_StatusTypeDef UART_Transmit_IT(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 2338 {
<> 144:ef7eb2e8f9f7 2339 uint16_t* tmp;
<> 144:ef7eb2e8f9f7 2340
AnnaBridge 165:e614a9f1c9e2 2341 /* Check that a Tx process is ongoing */
AnnaBridge 165:e614a9f1c9e2 2342 if(huart->gState == HAL_UART_STATE_BUSY_TX)
<> 144:ef7eb2e8f9f7 2343 {
<> 144:ef7eb2e8f9f7 2344 if(huart->Init.WordLength == UART_WORDLENGTH_9B)
<> 144:ef7eb2e8f9f7 2345 {
<> 144:ef7eb2e8f9f7 2346 tmp = (uint16_t*) huart->pTxBuffPtr;
<> 144:ef7eb2e8f9f7 2347 huart->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FF);
<> 144:ef7eb2e8f9f7 2348 if(huart->Init.Parity == UART_PARITY_NONE)
<> 144:ef7eb2e8f9f7 2349 {
AnnaBridge 165:e614a9f1c9e2 2350 huart->pTxBuffPtr += 2U;
<> 144:ef7eb2e8f9f7 2351 }
<> 144:ef7eb2e8f9f7 2352 else
<> 144:ef7eb2e8f9f7 2353 {
AnnaBridge 165:e614a9f1c9e2 2354 huart->pTxBuffPtr += 1U;
<> 144:ef7eb2e8f9f7 2355 }
<> 144:ef7eb2e8f9f7 2356 }
<> 144:ef7eb2e8f9f7 2357 else
<> 144:ef7eb2e8f9f7 2358 {
<> 144:ef7eb2e8f9f7 2359 huart->Instance->DR = (uint8_t)(*huart->pTxBuffPtr++ & (uint8_t)0x00FF);
<> 144:ef7eb2e8f9f7 2360 }
<> 144:ef7eb2e8f9f7 2361
AnnaBridge 165:e614a9f1c9e2 2362 if(--huart->TxXferCount == 0U)
<> 144:ef7eb2e8f9f7 2363 {
<> 144:ef7eb2e8f9f7 2364 /* Disable the UART Transmit Complete Interrupt */
<> 144:ef7eb2e8f9f7 2365 __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
<> 144:ef7eb2e8f9f7 2366
<> 144:ef7eb2e8f9f7 2367 /* Enable the UART Transmit Complete Interrupt */
<> 144:ef7eb2e8f9f7 2368 __HAL_UART_ENABLE_IT(huart, UART_IT_TC);
<> 144:ef7eb2e8f9f7 2369 }
<> 144:ef7eb2e8f9f7 2370 return HAL_OK;
<> 144:ef7eb2e8f9f7 2371 }
<> 144:ef7eb2e8f9f7 2372 else
<> 144:ef7eb2e8f9f7 2373 {
<> 144:ef7eb2e8f9f7 2374 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 2375 }
<> 144:ef7eb2e8f9f7 2376 }
<> 144:ef7eb2e8f9f7 2377
<> 144:ef7eb2e8f9f7 2378 /**
<> 144:ef7eb2e8f9f7 2379 * @brief Wraps up transmission in non blocking mode.
<> 144:ef7eb2e8f9f7 2380 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2381 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 2382 * @retval HAL status
<> 144:ef7eb2e8f9f7 2383 */
<> 144:ef7eb2e8f9f7 2384 static HAL_StatusTypeDef UART_EndTransmit_IT(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 2385 {
<> 144:ef7eb2e8f9f7 2386 /* Disable the UART Transmit Complete Interrupt */
<> 144:ef7eb2e8f9f7 2387 __HAL_UART_DISABLE_IT(huart, UART_IT_TC);
<> 144:ef7eb2e8f9f7 2388
AnnaBridge 165:e614a9f1c9e2 2389 /* Tx process is ended, restore huart->gState to Ready */
AnnaBridge 165:e614a9f1c9e2 2390 huart->gState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 2391 HAL_UART_TxCpltCallback(huart);
<> 144:ef7eb2e8f9f7 2392
<> 144:ef7eb2e8f9f7 2393 return HAL_OK;
<> 144:ef7eb2e8f9f7 2394 }
<> 144:ef7eb2e8f9f7 2395
<> 144:ef7eb2e8f9f7 2396 /**
<> 144:ef7eb2e8f9f7 2397 * @brief Receives an amount of data in non blocking mode
AnnaBridge 165:e614a9f1c9e2 2398 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2399 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 2400 * @retval HAL status
<> 144:ef7eb2e8f9f7 2401 */
<> 144:ef7eb2e8f9f7 2402 static HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 2403 {
<> 144:ef7eb2e8f9f7 2404 uint16_t* tmp;
<> 144:ef7eb2e8f9f7 2405
AnnaBridge 165:e614a9f1c9e2 2406 /* Check that a Rx process is ongoing */
AnnaBridge 165:e614a9f1c9e2 2407 if(huart->RxState == HAL_UART_STATE_BUSY_RX)
<> 144:ef7eb2e8f9f7 2408 {
<> 144:ef7eb2e8f9f7 2409 if(huart->Init.WordLength == UART_WORDLENGTH_9B)
<> 144:ef7eb2e8f9f7 2410 {
<> 144:ef7eb2e8f9f7 2411 tmp = (uint16_t*) huart->pRxBuffPtr;
<> 144:ef7eb2e8f9f7 2412 if(huart->Init.Parity == UART_PARITY_NONE)
<> 144:ef7eb2e8f9f7 2413 {
<> 144:ef7eb2e8f9f7 2414 *tmp = (uint16_t)(huart->Instance->DR & (uint16_t)0x01FF);
AnnaBridge 165:e614a9f1c9e2 2415 huart->pRxBuffPtr += 2U;
<> 144:ef7eb2e8f9f7 2416 }
<> 144:ef7eb2e8f9f7 2417 else
<> 144:ef7eb2e8f9f7 2418 {
<> 144:ef7eb2e8f9f7 2419 *tmp = (uint16_t)(huart->Instance->DR & (uint16_t)0x00FF);
AnnaBridge 165:e614a9f1c9e2 2420 huart->pRxBuffPtr += 1U;
<> 144:ef7eb2e8f9f7 2421 }
<> 144:ef7eb2e8f9f7 2422 }
<> 144:ef7eb2e8f9f7 2423 else
<> 144:ef7eb2e8f9f7 2424 {
<> 144:ef7eb2e8f9f7 2425 if(huart->Init.Parity == UART_PARITY_NONE)
<> 144:ef7eb2e8f9f7 2426 {
<> 144:ef7eb2e8f9f7 2427 *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->DR & (uint8_t)0x00FF);
<> 144:ef7eb2e8f9f7 2428 }
<> 144:ef7eb2e8f9f7 2429 else
<> 144:ef7eb2e8f9f7 2430 {
<> 144:ef7eb2e8f9f7 2431 *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->DR & (uint8_t)0x007F);
<> 144:ef7eb2e8f9f7 2432 }
<> 144:ef7eb2e8f9f7 2433 }
<> 144:ef7eb2e8f9f7 2434
AnnaBridge 165:e614a9f1c9e2 2435 if(--huart->RxXferCount == 0U)
<> 144:ef7eb2e8f9f7 2436 {
AnnaBridge 165:e614a9f1c9e2 2437 /* Disable the IRDA Data Register not empty Interrupt */
<> 144:ef7eb2e8f9f7 2438 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
<> 144:ef7eb2e8f9f7 2439
AnnaBridge 165:e614a9f1c9e2 2440 /* Disable the UART Parity Error Interrupt */
AnnaBridge 165:e614a9f1c9e2 2441 __HAL_UART_DISABLE_IT(huart, UART_IT_PE);
<> 144:ef7eb2e8f9f7 2442 /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */
<> 144:ef7eb2e8f9f7 2443 __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
<> 144:ef7eb2e8f9f7 2444
AnnaBridge 165:e614a9f1c9e2 2445 /* Rx process is completed, restore huart->RxState to Ready */
AnnaBridge 165:e614a9f1c9e2 2446 huart->RxState = HAL_UART_STATE_READY;
AnnaBridge 165:e614a9f1c9e2 2447
<> 144:ef7eb2e8f9f7 2448 HAL_UART_RxCpltCallback(huart);
<> 144:ef7eb2e8f9f7 2449
<> 144:ef7eb2e8f9f7 2450 return HAL_OK;
<> 144:ef7eb2e8f9f7 2451 }
<> 144:ef7eb2e8f9f7 2452 return HAL_OK;
<> 144:ef7eb2e8f9f7 2453 }
<> 144:ef7eb2e8f9f7 2454 else
<> 144:ef7eb2e8f9f7 2455 {
AnnaBridge 165:e614a9f1c9e2 2456 return HAL_BUSY;
<> 144:ef7eb2e8f9f7 2457 }
<> 144:ef7eb2e8f9f7 2458 }
<> 144:ef7eb2e8f9f7 2459
<> 144:ef7eb2e8f9f7 2460 /**
<> 144:ef7eb2e8f9f7 2461 * @brief Configures the UART peripheral.
AnnaBridge 165:e614a9f1c9e2 2462 * @param huart: pointer to a UART_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 2463 * the configuration information for the specified UART module.
<> 144:ef7eb2e8f9f7 2464 * @retval None
<> 144:ef7eb2e8f9f7 2465 */
<> 144:ef7eb2e8f9f7 2466 static void UART_SetConfig(UART_HandleTypeDef *huart)
<> 144:ef7eb2e8f9f7 2467 {
AnnaBridge 165:e614a9f1c9e2 2468 uint32_t tmpreg = 0x00U;
AnnaBridge 165:e614a9f1c9e2 2469
<> 144:ef7eb2e8f9f7 2470 /* Check the parameters */
AnnaBridge 165:e614a9f1c9e2 2471 assert_param(IS_UART_BAUDRATE(huart->Init.BaudRate));
<> 144:ef7eb2e8f9f7 2472 assert_param(IS_UART_STOPBITS(huart->Init.StopBits));
<> 144:ef7eb2e8f9f7 2473 assert_param(IS_UART_PARITY(huart->Init.Parity));
<> 144:ef7eb2e8f9f7 2474 assert_param(IS_UART_MODE(huart->Init.Mode));
<> 144:ef7eb2e8f9f7 2475
<> 144:ef7eb2e8f9f7 2476 /*------- UART-associated USART registers setting : CR2 Configuration ------*/
<> 144:ef7eb2e8f9f7 2477 /* Configure the UART Stop Bits: Set STOP[13:12] bits according
<> 144:ef7eb2e8f9f7 2478 * to huart->Init.StopBits value */
<> 144:ef7eb2e8f9f7 2479 MODIFY_REG(huart->Instance->CR2, USART_CR2_STOP, huart->Init.StopBits);
<> 144:ef7eb2e8f9f7 2480
<> 144:ef7eb2e8f9f7 2481 /*------- UART-associated USART registers setting : CR1 Configuration ------*/
<> 144:ef7eb2e8f9f7 2482 /* Configure the UART Word Length, Parity and mode:
<> 144:ef7eb2e8f9f7 2483 Set the M bits according to huart->Init.WordLength value
<> 144:ef7eb2e8f9f7 2484 Set PCE and PS bits according to huart->Init.Parity value
AnnaBridge 165:e614a9f1c9e2 2485 Set TE and RE bits according to huart->Init.Mode value
AnnaBridge 165:e614a9f1c9e2 2486 Set OVER8 bit according to huart->Init.OverSampling value */
AnnaBridge 165:e614a9f1c9e2 2487
AnnaBridge 165:e614a9f1c9e2 2488 #if defined(USART_CR1_OVER8)
AnnaBridge 165:e614a9f1c9e2 2489 tmpreg |= (uint32_t)huart->Init.WordLength | huart->Init.Parity | huart->Init.Mode | huart->Init.OverSampling;
AnnaBridge 165:e614a9f1c9e2 2490 MODIFY_REG(huart->Instance->CR1,
AnnaBridge 165:e614a9f1c9e2 2491 (uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | USART_CR1_RE | USART_CR1_OVER8),
AnnaBridge 165:e614a9f1c9e2 2492 tmpreg);
AnnaBridge 165:e614a9f1c9e2 2493 #else
AnnaBridge 165:e614a9f1c9e2 2494 tmpreg |= (uint32_t)huart->Init.WordLength | huart->Init.Parity | huart->Init.Mode;
<> 144:ef7eb2e8f9f7 2495 MODIFY_REG(huart->Instance->CR1,
<> 144:ef7eb2e8f9f7 2496 (uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | USART_CR1_TE | USART_CR1_RE),
<> 144:ef7eb2e8f9f7 2497 tmpreg);
AnnaBridge 165:e614a9f1c9e2 2498 #endif /* USART_CR1_OVER8 */
AnnaBridge 165:e614a9f1c9e2 2499
<> 144:ef7eb2e8f9f7 2500 /*------- UART-associated USART registers setting : CR3 Configuration ------*/
<> 144:ef7eb2e8f9f7 2501 /* Configure the UART HFC: Set CTSE and RTSE bits according to huart->Init.HwFlowCtl value */
<> 144:ef7eb2e8f9f7 2502 MODIFY_REG(huart->Instance->CR3, (USART_CR3_RTSE | USART_CR3_CTSE), huart->Init.HwFlowCtl);
AnnaBridge 165:e614a9f1c9e2 2503
AnnaBridge 165:e614a9f1c9e2 2504 #if defined(USART_CR1_OVER8)
AnnaBridge 165:e614a9f1c9e2 2505 /* Check the Over Sampling */
AnnaBridge 165:e614a9f1c9e2 2506 if(huart->Init.OverSampling == UART_OVERSAMPLING_8)
AnnaBridge 165:e614a9f1c9e2 2507 {
AnnaBridge 165:e614a9f1c9e2 2508 /*-------------------------- USART BRR Configuration ---------------------*/
AnnaBridge 165:e614a9f1c9e2 2509 if(huart->Instance == USART1)
AnnaBridge 165:e614a9f1c9e2 2510 {
AnnaBridge 165:e614a9f1c9e2 2511 huart->Instance->BRR = UART_BRR_SAMPLING8(HAL_RCC_GetPCLK2Freq(), huart->Init.BaudRate);
AnnaBridge 165:e614a9f1c9e2 2512 }
AnnaBridge 165:e614a9f1c9e2 2513 else
AnnaBridge 165:e614a9f1c9e2 2514 {
AnnaBridge 165:e614a9f1c9e2 2515 huart->Instance->BRR = UART_BRR_SAMPLING8(HAL_RCC_GetPCLK1Freq(), huart->Init.BaudRate);
AnnaBridge 165:e614a9f1c9e2 2516 }
AnnaBridge 165:e614a9f1c9e2 2517 }
AnnaBridge 165:e614a9f1c9e2 2518 else
AnnaBridge 165:e614a9f1c9e2 2519 {
AnnaBridge 165:e614a9f1c9e2 2520 /*-------------------------- USART BRR Configuration ---------------------*/
AnnaBridge 165:e614a9f1c9e2 2521 if(huart->Instance == USART1)
AnnaBridge 165:e614a9f1c9e2 2522 {
AnnaBridge 165:e614a9f1c9e2 2523 huart->Instance->BRR = UART_BRR_SAMPLING16(HAL_RCC_GetPCLK2Freq(), huart->Init.BaudRate);
AnnaBridge 165:e614a9f1c9e2 2524 }
AnnaBridge 165:e614a9f1c9e2 2525 else
AnnaBridge 165:e614a9f1c9e2 2526 {
AnnaBridge 165:e614a9f1c9e2 2527 huart->Instance->BRR = UART_BRR_SAMPLING16(HAL_RCC_GetPCLK1Freq(), huart->Init.BaudRate);
AnnaBridge 165:e614a9f1c9e2 2528 }
AnnaBridge 165:e614a9f1c9e2 2529 }
AnnaBridge 165:e614a9f1c9e2 2530 #else
AnnaBridge 165:e614a9f1c9e2 2531 /*-------------------------- USART BRR Configuration ---------------------*/
AnnaBridge 165:e614a9f1c9e2 2532 if(huart->Instance == USART1)
<> 144:ef7eb2e8f9f7 2533 {
<> 144:ef7eb2e8f9f7 2534 huart->Instance->BRR = UART_BRR_SAMPLING16(HAL_RCC_GetPCLK2Freq(), huart->Init.BaudRate);
<> 144:ef7eb2e8f9f7 2535 }
<> 144:ef7eb2e8f9f7 2536 else
<> 144:ef7eb2e8f9f7 2537 {
<> 144:ef7eb2e8f9f7 2538 huart->Instance->BRR = UART_BRR_SAMPLING16(HAL_RCC_GetPCLK1Freq(), huart->Init.BaudRate);
<> 144:ef7eb2e8f9f7 2539 }
AnnaBridge 165:e614a9f1c9e2 2540 #endif /* USART_CR1_OVER8 */
<> 144:ef7eb2e8f9f7 2541 }
AnnaBridge 165:e614a9f1c9e2 2542
<> 144:ef7eb2e8f9f7 2543 /**
<> 144:ef7eb2e8f9f7 2544 * @}
<> 144:ef7eb2e8f9f7 2545 */
<> 144:ef7eb2e8f9f7 2546
<> 144:ef7eb2e8f9f7 2547 #endif /* HAL_UART_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 2548 /**
<> 144:ef7eb2e8f9f7 2549 * @}
<> 144:ef7eb2e8f9f7 2550 */
<> 144:ef7eb2e8f9f7 2551
<> 144:ef7eb2e8f9f7 2552 /**
<> 144:ef7eb2e8f9f7 2553 * @}
<> 144:ef7eb2e8f9f7 2554 */
<> 144:ef7eb2e8f9f7 2555
<> 144:ef7eb2e8f9f7 2556 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/