mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_uart.c@610:813dcc80987e, 2015-08-14 (annotated)

Committer:
mbed_official
Date:
Fri Aug 14 13:15:17 2015 +0100
Revision:
610:813dcc80987e
Parent:
573:ad23fe03a082 
Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599



Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/



DISCO_F746NG - Improvements

Who changed what in which revision?

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