mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_usart.c@573:ad23fe03a082, 2015-06-19 (annotated)

Committer:
mbed_official
Date:
Fri Jun 19 09:15:11 2015 +0100
Revision:
573:ad23fe03a082
Child:
610:813dcc80987e
Synchronized with git revision d47834cd4d729e5b36b4c1ad4650f8b8f6a9ab86



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



DISCO_F746NG - Add new target

Who changed what in which revision?

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