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@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
573:ad23fe03a082
Child:
610:813dcc80987e
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



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



Initial version of drivers for SAMR21

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