Joris Aerts / mbed-src

mbed library sources

Dependents:   Marvino mbot

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_usart.c@637:ed69428d4850, 2015-12-22 (annotated)

Committer:
jaerts
Date:
Tue Dec 22 13:22:16 2015 +0000
Revision:
637:ed69428d4850
Parent:
610:813dcc80987e 
Add very shady LPC1768 CAN Filter implementation

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****/