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

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
394:83f921546702 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



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



Initial version of drivers for SAMR21

Who changed what in which revision?

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