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_STM32L0/stm32l0xx_hal_usart.c@387:643a59b3dbac, 2014-11-05 (annotated)

Committer:
mbed_official
Date:
Wed Nov 05 14:30:08 2014 +0000
Revision:
387:643a59b3dbac
Parent:
382:ee426a420dbb
Child:
489:119543c9f674
Synchronized with git revision cfeccf154f8f92c3ea9c0c881c577c154537aecc



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



Exporters: STM32L053R8 - IAR exporter

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 376:cb4d9db17537 1 /**
mbed_official 376:cb4d9db17537 2 ******************************************************************************
mbed_official 376:cb4d9db17537 3 * @file stm32l0xx_hal_usart.c
mbed_official 376:cb4d9db17537 4 * @author MCD Application Team
mbed_official 376:cb4d9db17537 5 * @version V1.1.0
mbed_official 376:cb4d9db17537 6 * @date 18-June-2014
mbed_official 376:cb4d9db17537 7 * @brief USART HAL module driver.
mbed_official 376:cb4d9db17537 8 *
mbed_official 376:cb4d9db17537 9 * This file provides firmware functions to manage the following
mbed_official 376:cb4d9db17537 10 * functionalities of the Universal Synchronous/Asynchronous Receiver Transmitter
mbed_official 376:cb4d9db17537 11 * Peripheral (USART).
mbed_official 376:cb4d9db17537 12 * + Initialization and de-initialization functions
mbed_official 376:cb4d9db17537 13 * + IO operation functions
mbed_official 376:cb4d9db17537 14 * + Peripheral Control functions
mbed_official 376:cb4d9db17537 15 *
mbed_official 376:cb4d9db17537 16 @verbatim
mbed_official 376:cb4d9db17537 17 ===============================================================================
mbed_official 376:cb4d9db17537 18 ##### How to use this driver #####
mbed_official 376:cb4d9db17537 19 ===============================================================================
mbed_official 376:cb4d9db17537 20 [..]
mbed_official 376:cb4d9db17537 21 The USART HAL driver can be used as follows:
mbed_official 376:cb4d9db17537 22
mbed_official 376:cb4d9db17537 23 (#) Declare a USART_HandleTypeDef handle structure.
mbed_official 376:cb4d9db17537 24 (#) Initialize the USART low level resources by implement the HAL_USART_MspInit ()API:
mbed_official 376:cb4d9db17537 25 (##) Enable the USARTx interface clock.
mbed_official 376:cb4d9db17537 26 (##) USART pins configuration:
mbed_official 376:cb4d9db17537 27 (+++) Enable the clock for the USART GPIOs.
mbed_official 376:cb4d9db17537 28 (+++) Configure these USART pins as alternate function pull-up.
mbed_official 376:cb4d9db17537 29 (##) NVIC configuration if you need to use interrupt process (HAL_USART_Transmit_IT(),
mbed_official 376:cb4d9db17537 30 HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):
mbed_official 376:cb4d9db17537 31 (+++) Configure the USARTx interrupt priority.
mbed_official 376:cb4d9db17537 32 (+++) Enable the NVIC USART IRQ handle.
mbed_official 376:cb4d9db17537 33 (@) The specific USART interrupts (Transmission complete interrupt,
mbed_official 376:cb4d9db17537 34 RXNE interrupt and Error Interrupts) will be managed using the macros
mbed_official 376:cb4d9db17537 35 __HAL_USART_ENABLE_IT() and __HAL_USART_DISABLE_IT() inside the transmit and receive process.
mbed_official 376:cb4d9db17537 36 (##) DMA Configuration if you need to use DMA process (HAL_USART_Transmit_DMA()
mbed_official 376:cb4d9db17537 37 HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):
mbed_official 376:cb4d9db17537 38 (+++) Declare a DMA handle structure for the Tx/Rx stream.
mbed_official 376:cb4d9db17537 39 (+++) Enable the DMAx interface clock.
mbed_official 376:cb4d9db17537 40 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
mbed_official 376:cb4d9db17537 41 (+++) Configure the DMA Tx/Rx Stream.
mbed_official 376:cb4d9db17537 42 (+++) Associate the initilalized DMA handle to the USART DMA Tx/Rx handle.
mbed_official 376:cb4d9db17537 43 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx Stream.
mbed_official 376:cb4d9db17537 44
mbed_official 376:cb4d9db17537 45 (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware
mbed_official 376:cb4d9db17537 46 flow control and Mode(Receiver/Transmitter) in the husart Init structure.
mbed_official 376:cb4d9db17537 47
mbed_official 376:cb4d9db17537 48 (#) Initialize the USART registers by calling the HAL_USART_Init() API:
mbed_official 376:cb4d9db17537 49 (+) These API's configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
mbed_official 376:cb4d9db17537 50 by calling the customed HAL_USART_MspInit(&husart) API.
mbed_official 376:cb4d9db17537 51
mbed_official 376:cb4d9db17537 52 @endverbatim
mbed_official 376:cb4d9db17537 53 ******************************************************************************
mbed_official 376:cb4d9db17537 54 * @attention
mbed_official 376:cb4d9db17537 55 *
mbed_official 376:cb4d9db17537 56 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 376:cb4d9db17537 57 *
mbed_official 376:cb4d9db17537 58 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 376:cb4d9db17537 59 * are permitted provided that the following conditions are met:
mbed_official 376:cb4d9db17537 60 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 376:cb4d9db17537 61 * this list of conditions and the following disclaimer.
mbed_official 376:cb4d9db17537 62 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 376:cb4d9db17537 63 * this list of conditions and the following disclaimer in the documentation
mbed_official 376:cb4d9db17537 64 * and/or other materials provided with the distribution.
mbed_official 376:cb4d9db17537 65 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 376:cb4d9db17537 66 * may be used to endorse or promote products derived from this software
mbed_official 376:cb4d9db17537 67 * without specific prior written permission.
mbed_official 376:cb4d9db17537 68 *
mbed_official 376:cb4d9db17537 69 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 376:cb4d9db17537 70 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 376:cb4d9db17537 71 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 376:cb4d9db17537 72 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 376:cb4d9db17537 73 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 376:cb4d9db17537 74 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 376:cb4d9db17537 75 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 376:cb4d9db17537 76 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 376:cb4d9db17537 77 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 376:cb4d9db17537 78 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 376:cb4d9db17537 79 *
mbed_official 376:cb4d9db17537 80 ******************************************************************************
mbed_official 376:cb4d9db17537 81 */
mbed_official 376:cb4d9db17537 82
mbed_official 376:cb4d9db17537 83 /* Includes ------------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 84 #include "stm32l0xx_hal.h"
mbed_official 376:cb4d9db17537 85
mbed_official 376:cb4d9db17537 86 /** @addtogroup STM32L0xx_HAL_Driver
mbed_official 376:cb4d9db17537 87 * @{
mbed_official 376:cb4d9db17537 88 */
mbed_official 376:cb4d9db17537 89
mbed_official 376:cb4d9db17537 90 /** @defgroup USART
mbed_official 376:cb4d9db17537 91 * @brief USART Synchronous module driver
mbed_official 376:cb4d9db17537 92 * @{
mbed_official 376:cb4d9db17537 93 */
mbed_official 376:cb4d9db17537 94 #ifdef HAL_USART_MODULE_ENABLED
mbed_official 376:cb4d9db17537 95 /* Private typedef -----------------------------------------------------------*/
mbed_official 376:cb4d9db17537 96 /* Private define ------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 97 #define DUMMY_DATA ((uint16_t) 0xFFFF)
mbed_official 376:cb4d9db17537 98 #define TEACK_REACK_TIMEOUT ((uint32_t) 1000)
mbed_official 376:cb4d9db17537 99 #define HAL_USART_TXDMA_TIMEOUTVALUE ((uint32_t) 22000)
mbed_official 376:cb4d9db17537 100
mbed_official 376:cb4d9db17537 101
mbed_official 376:cb4d9db17537 102 #define USART_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE | \
mbed_official 376:cb4d9db17537 103 USART_CR1_PS | USART_CR1_TE | USART_CR1_RE))
mbed_official 376:cb4d9db17537 104 #define USART_CR2_FIELDS ((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | \
mbed_official 376:cb4d9db17537 105 USART_CR2_CLKEN | USART_CR2_LBCL | USART_CR2_STOP))
mbed_official 376:cb4d9db17537 106 /* Private macro -------------------------------------------------------------*/
mbed_official 376:cb4d9db17537 107 /* Private variables ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 108 /* Private function prototypes -----------------------------------------------*/
mbed_official 376:cb4d9db17537 109 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 110 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 111 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 112 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 113 static void USART_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 376:cb4d9db17537 114 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
mbed_official 376:cb4d9db17537 115 static void USART_SetConfig (USART_HandleTypeDef *husart);
mbed_official 376:cb4d9db17537 116 static HAL_StatusTypeDef USART_CheckIdleState(USART_HandleTypeDef *husart);
mbed_official 376:cb4d9db17537 117 static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart);
mbed_official 376:cb4d9db17537 118 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart);
mbed_official 376:cb4d9db17537 119 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart);
mbed_official 376:cb4d9db17537 120 /* Private functions ---------------------------------------------------------*/
mbed_official 376:cb4d9db17537 121
mbed_official 376:cb4d9db17537 122
mbed_official 376:cb4d9db17537 123 /** @defgroup USART_Private_Functions
mbed_official 376:cb4d9db17537 124 * @{
mbed_official 376:cb4d9db17537 125 */
mbed_official 376:cb4d9db17537 126
mbed_official 376:cb4d9db17537 127 /** @defgroup USART_Group1 USART Initialization/de-initialization functions
mbed_official 376:cb4d9db17537 128 * @brief Initialization and Configuration functions
mbed_official 376:cb4d9db17537 129 *
mbed_official 376:cb4d9db17537 130 @verbatim
mbed_official 376:cb4d9db17537 131 ===============================================================================
mbed_official 376:cb4d9db17537 132 ##### Initialization and Configuration functions #####
mbed_official 376:cb4d9db17537 133 ===============================================================================
mbed_official 376:cb4d9db17537 134 [..]
mbed_official 376:cb4d9db17537 135 This subsection provides a set of functions allowing to initialize the USART
mbed_official 376:cb4d9db17537 136 in asynchronous and in synchronous modes.
mbed_official 376:cb4d9db17537 137 (+) For the asynchronous mode only these parameters can be configured:
mbed_official 376:cb4d9db17537 138 (++) Baud Rate
mbed_official 376:cb4d9db17537 139 (++) Word Length
mbed_official 376:cb4d9db17537 140 (++) Stop Bit
mbed_official 376:cb4d9db17537 141 (++) Parity: If the parity is enabled, then the MSB bit of the data written
mbed_official 376:cb4d9db17537 142 in the data register is transmitted but is changed by the parity bit.
mbed_official 376:cb4d9db17537 143 Depending on the frame length defined by the M bit (8-bits or 9-bits),
mbed_official 376:cb4d9db17537 144 the possible USART frame formats are as listed in the following table:
mbed_official 376:cb4d9db17537 145 +-------------------------------------------------------------+
mbed_official 376:cb4d9db17537 146 | M0 bit | PCE bit | USART frame |
mbed_official 376:cb4d9db17537 147 |---------------------|---------------------------------------|
mbed_official 376:cb4d9db17537 148 | 0 | 0 | | SB | 8 bit data | STB | |
mbed_official 376:cb4d9db17537 149 |---------|-----------|---------------------------------------|
mbed_official 376:cb4d9db17537 150 | 0 | 1 | | SB | 7 bit data | PB | STB | |
mbed_official 376:cb4d9db17537 151 |---------|-----------|---------------------------------------|
mbed_official 376:cb4d9db17537 152 | 1 | 0 | | SB | 9 bit data | STB | |
mbed_official 376:cb4d9db17537 153 |---------|-----------|---------------------------------------|
mbed_official 376:cb4d9db17537 154 | 1 | 1 | | SB | 8 bit data | PB | STB | |
mbed_official 376:cb4d9db17537 155 +-------------------------------------------------------------+
mbed_official 376:cb4d9db17537 156 (++) USART polarity
mbed_official 376:cb4d9db17537 157 (++) USART phase
mbed_official 376:cb4d9db17537 158 (++) USART LastBit
mbed_official 376:cb4d9db17537 159 (++) Receiver/transmitter modes
mbed_official 376:cb4d9db17537 160
mbed_official 376:cb4d9db17537 161 [..]
mbed_official 376:cb4d9db17537 162 The HAL_USART_Init() function follows the USART synchronous configuration
mbed_official 376:cb4d9db17537 163 procedure (details for the procedure are available in reference manual (RM0329)).
mbed_official 376:cb4d9db17537 164
mbed_official 376:cb4d9db17537 165 @endverbatim
mbed_official 376:cb4d9db17537 166 * @{
mbed_official 376:cb4d9db17537 167 */
mbed_official 376:cb4d9db17537 168
mbed_official 376:cb4d9db17537 169 /**
mbed_official 376:cb4d9db17537 170 * @brief Initializes the USART mode according to the specified
mbed_official 376:cb4d9db17537 171 * parameters in the USART_InitTypeDef and create the associated handle.
mbed_official 376:cb4d9db17537 172 * @param husart: USART handle
mbed_official 376:cb4d9db17537 173 * @retval HAL status
mbed_official 376:cb4d9db17537 174 */
mbed_official 376:cb4d9db17537 175 HAL_StatusTypeDef HAL_USART_Init(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 176 {
mbed_official 376:cb4d9db17537 177 /* Check the USART handle allocation */
mbed_official 387:643a59b3dbac 178 if(husart == HAL_NULL)
mbed_official 376:cb4d9db17537 179 {
mbed_official 376:cb4d9db17537 180 return HAL_ERROR;
mbed_official 376:cb4d9db17537 181 }
mbed_official 376:cb4d9db17537 182
mbed_official 376:cb4d9db17537 183 /* Check the parameters */
mbed_official 376:cb4d9db17537 184 assert_param(IS_USART_INSTANCE(husart->Instance));
mbed_official 376:cb4d9db17537 185
mbed_official 376:cb4d9db17537 186 if(husart->State == HAL_USART_STATE_RESET)
mbed_official 376:cb4d9db17537 187 {
mbed_official 376:cb4d9db17537 188 /* Init the low level hardware : GPIO, CLOCK, CORTEX */
mbed_official 376:cb4d9db17537 189 HAL_USART_MspInit(husart);
mbed_official 376:cb4d9db17537 190 }
mbed_official 376:cb4d9db17537 191
mbed_official 376:cb4d9db17537 192 husart->State = HAL_USART_STATE_BUSY;
mbed_official 376:cb4d9db17537 193
mbed_official 376:cb4d9db17537 194 /* Disable the Peripheral */
mbed_official 376:cb4d9db17537 195 __HAL_USART_DISABLE(husart);
mbed_official 376:cb4d9db17537 196
mbed_official 376:cb4d9db17537 197 /* Set the Usart Communication parameters */
mbed_official 376:cb4d9db17537 198 USART_SetConfig(husart);
mbed_official 376:cb4d9db17537 199
mbed_official 376:cb4d9db17537 200 /* In Synchronous mode, the following bits must be kept cleared:
mbed_official 376:cb4d9db17537 201 - LINEN bit in the USART_CR2 register
mbed_official 376:cb4d9db17537 202 - HDSEL, SCEN and IREN bits in the USART_CR3 register.*/
mbed_official 376:cb4d9db17537 203 husart->Instance->CR2 &= ~USART_CR2_LINEN;
mbed_official 376:cb4d9db17537 204 husart->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN);
mbed_official 376:cb4d9db17537 205
mbed_official 376:cb4d9db17537 206 /* Enable the Peripharal */
mbed_official 376:cb4d9db17537 207 __HAL_USART_ENABLE(husart);
mbed_official 376:cb4d9db17537 208
mbed_official 376:cb4d9db17537 209 /* TEACK and/or REACK to check before moving husart->State to Ready */
mbed_official 376:cb4d9db17537 210 return (USART_CheckIdleState(husart));
mbed_official 376:cb4d9db17537 211 }
mbed_official 376:cb4d9db17537 212
mbed_official 376:cb4d9db17537 213 /**
mbed_official 376:cb4d9db17537 214 * @brief DeInitializes the USART peripheral.
mbed_official 376:cb4d9db17537 215 * @param husart: USART handle
mbed_official 376:cb4d9db17537 216 * @retval HAL status
mbed_official 376:cb4d9db17537 217 */
mbed_official 376:cb4d9db17537 218 HAL_StatusTypeDef HAL_USART_DeInit(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 219 {
mbed_official 376:cb4d9db17537 220 /* Check the USART handle allocation */
mbed_official 387:643a59b3dbac 221 if(husart == HAL_NULL)
mbed_official 376:cb4d9db17537 222 {
mbed_official 376:cb4d9db17537 223 return HAL_ERROR;
mbed_official 376:cb4d9db17537 224 }
mbed_official 376:cb4d9db17537 225
mbed_official 376:cb4d9db17537 226 /* Check the parameters */
mbed_official 376:cb4d9db17537 227 assert_param(IS_USART_INSTANCE(husart->Instance));
mbed_official 376:cb4d9db17537 228
mbed_official 376:cb4d9db17537 229 husart->State = HAL_USART_STATE_BUSY;
mbed_official 376:cb4d9db17537 230
mbed_official 376:cb4d9db17537 231 husart->Instance->CR1 = 0x0;
mbed_official 376:cb4d9db17537 232 husart->Instance->CR2 = 0x0;
mbed_official 376:cb4d9db17537 233 husart->Instance->CR3 = 0x0;
mbed_official 376:cb4d9db17537 234
mbed_official 376:cb4d9db17537 235 /* DeInit the low level hardware */
mbed_official 376:cb4d9db17537 236 HAL_USART_MspDeInit(husart);
mbed_official 376:cb4d9db17537 237
mbed_official 376:cb4d9db17537 238 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 239 husart->State = HAL_USART_STATE_RESET;
mbed_official 376:cb4d9db17537 240
mbed_official 376:cb4d9db17537 241 /* Release Lock */
mbed_official 376:cb4d9db17537 242 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 243
mbed_official 376:cb4d9db17537 244 return HAL_OK;
mbed_official 376:cb4d9db17537 245 }
mbed_official 376:cb4d9db17537 246
mbed_official 376:cb4d9db17537 247 /**
mbed_official 376:cb4d9db17537 248 * @brief USART MSP Init.
mbed_official 376:cb4d9db17537 249 * @param husart: USART handle
mbed_official 376:cb4d9db17537 250 * @retval None
mbed_official 376:cb4d9db17537 251 */
mbed_official 376:cb4d9db17537 252 __weak void HAL_USART_MspInit(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 253 {
mbed_official 376:cb4d9db17537 254 /* NOTE: This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 255 the HAL_USART_MspInit could be implenetd in the user file
mbed_official 376:cb4d9db17537 256 */
mbed_official 376:cb4d9db17537 257 }
mbed_official 376:cb4d9db17537 258
mbed_official 376:cb4d9db17537 259 /**
mbed_official 376:cb4d9db17537 260 * @brief USART MSP DeInit.
mbed_official 376:cb4d9db17537 261 * @param husart: USART handle
mbed_official 376:cb4d9db17537 262 * @retval None
mbed_official 376:cb4d9db17537 263 */
mbed_official 376:cb4d9db17537 264 __weak void HAL_USART_MspDeInit(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 265 {
mbed_official 376:cb4d9db17537 266 /* NOTE: This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 267 the HAL_USART_MspDeInit could be implenetd in the user file
mbed_official 376:cb4d9db17537 268 */
mbed_official 376:cb4d9db17537 269 }
mbed_official 376:cb4d9db17537 270
mbed_official 376:cb4d9db17537 271 /**
mbed_official 376:cb4d9db17537 272 * @}
mbed_official 376:cb4d9db17537 273 */
mbed_official 376:cb4d9db17537 274
mbed_official 376:cb4d9db17537 275 /** @defgroup USART_Group2 IO operation functions
mbed_official 376:cb4d9db17537 276 * @brief USART Transmit and Receive functions
mbed_official 376:cb4d9db17537 277 *
mbed_official 376:cb4d9db17537 278 @verbatim
mbed_official 376:cb4d9db17537 279 ===============================================================================
mbed_official 376:cb4d9db17537 280 ##### IO operation functions #####
mbed_official 376:cb4d9db17537 281 ===============================================================================
mbed_official 376:cb4d9db17537 282 [..]
mbed_official 376:cb4d9db17537 283 This subsection provides a set of functions allowing to manage the USART synchronous
mbed_official 376:cb4d9db17537 284 data transfers.
mbed_official 376:cb4d9db17537 285
mbed_official 376:cb4d9db17537 286 [..] The USART supports master mode only: it cannot receive or send data related to an input
mbed_official 376:cb4d9db17537 287 clock (SCLK is always an output).
mbed_official 376:cb4d9db17537 288
mbed_official 376:cb4d9db17537 289 (#) There are two modes of transfer:
mbed_official 376:cb4d9db17537 290 (++) Blocking mode: The communication is performed in polling mode.
mbed_official 376:cb4d9db17537 291 The HAL status of all data processing is returned by the same function
mbed_official 376:cb4d9db17537 292 after finishing transfer.
mbed_official 376:cb4d9db17537 293 (++) No-Blocking mode: The communication is performed using Interrupts
mbed_official 376:cb4d9db17537 294 or DMA, These API's return the HAL status.
mbed_official 376:cb4d9db17537 295 The end of the data processing will be indicated through the
mbed_official 376:cb4d9db17537 296 dedicated USART IRQ when using Interrupt mode or the DMA IRQ when
mbed_official 376:cb4d9db17537 297 using DMA mode.
mbed_official 376:cb4d9db17537 298 The HAL_USART_TxCpltCallback(), HAL_USART_RxCpltCallback() and HAL_USART_TxRxCpltCallback() user callbacks
mbed_official 376:cb4d9db17537 299 will be executed respectivelly at the end of the transmit or Receive process
mbed_official 376:cb4d9db17537 300 The HAL_USART_ErrorCallback()user callback will be executed when a communication error is detected.
mbed_official 376:cb4d9db17537 301
mbed_official 376:cb4d9db17537 302 (#) Blocking mode API's are :
mbed_official 376:cb4d9db17537 303 (++) HAL_USART_Transmit()in simplex mode
mbed_official 376:cb4d9db17537 304 (++) HAL_USART_Receive() in full duplex receive only
mbed_official 376:cb4d9db17537 305 (++) HAL_USART_TransmitReceive() in full duplex mode
mbed_official 376:cb4d9db17537 306
mbed_official 376:cb4d9db17537 307 (#) Non-Blocking mode API's with Interrupt are :
mbed_official 376:cb4d9db17537 308 (++) HAL_USART_Transmit_IT()in simplex mode
mbed_official 376:cb4d9db17537 309 (++) HAL_USART_Receive_IT() in full duplex receive only
mbed_official 376:cb4d9db17537 310 (++) HAL_USART_TransmitReceive_IT()in full duplex mode
mbed_official 376:cb4d9db17537 311 (++) HAL_USART_IRQHandler()
mbed_official 376:cb4d9db17537 312
mbed_official 376:cb4d9db17537 313 (#) No-Blocking mode functions with DMA are :
mbed_official 376:cb4d9db17537 314 (++) HAL_USART_Transmit_DMA()in simplex mode
mbed_official 376:cb4d9db17537 315 (++) HAL_USART_Receive_DMA() in full duplex receive only
mbed_official 376:cb4d9db17537 316 (++) HAL_USART_TransmitReceive_DMA() in full duplex mode
mbed_official 376:cb4d9db17537 317 (++) HAL_USART_DMAPause()
mbed_official 376:cb4d9db17537 318 (++) HAL_USART_DMAResume()
mbed_official 376:cb4d9db17537 319 (++) HAL_USART_DMAStop()
mbed_official 376:cb4d9db17537 320
mbed_official 376:cb4d9db17537 321 (#) A set of Transfer Complete Callbacks are provided in No_Blocking mode:
mbed_official 376:cb4d9db17537 322 (++) HAL_USART_TxCpltCallback()
mbed_official 376:cb4d9db17537 323 (++) HAL_USART_RxCpltCallback()
mbed_official 376:cb4d9db17537 324 (++) HAL_USART_TxHalfCpltCallback()
mbed_official 376:cb4d9db17537 325 (++) HAL_USART_RxHalfCpltCallback()
mbed_official 376:cb4d9db17537 326 (++) HAL_USART_ErrorCallback()
mbed_official 376:cb4d9db17537 327 (++) HAL_USART_TxRxCpltCallback()
mbed_official 376:cb4d9db17537 328
mbed_official 376:cb4d9db17537 329 @endverbatim
mbed_official 376:cb4d9db17537 330 * @{
mbed_official 376:cb4d9db17537 331 */
mbed_official 376:cb4d9db17537 332
mbed_official 376:cb4d9db17537 333 /**
mbed_official 376:cb4d9db17537 334 * @brief Simplex Send an amount of data in blocking mode
mbed_official 376:cb4d9db17537 335 * @param husart: USART handle
mbed_official 376:cb4d9db17537 336 * @param pTxData: Pointer to data buffer
mbed_official 376:cb4d9db17537 337 * @param Size: Amount of data to be sent
mbed_official 376:cb4d9db17537 338 * @param Timeout : Timeout duration
mbed_official 376:cb4d9db17537 339 * @retval HAL status
mbed_official 376:cb4d9db17537 340 */
mbed_official 376:cb4d9db17537 341 HAL_StatusTypeDef HAL_USART_Transmit(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size, uint32_t Timeout)
mbed_official 376:cb4d9db17537 342 {
mbed_official 376:cb4d9db17537 343 uint16_t* tmp;
mbed_official 376:cb4d9db17537 344
mbed_official 376:cb4d9db17537 345 if(husart->State == HAL_USART_STATE_READY)
mbed_official 376:cb4d9db17537 346 {
mbed_official 387:643a59b3dbac 347 if((pTxData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 348 {
mbed_official 376:cb4d9db17537 349 return HAL_ERROR;
mbed_official 376:cb4d9db17537 350 }
mbed_official 376:cb4d9db17537 351
mbed_official 376:cb4d9db17537 352 /* Process Locked */
mbed_official 376:cb4d9db17537 353 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 354
mbed_official 376:cb4d9db17537 355 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 356 husart->State = HAL_USART_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 357
mbed_official 376:cb4d9db17537 358 husart->TxXferSize = Size;
mbed_official 376:cb4d9db17537 359 husart->TxXferCount = Size;
mbed_official 376:cb4d9db17537 360
mbed_official 376:cb4d9db17537 361 /* Check the remaining data to be sent */
mbed_official 376:cb4d9db17537 362 while(husart->TxXferCount > 0)
mbed_official 376:cb4d9db17537 363 {
mbed_official 376:cb4d9db17537 364 husart->TxXferCount--;
mbed_official 376:cb4d9db17537 365 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 366 {
mbed_official 376:cb4d9db17537 367 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 368 }
mbed_official 376:cb4d9db17537 369 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 376:cb4d9db17537 370 {
mbed_official 376:cb4d9db17537 371 tmp = (uint16_t*) pTxData;
mbed_official 376:cb4d9db17537 372 husart->Instance->TDR = (*tmp & (uint16_t)0x01FF);
mbed_official 376:cb4d9db17537 373 pTxData += 2;
mbed_official 376:cb4d9db17537 374 }
mbed_official 376:cb4d9db17537 375 else
mbed_official 376:cb4d9db17537 376 {
mbed_official 376:cb4d9db17537 377 husart->Instance->TDR = (*pTxData++ & (uint8_t)0xFF);
mbed_official 376:cb4d9db17537 378 }
mbed_official 376:cb4d9db17537 379 }
mbed_official 376:cb4d9db17537 380
mbed_official 376:cb4d9db17537 381 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 382 {
mbed_official 376:cb4d9db17537 383 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 384 }
mbed_official 376:cb4d9db17537 385
mbed_official 376:cb4d9db17537 386 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 387
mbed_official 376:cb4d9db17537 388 /* Process Unlocked */
mbed_official 376:cb4d9db17537 389 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 390
mbed_official 376:cb4d9db17537 391 return HAL_OK;
mbed_official 376:cb4d9db17537 392 }
mbed_official 376:cb4d9db17537 393 else
mbed_official 376:cb4d9db17537 394 {
mbed_official 376:cb4d9db17537 395 return HAL_BUSY;
mbed_official 376:cb4d9db17537 396 }
mbed_official 376:cb4d9db17537 397 }
mbed_official 376:cb4d9db17537 398
mbed_official 376:cb4d9db17537 399 /**
mbed_official 376:cb4d9db17537 400 * @brief Receive an amount of data in blocking mode
mbed_official 376:cb4d9db17537 401 * To receive synchronous data, dummy data are simultaneously transmitted
mbed_official 376:cb4d9db17537 402 * @param husart: USART handle
mbed_official 376:cb4d9db17537 403 * @param pRxData: pointer to data buffer
mbed_official 376:cb4d9db17537 404 * @param Size: amount of data to be received
mbed_official 376:cb4d9db17537 405 * @param Timeout : Timeout duration
mbed_official 376:cb4d9db17537 406 * @retval HAL status
mbed_official 376:cb4d9db17537 407 */
mbed_official 376:cb4d9db17537 408 HAL_StatusTypeDef HAL_USART_Receive(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
mbed_official 376:cb4d9db17537 409 {
mbed_official 376:cb4d9db17537 410 uint16_t* tmp;
mbed_official 376:cb4d9db17537 411 uint16_t uhMask;
mbed_official 376:cb4d9db17537 412
mbed_official 376:cb4d9db17537 413 if(husart->State == HAL_USART_STATE_READY)
mbed_official 376:cb4d9db17537 414 {
mbed_official 387:643a59b3dbac 415 if((pRxData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 416 {
mbed_official 376:cb4d9db17537 417 return HAL_ERROR;
mbed_official 376:cb4d9db17537 418 }
mbed_official 376:cb4d9db17537 419 /* Process Locked */
mbed_official 376:cb4d9db17537 420 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 421
mbed_official 376:cb4d9db17537 422 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 423 husart->State = HAL_USART_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 424
mbed_official 376:cb4d9db17537 425 husart->RxXferSize = Size;
mbed_official 376:cb4d9db17537 426 husart->RxXferCount = Size;
mbed_official 376:cb4d9db17537 427
mbed_official 376:cb4d9db17537 428 /* Computation of USART mask to apply to RDR register */
mbed_official 376:cb4d9db17537 429 __HAL_USART_MASK_COMPUTATION(husart);
mbed_official 376:cb4d9db17537 430 uhMask = husart->Mask;
mbed_official 376:cb4d9db17537 431
mbed_official 376:cb4d9db17537 432 /* as long as data have to be received */
mbed_official 376:cb4d9db17537 433 while(husart->RxXferCount > 0)
mbed_official 376:cb4d9db17537 434 {
mbed_official 376:cb4d9db17537 435 husart->RxXferCount--;
mbed_official 376:cb4d9db17537 436
mbed_official 376:cb4d9db17537 437 /* Wait until TXE flag is set to send dummy byte in order to generate the
mbed_official 376:cb4d9db17537 438 * clock for the slave to send data.
mbed_official 376:cb4d9db17537 439 * Whatever the frame length (7, 8 or 9-bit long), the same dummy value
mbed_official 376:cb4d9db17537 440 * can be written for all the cases. */
mbed_official 376:cb4d9db17537 441 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 442 {
mbed_official 376:cb4d9db17537 443 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 444 }
mbed_official 376:cb4d9db17537 445 husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x0FF);
mbed_official 376:cb4d9db17537 446
mbed_official 376:cb4d9db17537 447 /* Wait for RXNE Flag */
mbed_official 376:cb4d9db17537 448 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 449 {
mbed_official 376:cb4d9db17537 450 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 451 }
mbed_official 376:cb4d9db17537 452
mbed_official 376:cb4d9db17537 453 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 376:cb4d9db17537 454 {
mbed_official 376:cb4d9db17537 455 tmp = (uint16_t*) pRxData ;
mbed_official 376:cb4d9db17537 456 *tmp = (uint16_t)(husart->Instance->RDR & uhMask);
mbed_official 376:cb4d9db17537 457 pRxData +=2;
mbed_official 376:cb4d9db17537 458 }
mbed_official 376:cb4d9db17537 459 else
mbed_official 376:cb4d9db17537 460 {
mbed_official 376:cb4d9db17537 461 *pRxData++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);
mbed_official 376:cb4d9db17537 462 }
mbed_official 376:cb4d9db17537 463 }
mbed_official 376:cb4d9db17537 464
mbed_official 376:cb4d9db17537 465 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 466
mbed_official 376:cb4d9db17537 467 /* Process Unlocked */
mbed_official 376:cb4d9db17537 468 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 469
mbed_official 376:cb4d9db17537 470 return HAL_OK;
mbed_official 376:cb4d9db17537 471 }
mbed_official 376:cb4d9db17537 472 else
mbed_official 376:cb4d9db17537 473 {
mbed_official 376:cb4d9db17537 474 return HAL_BUSY;
mbed_official 376:cb4d9db17537 475 }
mbed_official 376:cb4d9db17537 476 }
mbed_official 376:cb4d9db17537 477
mbed_official 376:cb4d9db17537 478 /**
mbed_official 376:cb4d9db17537 479 * @brief Full-Duplex Send and Receive an amount of data in blocking mode
mbed_official 376:cb4d9db17537 480 * @param husart: USART handle
mbed_official 376:cb4d9db17537 481 * @param pTxData: pointer to TX data buffer
mbed_official 376:cb4d9db17537 482 * @param pRxData: pointer to RX data buffer
mbed_official 376:cb4d9db17537 483 * @param Size: amount of data to be sent (same amount to be received)
mbed_official 376:cb4d9db17537 484 * @param Timeout : Timeout duration
mbed_official 376:cb4d9db17537 485 * @retval HAL status
mbed_official 376:cb4d9db17537 486 */
mbed_official 376:cb4d9db17537 487 HAL_StatusTypeDef HAL_USART_TransmitReceive(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
mbed_official 376:cb4d9db17537 488 {
mbed_official 376:cb4d9db17537 489 uint16_t* tmp;
mbed_official 376:cb4d9db17537 490 uint16_t uhMask;
mbed_official 376:cb4d9db17537 491
mbed_official 376:cb4d9db17537 492 if(husart->State == HAL_USART_STATE_READY)
mbed_official 376:cb4d9db17537 493 {
mbed_official 387:643a59b3dbac 494 if((pTxData == HAL_NULL) || (pRxData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 495 {
mbed_official 376:cb4d9db17537 496 return HAL_ERROR;
mbed_official 376:cb4d9db17537 497 }
mbed_official 376:cb4d9db17537 498 /* Process Locked */
mbed_official 376:cb4d9db17537 499 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 500
mbed_official 376:cb4d9db17537 501 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 502 husart->State = HAL_USART_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 503
mbed_official 376:cb4d9db17537 504 husart->RxXferSize = Size;
mbed_official 376:cb4d9db17537 505 husart->TxXferSize = Size;
mbed_official 376:cb4d9db17537 506 husart->TxXferCount = Size;
mbed_official 376:cb4d9db17537 507 husart->RxXferCount = Size;
mbed_official 376:cb4d9db17537 508
mbed_official 376:cb4d9db17537 509 /* Computation of USART mask to apply to RDR register */
mbed_official 376:cb4d9db17537 510 __HAL_USART_MASK_COMPUTATION(husart);
mbed_official 376:cb4d9db17537 511 uhMask = husart->Mask;
mbed_official 376:cb4d9db17537 512
mbed_official 376:cb4d9db17537 513 /* Check the remain data to be sent */
mbed_official 376:cb4d9db17537 514 while(husart->TxXferCount > 0)
mbed_official 376:cb4d9db17537 515 {
mbed_official 376:cb4d9db17537 516 husart->TxXferCount--;
mbed_official 376:cb4d9db17537 517 husart->RxXferCount--;
mbed_official 376:cb4d9db17537 518
mbed_official 376:cb4d9db17537 519 /* Wait until TXE flag is set to send data */
mbed_official 376:cb4d9db17537 520 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 521 {
mbed_official 376:cb4d9db17537 522 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 523 }
mbed_official 376:cb4d9db17537 524 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 376:cb4d9db17537 525 {
mbed_official 376:cb4d9db17537 526 tmp = (uint16_t*) pTxData;
mbed_official 376:cb4d9db17537 527 husart->Instance->TDR = (*tmp & uhMask);
mbed_official 376:cb4d9db17537 528 pTxData += 2;
mbed_official 376:cb4d9db17537 529 }
mbed_official 376:cb4d9db17537 530 else
mbed_official 376:cb4d9db17537 531 {
mbed_official 376:cb4d9db17537 532 husart->Instance->TDR = (*pTxData++ & (uint8_t)uhMask);
mbed_official 376:cb4d9db17537 533 }
mbed_official 376:cb4d9db17537 534
mbed_official 376:cb4d9db17537 535 /* Wait for RXNE Flag */
mbed_official 376:cb4d9db17537 536 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, Timeout) != HAL_OK)
mbed_official 376:cb4d9db17537 537 {
mbed_official 376:cb4d9db17537 538 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 539 }
mbed_official 376:cb4d9db17537 540
mbed_official 376:cb4d9db17537 541 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 376:cb4d9db17537 542 {
mbed_official 376:cb4d9db17537 543 tmp = (uint16_t*) pRxData ;
mbed_official 376:cb4d9db17537 544 *tmp = (uint16_t)(husart->Instance->RDR & uhMask);
mbed_official 376:cb4d9db17537 545 pRxData +=2;
mbed_official 376:cb4d9db17537 546 }
mbed_official 376:cb4d9db17537 547 else
mbed_official 376:cb4d9db17537 548 {
mbed_official 376:cb4d9db17537 549 *pRxData++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);
mbed_official 376:cb4d9db17537 550 }
mbed_official 376:cb4d9db17537 551 }
mbed_official 376:cb4d9db17537 552
mbed_official 376:cb4d9db17537 553 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 554
mbed_official 376:cb4d9db17537 555 /* Process Unlocked */
mbed_official 376:cb4d9db17537 556 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 557
mbed_official 376:cb4d9db17537 558 return HAL_OK;
mbed_official 376:cb4d9db17537 559 }
mbed_official 376:cb4d9db17537 560 else
mbed_official 376:cb4d9db17537 561 {
mbed_official 376:cb4d9db17537 562 return HAL_BUSY;
mbed_official 376:cb4d9db17537 563 }
mbed_official 376:cb4d9db17537 564 }
mbed_official 376:cb4d9db17537 565
mbed_official 376:cb4d9db17537 566 /**
mbed_official 376:cb4d9db17537 567 * @brief Send an amount of data in interrupt mode
mbed_official 376:cb4d9db17537 568 * @param husart: USART handle
mbed_official 376:cb4d9db17537 569 * @param pTxData: Pointer to data buffer
mbed_official 376:cb4d9db17537 570 * @param Size: Amount of data to be sent
mbed_official 376:cb4d9db17537 571 * @retval HAL status
mbed_official 376:cb4d9db17537 572 */
mbed_official 376:cb4d9db17537 573 HAL_StatusTypeDef HAL_USART_Transmit_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size)
mbed_official 376:cb4d9db17537 574 {
mbed_official 376:cb4d9db17537 575 if(husart->State == HAL_USART_STATE_READY)
mbed_official 376:cb4d9db17537 576 {
mbed_official 387:643a59b3dbac 577 if((pTxData == HAL_NULL ) || (Size == 0))
mbed_official 376:cb4d9db17537 578 {
mbed_official 376:cb4d9db17537 579 return HAL_ERROR;
mbed_official 376:cb4d9db17537 580 }
mbed_official 376:cb4d9db17537 581
mbed_official 376:cb4d9db17537 582 /* Process Locked */
mbed_official 376:cb4d9db17537 583 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 584
mbed_official 376:cb4d9db17537 585 husart->pTxBuffPtr = pTxData;
mbed_official 376:cb4d9db17537 586 husart->TxXferSize = Size;
mbed_official 376:cb4d9db17537 587 husart->TxXferCount = Size;
mbed_official 376:cb4d9db17537 588
mbed_official 376:cb4d9db17537 589 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 590 husart->State = HAL_USART_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 591
mbed_official 376:cb4d9db17537 592 /* The USART Error Interrupts: (Frame error, noise error, overrun error)
mbed_official 376:cb4d9db17537 593 are not managed by the USART Transmit Process to avoid the overrun interrupt
mbed_official 376:cb4d9db17537 594 when the usart mode is configured for transmit and receive "USART_MODE_TX_RX"
mbed_official 376:cb4d9db17537 595 to benefit for the frame error and noise interrupts the usart mode should be
mbed_official 376:cb4d9db17537 596 configured only for transmit "USART_MODE_TX" */
mbed_official 376:cb4d9db17537 597
mbed_official 376:cb4d9db17537 598 /* Process Unlocked */
mbed_official 376:cb4d9db17537 599 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 600
mbed_official 376:cb4d9db17537 601 /* Enable the USART Transmit Complete Interrupt */
mbed_official 376:cb4d9db17537 602 __HAL_USART_ENABLE_IT(husart, USART_IT_TXE);
mbed_official 376:cb4d9db17537 603
mbed_official 376:cb4d9db17537 604 return HAL_OK;
mbed_official 376:cb4d9db17537 605 }
mbed_official 376:cb4d9db17537 606 else
mbed_official 376:cb4d9db17537 607 {
mbed_official 376:cb4d9db17537 608 return HAL_BUSY;
mbed_official 376:cb4d9db17537 609 }
mbed_official 376:cb4d9db17537 610 }
mbed_official 376:cb4d9db17537 611
mbed_official 376:cb4d9db17537 612 /**
mbed_official 376:cb4d9db17537 613 * @brief Receive an amount of data in blocking mode
mbed_official 376:cb4d9db17537 614 * To receive synchronous data, dummy data are simultaneously transmitted
mbed_official 376:cb4d9db17537 615 * @param husart: usart handle
mbed_official 376:cb4d9db17537 616 * @param pRxData: pointer to data buffer
mbed_official 376:cb4d9db17537 617 * @param Size: amount of data to be received
mbed_official 376:cb4d9db17537 618 * @retval HAL status
mbed_official 376:cb4d9db17537 619 */
mbed_official 376:cb4d9db17537 620 HAL_StatusTypeDef HAL_USART_Receive_IT(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)
mbed_official 376:cb4d9db17537 621 {
mbed_official 376:cb4d9db17537 622 if(husart->State == HAL_USART_STATE_READY)
mbed_official 376:cb4d9db17537 623 {
mbed_official 387:643a59b3dbac 624 if((pRxData == HAL_NULL ) || (Size == 0))
mbed_official 376:cb4d9db17537 625 {
mbed_official 376:cb4d9db17537 626 return HAL_ERROR;
mbed_official 376:cb4d9db17537 627 }
mbed_official 376:cb4d9db17537 628 /* Process Locked */
mbed_official 376:cb4d9db17537 629 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 630
mbed_official 376:cb4d9db17537 631 husart->pRxBuffPtr = pRxData;
mbed_official 376:cb4d9db17537 632 husart->RxXferSize = Size;
mbed_official 376:cb4d9db17537 633 husart->RxXferCount = Size;
mbed_official 376:cb4d9db17537 634
mbed_official 376:cb4d9db17537 635 __HAL_USART_MASK_COMPUTATION(husart);
mbed_official 376:cb4d9db17537 636
mbed_official 376:cb4d9db17537 637 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 638 husart->State = HAL_USART_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 639
mbed_official 376:cb4d9db17537 640 /* Enable the USART Parity Error Interrupt */
mbed_official 376:cb4d9db17537 641 __HAL_USART_ENABLE_IT(husart, USART_IT_PE);
mbed_official 376:cb4d9db17537 642
mbed_official 376:cb4d9db17537 643 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 644 __HAL_USART_ENABLE_IT(husart, USART_IT_ERR);
mbed_official 376:cb4d9db17537 645
mbed_official 376:cb4d9db17537 646 /* Enable the USART Data Register not empty Interrupt */
mbed_official 376:cb4d9db17537 647 __HAL_USART_ENABLE_IT(husart, USART_IT_RXNE);
mbed_official 376:cb4d9db17537 648
mbed_official 376:cb4d9db17537 649 /* Process Unlocked */
mbed_official 376:cb4d9db17537 650 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 651
mbed_official 376:cb4d9db17537 652 /* Send dummy byte in order to generate the clock for the Slave to send the next data */
mbed_official 376:cb4d9db17537 653 if(husart->Init.WordLength == USART_WORDLENGTH_9B)
mbed_official 376:cb4d9db17537 654 {
mbed_official 376:cb4d9db17537 655 husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x01FF);
mbed_official 376:cb4d9db17537 656 }
mbed_official 376:cb4d9db17537 657 else
mbed_official 376:cb4d9db17537 658 {
mbed_official 376:cb4d9db17537 659 husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x00FF);
mbed_official 376:cb4d9db17537 660 }
mbed_official 376:cb4d9db17537 661
mbed_official 376:cb4d9db17537 662 return HAL_OK;
mbed_official 376:cb4d9db17537 663 }
mbed_official 376:cb4d9db17537 664 else
mbed_official 376:cb4d9db17537 665 {
mbed_official 376:cb4d9db17537 666 return HAL_BUSY;
mbed_official 376:cb4d9db17537 667 }
mbed_official 376:cb4d9db17537 668 }
mbed_official 376:cb4d9db17537 669
mbed_official 376:cb4d9db17537 670 /**
mbed_official 376:cb4d9db17537 671 * @brief Full-Duplex Send and Receive an amount of data in interrupt mode
mbed_official 376:cb4d9db17537 672 * @param husart: USART handle
mbed_official 376:cb4d9db17537 673 * @param pTxData: pointer to TX data buffer
mbed_official 376:cb4d9db17537 674 * @param pRxData: pointer to RX data buffer
mbed_official 376:cb4d9db17537 675 * @param Size: amount of data to be sent (same amount to be received)
mbed_official 376:cb4d9db17537 676 * @retval HAL status
mbed_official 376:cb4d9db17537 677 */
mbed_official 376:cb4d9db17537 678 HAL_StatusTypeDef HAL_USART_TransmitReceive_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
mbed_official 376:cb4d9db17537 679 {
mbed_official 376:cb4d9db17537 680 if(husart->State == HAL_USART_STATE_READY)
mbed_official 376:cb4d9db17537 681 {
mbed_official 387:643a59b3dbac 682 if((pTxData == HAL_NULL) || (pRxData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 683 {
mbed_official 376:cb4d9db17537 684 return HAL_ERROR;
mbed_official 376:cb4d9db17537 685 }
mbed_official 376:cb4d9db17537 686 /* Process Locked */
mbed_official 376:cb4d9db17537 687 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 688
mbed_official 376:cb4d9db17537 689 husart->pRxBuffPtr = pRxData;
mbed_official 376:cb4d9db17537 690 husart->RxXferSize = Size;
mbed_official 376:cb4d9db17537 691 husart->RxXferCount = Size;
mbed_official 376:cb4d9db17537 692 husart->pTxBuffPtr = pTxData;
mbed_official 376:cb4d9db17537 693 husart->TxXferSize = Size;
mbed_official 376:cb4d9db17537 694 husart->TxXferCount = Size;
mbed_official 376:cb4d9db17537 695
mbed_official 376:cb4d9db17537 696 /* Computation of USART mask to apply to RDR register */
mbed_official 376:cb4d9db17537 697 __HAL_USART_MASK_COMPUTATION(husart);
mbed_official 376:cb4d9db17537 698
mbed_official 376:cb4d9db17537 699 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 700 husart->State = HAL_USART_STATE_BUSY_TX_RX;
mbed_official 376:cb4d9db17537 701
mbed_official 376:cb4d9db17537 702 /* Enable the USART Data Register not empty Interrupt */
mbed_official 376:cb4d9db17537 703 __HAL_USART_ENABLE_IT(husart, USART_IT_RXNE);
mbed_official 376:cb4d9db17537 704
mbed_official 376:cb4d9db17537 705 /* Enable the USART Parity Error Interrupt */
mbed_official 376:cb4d9db17537 706 __HAL_USART_ENABLE_IT(husart, USART_IT_PE);
mbed_official 376:cb4d9db17537 707
mbed_official 376:cb4d9db17537 708 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 709 __HAL_USART_ENABLE_IT(husart, USART_IT_ERR);
mbed_official 376:cb4d9db17537 710
mbed_official 376:cb4d9db17537 711 /* Process Unlocked */
mbed_official 376:cb4d9db17537 712 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 713
mbed_official 376:cb4d9db17537 714 /* Enable the USART Transmit Complete Interrupt */
mbed_official 376:cb4d9db17537 715 __HAL_USART_ENABLE_IT(husart, USART_IT_TXE);
mbed_official 376:cb4d9db17537 716
mbed_official 376:cb4d9db17537 717 return HAL_OK;
mbed_official 376:cb4d9db17537 718 }
mbed_official 376:cb4d9db17537 719 else
mbed_official 376:cb4d9db17537 720 {
mbed_official 376:cb4d9db17537 721 return HAL_BUSY;
mbed_official 376:cb4d9db17537 722 }
mbed_official 376:cb4d9db17537 723 }
mbed_official 376:cb4d9db17537 724
mbed_official 376:cb4d9db17537 725 /**
mbed_official 376:cb4d9db17537 726 * @brief Send an amount of data in DMA mode
mbed_official 376:cb4d9db17537 727 * @param husart: USART handle
mbed_official 376:cb4d9db17537 728 * @param pTxData: pointer to data buffer
mbed_official 376:cb4d9db17537 729 * @param Size: amount of data to be sent
mbed_official 376:cb4d9db17537 730 * @retval HAL status
mbed_official 376:cb4d9db17537 731 */
mbed_official 376:cb4d9db17537 732 HAL_StatusTypeDef HAL_USART_Transmit_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size)
mbed_official 376:cb4d9db17537 733 {
mbed_official 376:cb4d9db17537 734 uint32_t *tmp;
mbed_official 376:cb4d9db17537 735
mbed_official 376:cb4d9db17537 736 if(husart->State == HAL_USART_STATE_READY)
mbed_official 376:cb4d9db17537 737 {
mbed_official 387:643a59b3dbac 738 if((pTxData == HAL_NULL ) || (Size == 0))
mbed_official 376:cb4d9db17537 739 {
mbed_official 376:cb4d9db17537 740 return HAL_ERROR;
mbed_official 376:cb4d9db17537 741 }
mbed_official 376:cb4d9db17537 742 /* Process Locked */
mbed_official 376:cb4d9db17537 743 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 744
mbed_official 376:cb4d9db17537 745 husart->pTxBuffPtr = pTxData;
mbed_official 376:cb4d9db17537 746 husart->TxXferSize = Size;
mbed_official 376:cb4d9db17537 747 husart->TxXferCount = Size;
mbed_official 376:cb4d9db17537 748
mbed_official 376:cb4d9db17537 749 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 750 husart->State = HAL_USART_STATE_BUSY_TX;
mbed_official 376:cb4d9db17537 751
mbed_official 376:cb4d9db17537 752 /* Set the USART DMA transfer complete callback */
mbed_official 376:cb4d9db17537 753 husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;
mbed_official 376:cb4d9db17537 754
mbed_official 376:cb4d9db17537 755 /* Set the USART DMA Half transfer complete callback */
mbed_official 376:cb4d9db17537 756 husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;
mbed_official 376:cb4d9db17537 757
mbed_official 376:cb4d9db17537 758 /* Set the DMA error callback */
mbed_official 376:cb4d9db17537 759 husart->hdmatx->XferErrorCallback = USART_DMAError;
mbed_official 376:cb4d9db17537 760
mbed_official 376:cb4d9db17537 761 /* Enable the USART transmit DMA channel */
mbed_official 376:cb4d9db17537 762 tmp = (uint32_t*)&pTxData;
mbed_official 376:cb4d9db17537 763 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->TDR, Size);
mbed_official 376:cb4d9db17537 764
mbed_official 376:cb4d9db17537 765 /* Enable the DMA transfer for transmit request by setting the DMAT bit
mbed_official 376:cb4d9db17537 766 in the USART CR3 register */
mbed_official 376:cb4d9db17537 767 husart->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 768
mbed_official 376:cb4d9db17537 769 /* Process Unlocked */
mbed_official 376:cb4d9db17537 770 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 771
mbed_official 376:cb4d9db17537 772 return HAL_OK;
mbed_official 376:cb4d9db17537 773 }
mbed_official 376:cb4d9db17537 774 else
mbed_official 376:cb4d9db17537 775 {
mbed_official 376:cb4d9db17537 776 return HAL_BUSY;
mbed_official 376:cb4d9db17537 777 }
mbed_official 376:cb4d9db17537 778 }
mbed_official 376:cb4d9db17537 779
mbed_official 376:cb4d9db17537 780 /**
mbed_official 376:cb4d9db17537 781 * @brief Receive an amount of data in DMA mode
mbed_official 376:cb4d9db17537 782 * @param husart: USART handle
mbed_official 376:cb4d9db17537 783 * @param pRxData: pointer to data buffer
mbed_official 376:cb4d9db17537 784 * @param Size: amount of data to be received
mbed_official 376:cb4d9db17537 785 * @note When the USART parity is enabled (PCE = 1), the received data contain
mbed_official 376:cb4d9db17537 786 * the parity bit (MSB position)
mbed_official 376:cb4d9db17537 787 * @retval HAL status
mbed_official 376:cb4d9db17537 788 * @note The USART DMA transmit stream must be configured in order to generate the clock for the slave.
mbed_official 376:cb4d9db17537 789 */
mbed_official 376:cb4d9db17537 790 HAL_StatusTypeDef HAL_USART_Receive_DMA(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)
mbed_official 376:cb4d9db17537 791 {
mbed_official 376:cb4d9db17537 792 uint32_t *tmp;
mbed_official 376:cb4d9db17537 793
mbed_official 376:cb4d9db17537 794 if(husart->State == HAL_USART_STATE_READY)
mbed_official 376:cb4d9db17537 795 {
mbed_official 387:643a59b3dbac 796 if((pRxData == HAL_NULL ) || (Size == 0))
mbed_official 376:cb4d9db17537 797 {
mbed_official 376:cb4d9db17537 798 return HAL_ERROR;
mbed_official 376:cb4d9db17537 799 }
mbed_official 376:cb4d9db17537 800
mbed_official 376:cb4d9db17537 801 /* Process Locked */
mbed_official 376:cb4d9db17537 802 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 803
mbed_official 376:cb4d9db17537 804 husart->pRxBuffPtr = pRxData;
mbed_official 376:cb4d9db17537 805 husart->RxXferSize = Size;
mbed_official 376:cb4d9db17537 806 husart->pTxBuffPtr = pRxData;
mbed_official 376:cb4d9db17537 807 husart->TxXferSize = Size;
mbed_official 376:cb4d9db17537 808
mbed_official 376:cb4d9db17537 809 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 810 husart->State = HAL_USART_STATE_BUSY_RX;
mbed_official 376:cb4d9db17537 811
mbed_official 376:cb4d9db17537 812 /* Set the USART DMA Rx transfer complete callback */
mbed_official 376:cb4d9db17537 813 husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;
mbed_official 376:cb4d9db17537 814
mbed_official 376:cb4d9db17537 815 /* Set the USART DMA Half transfer complete callback */
mbed_official 376:cb4d9db17537 816 husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;
mbed_official 376:cb4d9db17537 817
mbed_official 376:cb4d9db17537 818 /* Set the USART DMA Rx transfer error callback */
mbed_official 376:cb4d9db17537 819 husart->hdmarx->XferErrorCallback = USART_DMAError;
mbed_official 376:cb4d9db17537 820
mbed_official 376:cb4d9db17537 821 /* Enable the USART receive DMA Stream */
mbed_official 376:cb4d9db17537 822 tmp = (uint32_t*)&pRxData;
mbed_official 376:cb4d9db17537 823 HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->RDR, *(uint32_t*)tmp, Size);
mbed_official 376:cb4d9db17537 824
mbed_official 376:cb4d9db17537 825 /* Enable the USART transmit DMA channel: the transmit channel is used in order
mbed_official 376:cb4d9db17537 826 to generate in the non-blocking mode the clock to the slave device,
mbed_official 376:cb4d9db17537 827 this mode isn't a simplex receive mode but a full-duplex receive mode */
mbed_official 376:cb4d9db17537 828 tmp = (uint32_t*)&pRxData;
mbed_official 376:cb4d9db17537 829 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->TDR, Size);
mbed_official 376:cb4d9db17537 830
mbed_official 376:cb4d9db17537 831 /* Clear the Overrun flag just before enabling the DMA Rx request: mandatory for the second transfer
mbed_official 376:cb4d9db17537 832 when using the USART in circular mode */
mbed_official 376:cb4d9db17537 833 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_OREF);
mbed_official 376:cb4d9db17537 834
mbed_official 376:cb4d9db17537 835 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official 376:cb4d9db17537 836 in the USART CR3 register */
mbed_official 376:cb4d9db17537 837 husart->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 838
mbed_official 376:cb4d9db17537 839 /* Enable the DMA transfer for transmit request by setting the DMAT bit
mbed_official 376:cb4d9db17537 840 in the USART CR3 register */
mbed_official 376:cb4d9db17537 841 husart->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 842
mbed_official 376:cb4d9db17537 843 /* Process Unlocked */
mbed_official 376:cb4d9db17537 844 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 845
mbed_official 376:cb4d9db17537 846 return HAL_OK;
mbed_official 376:cb4d9db17537 847 }
mbed_official 376:cb4d9db17537 848 else
mbed_official 376:cb4d9db17537 849 {
mbed_official 376:cb4d9db17537 850 return HAL_BUSY;
mbed_official 376:cb4d9db17537 851 }
mbed_official 376:cb4d9db17537 852 }
mbed_official 376:cb4d9db17537 853
mbed_official 376:cb4d9db17537 854 /**
mbed_official 376:cb4d9db17537 855 * @brief Full-Duplex Transmit Receive an amount of data in non blocking mode
mbed_official 376:cb4d9db17537 856 * @param husart: usart handle
mbed_official 376:cb4d9db17537 857 * @param pTxData: pointer to TX data buffer
mbed_official 376:cb4d9db17537 858 * @param pRxData: pointer to RX data buffer
mbed_official 376:cb4d9db17537 859 * @param Size: amount of data to be received/sent
mbed_official 376:cb4d9db17537 860 * @note When the USART parity is enabled (PCE = 1) the data received contain the parity bit.
mbed_official 376:cb4d9db17537 861 * @retval HAL status
mbed_official 376:cb4d9db17537 862 */
mbed_official 376:cb4d9db17537 863 HAL_StatusTypeDef HAL_USART_TransmitReceive_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
mbed_official 376:cb4d9db17537 864 {
mbed_official 376:cb4d9db17537 865 uint32_t *tmp;
mbed_official 376:cb4d9db17537 866
mbed_official 376:cb4d9db17537 867 if(husart->State == HAL_USART_STATE_READY)
mbed_official 376:cb4d9db17537 868 {
mbed_official 387:643a59b3dbac 869 if((pTxData == HAL_NULL) || (pRxData == HAL_NULL) || (Size == 0))
mbed_official 376:cb4d9db17537 870 {
mbed_official 376:cb4d9db17537 871 return HAL_ERROR;
mbed_official 376:cb4d9db17537 872 }
mbed_official 376:cb4d9db17537 873 /* Process Locked */
mbed_official 376:cb4d9db17537 874 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 875
mbed_official 376:cb4d9db17537 876 husart->pRxBuffPtr = pRxData;
mbed_official 376:cb4d9db17537 877 husart->RxXferSize = Size;
mbed_official 376:cb4d9db17537 878 husart->pTxBuffPtr = pTxData;
mbed_official 376:cb4d9db17537 879 husart->TxXferSize = Size;
mbed_official 376:cb4d9db17537 880
mbed_official 376:cb4d9db17537 881 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 882 husart->State = HAL_USART_STATE_BUSY_TX_RX;
mbed_official 376:cb4d9db17537 883
mbed_official 376:cb4d9db17537 884 /* Set the USART DMA Rx transfer complete callback */
mbed_official 376:cb4d9db17537 885 husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;
mbed_official 376:cb4d9db17537 886
mbed_official 376:cb4d9db17537 887 /* Set the USART DMA Half transfer complete callback */
mbed_official 376:cb4d9db17537 888 husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;
mbed_official 376:cb4d9db17537 889
mbed_official 376:cb4d9db17537 890 /* Set the USART DMA Tx transfer complete callback */
mbed_official 376:cb4d9db17537 891 husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;
mbed_official 376:cb4d9db17537 892
mbed_official 376:cb4d9db17537 893 /* Set the USART DMA Half transfer complete callback */
mbed_official 376:cb4d9db17537 894 husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;
mbed_official 376:cb4d9db17537 895
mbed_official 376:cb4d9db17537 896 /* Set the USART DMA Tx transfer error callback */
mbed_official 376:cb4d9db17537 897 husart->hdmatx->XferErrorCallback = USART_DMAError;
mbed_official 376:cb4d9db17537 898
mbed_official 376:cb4d9db17537 899 /* Set the USART DMA Rx transfer error callback */
mbed_official 376:cb4d9db17537 900 husart->hdmarx->XferErrorCallback = USART_DMAError;
mbed_official 376:cb4d9db17537 901
mbed_official 376:cb4d9db17537 902 /* Enable the USART receive DMA Stream */
mbed_official 376:cb4d9db17537 903 tmp = (uint32_t*)&pRxData;
mbed_official 376:cb4d9db17537 904 HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->RDR, *(uint32_t*)tmp, Size);
mbed_official 376:cb4d9db17537 905
mbed_official 376:cb4d9db17537 906 /* Enable the USART transmit DMA Stream */
mbed_official 376:cb4d9db17537 907 tmp = (uint32_t*)&pTxData;
mbed_official 376:cb4d9db17537 908 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->TDR, Size);
mbed_official 376:cb4d9db17537 909
mbed_official 376:cb4d9db17537 910 /* Clear the Overrun flag: mandatory for the second transfer in circular mode */
mbed_official 376:cb4d9db17537 911 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_OREF);
mbed_official 376:cb4d9db17537 912
mbed_official 376:cb4d9db17537 913 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
mbed_official 376:cb4d9db17537 914 in the USART CR3 register */
mbed_official 376:cb4d9db17537 915 husart->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 916
mbed_official 376:cb4d9db17537 917 /* Enable the DMA transfer for transmit request by setting the DMAT bit
mbed_official 376:cb4d9db17537 918 in the USART CR3 register */
mbed_official 376:cb4d9db17537 919 husart->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 920
mbed_official 376:cb4d9db17537 921 /* Process Unlocked */
mbed_official 376:cb4d9db17537 922 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 923
mbed_official 376:cb4d9db17537 924 return HAL_OK;
mbed_official 376:cb4d9db17537 925 }
mbed_official 376:cb4d9db17537 926 else
mbed_official 376:cb4d9db17537 927 {
mbed_official 376:cb4d9db17537 928 return HAL_BUSY;
mbed_official 376:cb4d9db17537 929 }
mbed_official 376:cb4d9db17537 930 }
mbed_official 376:cb4d9db17537 931
mbed_official 376:cb4d9db17537 932 /**
mbed_official 376:cb4d9db17537 933 * @brief Pauses the DMA Transfer.
mbed_official 376:cb4d9db17537 934 * @param husart: USART handle
mbed_official 376:cb4d9db17537 935 * @retval None
mbed_official 376:cb4d9db17537 936 */
mbed_official 376:cb4d9db17537 937 HAL_StatusTypeDef HAL_USART_DMAPause(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 938 {
mbed_official 376:cb4d9db17537 939 /* Process Locked */
mbed_official 376:cb4d9db17537 940 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 941
mbed_official 376:cb4d9db17537 942 /* Disable the USART DMA Tx request */
mbed_official 376:cb4d9db17537 943 husart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
mbed_official 376:cb4d9db17537 944
mbed_official 376:cb4d9db17537 945 /* Process Unlocked */
mbed_official 376:cb4d9db17537 946 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 947
mbed_official 376:cb4d9db17537 948 return HAL_OK;
mbed_official 376:cb4d9db17537 949 }
mbed_official 376:cb4d9db17537 950
mbed_official 376:cb4d9db17537 951 /**
mbed_official 376:cb4d9db17537 952 * @brief Resumes the DMA Transfer.
mbed_official 376:cb4d9db17537 953 * @param husart: USART handle
mbed_official 376:cb4d9db17537 954 * @retval None
mbed_official 376:cb4d9db17537 955 */
mbed_official 376:cb4d9db17537 956 HAL_StatusTypeDef HAL_USART_DMAResume(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 957 {
mbed_official 376:cb4d9db17537 958 /* Process Locked */
mbed_official 376:cb4d9db17537 959 __HAL_LOCK(husart);
mbed_official 376:cb4d9db17537 960
mbed_official 376:cb4d9db17537 961 /* Enable the USART DMA Tx request */
mbed_official 376:cb4d9db17537 962 husart->Instance->CR3 |= USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 963
mbed_official 376:cb4d9db17537 964 /* Process Unlocked */
mbed_official 376:cb4d9db17537 965 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 966
mbed_official 376:cb4d9db17537 967 return HAL_OK;
mbed_official 376:cb4d9db17537 968 }
mbed_official 376:cb4d9db17537 969
mbed_official 376:cb4d9db17537 970 /**
mbed_official 376:cb4d9db17537 971 * @brief Stops the DMA Transfer.
mbed_official 376:cb4d9db17537 972 * @param husart: USART handle
mbed_official 376:cb4d9db17537 973 * @retval None
mbed_official 376:cb4d9db17537 974 */
mbed_official 376:cb4d9db17537 975 HAL_StatusTypeDef HAL_USART_DMAStop(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 976 {
mbed_official 376:cb4d9db17537 977 /* The Lock is not implemented on this API to allow the user application
mbed_official 376:cb4d9db17537 978 to call the HAL USART API under callbacks HAL_USART_TxCpltCallback() / HAL_USART_RxCpltCallback():
mbed_official 376:cb4d9db17537 979 when calling HAL_DMA_Abort() API the DMA TX/RX Transfer complete interrupt is generated
mbed_official 376:cb4d9db17537 980 and the correspond call back is executed HAL_USART_TxCpltCallback() / HAL_USART_RxCpltCallback()
mbed_official 376:cb4d9db17537 981 */
mbed_official 376:cb4d9db17537 982
mbed_official 376:cb4d9db17537 983 /* Abort the USART DMA tx Stream */
mbed_official 387:643a59b3dbac 984 if(husart->hdmatx != HAL_NULL)
mbed_official 376:cb4d9db17537 985 {
mbed_official 376:cb4d9db17537 986 HAL_DMA_Abort(husart->hdmatx);
mbed_official 376:cb4d9db17537 987 }
mbed_official 376:cb4d9db17537 988 /* Abort the USART DMA rx Stream */
mbed_official 387:643a59b3dbac 989 if(husart->hdmarx != HAL_NULL)
mbed_official 376:cb4d9db17537 990 {
mbed_official 376:cb4d9db17537 991 HAL_DMA_Abort(husart->hdmarx);
mbed_official 376:cb4d9db17537 992 }
mbed_official 376:cb4d9db17537 993
mbed_official 376:cb4d9db17537 994 /* Disable the USART Tx/Rx DMA requests */
mbed_official 376:cb4d9db17537 995 husart->Instance->CR3 &= ~USART_CR3_DMAT;
mbed_official 376:cb4d9db17537 996 husart->Instance->CR3 &= ~USART_CR3_DMAR;
mbed_official 376:cb4d9db17537 997
mbed_official 376:cb4d9db17537 998 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 999
mbed_official 376:cb4d9db17537 1000 return HAL_OK;
mbed_official 376:cb4d9db17537 1001 }
mbed_official 376:cb4d9db17537 1002
mbed_official 376:cb4d9db17537 1003 /**
mbed_official 376:cb4d9db17537 1004 * @brief This function handles USART interrupt request.
mbed_official 376:cb4d9db17537 1005 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1006 * @retval None
mbed_official 376:cb4d9db17537 1007 */
mbed_official 376:cb4d9db17537 1008 void HAL_USART_IRQHandler(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1009 {
mbed_official 376:cb4d9db17537 1010
mbed_official 376:cb4d9db17537 1011 /* USART parity error interrupt occured ------------------------------------*/
mbed_official 376:cb4d9db17537 1012 if((__HAL_USART_GET_IT(husart, USART_IT_PE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_PE) != RESET))
mbed_official 376:cb4d9db17537 1013 {
mbed_official 376:cb4d9db17537 1014 __HAL_USART_CLEAR_IT(husart, USART_IT_PE);
mbed_official 376:cb4d9db17537 1015 husart->ErrorCode |= HAL_USART_ERROR_PE;
mbed_official 376:cb4d9db17537 1016 /* Set the USART state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 1017 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1018 }
mbed_official 376:cb4d9db17537 1019
mbed_official 376:cb4d9db17537 1020 /* USART frame error interrupt occured -------------------------------------*/
mbed_official 376:cb4d9db17537 1021 if((__HAL_USART_GET_IT(husart, USART_IT_FE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 1022 {
mbed_official 376:cb4d9db17537 1023 __HAL_USART_CLEAR_IT(husart, USART_IT_FE);
mbed_official 376:cb4d9db17537 1024 husart->ErrorCode |= HAL_USART_ERROR_FE;
mbed_official 376:cb4d9db17537 1025 /* Set the USART state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 1026 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1027 }
mbed_official 376:cb4d9db17537 1028
mbed_official 376:cb4d9db17537 1029 /* USART noise error interrupt occured -------------------------------------*/
mbed_official 376:cb4d9db17537 1030 if((__HAL_USART_GET_IT(husart, USART_IT_NE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 1031 {
mbed_official 376:cb4d9db17537 1032 __HAL_USART_CLEAR_IT(husart, USART_IT_NE);
mbed_official 376:cb4d9db17537 1033 husart->ErrorCode |= HAL_USART_ERROR_NE;
mbed_official 376:cb4d9db17537 1034 /* Set the USART state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 1035 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1036 }
mbed_official 376:cb4d9db17537 1037
mbed_official 376:cb4d9db17537 1038 /* USART Over-Run interrupt occured ----------------------------------------*/
mbed_official 376:cb4d9db17537 1039 if((__HAL_USART_GET_IT(husart, USART_IT_ORE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))
mbed_official 376:cb4d9db17537 1040 {
mbed_official 376:cb4d9db17537 1041 __HAL_USART_CLEAR_IT(husart, USART_IT_ORE);
mbed_official 376:cb4d9db17537 1042 husart->ErrorCode |= HAL_USART_ERROR_ORE;
mbed_official 376:cb4d9db17537 1043 /* Set the USART state ready to be able to start again the process */
mbed_official 376:cb4d9db17537 1044 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1045 }
mbed_official 376:cb4d9db17537 1046
mbed_official 376:cb4d9db17537 1047 /* Call USART Error Call back function if need be --------------------------*/
mbed_official 376:cb4d9db17537 1048 if(husart->ErrorCode != HAL_USART_ERROR_NONE)
mbed_official 376:cb4d9db17537 1049 {
mbed_official 376:cb4d9db17537 1050 HAL_USART_ErrorCallback(husart);
mbed_official 376:cb4d9db17537 1051 }
mbed_official 376:cb4d9db17537 1052
mbed_official 376:cb4d9db17537 1053 /* USART in mode Receiver --------------------------------------------------*/
mbed_official 376:cb4d9db17537 1054 if((__HAL_USART_GET_IT(husart, USART_IT_RXNE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_RXNE) != RESET))
mbed_official 376:cb4d9db17537 1055 {
mbed_official 376:cb4d9db17537 1056 if(husart->State == HAL_USART_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 1057 {
mbed_official 376:cb4d9db17537 1058 USART_Receive_IT(husart);
mbed_official 376:cb4d9db17537 1059 }
mbed_official 376:cb4d9db17537 1060 else
mbed_official 376:cb4d9db17537 1061 {
mbed_official 376:cb4d9db17537 1062 USART_TransmitReceive_IT(husart);
mbed_official 376:cb4d9db17537 1063 }
mbed_official 376:cb4d9db17537 1064 }
mbed_official 376:cb4d9db17537 1065
mbed_official 376:cb4d9db17537 1066 /* USART in mode Transmitter -----------------------------------------------*/
mbed_official 376:cb4d9db17537 1067 if((__HAL_USART_GET_IT(husart, USART_IT_TXE) != RESET) &&(__HAL_USART_GET_IT_SOURCE(husart, USART_IT_TXE) != RESET))
mbed_official 376:cb4d9db17537 1068 {
mbed_official 376:cb4d9db17537 1069 if(husart->State == HAL_USART_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 1070 {
mbed_official 376:cb4d9db17537 1071 USART_Transmit_IT(husart);
mbed_official 376:cb4d9db17537 1072 }
mbed_official 376:cb4d9db17537 1073 else
mbed_official 376:cb4d9db17537 1074 {
mbed_official 376:cb4d9db17537 1075 USART_TransmitReceive_IT(husart);
mbed_official 376:cb4d9db17537 1076 }
mbed_official 376:cb4d9db17537 1077 }
mbed_official 376:cb4d9db17537 1078 }
mbed_official 376:cb4d9db17537 1079
mbed_official 376:cb4d9db17537 1080 /**
mbed_official 376:cb4d9db17537 1081 * @brief Tx Transfer completed callbacks.
mbed_official 376:cb4d9db17537 1082 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1083 * @retval None
mbed_official 376:cb4d9db17537 1084 */
mbed_official 376:cb4d9db17537 1085 __weak void HAL_USART_TxCpltCallback(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1086 {
mbed_official 376:cb4d9db17537 1087 /* NOTE: This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1088 the HAL_USART_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1089 */
mbed_official 376:cb4d9db17537 1090 }
mbed_official 376:cb4d9db17537 1091
mbed_official 376:cb4d9db17537 1092 /**
mbed_official 376:cb4d9db17537 1093 * @brief Tx Half Transfer completed callbacks.
mbed_official 376:cb4d9db17537 1094 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1095 * @retval None
mbed_official 376:cb4d9db17537 1096 */
mbed_official 376:cb4d9db17537 1097 __weak void HAL_USART_TxHalfCpltCallback(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1098 {
mbed_official 376:cb4d9db17537 1099 /* NOTE: This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1100 the HAL_USART_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1101 */
mbed_official 376:cb4d9db17537 1102 }
mbed_official 376:cb4d9db17537 1103
mbed_official 376:cb4d9db17537 1104 /**
mbed_official 376:cb4d9db17537 1105 * @brief Rx Transfer completed callbacks.
mbed_official 376:cb4d9db17537 1106 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1107 * @retval None
mbed_official 376:cb4d9db17537 1108 */
mbed_official 376:cb4d9db17537 1109 __weak void HAL_USART_RxCpltCallback(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1110 {
mbed_official 376:cb4d9db17537 1111 /* NOTE: This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1112 the HAL_USART_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1113 */
mbed_official 376:cb4d9db17537 1114 }
mbed_official 376:cb4d9db17537 1115
mbed_official 376:cb4d9db17537 1116 /**
mbed_official 376:cb4d9db17537 1117 * @brief Rx Half Transfer completed callbacks.
mbed_official 376:cb4d9db17537 1118 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1119 * @retval None
mbed_official 376:cb4d9db17537 1120 */
mbed_official 376:cb4d9db17537 1121 __weak void HAL_USART_RxHalfCpltCallback(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1122 {
mbed_official 376:cb4d9db17537 1123 /* NOTE: This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1124 the HAL_USART_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1125 */
mbed_official 376:cb4d9db17537 1126 }
mbed_official 376:cb4d9db17537 1127
mbed_official 376:cb4d9db17537 1128 /**
mbed_official 376:cb4d9db17537 1129 * @brief Tx/Rx Transfers completed callback for the non-blocking process.
mbed_official 376:cb4d9db17537 1130 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1131 * @retval None
mbed_official 376:cb4d9db17537 1132 */
mbed_official 376:cb4d9db17537 1133 __weak void HAL_USART_TxRxCpltCallback(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1134 {
mbed_official 376:cb4d9db17537 1135 /* NOTE: This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1136 the HAL_USART_TxCpltCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1137 */
mbed_official 376:cb4d9db17537 1138 }
mbed_official 376:cb4d9db17537 1139
mbed_official 376:cb4d9db17537 1140 /**
mbed_official 376:cb4d9db17537 1141 * @brief USART error callbacks.
mbed_official 376:cb4d9db17537 1142 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1143 * @retval None
mbed_official 376:cb4d9db17537 1144 */
mbed_official 376:cb4d9db17537 1145 __weak void HAL_USART_ErrorCallback(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1146 {
mbed_official 376:cb4d9db17537 1147 /* NOTE: This function Should not be modified, when the callback is needed,
mbed_official 376:cb4d9db17537 1148 the HAL_USART_ErrorCallback could be implemented in the user file
mbed_official 376:cb4d9db17537 1149 */
mbed_official 376:cb4d9db17537 1150 }
mbed_official 376:cb4d9db17537 1151
mbed_official 376:cb4d9db17537 1152 /**
mbed_official 376:cb4d9db17537 1153 * @}
mbed_official 376:cb4d9db17537 1154 */
mbed_official 376:cb4d9db17537 1155
mbed_official 376:cb4d9db17537 1156 /** @defgroup USART_Group3 Peripheral State functions
mbed_official 376:cb4d9db17537 1157 * @brief USART State functions
mbed_official 376:cb4d9db17537 1158 *
mbed_official 376:cb4d9db17537 1159 @verbatim
mbed_official 376:cb4d9db17537 1160 ===============================================================================
mbed_official 376:cb4d9db17537 1161 ##### Peripheral State functions #####
mbed_official 376:cb4d9db17537 1162 ===============================================================================
mbed_official 376:cb4d9db17537 1163 [..]
mbed_official 376:cb4d9db17537 1164 This subsection provides a set of functions allowing to control the USART.
mbed_official 376:cb4d9db17537 1165 (+) HAL_USART_GetState() API can be helpful to check in run-time the state of the USART peripheral.
mbed_official 376:cb4d9db17537 1166 (+) HAL_USART_GetError() API can be helpful to check in run-time the Error Code of the USART peripheral.
mbed_official 376:cb4d9db17537 1167 (+) USART_SetConfig() API is used to set the USART communication parameters.
mbed_official 376:cb4d9db17537 1168 (+) USART_CheckIdleState() APi ensures that TEACK and/or REACK bits are set after initialization
mbed_official 376:cb4d9db17537 1169
mbed_official 376:cb4d9db17537 1170 @endverbatim
mbed_official 376:cb4d9db17537 1171 * @{
mbed_official 376:cb4d9db17537 1172 */
mbed_official 376:cb4d9db17537 1173
mbed_official 376:cb4d9db17537 1174 /**
mbed_official 376:cb4d9db17537 1175 * @brief Returns the USART state.
mbed_official 376:cb4d9db17537 1176 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1177 * @retval HAL state
mbed_official 376:cb4d9db17537 1178 */
mbed_official 376:cb4d9db17537 1179 HAL_USART_StateTypeDef HAL_USART_GetState(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1180 {
mbed_official 376:cb4d9db17537 1181 return husart->State;
mbed_official 376:cb4d9db17537 1182 }
mbed_official 376:cb4d9db17537 1183
mbed_official 376:cb4d9db17537 1184 /**
mbed_official 376:cb4d9db17537 1185 * @brief Return the USART error code
mbed_official 376:cb4d9db17537 1186 * @param husart : pointer to a USART_HandleTypeDef structure that contains
mbed_official 376:cb4d9db17537 1187 * the configuration information for the specified USART.
mbed_official 376:cb4d9db17537 1188 * @retval USART Error Code
mbed_official 376:cb4d9db17537 1189 */
mbed_official 376:cb4d9db17537 1190 uint32_t HAL_USART_GetError(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1191 {
mbed_official 376:cb4d9db17537 1192 return husart->ErrorCode;
mbed_official 376:cb4d9db17537 1193 }
mbed_official 376:cb4d9db17537 1194
mbed_official 376:cb4d9db17537 1195 /**
mbed_official 376:cb4d9db17537 1196 * @}
mbed_official 376:cb4d9db17537 1197 */
mbed_official 376:cb4d9db17537 1198
mbed_official 376:cb4d9db17537 1199 /**
mbed_official 376:cb4d9db17537 1200 * @brief This function handles USART Communication Timeout.
mbed_official 376:cb4d9db17537 1201 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1202 * @param Flag: specifies the USART flag to check.
mbed_official 376:cb4d9db17537 1203 * @param Status: The new Flag status (SET or RESET).
mbed_official 376:cb4d9db17537 1204 * @param Timeout: Timeout duration
mbed_official 376:cb4d9db17537 1205 * @retval HAL status
mbed_official 376:cb4d9db17537 1206 */
mbed_official 376:cb4d9db17537 1207 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
mbed_official 376:cb4d9db17537 1208 {
mbed_official 376:cb4d9db17537 1209 uint32_t tickstart = 0x00;
mbed_official 376:cb4d9db17537 1210 tickstart = HAL_GetTick();
mbed_official 376:cb4d9db17537 1211
mbed_official 376:cb4d9db17537 1212 /* Wait until flag is set */
mbed_official 376:cb4d9db17537 1213 if(Status == RESET)
mbed_official 376:cb4d9db17537 1214 {
mbed_official 376:cb4d9db17537 1215 while(__HAL_USART_GET_FLAG(husart, Flag) == RESET)
mbed_official 376:cb4d9db17537 1216 {
mbed_official 376:cb4d9db17537 1217 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1218 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1219 {
mbed_official 376:cb4d9db17537 1220 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 1221 {
mbed_official 376:cb4d9db17537 1222 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 376:cb4d9db17537 1223 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
mbed_official 376:cb4d9db17537 1224 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
mbed_official 376:cb4d9db17537 1225 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
mbed_official 376:cb4d9db17537 1226 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
mbed_official 376:cb4d9db17537 1227
mbed_official 376:cb4d9db17537 1228 husart->State= HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1229
mbed_official 376:cb4d9db17537 1230 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1231 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 1232
mbed_official 376:cb4d9db17537 1233 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1234 }
mbed_official 376:cb4d9db17537 1235 }
mbed_official 376:cb4d9db17537 1236 }
mbed_official 376:cb4d9db17537 1237 }
mbed_official 376:cb4d9db17537 1238 else
mbed_official 376:cb4d9db17537 1239 {
mbed_official 376:cb4d9db17537 1240 while(__HAL_USART_GET_FLAG(husart, Flag) != RESET)
mbed_official 376:cb4d9db17537 1241 {
mbed_official 376:cb4d9db17537 1242 /* Check for the Timeout */
mbed_official 376:cb4d9db17537 1243 if(Timeout != HAL_MAX_DELAY)
mbed_official 376:cb4d9db17537 1244 {
mbed_official 376:cb4d9db17537 1245 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 376:cb4d9db17537 1246 {
mbed_official 376:cb4d9db17537 1247 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 376:cb4d9db17537 1248 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
mbed_official 376:cb4d9db17537 1249 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
mbed_official 376:cb4d9db17537 1250 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
mbed_official 376:cb4d9db17537 1251 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
mbed_official 376:cb4d9db17537 1252
mbed_official 376:cb4d9db17537 1253 husart->State= HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1254
mbed_official 376:cb4d9db17537 1255 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1256 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 1257
mbed_official 376:cb4d9db17537 1258 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1259 }
mbed_official 376:cb4d9db17537 1260 }
mbed_official 376:cb4d9db17537 1261 }
mbed_official 376:cb4d9db17537 1262 }
mbed_official 376:cb4d9db17537 1263 return HAL_OK;
mbed_official 376:cb4d9db17537 1264 }
mbed_official 376:cb4d9db17537 1265
mbed_official 376:cb4d9db17537 1266 /**
mbed_official 376:cb4d9db17537 1267 * @brief DMA USART transmit process complete callback.
mbed_official 376:cb4d9db17537 1268 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1269 * @retval None
mbed_official 376:cb4d9db17537 1270 */
mbed_official 376:cb4d9db17537 1271 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1272 {
mbed_official 376:cb4d9db17537 1273 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1274 /* DMA Normal mode */
mbed_official 376:cb4d9db17537 1275 if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0)
mbed_official 376:cb4d9db17537 1276 {
mbed_official 376:cb4d9db17537 1277
mbed_official 376:cb4d9db17537 1278 husart->TxXferCount = 0;
mbed_official 376:cb4d9db17537 1279 if(husart->State == HAL_USART_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 1280 {
mbed_official 376:cb4d9db17537 1281 /* Wait for USART TC Flag */
mbed_official 376:cb4d9db17537 1282 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, HAL_USART_TXDMA_TIMEOUTVALUE) != HAL_OK)
mbed_official 376:cb4d9db17537 1283 {
mbed_official 376:cb4d9db17537 1284 /* Timeout Occured */
mbed_official 376:cb4d9db17537 1285 husart->State = HAL_USART_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 1286 HAL_USART_ErrorCallback(husart);
mbed_official 376:cb4d9db17537 1287 }
mbed_official 376:cb4d9db17537 1288 else
mbed_official 376:cb4d9db17537 1289 {
mbed_official 376:cb4d9db17537 1290 /* No Timeout */
mbed_official 376:cb4d9db17537 1291 /* Disable the DMA transfer for transmit request by setting the DMAT bit
mbed_official 376:cb4d9db17537 1292 in the USART CR3 register */
mbed_official 376:cb4d9db17537 1293 husart->Instance->CR3 &= ~(USART_CR3_DMAT);
mbed_official 376:cb4d9db17537 1294 husart->State= HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1295 }
mbed_official 376:cb4d9db17537 1296 }
mbed_official 376:cb4d9db17537 1297 }
mbed_official 376:cb4d9db17537 1298 /* DMA Circular mode */
mbed_official 376:cb4d9db17537 1299 else
mbed_official 376:cb4d9db17537 1300 {
mbed_official 376:cb4d9db17537 1301 if(husart->State == HAL_USART_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 1302 {
mbed_official 376:cb4d9db17537 1303 HAL_USART_TxCpltCallback(husart);
mbed_official 376:cb4d9db17537 1304 }
mbed_official 376:cb4d9db17537 1305 }
mbed_official 376:cb4d9db17537 1306 }
mbed_official 376:cb4d9db17537 1307
mbed_official 376:cb4d9db17537 1308 /**
mbed_official 376:cb4d9db17537 1309 * @brief DMA USART transmit process half complete callback
mbed_official 376:cb4d9db17537 1310 * @param hdma : DMA handle
mbed_official 376:cb4d9db17537 1311 * @retval None
mbed_official 376:cb4d9db17537 1312 */
mbed_official 376:cb4d9db17537 1313 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1314 {
mbed_official 376:cb4d9db17537 1315 USART_HandleTypeDef* husart = (USART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 376:cb4d9db17537 1316
mbed_official 376:cb4d9db17537 1317 HAL_USART_TxHalfCpltCallback(husart);
mbed_official 376:cb4d9db17537 1318 }
mbed_official 376:cb4d9db17537 1319
mbed_official 376:cb4d9db17537 1320 /**
mbed_official 376:cb4d9db17537 1321 * @brief DMA USART receive process complete callback.
mbed_official 376:cb4d9db17537 1322 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1323 * @retval None
mbed_official 376:cb4d9db17537 1324 */
mbed_official 376:cb4d9db17537 1325 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1326 {
mbed_official 376:cb4d9db17537 1327 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1328 /* DMA Normal mode */
mbed_official 376:cb4d9db17537 1329 if((hdma->Instance->CCR & DMA_CCR_CIRC) == 0)
mbed_official 376:cb4d9db17537 1330 {
mbed_official 376:cb4d9db17537 1331 husart->RxXferCount = 0;
mbed_official 376:cb4d9db17537 1332 husart->State= HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1333 if(husart->State == HAL_USART_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 1334 {
mbed_official 376:cb4d9db17537 1335 /* Disable the DMA transfer for the Transmit/receiver requests by setting the DMAT/DMAR bit
mbed_official 376:cb4d9db17537 1336 in the USART CR3 register */
mbed_official 376:cb4d9db17537 1337 husart->Instance->CR3 &= ~(USART_CR3_DMAR);
mbed_official 376:cb4d9db17537 1338
mbed_official 376:cb4d9db17537 1339 HAL_USART_RxCpltCallback(husart);
mbed_official 376:cb4d9db17537 1340 }
mbed_official 376:cb4d9db17537 1341 /* the usart state is HAL_USART_STATE_BUSY_TX_RX*/
mbed_official 376:cb4d9db17537 1342 else
mbed_official 376:cb4d9db17537 1343 {
mbed_official 376:cb4d9db17537 1344 /* Disable the DMA transfer for the Transmit/receiver requests by setting the DMAT/DMAR bit
mbed_official 376:cb4d9db17537 1345 in the USART CR3 register */
mbed_official 376:cb4d9db17537 1346 husart->Instance->CR3 &= ~(USART_CR3_DMAR);
mbed_official 376:cb4d9db17537 1347 husart->Instance->CR3 &= ~(USART_CR3_DMAT);
mbed_official 376:cb4d9db17537 1348
mbed_official 376:cb4d9db17537 1349 HAL_USART_TxRxCpltCallback(husart);
mbed_official 376:cb4d9db17537 1350 }
mbed_official 376:cb4d9db17537 1351 }
mbed_official 376:cb4d9db17537 1352 /* DMA circular mode */
mbed_official 376:cb4d9db17537 1353 else
mbed_official 376:cb4d9db17537 1354 {
mbed_official 376:cb4d9db17537 1355 if(husart->State == HAL_USART_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 1356 {
mbed_official 376:cb4d9db17537 1357 HAL_USART_RxCpltCallback(husart);
mbed_official 376:cb4d9db17537 1358 }
mbed_official 376:cb4d9db17537 1359 /* the usart state is HAL_USART_STATE_BUSY_TX_RX*/
mbed_official 376:cb4d9db17537 1360 else
mbed_official 376:cb4d9db17537 1361 {
mbed_official 376:cb4d9db17537 1362 HAL_USART_TxRxCpltCallback(husart);
mbed_official 376:cb4d9db17537 1363 }
mbed_official 376:cb4d9db17537 1364 }
mbed_official 376:cb4d9db17537 1365 }
mbed_official 376:cb4d9db17537 1366
mbed_official 376:cb4d9db17537 1367 /**
mbed_official 376:cb4d9db17537 1368 * @brief DMA USART receive process half complete callback
mbed_official 376:cb4d9db17537 1369 * @param hdma : DMA handle
mbed_official 376:cb4d9db17537 1370 * @retval None
mbed_official 376:cb4d9db17537 1371 */
mbed_official 376:cb4d9db17537 1372 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1373 {
mbed_official 376:cb4d9db17537 1374 USART_HandleTypeDef* husart = (USART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 376:cb4d9db17537 1375
mbed_official 376:cb4d9db17537 1376 HAL_USART_RxHalfCpltCallback(husart);
mbed_official 376:cb4d9db17537 1377 }
mbed_official 376:cb4d9db17537 1378
mbed_official 376:cb4d9db17537 1379 /**
mbed_official 376:cb4d9db17537 1380 * @brief DMA USART communication error callback.
mbed_official 376:cb4d9db17537 1381 * @param hdma: DMA handle
mbed_official 376:cb4d9db17537 1382 * @retval None
mbed_official 376:cb4d9db17537 1383 */
mbed_official 376:cb4d9db17537 1384 static void USART_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 376:cb4d9db17537 1385 {
mbed_official 376:cb4d9db17537 1386 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 376:cb4d9db17537 1387
mbed_official 376:cb4d9db17537 1388 husart->RxXferCount = 0;
mbed_official 376:cb4d9db17537 1389 husart->TxXferCount = 0;
mbed_official 376:cb4d9db17537 1390 husart->ErrorCode |= HAL_USART_ERROR_DMA;
mbed_official 376:cb4d9db17537 1391 husart->State= HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1392
mbed_official 376:cb4d9db17537 1393 HAL_USART_ErrorCallback(husart);
mbed_official 376:cb4d9db17537 1394 }
mbed_official 376:cb4d9db17537 1395
mbed_official 376:cb4d9db17537 1396 /**
mbed_official 376:cb4d9db17537 1397 * @brief Simplex Send an amount of data in non-blocking mode.
mbed_official 376:cb4d9db17537 1398 * Function called under interruption only, once
mbed_official 376:cb4d9db17537 1399 * interruptions have been enabled by HAL_USART_Transmit_IT()
mbed_official 376:cb4d9db17537 1400 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1401 * @retval HAL status
mbed_official 376:cb4d9db17537 1402 * @note The USART errors are not managed to avoid the overrun error.
mbed_official 376:cb4d9db17537 1403 */
mbed_official 376:cb4d9db17537 1404 static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1405 {
mbed_official 376:cb4d9db17537 1406 uint16_t* tmp;
mbed_official 376:cb4d9db17537 1407
mbed_official 376:cb4d9db17537 1408 if(husart->State == HAL_USART_STATE_BUSY_TX)
mbed_official 376:cb4d9db17537 1409 {
mbed_official 376:cb4d9db17537 1410 if(husart->Init.WordLength == USART_WORDLENGTH_9B)
mbed_official 376:cb4d9db17537 1411 {
mbed_official 376:cb4d9db17537 1412 tmp = (uint16_t*) husart->pTxBuffPtr;
mbed_official 376:cb4d9db17537 1413 husart->Instance->TDR = (uint16_t)(*tmp & (uint16_t)0x01FF);
mbed_official 376:cb4d9db17537 1414 if(husart->Init.Parity == USART_PARITY_NONE)
mbed_official 376:cb4d9db17537 1415 {
mbed_official 376:cb4d9db17537 1416 husart->pTxBuffPtr += 2;
mbed_official 376:cb4d9db17537 1417 }
mbed_official 376:cb4d9db17537 1418 else
mbed_official 376:cb4d9db17537 1419 {
mbed_official 376:cb4d9db17537 1420 husart->pTxBuffPtr += 1;
mbed_official 376:cb4d9db17537 1421 }
mbed_official 376:cb4d9db17537 1422 }
mbed_official 376:cb4d9db17537 1423 else
mbed_official 376:cb4d9db17537 1424 {
mbed_official 376:cb4d9db17537 1425 husart->Instance->TDR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0x00FF);
mbed_official 376:cb4d9db17537 1426 }
mbed_official 376:cb4d9db17537 1427
mbed_official 376:cb4d9db17537 1428 if(--husart->TxXferCount == 0)
mbed_official 376:cb4d9db17537 1429 {
mbed_official 376:cb4d9db17537 1430 /* Disable the USART Transmit data register empty Interrupt */
mbed_official 376:cb4d9db17537 1431 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
mbed_official 376:cb4d9db17537 1432
mbed_official 376:cb4d9db17537 1433 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 1434 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
mbed_official 376:cb4d9db17537 1435
mbed_official 376:cb4d9db17537 1436
mbed_official 376:cb4d9db17537 1437 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, HAL_USART_TXDMA_TIMEOUTVALUE) != HAL_OK)
mbed_official 376:cb4d9db17537 1438 {
mbed_official 376:cb4d9db17537 1439 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1440 }
mbed_official 376:cb4d9db17537 1441 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1442
mbed_official 376:cb4d9db17537 1443 HAL_USART_TxCpltCallback(husart);
mbed_official 376:cb4d9db17537 1444
mbed_official 376:cb4d9db17537 1445 return HAL_OK;
mbed_official 376:cb4d9db17537 1446 }
mbed_official 376:cb4d9db17537 1447 return HAL_OK;
mbed_official 376:cb4d9db17537 1448 }
mbed_official 376:cb4d9db17537 1449 else
mbed_official 376:cb4d9db17537 1450 {
mbed_official 376:cb4d9db17537 1451 return HAL_BUSY;
mbed_official 376:cb4d9db17537 1452 }
mbed_official 376:cb4d9db17537 1453 }
mbed_official 376:cb4d9db17537 1454
mbed_official 376:cb4d9db17537 1455 /**
mbed_official 376:cb4d9db17537 1456 * @brief Simplex Receive an amount of data in non-blocking mode.
mbed_official 376:cb4d9db17537 1457 * Function called under interruption only, once
mbed_official 376:cb4d9db17537 1458 * interruptions have been enabled by HAL_USART_Receive_IT()
mbed_official 376:cb4d9db17537 1459 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1460 * @retval HAL status
mbed_official 376:cb4d9db17537 1461 */
mbed_official 376:cb4d9db17537 1462 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1463 {
mbed_official 376:cb4d9db17537 1464 uint16_t* tmp;
mbed_official 376:cb4d9db17537 1465 uint16_t uhMask = husart->Mask;
mbed_official 376:cb4d9db17537 1466
mbed_official 376:cb4d9db17537 1467 if(husart->State == HAL_USART_STATE_BUSY_RX)
mbed_official 376:cb4d9db17537 1468 {
mbed_official 376:cb4d9db17537 1469
mbed_official 376:cb4d9db17537 1470 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 376:cb4d9db17537 1471 {
mbed_official 376:cb4d9db17537 1472 tmp = (uint16_t*) husart->pRxBuffPtr;
mbed_official 376:cb4d9db17537 1473 *tmp = (uint16_t)(husart->Instance->RDR & uhMask);
mbed_official 376:cb4d9db17537 1474 husart->pRxBuffPtr += 2;
mbed_official 376:cb4d9db17537 1475 }
mbed_official 376:cb4d9db17537 1476 else
mbed_official 376:cb4d9db17537 1477 {
mbed_official 376:cb4d9db17537 1478 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);
mbed_official 376:cb4d9db17537 1479 }
mbed_official 376:cb4d9db17537 1480 /* Send dummy byte in order to generate the clock for the Slave to Send the next data */
mbed_official 376:cb4d9db17537 1481 husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x00FF);
mbed_official 376:cb4d9db17537 1482
mbed_official 376:cb4d9db17537 1483 if(--husart->RxXferCount == 0)
mbed_official 376:cb4d9db17537 1484 {
mbed_official 376:cb4d9db17537 1485 /* Wait for RXNE Flag */
mbed_official 376:cb4d9db17537 1486 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, HAL_USART_TXDMA_TIMEOUTVALUE) != HAL_OK)
mbed_official 376:cb4d9db17537 1487 {
mbed_official 376:cb4d9db17537 1488 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1489 }
mbed_official 376:cb4d9db17537 1490
mbed_official 376:cb4d9db17537 1491 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
mbed_official 376:cb4d9db17537 1492
mbed_official 376:cb4d9db17537 1493 /* Disable the USART Parity Error Interrupt */
mbed_official 376:cb4d9db17537 1494 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
mbed_official 376:cb4d9db17537 1495
mbed_official 376:cb4d9db17537 1496 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 1497 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
mbed_official 376:cb4d9db17537 1498
mbed_official 376:cb4d9db17537 1499 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1500
mbed_official 376:cb4d9db17537 1501
mbed_official 376:cb4d9db17537 1502 HAL_USART_RxCpltCallback(husart);
mbed_official 376:cb4d9db17537 1503
mbed_official 376:cb4d9db17537 1504 return HAL_OK;
mbed_official 376:cb4d9db17537 1505 }
mbed_official 376:cb4d9db17537 1506
mbed_official 376:cb4d9db17537 1507
mbed_official 376:cb4d9db17537 1508 return HAL_OK;
mbed_official 376:cb4d9db17537 1509 }
mbed_official 376:cb4d9db17537 1510 else
mbed_official 376:cb4d9db17537 1511 {
mbed_official 376:cb4d9db17537 1512 return HAL_BUSY;
mbed_official 376:cb4d9db17537 1513 }
mbed_official 376:cb4d9db17537 1514 }
mbed_official 376:cb4d9db17537 1515
mbed_official 376:cb4d9db17537 1516 /**
mbed_official 376:cb4d9db17537 1517 * @brief Full-Duplex Send receive an amount of data in full-duplex mode (non-blocking).
mbed_official 376:cb4d9db17537 1518 * Function called under interruption only, once
mbed_official 376:cb4d9db17537 1519 * interruptions have been enabled by HAL_USART_TransmitReceive_IT()
mbed_official 376:cb4d9db17537 1520 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1521 * @retval HAL status
mbed_official 376:cb4d9db17537 1522 */
mbed_official 376:cb4d9db17537 1523 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1524 {
mbed_official 376:cb4d9db17537 1525 uint16_t* tmp;
mbed_official 376:cb4d9db17537 1526 uint16_t uhMask = husart->Mask;
mbed_official 376:cb4d9db17537 1527
mbed_official 376:cb4d9db17537 1528 if(husart->State == HAL_USART_STATE_BUSY_TX_RX)
mbed_official 376:cb4d9db17537 1529 {
mbed_official 376:cb4d9db17537 1530 if(husart->TxXferCount != 0x00)
mbed_official 376:cb4d9db17537 1531 {
mbed_official 376:cb4d9db17537 1532 if(__HAL_USART_GET_FLAG(husart, USART_FLAG_TC) != RESET)
mbed_official 376:cb4d9db17537 1533 {
mbed_official 376:cb4d9db17537 1534 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 376:cb4d9db17537 1535 {
mbed_official 376:cb4d9db17537 1536 tmp = (uint16_t*) husart->pTxBuffPtr;
mbed_official 376:cb4d9db17537 1537 husart->Instance->TDR = (uint16_t)(*tmp & uhMask);
mbed_official 376:cb4d9db17537 1538 husart->pTxBuffPtr += 2;
mbed_official 376:cb4d9db17537 1539 }
mbed_official 376:cb4d9db17537 1540 else
mbed_official 376:cb4d9db17537 1541 {
mbed_official 376:cb4d9db17537 1542 husart->Instance->TDR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)uhMask);
mbed_official 376:cb4d9db17537 1543 }
mbed_official 376:cb4d9db17537 1544 husart->TxXferCount--;
mbed_official 376:cb4d9db17537 1545
mbed_official 376:cb4d9db17537 1546 /* Check the latest data transmitted */
mbed_official 376:cb4d9db17537 1547 if(husart->TxXferCount == 0)
mbed_official 376:cb4d9db17537 1548 {
mbed_official 376:cb4d9db17537 1549 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
mbed_official 376:cb4d9db17537 1550 }
mbed_official 376:cb4d9db17537 1551 }
mbed_official 376:cb4d9db17537 1552 }
mbed_official 376:cb4d9db17537 1553
mbed_official 376:cb4d9db17537 1554 if(husart->RxXferCount != 0x00)
mbed_official 376:cb4d9db17537 1555 {
mbed_official 376:cb4d9db17537 1556 if(__HAL_USART_GET_FLAG(husart, USART_FLAG_RXNE) != RESET)
mbed_official 376:cb4d9db17537 1557 {
mbed_official 376:cb4d9db17537 1558 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 376:cb4d9db17537 1559 {
mbed_official 376:cb4d9db17537 1560 tmp = (uint16_t*) husart->pRxBuffPtr;
mbed_official 376:cb4d9db17537 1561 *tmp = (uint16_t)(husart->Instance->RDR & uhMask);
mbed_official 376:cb4d9db17537 1562 husart->pRxBuffPtr += 2;
mbed_official 376:cb4d9db17537 1563 }
mbed_official 376:cb4d9db17537 1564 else
mbed_official 376:cb4d9db17537 1565 {
mbed_official 376:cb4d9db17537 1566 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);
mbed_official 376:cb4d9db17537 1567 }
mbed_official 376:cb4d9db17537 1568 husart->RxXferCount--;
mbed_official 376:cb4d9db17537 1569 }
mbed_official 376:cb4d9db17537 1570 }
mbed_official 376:cb4d9db17537 1571
mbed_official 376:cb4d9db17537 1572 /* Check the latest data received */
mbed_official 376:cb4d9db17537 1573 if(husart->RxXferCount == 0)
mbed_official 376:cb4d9db17537 1574 {
mbed_official 376:cb4d9db17537 1575 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
mbed_official 376:cb4d9db17537 1576
mbed_official 376:cb4d9db17537 1577 /* Disable the USART Parity Error Interrupt */
mbed_official 376:cb4d9db17537 1578 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
mbed_official 376:cb4d9db17537 1579
mbed_official 376:cb4d9db17537 1580 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 376:cb4d9db17537 1581 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
mbed_official 376:cb4d9db17537 1582
mbed_official 376:cb4d9db17537 1583 husart->State = HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1584
mbed_official 376:cb4d9db17537 1585 HAL_USART_TxRxCpltCallback(husart);
mbed_official 376:cb4d9db17537 1586
mbed_official 376:cb4d9db17537 1587 return HAL_OK;
mbed_official 376:cb4d9db17537 1588 }
mbed_official 376:cb4d9db17537 1589
mbed_official 376:cb4d9db17537 1590 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1591 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 1592
mbed_official 376:cb4d9db17537 1593 return HAL_OK;
mbed_official 376:cb4d9db17537 1594 }
mbed_official 376:cb4d9db17537 1595 else
mbed_official 376:cb4d9db17537 1596 {
mbed_official 376:cb4d9db17537 1597 return HAL_BUSY;
mbed_official 376:cb4d9db17537 1598 }
mbed_official 376:cb4d9db17537 1599 }
mbed_official 376:cb4d9db17537 1600
mbed_official 376:cb4d9db17537 1601 /**
mbed_official 376:cb4d9db17537 1602 * @brief Configure the USART peripheral
mbed_official 376:cb4d9db17537 1603 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1604 * @retval None
mbed_official 376:cb4d9db17537 1605 */
mbed_official 376:cb4d9db17537 1606 static void USART_SetConfig(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1607 {
mbed_official 376:cb4d9db17537 1608 uint32_t tmpreg = 0x0;
mbed_official 376:cb4d9db17537 1609 uint32_t clocksource = 0x0;
mbed_official 376:cb4d9db17537 1610
mbed_official 376:cb4d9db17537 1611 /* Check the parameters */
mbed_official 376:cb4d9db17537 1612 assert_param(IS_USART_INSTANCE(husart->Instance));
mbed_official 376:cb4d9db17537 1613 assert_param(IS_USART_POLARITY(husart->Init.CLKPolarity));
mbed_official 376:cb4d9db17537 1614 assert_param(IS_USART_PHASE(husart->Init.CLKPhase));
mbed_official 376:cb4d9db17537 1615 assert_param(IS_USART_LASTBIT(husart->Init.CLKLastBit));
mbed_official 376:cb4d9db17537 1616 assert_param(IS_USART_BAUDRATE(husart->Init.BaudRate));
mbed_official 376:cb4d9db17537 1617 assert_param(IS_USART_WORD_LENGTH(husart->Init.WordLength));
mbed_official 376:cb4d9db17537 1618 assert_param(IS_USART_STOPBITS(husart->Init.StopBits));
mbed_official 376:cb4d9db17537 1619 assert_param(IS_USART_PARITY(husart->Init.Parity));
mbed_official 376:cb4d9db17537 1620 assert_param(IS_USART_MODE(husart->Init.Mode));
mbed_official 376:cb4d9db17537 1621
mbed_official 376:cb4d9db17537 1622 /*-------------------------- USART CR1 Configuration -----------------------*/
mbed_official 376:cb4d9db17537 1623 /* Clear M, PCE, PS, TE and RE bits and configure
mbed_official 376:cb4d9db17537 1624 * the USART Word Length, Parity, Mode and oversampling:
mbed_official 376:cb4d9db17537 1625 * set the M bits according to husart->Init.WordLength value
mbed_official 376:cb4d9db17537 1626 * set PCE and PS bits according to husart->Init.Parity value
mbed_official 376:cb4d9db17537 1627 * set TE and RE bits according to husart->Init.Mode value */
mbed_official 376:cb4d9db17537 1628 tmpreg = (uint32_t)husart->Init.WordLength | husart->Init.Parity | husart->Init.Mode ;
mbed_official 376:cb4d9db17537 1629 MODIFY_REG(husart->Instance->CR1, USART_CR1_FIELDS, tmpreg);
mbed_official 376:cb4d9db17537 1630
mbed_official 376:cb4d9db17537 1631 /*---------------------------- USART CR2 Configuration ---------------------*/
mbed_official 376:cb4d9db17537 1632 /* Clear and configure the USART Clock, CPOL, CPHA, LBCL and STOP bits:
mbed_official 376:cb4d9db17537 1633 * set CPOL bit according to husart->Init.CLKPolarity value
mbed_official 376:cb4d9db17537 1634 * set CPHA bit according to husart->Init.CLKPhase value
mbed_official 376:cb4d9db17537 1635 * set LBCL bit according to husart->Init.CLKLastBit value
mbed_official 376:cb4d9db17537 1636 * set STOP[13:12] bits according to husart->Init.StopBits value */
mbed_official 376:cb4d9db17537 1637 tmpreg = (uint32_t)(USART_CLOCK_ENABLED);
mbed_official 376:cb4d9db17537 1638 tmpreg |= (uint32_t)(husart->Init.CLKPolarity | husart->Init.CLKPhase);
mbed_official 376:cb4d9db17537 1639 tmpreg |= (uint32_t)(husart->Init.CLKLastBit | husart->Init.StopBits);
mbed_official 376:cb4d9db17537 1640 MODIFY_REG(husart->Instance->CR2, USART_CR2_FIELDS, tmpreg);
mbed_official 376:cb4d9db17537 1641
mbed_official 376:cb4d9db17537 1642 /*-------------------------- USART CR3 Configuration -----------------------*/
mbed_official 376:cb4d9db17537 1643 /* no CR3 register configuration */
mbed_official 376:cb4d9db17537 1644
mbed_official 376:cb4d9db17537 1645 /*-------------------------- USART BRR Configuration -----------------------*/
mbed_official 376:cb4d9db17537 1646 __HAL_USART_GETCLOCKSOURCE(husart, clocksource);
mbed_official 376:cb4d9db17537 1647 switch (clocksource)
mbed_official 376:cb4d9db17537 1648 {
mbed_official 376:cb4d9db17537 1649 case USART_CLOCKSOURCE_PCLK1:
mbed_official 376:cb4d9db17537 1650 husart->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK1Freq() / husart->Init.BaudRate);
mbed_official 376:cb4d9db17537 1651 break;
mbed_official 376:cb4d9db17537 1652 case USART_CLOCKSOURCE_PCLK2:
mbed_official 376:cb4d9db17537 1653 husart->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK2Freq() / husart->Init.BaudRate);
mbed_official 376:cb4d9db17537 1654 break;
mbed_official 376:cb4d9db17537 1655 case USART_CLOCKSOURCE_HSI:
mbed_official 376:cb4d9db17537 1656 husart->Instance->BRR = (uint16_t)(HSI_VALUE / husart->Init.BaudRate);
mbed_official 376:cb4d9db17537 1657 break;
mbed_official 376:cb4d9db17537 1658 case USART_CLOCKSOURCE_SYSCLK:
mbed_official 376:cb4d9db17537 1659 husart->Instance->BRR = (uint16_t)(HAL_RCC_GetSysClockFreq() / husart->Init.BaudRate);
mbed_official 376:cb4d9db17537 1660 break;
mbed_official 376:cb4d9db17537 1661 case USART_CLOCKSOURCE_LSE:
mbed_official 376:cb4d9db17537 1662 husart->Instance->BRR = (uint16_t)(LSE_VALUE / husart->Init.BaudRate);
mbed_official 376:cb4d9db17537 1663 break;
mbed_official 376:cb4d9db17537 1664 default:
mbed_official 376:cb4d9db17537 1665 break;
mbed_official 376:cb4d9db17537 1666 }
mbed_official 376:cb4d9db17537 1667 }
mbed_official 376:cb4d9db17537 1668
mbed_official 376:cb4d9db17537 1669 /**
mbed_official 376:cb4d9db17537 1670 * @brief Check the USART Idle State
mbed_official 376:cb4d9db17537 1671 * @param husart: USART handle
mbed_official 376:cb4d9db17537 1672 * @retval HAL status
mbed_official 376:cb4d9db17537 1673 */
mbed_official 376:cb4d9db17537 1674 static HAL_StatusTypeDef USART_CheckIdleState(USART_HandleTypeDef *husart)
mbed_official 376:cb4d9db17537 1675 {
mbed_official 376:cb4d9db17537 1676 /* Initialize the USART ErrorCode */
mbed_official 376:cb4d9db17537 1677 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 376:cb4d9db17537 1678
mbed_official 376:cb4d9db17537 1679 /* Check if the Transmitter is enabled */
mbed_official 376:cb4d9db17537 1680 if((husart->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
mbed_official 376:cb4d9db17537 1681 {
mbed_official 376:cb4d9db17537 1682 /* Wait until TEACK flag is set */
mbed_official 376:cb4d9db17537 1683 if(USART_WaitOnFlagUntilTimeout(husart, USART_ISR_TEACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official 376:cb4d9db17537 1684 {
mbed_official 376:cb4d9db17537 1685 husart->State= HAL_USART_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 1686 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1687 }
mbed_official 376:cb4d9db17537 1688 }
mbed_official 376:cb4d9db17537 1689 /* Check if the Receiver is enabled */
mbed_official 376:cb4d9db17537 1690 if((husart->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
mbed_official 376:cb4d9db17537 1691 {
mbed_official 376:cb4d9db17537 1692 /* Wait until REACK flag is set */
mbed_official 376:cb4d9db17537 1693 if(USART_WaitOnFlagUntilTimeout(husart, USART_ISR_REACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official 376:cb4d9db17537 1694 {
mbed_official 376:cb4d9db17537 1695 husart->State= HAL_USART_STATE_TIMEOUT;
mbed_official 376:cb4d9db17537 1696 return HAL_TIMEOUT;
mbed_official 376:cb4d9db17537 1697 }
mbed_official 376:cb4d9db17537 1698 }
mbed_official 376:cb4d9db17537 1699
mbed_official 376:cb4d9db17537 1700 /* Process Unlocked */
mbed_official 376:cb4d9db17537 1701 __HAL_UNLOCK(husart);
mbed_official 376:cb4d9db17537 1702
mbed_official 376:cb4d9db17537 1703 /* Initialize the USART state*/
mbed_official 376:cb4d9db17537 1704 husart->State= HAL_USART_STATE_READY;
mbed_official 376:cb4d9db17537 1705
mbed_official 376:cb4d9db17537 1706 return HAL_OK;
mbed_official 376:cb4d9db17537 1707 }
mbed_official 376:cb4d9db17537 1708
mbed_official 376:cb4d9db17537 1709 /**
mbed_official 376:cb4d9db17537 1710 * @}
mbed_official 376:cb4d9db17537 1711 */
mbed_official 376:cb4d9db17537 1712
mbed_official 376:cb4d9db17537 1713 #endif /* HAL_USART_MODULE_ENABLED */
mbed_official 376:cb4d9db17537 1714 /**
mbed_official 376:cb4d9db17537 1715 * @}
mbed_official 376:cb4d9db17537 1716 */
mbed_official 376:cb4d9db17537 1717
mbed_official 376:cb4d9db17537 1718 /**
mbed_official 376:cb4d9db17537 1719 * @}
mbed_official 376:cb4d9db17537 1720 */
mbed_official 376:cb4d9db17537 1721
mbed_official 376:cb4d9db17537 1722 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/