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@610:813dcc80987e, 2015-08-14 (annotated)

Committer:
mbed_official
Date:
Fri Aug 14 13:15:17 2015 +0100
Revision:
610:813dcc80987e
Parent:
573:ad23fe03a082 
Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599



Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/



DISCO_F746NG - Improvements

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 610:813dcc80987e 5 * @version V1.0.1
mbed_official 610:813dcc80987e 6 * @date 25-June-2015
mbed_official 573:ad23fe03a082 7 * @brief USART HAL module driver.
mbed_official 573:ad23fe03a082 8 * This file provides firmware functions to manage the following
mbed_official 573:ad23fe03a082 9 * functionalities of the Universal Synchronous/Asynchronous Receiver Transmitter
mbed_official 573:ad23fe03a082 10 * Peripheral (USART).
mbed_official 573:ad23fe03a082 11 * + Initialization and de-initialization functions
mbed_official 573:ad23fe03a082 12 * + IO operation functions
mbed_official 573:ad23fe03a082 13 * + Peripheral Control functions
mbed_official 573:ad23fe03a082 14 *
mbed_official 573:ad23fe03a082 15 @verbatim
mbed_official 573:ad23fe03a082 16 ===============================================================================
mbed_official 573:ad23fe03a082 17 ##### How to use this driver #####
mbed_official 573:ad23fe03a082 18 ===============================================================================
mbed_official 573:ad23fe03a082 19 [..]
mbed_official 573:ad23fe03a082 20 The USART HAL driver can be used as follows:
mbed_official 573:ad23fe03a082 21
mbed_official 573:ad23fe03a082 22 (#) Declare a USART_HandleTypeDef handle structure.
mbed_official 573:ad23fe03a082 23 (#) Initialize the USART low level resources by implement the HAL_USART_MspInit ()API:
mbed_official 573:ad23fe03a082 24 (##) Enable the USARTx interface clock.
mbed_official 573:ad23fe03a082 25 (##) USART pins configuration:
mbed_official 610:813dcc80987e 26 (+++) Enable the clock for the USART GPIOs.
mbed_official 610:813dcc80987e 27 (+++) Configure these USART pins as alternate function pull-up.
mbed_official 573:ad23fe03a082 28 (##) NVIC configuration if you need to use interrupt process (HAL_USART_Transmit_IT(),
mbed_official 573:ad23fe03a082 29 HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):
mbed_official 610:813dcc80987e 30 (+++) Configure the USARTx interrupt priority.
mbed_official 610:813dcc80987e 31 (+++) Enable the NVIC USART IRQ handle.
mbed_official 610:813dcc80987e 32 (+++) The specific USART interrupts (Transmission complete interrupt,
mbed_official 573:ad23fe03a082 33 RXNE interrupt and Error Interrupts) will be managed using the macros
mbed_official 573:ad23fe03a082 34 __HAL_USART_ENABLE_IT() and __HAL_USART_DISABLE_IT() inside the transmit and receive process.
mbed_official 573:ad23fe03a082 35 (##) DMA Configuration if you need to use DMA process (HAL_USART_Transmit_DMA()
mbed_official 573:ad23fe03a082 36 HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):
mbed_official 610:813dcc80987e 37 (+++) Declare a DMA handle structure for the Tx/Rx stream.
mbed_official 610:813dcc80987e 38 (+++) Enable the DMAx interface clock.
mbed_official 610:813dcc80987e 39 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
mbed_official 610:813dcc80987e 40 (+++) Configure the DMA Tx/Rx Stream.
mbed_official 610:813dcc80987e 41 (+++) Associate the initialized DMA handle to the USART DMA Tx/Rx handle.
mbed_official 610:813dcc80987e 42 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx Stream.
mbed_official 573:ad23fe03a082 43
mbed_official 573:ad23fe03a082 44 (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware
mbed_official 573:ad23fe03a082 45 flow control and Mode(Receiver/Transmitter) in the husart Init structure.
mbed_official 573:ad23fe03a082 46
mbed_official 573:ad23fe03a082 47 (#) Initialize the USART registers by calling the HAL_USART_Init() API:
mbed_official 610:813dcc80987e 48 (++) These API's configures also the low level Hardware (GPIO, CLOCK, CORTEX...etc)
mbed_official 610:813dcc80987e 49 by calling the customed HAL_USART_MspInit(&husart) API.
mbed_official 573:ad23fe03a082 50
mbed_official 573:ad23fe03a082 51 @endverbatim
mbed_official 573:ad23fe03a082 52 ******************************************************************************
mbed_official 573:ad23fe03a082 53 * @attention
mbed_official 573:ad23fe03a082 54 *
mbed_official 573:ad23fe03a082 55 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 573:ad23fe03a082 56 *
mbed_official 573:ad23fe03a082 57 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 573:ad23fe03a082 58 * are permitted provided that the following conditions are met:
mbed_official 573:ad23fe03a082 59 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 573:ad23fe03a082 60 * this list of conditions and the following disclaimer.
mbed_official 573:ad23fe03a082 61 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 573:ad23fe03a082 62 * this list of conditions and the following disclaimer in the documentation
mbed_official 573:ad23fe03a082 63 * and/or other materials provided with the distribution.
mbed_official 573:ad23fe03a082 64 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 573:ad23fe03a082 65 * may be used to endorse or promote products derived from this software
mbed_official 573:ad23fe03a082 66 * without specific prior written permission.
mbed_official 573:ad23fe03a082 67 *
mbed_official 573:ad23fe03a082 68 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 573:ad23fe03a082 69 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 573:ad23fe03a082 70 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 573:ad23fe03a082 71 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 573:ad23fe03a082 72 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 573:ad23fe03a082 73 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 573:ad23fe03a082 74 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 573:ad23fe03a082 75 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 573:ad23fe03a082 76 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 573:ad23fe03a082 77 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 573:ad23fe03a082 78 *
mbed_official 573:ad23fe03a082 79 ******************************************************************************
mbed_official 573:ad23fe03a082 80 */
mbed_official 573:ad23fe03a082 81
mbed_official 573:ad23fe03a082 82 /* Includes ------------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 83 #include "stm32f7xx_hal.h"
mbed_official 573:ad23fe03a082 84
mbed_official 573:ad23fe03a082 85 /** @addtogroup STM32F7xx_HAL_Driver
mbed_official 573:ad23fe03a082 86 * @{
mbed_official 573:ad23fe03a082 87 */
mbed_official 573:ad23fe03a082 88
mbed_official 573:ad23fe03a082 89 /** @defgroup USART USART
mbed_official 573:ad23fe03a082 90 * @brief HAL USART Synchronous module driver
mbed_official 573:ad23fe03a082 91 * @{
mbed_official 573:ad23fe03a082 92 */
mbed_official 573:ad23fe03a082 93
mbed_official 573:ad23fe03a082 94 #ifdef HAL_USART_MODULE_ENABLED
mbed_official 573:ad23fe03a082 95
mbed_official 573:ad23fe03a082 96 /* Private typedef -----------------------------------------------------------*/
mbed_official 573:ad23fe03a082 97 /* Private define ------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 98 /** @addtogroup USART_Private_Constants
mbed_official 573:ad23fe03a082 99 * @{
mbed_official 573:ad23fe03a082 100 */
mbed_official 573:ad23fe03a082 101 #define DUMMY_DATA ((uint16_t) 0xFFFF)
mbed_official 573:ad23fe03a082 102 #define TEACK_REACK_TIMEOUT ((uint32_t) 1000)
mbed_official 573:ad23fe03a082 103 #define USART_TXDMA_TIMEOUTVALUE 22000
mbed_official 573:ad23fe03a082 104 #define USART_TIMEOUT_VALUE 22000
mbed_official 573:ad23fe03a082 105 #define USART_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | \
mbed_official 573:ad23fe03a082 106 USART_CR1_TE | USART_CR1_RE | USART_CR1_OVER8))
mbed_official 573:ad23fe03a082 107 #define USART_CR2_FIELDS ((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | \
mbed_official 573:ad23fe03a082 108 USART_CR2_CLKEN | USART_CR2_LBCL | USART_CR2_STOP))
mbed_official 573:ad23fe03a082 109 /**
mbed_official 573:ad23fe03a082 110 * @}
mbed_official 573:ad23fe03a082 111 */
mbed_official 573:ad23fe03a082 112 /* Private macro -------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 113 /* Private variables ---------------------------------------------------------*/
mbed_official 573:ad23fe03a082 114 /* Private function prototypes -----------------------------------------------*/
mbed_official 573:ad23fe03a082 115 /* Private functions ---------------------------------------------------------*/
mbed_official 573:ad23fe03a082 116 /** @addtogroup USART_Private_Functions
mbed_official 573:ad23fe03a082 117 * @{
mbed_official 573:ad23fe03a082 118 */
mbed_official 573:ad23fe03a082 119 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 120 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 121 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 122 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 123 static void USART_DMAError(DMA_HandleTypeDef *hdma);
mbed_official 573:ad23fe03a082 124 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
mbed_official 573:ad23fe03a082 125 static HAL_StatusTypeDef USART_SetConfig(USART_HandleTypeDef *husart);
mbed_official 573:ad23fe03a082 126 static HAL_StatusTypeDef USART_CheckIdleState(USART_HandleTypeDef *husart);
mbed_official 573:ad23fe03a082 127 static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart);
mbed_official 573:ad23fe03a082 128 static HAL_StatusTypeDef USART_EndTransmit_IT(USART_HandleTypeDef *husart);
mbed_official 573:ad23fe03a082 129 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart);
mbed_official 573:ad23fe03a082 130 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart);
mbed_official 573:ad23fe03a082 131 /**
mbed_official 573:ad23fe03a082 132 * @}
mbed_official 573:ad23fe03a082 133 */
mbed_official 573:ad23fe03a082 134
mbed_official 573:ad23fe03a082 135 /* Exported functions --------------------------------------------------------*/
mbed_official 573:ad23fe03a082 136
mbed_official 573:ad23fe03a082 137 /** @defgroup USART_Exported_Functions USART Exported Functions
mbed_official 573:ad23fe03a082 138 * @{
mbed_official 573:ad23fe03a082 139 */
mbed_official 573:ad23fe03a082 140
mbed_official 573:ad23fe03a082 141 /** @defgroup USART_Exported_Functions_Group1 USART Initialization and de-initialization functions
mbed_official 573:ad23fe03a082 142 * @brief Initialization and Configuration functions
mbed_official 573:ad23fe03a082 143 *
mbed_official 573:ad23fe03a082 144 @verbatim
mbed_official 573:ad23fe03a082 145 ===============================================================================
mbed_official 573:ad23fe03a082 146 ##### Initialization and Configuration functions #####
mbed_official 573:ad23fe03a082 147 ===============================================================================
mbed_official 573:ad23fe03a082 148 [..]
mbed_official 573:ad23fe03a082 149 This subsection provides a set of functions allowing to initialize the USART
mbed_official 573:ad23fe03a082 150 in asynchronous and in synchronous modes.
mbed_official 573:ad23fe03a082 151 (+) For the asynchronous mode only these parameters can be configured:
mbed_official 573:ad23fe03a082 152 (++) Baud Rate
mbed_official 573:ad23fe03a082 153 (++) Word Length
mbed_official 573:ad23fe03a082 154 (++) Stop Bit
mbed_official 573:ad23fe03a082 155 (++) Parity: If the parity is enabled, then the MSB bit of the data written
mbed_official 573:ad23fe03a082 156 in the data register is transmitted but is changed by the parity bit.
mbed_official 573:ad23fe03a082 157 Depending on the frame length defined by the M1 and M0 bits (7-bit,
mbed_official 573:ad23fe03a082 158 8-bit or 9-bit), the possible USART frame formats are as listed in the
mbed_official 573:ad23fe03a082 159 following table:
mbed_official 573:ad23fe03a082 160
mbed_official 610:813dcc80987e 161 (+++) +---------------------------------------------------------------+
mbed_official 610:813dcc80987e 162 (+++) | M1M0 bits | PCE bit | USART frame |
mbed_official 610:813dcc80987e 163 (+++) |-----------------------|---------------------------------------|
mbed_official 610:813dcc80987e 164 (+++) | 10 | 0 | | SB | 7-bit data | STB | |
mbed_official 610:813dcc80987e 165 (+++) |-----------|-----------|---------------------------------------|
mbed_official 610:813dcc80987e 166 (+++) | 10 | 1 | | SB | 6-bit data | PB | STB | |
mbed_official 610:813dcc80987e 167 (+++) +---------------------------------------------------------------+
mbed_official 610:813dcc80987e 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 610:813dcc80987e 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 610:813dcc80987e 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 610:813dcc80987e 320 (++) HAL_USART_Transmit()in simplex mode
mbed_official 610:813dcc80987e 321 (++) HAL_USART_Receive() in full duplex receive only
mbed_official 610:813dcc80987e 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 610:813dcc80987e 325 (++) HAL_USART_Transmit_IT()in simplex mode
mbed_official 610:813dcc80987e 326 (++) HAL_USART_Receive_IT() in full duplex receive only
mbed_official 610:813dcc80987e 327 (++) HAL_USART_TransmitReceive_IT()in full duplex mode
mbed_official 610:813dcc80987e 328 (++) HAL_USART_IRQHandler()
mbed_official 573:ad23fe03a082 329
mbed_official 573:ad23fe03a082 330 (#) No-Blocking mode functions with DMA are :
mbed_official 610:813dcc80987e 331 (++) HAL_USART_Transmit_DMA()in simplex mode
mbed_official 610:813dcc80987e 332 (++) HAL_USART_Receive_DMA() in full duplex receive only
mbed_official 610:813dcc80987e 333 (++) HAL_USART_TransmitReceive_DMA() in full duplex mode
mbed_official 610:813dcc80987e 334 (++) HAL_USART_DMAPause()
mbed_official 610:813dcc80987e 335 (++) HAL_USART_DMAResume()
mbed_official 610:813dcc80987e 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 610:813dcc80987e 339 (++) HAL_USART_TxCpltCallback()
mbed_official 610:813dcc80987e 340 (++) HAL_USART_RxCpltCallback()
mbed_official 610:813dcc80987e 341 (++) HAL_USART_TxHalfCpltCallback()
mbed_official 610:813dcc80987e 342 (++) HAL_USART_RxHalfCpltCallback()
mbed_official 610:813dcc80987e 343 (++) HAL_USART_ErrorCallback()
mbed_official 610:813dcc80987e 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 610:813dcc80987e 1003 /* Clear the Overrun flag before resuming the Rx transfer*/
mbed_official 610:813dcc80987e 1004 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_OREF);
mbed_official 610:813dcc80987e 1005
mbed_official 573:ad23fe03a082 1006 /* Enable the USART DMA Rx request */
mbed_official 573:ad23fe03a082 1007 husart->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 573:ad23fe03a082 1008 }
mbed_official 573:ad23fe03a082 1009 else if(husart->State == HAL_USART_STATE_BUSY_TX_RX)
mbed_official 573:ad23fe03a082 1010 {
mbed_official 610:813dcc80987e 1011 /* Clear the Overrun flag before resuming the Rx transfer*/
mbed_official 610:813dcc80987e 1012 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_OREF);
mbed_official 610:813dcc80987e 1013
mbed_official 573:ad23fe03a082 1014 /* Enable the USART DMA Rx request before the DMA Tx request */
mbed_official 573:ad23fe03a082 1015 husart->Instance->CR3 |= USART_CR3_DMAR;
mbed_official 610:813dcc80987e 1016
mbed_official 573:ad23fe03a082 1017 /* Enable the USART DMA Tx request */
mbed_official 573:ad23fe03a082 1018 husart->Instance->CR3 |= USART_CR3_DMAT;
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 610:813dcc80987e 1034 /* The Lock is not implemented on this API to allow the user application
mbed_official 610:813dcc80987e 1035 to call the HAL USART API under callbacks HAL_USART_TxCpltCallback() / HAL_USART_RxCpltCallback() /
mbed_official 610:813dcc80987e 1036 HAL_USART_TxHalfCpltCallback / HAL_USART_RxHalfCpltCallback:
mbed_official 610:813dcc80987e 1037 indeed, when HAL_DMA_Abort() API is called, the DMA TX/RX Transfer or Half Transfer complete
mbed_official 610:813dcc80987e 1038 interrupt is generated if the DMA transfer interruption occurs at the middle or at the end of
mbed_official 610:813dcc80987e 1039 the stream and the corresponding call back is executed. */
mbed_official 573:ad23fe03a082 1040
mbed_official 573:ad23fe03a082 1041 /* Disable the USART Tx/Rx DMA requests */
mbed_official 573:ad23fe03a082 1042 husart->Instance->CR3 &= ~USART_CR3_DMAT;
mbed_official 573:ad23fe03a082 1043 husart->Instance->CR3 &= ~USART_CR3_DMAR;
mbed_official 573:ad23fe03a082 1044
mbed_official 573:ad23fe03a082 1045 /* Abort the USART DMA tx Stream */
mbed_official 573:ad23fe03a082 1046 if(husart->hdmatx != NULL)
mbed_official 573:ad23fe03a082 1047 {
mbed_official 573:ad23fe03a082 1048 HAL_DMA_Abort(husart->hdmatx);
mbed_official 573:ad23fe03a082 1049 }
mbed_official 573:ad23fe03a082 1050 /* Abort the USART DMA rx Stream */
mbed_official 573:ad23fe03a082 1051 if(husart->hdmarx != NULL)
mbed_official 573:ad23fe03a082 1052 {
mbed_official 573:ad23fe03a082 1053 HAL_DMA_Abort(husart->hdmarx);
mbed_official 573:ad23fe03a082 1054 }
mbed_official 573:ad23fe03a082 1055
mbed_official 573:ad23fe03a082 1056 husart->State = HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1057
mbed_official 573:ad23fe03a082 1058 return HAL_OK;
mbed_official 573:ad23fe03a082 1059 }
mbed_official 573:ad23fe03a082 1060
mbed_official 573:ad23fe03a082 1061 /**
mbed_official 573:ad23fe03a082 1062 * @brief This function handles USART interrupt request.
mbed_official 573:ad23fe03a082 1063 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1064 * @retval None
mbed_official 573:ad23fe03a082 1065 */
mbed_official 573:ad23fe03a082 1066 void HAL_USART_IRQHandler(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1067 {
mbed_official 573:ad23fe03a082 1068
mbed_official 573:ad23fe03a082 1069 /* USART parity error interrupt occurred ------------------------------------*/
mbed_official 573:ad23fe03a082 1070 if((__HAL_USART_GET_IT(husart, USART_IT_PE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_PE) != RESET))
mbed_official 573:ad23fe03a082 1071 {
mbed_official 573:ad23fe03a082 1072 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_PEF);
mbed_official 573:ad23fe03a082 1073 husart->ErrorCode |= HAL_USART_ERROR_PE;
mbed_official 573:ad23fe03a082 1074 /* Set the USART state ready to be able to start again the process */
mbed_official 573:ad23fe03a082 1075 husart->State = HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1076 }
mbed_official 573:ad23fe03a082 1077
mbed_official 573:ad23fe03a082 1078 /* USART frame error interrupt occurred -------------------------------------*/
mbed_official 573:ad23fe03a082 1079 if((__HAL_USART_GET_IT(husart, USART_IT_FE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))
mbed_official 573:ad23fe03a082 1080 {
mbed_official 573:ad23fe03a082 1081 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_FEF);
mbed_official 573:ad23fe03a082 1082 husart->ErrorCode |= HAL_USART_ERROR_FE;
mbed_official 573:ad23fe03a082 1083 /* Set the USART state ready to be able to start again the process */
mbed_official 573:ad23fe03a082 1084 husart->State = HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1085 }
mbed_official 573:ad23fe03a082 1086
mbed_official 573:ad23fe03a082 1087 /* USART noise error interrupt occurred -------------------------------------*/
mbed_official 573:ad23fe03a082 1088 if((__HAL_USART_GET_IT(husart, USART_IT_NE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))
mbed_official 573:ad23fe03a082 1089 {
mbed_official 573:ad23fe03a082 1090 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_NEF);
mbed_official 573:ad23fe03a082 1091 husart->ErrorCode |= HAL_USART_ERROR_NE;
mbed_official 573:ad23fe03a082 1092 /* Set the USART state ready to be able to start again the process */
mbed_official 573:ad23fe03a082 1093 husart->State = HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1094 }
mbed_official 573:ad23fe03a082 1095
mbed_official 573:ad23fe03a082 1096 /* USART Over-Run interrupt occurred ----------------------------------------*/
mbed_official 573:ad23fe03a082 1097 if((__HAL_USART_GET_IT(husart, USART_IT_ORE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))
mbed_official 573:ad23fe03a082 1098 {
mbed_official 573:ad23fe03a082 1099 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_OREF);
mbed_official 573:ad23fe03a082 1100 husart->ErrorCode |= HAL_USART_ERROR_ORE;
mbed_official 573:ad23fe03a082 1101 /* Set the USART state ready to be able to start again the process */
mbed_official 573:ad23fe03a082 1102 husart->State = HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1103 }
mbed_official 573:ad23fe03a082 1104
mbed_official 573:ad23fe03a082 1105 /* Call USART Error Call back function if need be --------------------------*/
mbed_official 573:ad23fe03a082 1106 if(husart->ErrorCode != HAL_USART_ERROR_NONE)
mbed_official 573:ad23fe03a082 1107 {
mbed_official 573:ad23fe03a082 1108 HAL_USART_ErrorCallback(husart);
mbed_official 573:ad23fe03a082 1109 }
mbed_official 573:ad23fe03a082 1110
mbed_official 573:ad23fe03a082 1111 /* USART in mode Receiver --------------------------------------------------*/
mbed_official 573:ad23fe03a082 1112 if((__HAL_USART_GET_IT(husart, USART_IT_RXNE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_RXNE) != RESET))
mbed_official 573:ad23fe03a082 1113 {
mbed_official 573:ad23fe03a082 1114 if(husart->State == HAL_USART_STATE_BUSY_RX)
mbed_official 573:ad23fe03a082 1115 {
mbed_official 573:ad23fe03a082 1116 USART_Receive_IT(husart);
mbed_official 573:ad23fe03a082 1117 }
mbed_official 573:ad23fe03a082 1118 else
mbed_official 573:ad23fe03a082 1119 {
mbed_official 573:ad23fe03a082 1120 USART_TransmitReceive_IT(husart);
mbed_official 573:ad23fe03a082 1121 }
mbed_official 573:ad23fe03a082 1122 }
mbed_official 573:ad23fe03a082 1123
mbed_official 573:ad23fe03a082 1124 /* USART in mode Transmitter -----------------------------------------------*/
mbed_official 573:ad23fe03a082 1125 if((__HAL_USART_GET_IT(husart, USART_IT_TXE) != RESET) &&(__HAL_USART_GET_IT_SOURCE(husart, USART_IT_TXE) != RESET))
mbed_official 573:ad23fe03a082 1126 {
mbed_official 573:ad23fe03a082 1127 if(husart->State == HAL_USART_STATE_BUSY_TX)
mbed_official 573:ad23fe03a082 1128 {
mbed_official 573:ad23fe03a082 1129 USART_Transmit_IT(husart);
mbed_official 573:ad23fe03a082 1130 }
mbed_official 573:ad23fe03a082 1131 else
mbed_official 573:ad23fe03a082 1132 {
mbed_official 573:ad23fe03a082 1133 USART_TransmitReceive_IT(husart);
mbed_official 573:ad23fe03a082 1134 }
mbed_official 573:ad23fe03a082 1135 }
mbed_official 573:ad23fe03a082 1136
mbed_official 573:ad23fe03a082 1137 /* USART in mode Transmitter (transmission end) -----------------------------*/
mbed_official 573:ad23fe03a082 1138 if((__HAL_USART_GET_IT(husart, USART_IT_TC) != RESET) &&(__HAL_USART_GET_IT_SOURCE(husart, USART_IT_TC) != RESET))
mbed_official 573:ad23fe03a082 1139 {
mbed_official 573:ad23fe03a082 1140 USART_EndTransmit_IT(husart);
mbed_official 573:ad23fe03a082 1141 }
mbed_official 573:ad23fe03a082 1142
mbed_official 573:ad23fe03a082 1143 }
mbed_official 573:ad23fe03a082 1144
mbed_official 573:ad23fe03a082 1145 /**
mbed_official 573:ad23fe03a082 1146 * @brief Tx Transfer completed callbacks
mbed_official 573:ad23fe03a082 1147 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1148 * @retval None
mbed_official 573:ad23fe03a082 1149 */
mbed_official 573:ad23fe03a082 1150 __weak void HAL_USART_TxCpltCallback(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1151 {
mbed_official 573:ad23fe03a082 1152 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 1153 the HAL_USART_TxCpltCallback can be implemented in the user file
mbed_official 573:ad23fe03a082 1154 */
mbed_official 573:ad23fe03a082 1155 }
mbed_official 573:ad23fe03a082 1156
mbed_official 573:ad23fe03a082 1157 /**
mbed_official 573:ad23fe03a082 1158 * @brief Tx Half Transfer completed callbacks.
mbed_official 573:ad23fe03a082 1159 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1160 * @retval None
mbed_official 573:ad23fe03a082 1161 */
mbed_official 573:ad23fe03a082 1162 __weak void HAL_USART_TxHalfCpltCallback(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1163 {
mbed_official 573:ad23fe03a082 1164 /* NOTE: This function should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 1165 the HAL_USART_TxHalfCpltCallback can be implemented in the user file
mbed_official 573:ad23fe03a082 1166 */
mbed_official 573:ad23fe03a082 1167 }
mbed_official 573:ad23fe03a082 1168
mbed_official 573:ad23fe03a082 1169 /**
mbed_official 573:ad23fe03a082 1170 * @brief Rx Transfer completed callbacks.
mbed_official 573:ad23fe03a082 1171 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1172 * @retval None
mbed_official 573:ad23fe03a082 1173 */
mbed_official 573:ad23fe03a082 1174 __weak void HAL_USART_RxCpltCallback(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1175 {
mbed_official 573:ad23fe03a082 1176 /* NOTE: This function should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 1177 the HAL_USART_RxCpltCallback can be implemented in the user file
mbed_official 573:ad23fe03a082 1178 */
mbed_official 573:ad23fe03a082 1179 }
mbed_official 573:ad23fe03a082 1180
mbed_official 573:ad23fe03a082 1181 /**
mbed_official 573:ad23fe03a082 1182 * @brief Rx Half Transfer completed callbacks
mbed_official 573:ad23fe03a082 1183 * @param husart: usart handle
mbed_official 573:ad23fe03a082 1184 * @retval None
mbed_official 573:ad23fe03a082 1185 */
mbed_official 573:ad23fe03a082 1186 __weak void HAL_USART_RxHalfCpltCallback(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1187 {
mbed_official 573:ad23fe03a082 1188 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 1189 the HAL_USART_RxHalfCpltCallback can be implemented in the user file
mbed_official 573:ad23fe03a082 1190 */
mbed_official 573:ad23fe03a082 1191 }
mbed_official 573:ad23fe03a082 1192
mbed_official 573:ad23fe03a082 1193 /**
mbed_official 573:ad23fe03a082 1194 * @brief Tx/Rx Transfers completed callback for the non-blocking process
mbed_official 573:ad23fe03a082 1195 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1196 * @retval None
mbed_official 573:ad23fe03a082 1197 */
mbed_official 573:ad23fe03a082 1198 __weak void HAL_USART_TxRxCpltCallback(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1199 {
mbed_official 573:ad23fe03a082 1200 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 1201 the HAL_USART_TxRxCpltCallback can be implemented in the user file
mbed_official 573:ad23fe03a082 1202 */
mbed_official 573:ad23fe03a082 1203 }
mbed_official 573:ad23fe03a082 1204
mbed_official 573:ad23fe03a082 1205 /**
mbed_official 573:ad23fe03a082 1206 * @brief USART error callbacks
mbed_official 573:ad23fe03a082 1207 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1208 * @retval None
mbed_official 573:ad23fe03a082 1209 */
mbed_official 573:ad23fe03a082 1210 __weak void HAL_USART_ErrorCallback(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1211 {
mbed_official 573:ad23fe03a082 1212 /* NOTE : This function should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 1213 the HAL_USART_ErrorCallback can be implemented in the user file
mbed_official 573:ad23fe03a082 1214 */
mbed_official 573:ad23fe03a082 1215 }
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 /** @defgroup USART_Exported_Functions_Group3 Peripheral State and Errors functions
mbed_official 573:ad23fe03a082 1222 * @brief USART State and Errors functions
mbed_official 573:ad23fe03a082 1223 *
mbed_official 573:ad23fe03a082 1224 @verbatim
mbed_official 573:ad23fe03a082 1225 ==============================================================================
mbed_official 573:ad23fe03a082 1226 ##### Peripheral State and Errors functions #####
mbed_official 573:ad23fe03a082 1227 ==============================================================================
mbed_official 573:ad23fe03a082 1228 [..]
mbed_official 573:ad23fe03a082 1229 This subsection provides a set of functions allowing to return the State of
mbed_official 573:ad23fe03a082 1230 USART communication
mbed_official 573:ad23fe03a082 1231 process, return Peripheral Errors occurred during communication process
mbed_official 573:ad23fe03a082 1232 (+) HAL_USART_GetState() API can be helpful to check in run-time the state
mbed_official 573:ad23fe03a082 1233 of the USART peripheral.
mbed_official 573:ad23fe03a082 1234 (+) HAL_USART_GetError() check in run-time errors that could be occurred during
mbed_official 573:ad23fe03a082 1235 communication.
mbed_official 573:ad23fe03a082 1236 @endverbatim
mbed_official 573:ad23fe03a082 1237 * @{
mbed_official 573:ad23fe03a082 1238 */
mbed_official 573:ad23fe03a082 1239
mbed_official 573:ad23fe03a082 1240 /**
mbed_official 573:ad23fe03a082 1241 * @brief return the USART state
mbed_official 573:ad23fe03a082 1242 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1243 * @retval HAL state
mbed_official 573:ad23fe03a082 1244 */
mbed_official 573:ad23fe03a082 1245 HAL_USART_StateTypeDef HAL_USART_GetState(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1246 {
mbed_official 573:ad23fe03a082 1247 return husart->State;
mbed_official 573:ad23fe03a082 1248 }
mbed_official 573:ad23fe03a082 1249
mbed_official 573:ad23fe03a082 1250 /**
mbed_official 573:ad23fe03a082 1251 * @brief Return the USART error code
mbed_official 573:ad23fe03a082 1252 * @param husart : pointer to a USART_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1253 * the configuration information for the specified USART.
mbed_official 573:ad23fe03a082 1254 * @retval USART Error Code
mbed_official 573:ad23fe03a082 1255 */
mbed_official 573:ad23fe03a082 1256 uint32_t HAL_USART_GetError(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1257 {
mbed_official 573:ad23fe03a082 1258 return husart->ErrorCode;
mbed_official 573:ad23fe03a082 1259 }
mbed_official 573:ad23fe03a082 1260
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 * @brief Simplex Send an amount of data in non-blocking mode.
mbed_official 573:ad23fe03a082 1268 * @note Function called under interruption only, once
mbed_official 573:ad23fe03a082 1269 * interruptions have been enabled by HAL_USART_Transmit_IT().
mbed_official 573:ad23fe03a082 1270 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1271 * @retval HAL status
mbed_official 573:ad23fe03a082 1272 * @note The USART errors are not managed to avoid the overrun error.
mbed_official 573:ad23fe03a082 1273 */
mbed_official 573:ad23fe03a082 1274 static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1275 {
mbed_official 573:ad23fe03a082 1276 uint16_t* tmp;
mbed_official 573:ad23fe03a082 1277
mbed_official 573:ad23fe03a082 1278 if(husart->State == HAL_USART_STATE_BUSY_TX)
mbed_official 573:ad23fe03a082 1279 {
mbed_official 573:ad23fe03a082 1280
mbed_official 573:ad23fe03a082 1281 if(husart->TxXferCount == 0)
mbed_official 573:ad23fe03a082 1282 {
mbed_official 573:ad23fe03a082 1283 /* Disable the USART Transmit Complete Interrupt */
mbed_official 573:ad23fe03a082 1284 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
mbed_official 573:ad23fe03a082 1285
mbed_official 573:ad23fe03a082 1286 /* Enable the USART Transmit Complete Interrupt */
mbed_official 573:ad23fe03a082 1287 __HAL_USART_ENABLE_IT(husart, USART_IT_TC);
mbed_official 573:ad23fe03a082 1288
mbed_official 573:ad23fe03a082 1289 return HAL_OK;
mbed_official 573:ad23fe03a082 1290 }
mbed_official 573:ad23fe03a082 1291 else
mbed_official 573:ad23fe03a082 1292 {
mbed_official 573:ad23fe03a082 1293 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 573:ad23fe03a082 1294 {
mbed_official 573:ad23fe03a082 1295 tmp = (uint16_t*) husart->pTxBuffPtr;
mbed_official 573:ad23fe03a082 1296 husart->Instance->TDR = (*tmp & (uint16_t)0x01FF);
mbed_official 573:ad23fe03a082 1297 husart->pTxBuffPtr += 2;
mbed_official 573:ad23fe03a082 1298 }
mbed_official 573:ad23fe03a082 1299 else
mbed_official 573:ad23fe03a082 1300 {
mbed_official 573:ad23fe03a082 1301 husart->Instance->TDR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0xFF);
mbed_official 573:ad23fe03a082 1302 }
mbed_official 573:ad23fe03a082 1303
mbed_official 573:ad23fe03a082 1304 husart->TxXferCount--;
mbed_official 573:ad23fe03a082 1305
mbed_official 573:ad23fe03a082 1306 return HAL_OK;
mbed_official 573:ad23fe03a082 1307 }
mbed_official 573:ad23fe03a082 1308 }
mbed_official 573:ad23fe03a082 1309 else
mbed_official 573:ad23fe03a082 1310 {
mbed_official 573:ad23fe03a082 1311 return HAL_BUSY;
mbed_official 573:ad23fe03a082 1312 }
mbed_official 573:ad23fe03a082 1313 }
mbed_official 573:ad23fe03a082 1314
mbed_official 573:ad23fe03a082 1315 /**
mbed_official 573:ad23fe03a082 1316 * @brief Wraps up transmission in non-blocking mode.
mbed_official 573:ad23fe03a082 1317 * @param husart: pointer to a USART_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 1318 * the configuration information for the specified USART module.
mbed_official 573:ad23fe03a082 1319 * @retval HAL status
mbed_official 573:ad23fe03a082 1320 */
mbed_official 573:ad23fe03a082 1321 static HAL_StatusTypeDef USART_EndTransmit_IT(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1322 {
mbed_official 573:ad23fe03a082 1323 /* Disable the USART Transmit Complete Interrupt */
mbed_official 573:ad23fe03a082 1324 __HAL_USART_DISABLE_IT(husart, USART_IT_TC);
mbed_official 573:ad23fe03a082 1325
mbed_official 573:ad23fe03a082 1326 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 573:ad23fe03a082 1327 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
mbed_official 573:ad23fe03a082 1328
mbed_official 573:ad23fe03a082 1329 husart->State = HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1330
mbed_official 573:ad23fe03a082 1331 HAL_USART_TxCpltCallback(husart);
mbed_official 573:ad23fe03a082 1332
mbed_official 573:ad23fe03a082 1333 return HAL_OK;
mbed_official 573:ad23fe03a082 1334 }
mbed_official 573:ad23fe03a082 1335
mbed_official 573:ad23fe03a082 1336 /**
mbed_official 573:ad23fe03a082 1337 * @brief Simplex Receive an amount of data in non-blocking mode.
mbed_official 573:ad23fe03a082 1338 * Function called under interruption only, once
mbed_official 573:ad23fe03a082 1339 * interruptions have been enabled by HAL_USART_Receive_IT()
mbed_official 573:ad23fe03a082 1340 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1341 * @retval HAL status
mbed_official 573:ad23fe03a082 1342 */
mbed_official 573:ad23fe03a082 1343 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1344 {
mbed_official 573:ad23fe03a082 1345 uint16_t* tmp;
mbed_official 573:ad23fe03a082 1346 uint16_t uhMask = husart->Mask;
mbed_official 573:ad23fe03a082 1347
mbed_official 573:ad23fe03a082 1348 if(husart->State == HAL_USART_STATE_BUSY_RX)
mbed_official 573:ad23fe03a082 1349 {
mbed_official 573:ad23fe03a082 1350
mbed_official 573:ad23fe03a082 1351 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 573:ad23fe03a082 1352 {
mbed_official 573:ad23fe03a082 1353 tmp = (uint16_t*) husart->pRxBuffPtr;
mbed_official 573:ad23fe03a082 1354 *tmp = (uint16_t)(husart->Instance->RDR & uhMask);
mbed_official 573:ad23fe03a082 1355 husart->pRxBuffPtr += 2;
mbed_official 573:ad23fe03a082 1356 }
mbed_official 573:ad23fe03a082 1357 else
mbed_official 573:ad23fe03a082 1358 {
mbed_official 573:ad23fe03a082 1359 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);
mbed_official 573:ad23fe03a082 1360 }
mbed_official 573:ad23fe03a082 1361 /* Send dummy byte in order to generate the clock for the Slave to Send the next data */
mbed_official 573:ad23fe03a082 1362 husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x00FF);
mbed_official 573:ad23fe03a082 1363
mbed_official 573:ad23fe03a082 1364 if(--husart->RxXferCount == 0)
mbed_official 573:ad23fe03a082 1365 {
mbed_official 573:ad23fe03a082 1366 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
mbed_official 573:ad23fe03a082 1367
mbed_official 573:ad23fe03a082 1368 /* Disable the USART Parity Error Interrupt */
mbed_official 573:ad23fe03a082 1369 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
mbed_official 573:ad23fe03a082 1370
mbed_official 573:ad23fe03a082 1371 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 573:ad23fe03a082 1372 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
mbed_official 573:ad23fe03a082 1373
mbed_official 573:ad23fe03a082 1374 husart->State = HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1375
mbed_official 573:ad23fe03a082 1376 HAL_USART_RxCpltCallback(husart);
mbed_official 573:ad23fe03a082 1377
mbed_official 573:ad23fe03a082 1378 return HAL_OK;
mbed_official 573:ad23fe03a082 1379 }
mbed_official 573:ad23fe03a082 1380
mbed_official 573:ad23fe03a082 1381 return HAL_OK;
mbed_official 573:ad23fe03a082 1382 }
mbed_official 573:ad23fe03a082 1383 else
mbed_official 573:ad23fe03a082 1384 {
mbed_official 573:ad23fe03a082 1385 return HAL_BUSY;
mbed_official 573:ad23fe03a082 1386 }
mbed_official 573:ad23fe03a082 1387 }
mbed_official 573:ad23fe03a082 1388
mbed_official 573:ad23fe03a082 1389 /**
mbed_official 573:ad23fe03a082 1390 * @brief Full-Duplex Send receive an amount of data in full-duplex mode (non-blocking).
mbed_official 573:ad23fe03a082 1391 * Function called under interruption only, once
mbed_official 573:ad23fe03a082 1392 * interruptions have been enabled by HAL_USART_TransmitReceive_IT()
mbed_official 573:ad23fe03a082 1393 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1394 * @retval HAL status
mbed_official 573:ad23fe03a082 1395 */
mbed_official 573:ad23fe03a082 1396 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1397 {
mbed_official 573:ad23fe03a082 1398 uint16_t* tmp;
mbed_official 573:ad23fe03a082 1399 uint16_t uhMask = husart->Mask;
mbed_official 573:ad23fe03a082 1400
mbed_official 573:ad23fe03a082 1401 if(husart->State == HAL_USART_STATE_BUSY_TX_RX)
mbed_official 573:ad23fe03a082 1402 {
mbed_official 573:ad23fe03a082 1403 if(husart->TxXferCount != 0x00)
mbed_official 573:ad23fe03a082 1404 {
mbed_official 573:ad23fe03a082 1405 if(__HAL_USART_GET_FLAG(husart, USART_FLAG_TXE) != RESET)
mbed_official 573:ad23fe03a082 1406 {
mbed_official 573:ad23fe03a082 1407 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 573:ad23fe03a082 1408 {
mbed_official 573:ad23fe03a082 1409 tmp = (uint16_t*) husart->pTxBuffPtr;
mbed_official 573:ad23fe03a082 1410 husart->Instance->TDR = (uint16_t)(*tmp & uhMask);
mbed_official 573:ad23fe03a082 1411 husart->pTxBuffPtr += 2;
mbed_official 573:ad23fe03a082 1412 }
mbed_official 573:ad23fe03a082 1413 else
mbed_official 573:ad23fe03a082 1414 {
mbed_official 573:ad23fe03a082 1415 husart->Instance->TDR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)uhMask);
mbed_official 573:ad23fe03a082 1416 }
mbed_official 573:ad23fe03a082 1417 husart->TxXferCount--;
mbed_official 573:ad23fe03a082 1418
mbed_official 573:ad23fe03a082 1419 /* Check the latest data transmitted */
mbed_official 573:ad23fe03a082 1420 if(husart->TxXferCount == 0)
mbed_official 573:ad23fe03a082 1421 {
mbed_official 573:ad23fe03a082 1422 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
mbed_official 573:ad23fe03a082 1423 }
mbed_official 573:ad23fe03a082 1424 }
mbed_official 573:ad23fe03a082 1425 }
mbed_official 573:ad23fe03a082 1426
mbed_official 573:ad23fe03a082 1427 if(husart->RxXferCount != 0x00)
mbed_official 573:ad23fe03a082 1428 {
mbed_official 573:ad23fe03a082 1429 if(__HAL_USART_GET_FLAG(husart, USART_FLAG_RXNE) != RESET)
mbed_official 573:ad23fe03a082 1430 {
mbed_official 573:ad23fe03a082 1431 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
mbed_official 573:ad23fe03a082 1432 {
mbed_official 573:ad23fe03a082 1433 tmp = (uint16_t*) husart->pRxBuffPtr;
mbed_official 573:ad23fe03a082 1434 *tmp = (uint16_t)(husart->Instance->RDR & uhMask);
mbed_official 573:ad23fe03a082 1435 husart->pRxBuffPtr += 2;
mbed_official 573:ad23fe03a082 1436 }
mbed_official 573:ad23fe03a082 1437 else
mbed_official 573:ad23fe03a082 1438 {
mbed_official 573:ad23fe03a082 1439 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);
mbed_official 573:ad23fe03a082 1440 }
mbed_official 573:ad23fe03a082 1441 husart->RxXferCount--;
mbed_official 573:ad23fe03a082 1442 }
mbed_official 573:ad23fe03a082 1443 }
mbed_official 573:ad23fe03a082 1444
mbed_official 573:ad23fe03a082 1445 /* Check the latest data received */
mbed_official 573:ad23fe03a082 1446 if(husart->RxXferCount == 0)
mbed_official 573:ad23fe03a082 1447 {
mbed_official 573:ad23fe03a082 1448 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
mbed_official 573:ad23fe03a082 1449
mbed_official 573:ad23fe03a082 1450 /* Disable the USART Parity Error Interrupt */
mbed_official 573:ad23fe03a082 1451 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
mbed_official 573:ad23fe03a082 1452
mbed_official 573:ad23fe03a082 1453 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
mbed_official 573:ad23fe03a082 1454 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
mbed_official 573:ad23fe03a082 1455
mbed_official 573:ad23fe03a082 1456 husart->State = HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1457
mbed_official 573:ad23fe03a082 1458 HAL_USART_TxRxCpltCallback(husart);
mbed_official 573:ad23fe03a082 1459
mbed_official 573:ad23fe03a082 1460 return HAL_OK;
mbed_official 573:ad23fe03a082 1461 }
mbed_official 573:ad23fe03a082 1462
mbed_official 573:ad23fe03a082 1463 return HAL_OK;
mbed_official 573:ad23fe03a082 1464 }
mbed_official 573:ad23fe03a082 1465 else
mbed_official 573:ad23fe03a082 1466 {
mbed_official 573:ad23fe03a082 1467 return HAL_BUSY;
mbed_official 573:ad23fe03a082 1468 }
mbed_official 573:ad23fe03a082 1469 }
mbed_official 573:ad23fe03a082 1470
mbed_official 573:ad23fe03a082 1471 /**
mbed_official 573:ad23fe03a082 1472 * @brief This function handles USART Communication Timeout.
mbed_official 573:ad23fe03a082 1473 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1474 * @param Flag: specifies the USART flag to check.
mbed_official 573:ad23fe03a082 1475 * @param Status: The new Flag status (SET or RESET).
mbed_official 573:ad23fe03a082 1476 * @param Timeout: Timeout duration
mbed_official 573:ad23fe03a082 1477 * @retval HAL status
mbed_official 573:ad23fe03a082 1478 */
mbed_official 573:ad23fe03a082 1479 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
mbed_official 573:ad23fe03a082 1480 {
mbed_official 573:ad23fe03a082 1481 uint32_t tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 1482
mbed_official 573:ad23fe03a082 1483 /* Wait until flag is set */
mbed_official 573:ad23fe03a082 1484 if(Status == RESET)
mbed_official 573:ad23fe03a082 1485 {
mbed_official 573:ad23fe03a082 1486 while(__HAL_USART_GET_FLAG(husart, Flag) == RESET)
mbed_official 573:ad23fe03a082 1487 {
mbed_official 573:ad23fe03a082 1488 /* Check for the Timeout */
mbed_official 573:ad23fe03a082 1489 if(Timeout != HAL_MAX_DELAY)
mbed_official 573:ad23fe03a082 1490 {
mbed_official 573:ad23fe03a082 1491 if((Timeout == 0)||((HAL_GetTick()-tickstart) >= Timeout))
mbed_official 573:ad23fe03a082 1492 {
mbed_official 573:ad23fe03a082 1493 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 573:ad23fe03a082 1494 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
mbed_official 573:ad23fe03a082 1495 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
mbed_official 573:ad23fe03a082 1496 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
mbed_official 573:ad23fe03a082 1497 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
mbed_official 573:ad23fe03a082 1498
mbed_official 573:ad23fe03a082 1499 husart->State= HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1500
mbed_official 573:ad23fe03a082 1501 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1502 __HAL_UNLOCK(husart);
mbed_official 573:ad23fe03a082 1503
mbed_official 573:ad23fe03a082 1504 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1505 }
mbed_official 573:ad23fe03a082 1506 }
mbed_official 573:ad23fe03a082 1507 }
mbed_official 573:ad23fe03a082 1508 }
mbed_official 573:ad23fe03a082 1509 else
mbed_official 573:ad23fe03a082 1510 {
mbed_official 573:ad23fe03a082 1511 while(__HAL_USART_GET_FLAG(husart, Flag) != RESET)
mbed_official 573:ad23fe03a082 1512 {
mbed_official 573:ad23fe03a082 1513 /* Check for the Timeout */
mbed_official 573:ad23fe03a082 1514 if(Timeout != HAL_MAX_DELAY)
mbed_official 573:ad23fe03a082 1515 {
mbed_official 573:ad23fe03a082 1516 if((Timeout == 0)||((HAL_GetTick()-tickstart) >= Timeout))
mbed_official 573:ad23fe03a082 1517 {
mbed_official 573:ad23fe03a082 1518 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
mbed_official 573:ad23fe03a082 1519 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
mbed_official 573:ad23fe03a082 1520 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
mbed_official 573:ad23fe03a082 1521 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
mbed_official 573:ad23fe03a082 1522 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
mbed_official 573:ad23fe03a082 1523
mbed_official 573:ad23fe03a082 1524 husart->State= HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1525
mbed_official 573:ad23fe03a082 1526 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1527 __HAL_UNLOCK(husart);
mbed_official 573:ad23fe03a082 1528
mbed_official 573:ad23fe03a082 1529 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1530 }
mbed_official 573:ad23fe03a082 1531 }
mbed_official 573:ad23fe03a082 1532 }
mbed_official 573:ad23fe03a082 1533 }
mbed_official 573:ad23fe03a082 1534 return HAL_OK;
mbed_official 573:ad23fe03a082 1535 }
mbed_official 573:ad23fe03a082 1536
mbed_official 573:ad23fe03a082 1537
mbed_official 573:ad23fe03a082 1538 /**
mbed_official 573:ad23fe03a082 1539 * @brief DMA USART transmit process complete callback
mbed_official 573:ad23fe03a082 1540 * @param hdma: DMA handle
mbed_official 573:ad23fe03a082 1541 * @retval None
mbed_official 573:ad23fe03a082 1542 */
mbed_official 573:ad23fe03a082 1543 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1544 {
mbed_official 573:ad23fe03a082 1545 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 573:ad23fe03a082 1546
mbed_official 573:ad23fe03a082 1547 /* DMA Normal mode */
mbed_official 573:ad23fe03a082 1548 if((hdma->Instance->CR & DMA_SxCR_CIRC) == 0)
mbed_official 573:ad23fe03a082 1549 {
mbed_official 573:ad23fe03a082 1550 husart->TxXferCount = 0;
mbed_official 573:ad23fe03a082 1551
mbed_official 573:ad23fe03a082 1552 if(husart->State == HAL_USART_STATE_BUSY_TX)
mbed_official 573:ad23fe03a082 1553 {
mbed_official 573:ad23fe03a082 1554 /* Disable the DMA transfer for transmit request by resetting the DMAT bit
mbed_official 573:ad23fe03a082 1555 in the USART CR3 register */
mbed_official 573:ad23fe03a082 1556 husart->Instance->CR3 &= ~(USART_CR3_DMAT);
mbed_official 573:ad23fe03a082 1557
mbed_official 573:ad23fe03a082 1558 /* Enable the USART Transmit Complete Interrupt */
mbed_official 573:ad23fe03a082 1559 __HAL_USART_ENABLE_IT(husart, USART_IT_TC);
mbed_official 573:ad23fe03a082 1560 }
mbed_official 573:ad23fe03a082 1561 }
mbed_official 573:ad23fe03a082 1562 /* DMA Circular mode */
mbed_official 573:ad23fe03a082 1563 else
mbed_official 573:ad23fe03a082 1564 {
mbed_official 573:ad23fe03a082 1565 if(husart->State == HAL_USART_STATE_BUSY_TX)
mbed_official 573:ad23fe03a082 1566 {
mbed_official 573:ad23fe03a082 1567 HAL_USART_TxCpltCallback(husart);
mbed_official 573:ad23fe03a082 1568 }
mbed_official 573:ad23fe03a082 1569 }
mbed_official 573:ad23fe03a082 1570 }
mbed_official 573:ad23fe03a082 1571
mbed_official 573:ad23fe03a082 1572
mbed_official 573:ad23fe03a082 1573 /**
mbed_official 573:ad23fe03a082 1574 * @brief DMA USART transmit process half complete callback
mbed_official 573:ad23fe03a082 1575 * @param hdma : DMA handle
mbed_official 573:ad23fe03a082 1576 * @retval None
mbed_official 573:ad23fe03a082 1577 */
mbed_official 573:ad23fe03a082 1578 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1579 {
mbed_official 573:ad23fe03a082 1580 USART_HandleTypeDef* husart = (USART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 573:ad23fe03a082 1581
mbed_official 573:ad23fe03a082 1582 HAL_USART_TxHalfCpltCallback(husart);
mbed_official 573:ad23fe03a082 1583 }
mbed_official 573:ad23fe03a082 1584
mbed_official 573:ad23fe03a082 1585 /**
mbed_official 573:ad23fe03a082 1586 * @brief DMA USART receive process complete callback
mbed_official 573:ad23fe03a082 1587 * @param hdma: DMA handle
mbed_official 573:ad23fe03a082 1588 * @retval None
mbed_official 573:ad23fe03a082 1589 */
mbed_official 573:ad23fe03a082 1590 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1591 {
mbed_official 573:ad23fe03a082 1592 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 573:ad23fe03a082 1593
mbed_official 573:ad23fe03a082 1594 /* DMA Normal mode */
mbed_official 573:ad23fe03a082 1595 if((hdma->Instance->CR & DMA_SxCR_CIRC) == 0)
mbed_official 573:ad23fe03a082 1596 {
mbed_official 573:ad23fe03a082 1597 husart->RxXferCount = 0;
mbed_official 573:ad23fe03a082 1598
mbed_official 573:ad23fe03a082 1599 /* Disable the DMA RX transfer for the receiver request by resetting the DMAR bit
mbed_official 573:ad23fe03a082 1600 in USART CR3 register */
mbed_official 573:ad23fe03a082 1601 husart->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DMAR);
mbed_official 573:ad23fe03a082 1602 /* similarly, disable the DMA TX transfer that was started to provide the
mbed_official 573:ad23fe03a082 1603 clock to the slave device */
mbed_official 573:ad23fe03a082 1604 husart->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DMAT);
mbed_official 573:ad23fe03a082 1605
mbed_official 573:ad23fe03a082 1606 if(husart->State == HAL_USART_STATE_BUSY_RX)
mbed_official 573:ad23fe03a082 1607 {
mbed_official 573:ad23fe03a082 1608 HAL_USART_RxCpltCallback(husart);
mbed_official 573:ad23fe03a082 1609 }
mbed_official 573:ad23fe03a082 1610 /* The USART state is HAL_USART_STATE_BUSY_TX_RX */
mbed_official 573:ad23fe03a082 1611 else
mbed_official 573:ad23fe03a082 1612 {
mbed_official 573:ad23fe03a082 1613 HAL_USART_TxRxCpltCallback(husart);
mbed_official 573:ad23fe03a082 1614 }
mbed_official 573:ad23fe03a082 1615 husart->State= HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1616 }
mbed_official 573:ad23fe03a082 1617 /* DMA circular mode */
mbed_official 573:ad23fe03a082 1618 else
mbed_official 573:ad23fe03a082 1619 {
mbed_official 573:ad23fe03a082 1620 if(husart->State == HAL_USART_STATE_BUSY_RX)
mbed_official 573:ad23fe03a082 1621 {
mbed_official 573:ad23fe03a082 1622 HAL_USART_RxCpltCallback(husart);
mbed_official 573:ad23fe03a082 1623 }
mbed_official 573:ad23fe03a082 1624 /* The USART state is HAL_USART_STATE_BUSY_TX_RX */
mbed_official 573:ad23fe03a082 1625 else
mbed_official 573:ad23fe03a082 1626 {
mbed_official 573:ad23fe03a082 1627 HAL_USART_TxRxCpltCallback(husart);
mbed_official 573:ad23fe03a082 1628 }
mbed_official 573:ad23fe03a082 1629 }
mbed_official 573:ad23fe03a082 1630 }
mbed_official 573:ad23fe03a082 1631
mbed_official 573:ad23fe03a082 1632 /**
mbed_official 573:ad23fe03a082 1633 * @brief DMA USART receive process half complete callback
mbed_official 573:ad23fe03a082 1634 * @param hdma : DMA handle
mbed_official 573:ad23fe03a082 1635 * @retval None
mbed_official 573:ad23fe03a082 1636 */
mbed_official 573:ad23fe03a082 1637 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1638 {
mbed_official 573:ad23fe03a082 1639 USART_HandleTypeDef* husart = (USART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
mbed_official 573:ad23fe03a082 1640
mbed_official 573:ad23fe03a082 1641 HAL_USART_RxHalfCpltCallback(husart);
mbed_official 573:ad23fe03a082 1642 }
mbed_official 573:ad23fe03a082 1643
mbed_official 573:ad23fe03a082 1644 /**
mbed_official 573:ad23fe03a082 1645 * @brief DMA USART communication error callback
mbed_official 573:ad23fe03a082 1646 * @param hdma: DMA handle
mbed_official 573:ad23fe03a082 1647 * @retval None
mbed_official 573:ad23fe03a082 1648 */
mbed_official 573:ad23fe03a082 1649 static void USART_DMAError(DMA_HandleTypeDef *hdma)
mbed_official 573:ad23fe03a082 1650 {
mbed_official 573:ad23fe03a082 1651 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
mbed_official 573:ad23fe03a082 1652
mbed_official 573:ad23fe03a082 1653 husart->RxXferCount = 0;
mbed_official 573:ad23fe03a082 1654 husart->TxXferCount = 0;
mbed_official 573:ad23fe03a082 1655 husart->ErrorCode |= HAL_USART_ERROR_DMA;
mbed_official 573:ad23fe03a082 1656 husart->State= HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1657
mbed_official 573:ad23fe03a082 1658 HAL_USART_ErrorCallback(husart);
mbed_official 573:ad23fe03a082 1659 }
mbed_official 573:ad23fe03a082 1660
mbed_official 573:ad23fe03a082 1661 /**
mbed_official 573:ad23fe03a082 1662 * @brief Configure the USART peripheral
mbed_official 573:ad23fe03a082 1663 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1664 * @retval None
mbed_official 573:ad23fe03a082 1665 */
mbed_official 573:ad23fe03a082 1666 static HAL_StatusTypeDef USART_SetConfig(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1667 {
mbed_official 573:ad23fe03a082 1668 uint32_t tmpreg = 0x0;
mbed_official 573:ad23fe03a082 1669 USART_ClockSourceTypeDef clocksource = USART_CLOCKSOURCE_UNDEFINED;
mbed_official 573:ad23fe03a082 1670 HAL_StatusTypeDef ret = HAL_OK;
mbed_official 573:ad23fe03a082 1671 uint16_t brrtemp = 0x0000;
mbed_official 573:ad23fe03a082 1672 uint16_t usartdiv = 0x0000;
mbed_official 573:ad23fe03a082 1673
mbed_official 573:ad23fe03a082 1674 /* Check the parameters */
mbed_official 573:ad23fe03a082 1675 assert_param(IS_USART_POLARITY(husart->Init.CLKPolarity));
mbed_official 573:ad23fe03a082 1676 assert_param(IS_USART_PHASE(husart->Init.CLKPhase));
mbed_official 573:ad23fe03a082 1677 assert_param(IS_USART_LASTBIT(husart->Init.CLKLastBit));
mbed_official 573:ad23fe03a082 1678 assert_param(IS_USART_BAUDRATE(husart->Init.BaudRate));
mbed_official 573:ad23fe03a082 1679 assert_param(IS_USART_WORD_LENGTH(husart->Init.WordLength));
mbed_official 573:ad23fe03a082 1680 assert_param(IS_USART_STOPBITS(husart->Init.StopBits));
mbed_official 573:ad23fe03a082 1681 assert_param(IS_USART_PARITY(husart->Init.Parity));
mbed_official 573:ad23fe03a082 1682 assert_param(IS_USART_MODE(husart->Init.Mode));
mbed_official 573:ad23fe03a082 1683 assert_param(IS_USART_OVERSAMPLING(husart->Init.OverSampling));
mbed_official 573:ad23fe03a082 1684
mbed_official 573:ad23fe03a082 1685
mbed_official 573:ad23fe03a082 1686 /*-------------------------- USART CR1 Configuration -----------------------*/
mbed_official 573:ad23fe03a082 1687 /* Clear M, PCE, PS, TE and RE bits and configure
mbed_official 573:ad23fe03a082 1688 * the USART Word Length, Parity, Mode and OverSampling:
mbed_official 573:ad23fe03a082 1689 * set the M bits according to husart->Init.WordLength value
mbed_official 573:ad23fe03a082 1690 * set PCE and PS bits according to husart->Init.Parity value
mbed_official 573:ad23fe03a082 1691 * set TE and RE bits according to husart->Init.Mode value
mbed_official 573:ad23fe03a082 1692 * force OVER8 to 1 to allow to reach the maximum speed (Fclock/8) */
mbed_official 573:ad23fe03a082 1693 tmpreg = (uint32_t)husart->Init.WordLength | husart->Init.Parity | husart->Init.Mode | USART_CR1_OVER8;
mbed_official 573:ad23fe03a082 1694 MODIFY_REG(husart->Instance->CR1, USART_CR1_FIELDS, tmpreg);
mbed_official 573:ad23fe03a082 1695
mbed_official 573:ad23fe03a082 1696 /*---------------------------- USART CR2 Configuration ---------------------*/
mbed_official 573:ad23fe03a082 1697 /* Clear and configure the USART Clock, CPOL, CPHA, LBCL and STOP bits:
mbed_official 573:ad23fe03a082 1698 * set CPOL bit according to husart->Init.CLKPolarity value
mbed_official 573:ad23fe03a082 1699 * set CPHA bit according to husart->Init.CLKPhase value
mbed_official 573:ad23fe03a082 1700 * set LBCL bit according to husart->Init.CLKLastBit value
mbed_official 573:ad23fe03a082 1701 * set STOP[13:12] bits according to husart->Init.StopBits value */
mbed_official 573:ad23fe03a082 1702 tmpreg = (uint32_t)(USART_CLOCK_ENABLE);
mbed_official 573:ad23fe03a082 1703 tmpreg |= ((uint32_t)husart->Init.CLKPolarity | (uint32_t)husart->Init.CLKPhase);
mbed_official 573:ad23fe03a082 1704 tmpreg |= ((uint32_t)husart->Init.CLKLastBit | (uint32_t)husart->Init.StopBits);
mbed_official 573:ad23fe03a082 1705 MODIFY_REG(husart->Instance->CR2, USART_CR2_FIELDS, tmpreg);
mbed_official 573:ad23fe03a082 1706
mbed_official 573:ad23fe03a082 1707 /*-------------------------- USART CR3 Configuration -----------------------*/
mbed_official 573:ad23fe03a082 1708 /* no CR3 register configuration */
mbed_official 573:ad23fe03a082 1709
mbed_official 573:ad23fe03a082 1710 /*-------------------------- USART BRR Configuration -----------------------*/
mbed_official 573:ad23fe03a082 1711 /* BRR is filled-up according to OVER8 bit setting which is forced to 1 */
mbed_official 573:ad23fe03a082 1712 USART_GETCLOCKSOURCE(husart, clocksource);
mbed_official 573:ad23fe03a082 1713 switch (clocksource)
mbed_official 573:ad23fe03a082 1714 {
mbed_official 573:ad23fe03a082 1715 case USART_CLOCKSOURCE_PCLK1:
mbed_official 573:ad23fe03a082 1716 usartdiv = (uint16_t)((2*HAL_RCC_GetPCLK1Freq()) / husart->Init.BaudRate);
mbed_official 573:ad23fe03a082 1717 break;
mbed_official 573:ad23fe03a082 1718 case USART_CLOCKSOURCE_PCLK2:
mbed_official 573:ad23fe03a082 1719 usartdiv = (uint16_t)((2*HAL_RCC_GetPCLK2Freq()) / husart->Init.BaudRate);
mbed_official 573:ad23fe03a082 1720 break;
mbed_official 573:ad23fe03a082 1721 case USART_CLOCKSOURCE_HSI:
mbed_official 573:ad23fe03a082 1722 usartdiv = (uint16_t)((2*HSI_VALUE) / husart->Init.BaudRate);
mbed_official 573:ad23fe03a082 1723 break;
mbed_official 573:ad23fe03a082 1724 case USART_CLOCKSOURCE_SYSCLK:
mbed_official 573:ad23fe03a082 1725 usartdiv = (uint16_t)((2*HAL_RCC_GetSysClockFreq()) / husart->Init.BaudRate);
mbed_official 573:ad23fe03a082 1726 break;
mbed_official 573:ad23fe03a082 1727 case USART_CLOCKSOURCE_LSE:
mbed_official 573:ad23fe03a082 1728 usartdiv = (uint16_t)((2*LSE_VALUE) / husart->Init.BaudRate);
mbed_official 573:ad23fe03a082 1729 break;
mbed_official 573:ad23fe03a082 1730 case USART_CLOCKSOURCE_UNDEFINED:
mbed_official 573:ad23fe03a082 1731 default:
mbed_official 573:ad23fe03a082 1732 ret = HAL_ERROR;
mbed_official 573:ad23fe03a082 1733 break;
mbed_official 573:ad23fe03a082 1734 }
mbed_official 573:ad23fe03a082 1735
mbed_official 573:ad23fe03a082 1736 brrtemp = usartdiv & 0xFFF0;
mbed_official 573:ad23fe03a082 1737 brrtemp |= (uint16_t)((usartdiv & (uint16_t)0x000F) >> 1U);
mbed_official 573:ad23fe03a082 1738 husart->Instance->BRR = brrtemp;
mbed_official 573:ad23fe03a082 1739
mbed_official 573:ad23fe03a082 1740 return ret;
mbed_official 573:ad23fe03a082 1741 }
mbed_official 573:ad23fe03a082 1742
mbed_official 573:ad23fe03a082 1743 /**
mbed_official 573:ad23fe03a082 1744 * @brief Check the USART Idle State
mbed_official 573:ad23fe03a082 1745 * @param husart: USART handle
mbed_official 573:ad23fe03a082 1746 * @retval HAL status
mbed_official 573:ad23fe03a082 1747 */
mbed_official 573:ad23fe03a082 1748 static HAL_StatusTypeDef USART_CheckIdleState(USART_HandleTypeDef *husart)
mbed_official 573:ad23fe03a082 1749 {
mbed_official 573:ad23fe03a082 1750 /* Initialize the USART ErrorCode */
mbed_official 573:ad23fe03a082 1751 husart->ErrorCode = HAL_USART_ERROR_NONE;
mbed_official 573:ad23fe03a082 1752
mbed_official 573:ad23fe03a082 1753 /* Check if the Transmitter is enabled */
mbed_official 573:ad23fe03a082 1754 if((husart->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
mbed_official 573:ad23fe03a082 1755 {
mbed_official 573:ad23fe03a082 1756 /* Wait until TEACK flag is set */
mbed_official 573:ad23fe03a082 1757 if(USART_WaitOnFlagUntilTimeout(husart, USART_ISR_TEACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official 573:ad23fe03a082 1758 {
mbed_official 573:ad23fe03a082 1759 husart->State= HAL_USART_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1760 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1761 }
mbed_official 573:ad23fe03a082 1762 }
mbed_official 573:ad23fe03a082 1763 /* Check if the Receiver is enabled */
mbed_official 573:ad23fe03a082 1764 if((husart->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
mbed_official 573:ad23fe03a082 1765 {
mbed_official 573:ad23fe03a082 1766 /* Wait until REACK flag is set */
mbed_official 573:ad23fe03a082 1767 if(USART_WaitOnFlagUntilTimeout(husart, USART_ISR_REACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
mbed_official 573:ad23fe03a082 1768 {
mbed_official 573:ad23fe03a082 1769 husart->State= HAL_USART_STATE_TIMEOUT;
mbed_official 573:ad23fe03a082 1770 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 1771 }
mbed_official 573:ad23fe03a082 1772 }
mbed_official 573:ad23fe03a082 1773
mbed_official 573:ad23fe03a082 1774 /* Initialize the USART state*/
mbed_official 573:ad23fe03a082 1775 husart->State= HAL_USART_STATE_READY;
mbed_official 573:ad23fe03a082 1776
mbed_official 573:ad23fe03a082 1777 /* Process Unlocked */
mbed_official 573:ad23fe03a082 1778 __HAL_UNLOCK(husart);
mbed_official 573:ad23fe03a082 1779
mbed_official 573:ad23fe03a082 1780 return HAL_OK;
mbed_official 573:ad23fe03a082 1781 }
mbed_official 573:ad23fe03a082 1782
mbed_official 573:ad23fe03a082 1783 /**
mbed_official 573:ad23fe03a082 1784 * @}
mbed_official 573:ad23fe03a082 1785 */
mbed_official 573:ad23fe03a082 1786
mbed_official 573:ad23fe03a082 1787 #endif /* HAL_USART_MODULE_ENABLED */
mbed_official 573:ad23fe03a082 1788 /**
mbed_official 573:ad23fe03a082 1789 * @}
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 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/