Stuart Northfield / mbed-src

mbed library sources

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_usart.c@394:83f921546702, 2014-11-07 (annotated)

Committer:
mbed_official
Date:
Fri Nov 07 15:45:07 2014 +0000
Revision:
394:83f921546702
Parent:
targets/cmsis/TARGET_STM/TARGET_NUCLEO_L152RE/stm32l1xx_hal_usart.c@354:e67efb2aab0e 
Synchronized with git revision aab52cb7ec5a665869e507dd988bbfd55b7e087e



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



Tests: Fix cpputest testrunner

Who changed what in which revision?

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