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_STM32F4/stm32f4xx_hal_uart.c@581:39197bcd20f2, 2015-07-02 (annotated)

Committer:
mbed_official
Date:
Thu Jul 02 16:30:08 2015 +0100
Revision:
581:39197bcd20f2
Parent:
532:fe11edbda85c
Child:
613:bc40b8d2aec4
Synchronized with git revision ae2d3cdffe70184eb8736d94f76c45c93f4b7724



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



Make it possible to build the core mbed library with yotta

Who changed what in which revision?

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