STM32L486xx HAL User Manual
|
00001 /** 00002 ****************************************************************************** 00003 * @file stm32l4xx_hal_usart.c 00004 * @author MCD Application Team 00005 * @brief USART HAL module driver. 00006 * This file provides firmware functions to manage the following 00007 * functionalities of the Universal Synchronous/Asynchronous Receiver Transmitter 00008 * Peripheral (USART). 00009 * + Initialization and de-initialization functions 00010 * + IO operation functions 00011 * + Peripheral Control functions 00012 * + Peripheral State and Error functions 00013 * 00014 @verbatim 00015 =============================================================================== 00016 ##### How to use this driver ##### 00017 =============================================================================== 00018 [..] 00019 The USART HAL driver can be used as follows: 00020 00021 (#) Declare a USART_HandleTypeDef handle structure (eg. USART_HandleTypeDef husart). 00022 (#) Initialize the USART low level resources by implementing the HAL_USART_MspInit() API: 00023 (++) Enable the USARTx interface clock. 00024 (++) USART pins configuration: 00025 (+++) Enable the clock for the USART GPIOs. 00026 (+++) Configure these USART pins as alternate function pull-up. 00027 (++) NVIC configuration if you need to use interrupt process (HAL_USART_Transmit_IT(), 00028 HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs): 00029 (+++) Configure the USARTx interrupt priority. 00030 (+++) Enable the NVIC USART IRQ handle. 00031 (++) USART interrupts handling: 00032 -@@- The specific USART interrupts (Transmission complete interrupt, 00033 RXNE interrupt and Error Interrupts) will be managed using the macros 00034 __HAL_USART_ENABLE_IT() and __HAL_USART_DISABLE_IT() inside the transmit and receive process. 00035 (++) DMA Configuration if you need to use DMA process (HAL_USART_Transmit_DMA() 00036 HAL_USART_Receive_DMA() and HAL_USART_TransmitReceive_DMA() APIs): 00037 (+++) Declare a DMA handle structure for the Tx/Rx channel. 00038 (+++) Enable the DMAx interface clock. 00039 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters. 00040 (+++) Configure the DMA Tx/Rx channel. 00041 (+++) Associate the initialized DMA handle to the USART DMA Tx/Rx handle. 00042 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel. 00043 00044 (#) Program the Baud Rate, Word Length, Stop Bit, Parity, and Mode 00045 (Receiver/Transmitter) in the husart handle Init structure. 00046 00047 (#) Initialize the USART registers by calling the HAL_USART_Init() API: 00048 (++) This API configures also the low level Hardware GPIO, CLOCK, CORTEX...etc) 00049 by calling the customized HAL_USART_MspInit(&husart) API. 00050 00051 [..] 00052 (@) To configure and enable/disable the USART to wake up the MCU from stop mode, resort to UART API's 00053 HAL_UARTEx_StopModeWakeUpSourceConfig(), HAL_UARTEx_EnableStopMode() and 00054 HAL_UARTEx_DisableStopMode() in casting the USART handle to UART type UART_HandleTypeDef. 00055 00056 ##### Callback registration ##### 00057 ================================== 00058 00059 [..] 00060 The compilation define USE_HAL_USART_REGISTER_CALLBACKS when set to 1 00061 allows the user to configure dynamically the driver callbacks. 00062 00063 [..] 00064 Use Function @ref HAL_USART_RegisterCallback() to register a user callback. 00065 Function @ref HAL_USART_RegisterCallback() allows to register following callbacks: 00066 (+) TxHalfCpltCallback : Tx Half Complete Callback. 00067 (+) TxCpltCallback : Tx Complete Callback. 00068 (+) RxHalfCpltCallback : Rx Half Complete Callback. 00069 (+) RxCpltCallback : Rx Complete Callback. 00070 (+) TxRxCpltCallback : Tx Rx Complete Callback. 00071 (+) ErrorCallback : Error Callback. 00072 (+) AbortCpltCallback : Abort Complete Callback. 00073 (+) RxFifoFullCallback : Rx Fifo Full Callback. 00074 (+) TxFifoEmptyCallback : Tx Fifo Empty Callback. 00075 (+) MspInitCallback : USART MspInit. 00076 (+) MspDeInitCallback : USART MspDeInit. 00077 This function takes as parameters the HAL peripheral handle, the Callback ID 00078 and a pointer to the user callback function. 00079 00080 [..] 00081 Use function @ref HAL_USART_UnRegisterCallback() to reset a callback to the default 00082 weak (surcharged) function. 00083 @ref HAL_USART_UnRegisterCallback() takes as parameters the HAL peripheral handle, 00084 and the Callback ID. 00085 This function allows to reset following callbacks: 00086 (+) TxHalfCpltCallback : Tx Half Complete Callback. 00087 (+) TxCpltCallback : Tx Complete Callback. 00088 (+) RxHalfCpltCallback : Rx Half Complete Callback. 00089 (+) RxCpltCallback : Rx Complete Callback. 00090 (+) TxRxCpltCallback : Tx Rx Complete Callback. 00091 (+) ErrorCallback : Error Callback. 00092 (+) AbortCpltCallback : Abort Complete Callback. 00093 (+) RxFifoFullCallback : Rx Fifo Full Callback. 00094 (+) TxFifoEmptyCallback : Tx Fifo Empty Callback. 00095 (+) MspInitCallback : USART MspInit. 00096 (+) MspDeInitCallback : USART MspDeInit. 00097 00098 [..] 00099 By default, after the @ref HAL_USART_Init() and when the state is HAL_USART_STATE_RESET 00100 all callbacks are set to the corresponding weak (surcharged) functions: 00101 examples @ref HAL_USART_TxCpltCallback(), @ref HAL_USART_RxHalfCpltCallback(). 00102 Exception done for MspInit and MspDeInit functions that are respectively 00103 reset to the legacy weak (surcharged) functions in the @ref HAL_USART_Init() 00104 and @ref HAL_USART_DeInit() only when these callbacks are null (not registered beforehand). 00105 If not, MspInit or MspDeInit are not null, the @ref HAL_USART_Init() and @ref HAL_USART_DeInit() 00106 keep and use the user MspInit/MspDeInit callbacks (registered beforehand). 00107 00108 [..] 00109 Callbacks can be registered/unregistered in HAL_USART_STATE_READY state only. 00110 Exception done MspInit/MspDeInit that can be registered/unregistered 00111 in HAL_USART_STATE_READY or HAL_USART_STATE_RESET state, thus registered (user) 00112 MspInit/DeInit callbacks can be used during the Init/DeInit. 00113 In that case first register the MspInit/MspDeInit user callbacks 00114 using @ref HAL_USART_RegisterCallback() before calling @ref HAL_USART_DeInit() 00115 or @ref HAL_USART_Init() function. 00116 00117 [..] 00118 When The compilation define USE_HAL_USART_REGISTER_CALLBACKS is set to 0 or 00119 not defined, the callback registration feature is not available 00120 and weak (surcharged) callbacks are used. 00121 00122 00123 @endverbatim 00124 ****************************************************************************** 00125 * @attention 00126 * 00127 * <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2> 00128 * 00129 * Redistribution and use in source and binary forms, with or without modification, 00130 * are permitted provided that the following conditions are met: 00131 * 1. Redistributions of source code must retain the above copyright notice, 00132 * this list of conditions and the following disclaimer. 00133 * 2. Redistributions in binary form must reproduce the above copyright notice, 00134 * this list of conditions and the following disclaimer in the documentation 00135 * and/or other materials provided with the distribution. 00136 * 3. Neither the name of STMicroelectronics nor the names of its contributors 00137 * may be used to endorse or promote products derived from this software 00138 * without specific prior written permission. 00139 * 00140 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 00141 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00142 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00143 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 00144 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 00145 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 00146 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 00147 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 00148 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00149 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00150 * 00151 ****************************************************************************** 00152 */ 00153 00154 /* Includes ------------------------------------------------------------------*/ 00155 #include "stm32l4xx_hal.h" 00156 00157 /** @addtogroup STM32L4xx_HAL_Driver 00158 * @{ 00159 */ 00160 00161 /** @defgroup USART USART 00162 * @brief HAL USART Synchronous module driver 00163 * @{ 00164 */ 00165 00166 #ifdef HAL_USART_MODULE_ENABLED 00167 00168 /* Private typedef -----------------------------------------------------------*/ 00169 /* Private define ------------------------------------------------------------*/ 00170 /** @defgroup USART_Private_Constants USART Private Constants 00171 * @{ 00172 */ 00173 #define USART_DUMMY_DATA ((uint16_t) 0xFFFF) /*!< USART transmitted dummy data */ 00174 #define USART_TEACK_REACK_TIMEOUT 1000U /*!< USART TX or RX enable acknowledge time-out value */ 00175 #if defined(USART_CR1_FIFOEN) 00176 #define USART_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | \ 00177 USART_CR1_TE | USART_CR1_RE | USART_CR1_OVER8 | \ 00178 USART_CR1_FIFOEN )) /*!< USART CR1 fields of parameters set by USART_SetConfig API */ 00179 00180 #define USART_CR2_FIELDS ((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | USART_CR2_CLKEN | \ 00181 USART_CR2_LBCL | USART_CR2_STOP | USART_CR2_SLVEN | \ 00182 USART_CR2_DIS_NSS)) /*!< USART CR2 fields of parameters set by USART_SetConfig API */ 00183 00184 #define USART_CR3_FIELDS ((uint32_t)(USART_CR3_TXFTCFG | USART_CR3_RXFTCFG )) /*!< USART or USART CR3 fields of parameters set by USART_SetConfig API */ 00185 #else 00186 #define USART_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | \ 00187 USART_CR1_TE | USART_CR1_RE | USART_CR1_OVER8)) /*!< USART CR1 fields of parameters set by USART_SetConfig API */ 00188 #define USART_CR2_FIELDS ((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | \ 00189 USART_CR2_CLKEN | USART_CR2_LBCL | USART_CR2_STOP)) /*!< USART CR2 fields of parameters set by USART_SetConfig API */ 00190 #endif 00191 00192 #define USART_BRR_MIN 0x10U /* USART BRR minimum authorized value */ 00193 #define USART_BRR_MAX 0xFFFFU /* USART BRR maximum authorized value */ 00194 /** 00195 * @} 00196 */ 00197 00198 /* Private macros ------------------------------------------------------------*/ 00199 /* Private variables ---------------------------------------------------------*/ 00200 /* Private function prototypes -----------------------------------------------*/ 00201 /** @addtogroup USART_Private_Functions 00202 * @{ 00203 */ 00204 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 00205 void USART_InitCallbacksToDefault(USART_HandleTypeDef *husart); 00206 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 00207 static void USART_EndTransfer(USART_HandleTypeDef *husart); 00208 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma); 00209 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma); 00210 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma); 00211 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma); 00212 static void USART_DMAError(DMA_HandleTypeDef *hdma); 00213 static void USART_DMAAbortOnError(DMA_HandleTypeDef *hdma); 00214 static void USART_DMATxAbortCallback(DMA_HandleTypeDef *hdma); 00215 static void USART_DMARxAbortCallback(DMA_HandleTypeDef *hdma); 00216 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout); 00217 static HAL_StatusTypeDef USART_SetConfig(USART_HandleTypeDef *husart); 00218 static HAL_StatusTypeDef USART_CheckIdleState(USART_HandleTypeDef *husart); 00219 static void USART_TxISR_8BIT(USART_HandleTypeDef *husart); 00220 static void USART_TxISR_16BIT(USART_HandleTypeDef *husart); 00221 #if defined(USART_CR1_FIFOEN) 00222 static void USART_TxISR_8BIT_FIFOEN(USART_HandleTypeDef *husart); 00223 static void USART_TxISR_16BIT_FIFOEN(USART_HandleTypeDef *husart); 00224 #endif 00225 static void USART_EndTransmit_IT(USART_HandleTypeDef *husart); 00226 static void USART_RxISR_8BIT(USART_HandleTypeDef *husart); 00227 static void USART_RxISR_16BIT(USART_HandleTypeDef *husart); 00228 #if defined(USART_CR1_FIFOEN) 00229 static void USART_RxISR_8BIT_FIFOEN(USART_HandleTypeDef *husart); 00230 static void USART_RxISR_16BIT_FIFOEN(USART_HandleTypeDef *husart); 00231 #endif 00232 00233 00234 /** 00235 * @} 00236 */ 00237 00238 /* Exported functions --------------------------------------------------------*/ 00239 00240 /** @defgroup USART_Exported_Functions USART Exported Functions 00241 * @{ 00242 */ 00243 00244 /** @defgroup USART_Exported_Functions_Group1 Initialization and de-initialization functions 00245 * @brief Initialization and Configuration functions 00246 * 00247 @verbatim 00248 =============================================================================== 00249 ##### Initialization and Configuration functions ##### 00250 =============================================================================== 00251 [..] 00252 This subsection provides a set of functions allowing to initialize the USART 00253 in asynchronous and in synchronous modes. 00254 (+) For the asynchronous mode only these parameters can be configured: 00255 (++) Baud Rate 00256 (++) Word Length 00257 (++) Stop Bit 00258 (++) Parity: If the parity is enabled, then the MSB bit of the data written 00259 in the data register is transmitted but is changed by the parity bit. 00260 (++) USART polarity 00261 (++) USART phase 00262 (++) USART LastBit 00263 (++) Receiver/transmitter modes 00264 00265 [..] 00266 The HAL_USART_Init() function follows the USART synchronous configuration 00267 procedure (details for the procedure are available in reference manual). 00268 00269 @endverbatim 00270 00271 Depending on the frame length defined by the M1 and M0 bits (7-bit, 00272 8-bit or 9-bit), the possible USART formats are listed in the 00273 following table. 00274 00275 Table 1. USART frame format. 00276 +-----------------------------------------------------------------------+ 00277 | M1 bit | M0 bit | PCE bit | USART frame | 00278 |---------|---------|-----------|---------------------------------------| 00279 | 0 | 0 | 0 | | SB | 8 bit data | STB | | 00280 |---------|---------|-----------|---------------------------------------| 00281 | 0 | 0 | 1 | | SB | 7 bit data | PB | STB | | 00282 |---------|---------|-----------|---------------------------------------| 00283 | 0 | 1 | 0 | | SB | 9 bit data | STB | | 00284 |---------|---------|-----------|---------------------------------------| 00285 | 0 | 1 | 1 | | SB | 8 bit data | PB | STB | | 00286 |---------|---------|-----------|---------------------------------------| 00287 | 1 | 0 | 0 | | SB | 7 bit data | STB | | 00288 |---------|---------|-----------|---------------------------------------| 00289 | 1 | 0 | 1 | | SB | 6 bit data | PB | STB | | 00290 +-----------------------------------------------------------------------+ 00291 00292 * @{ 00293 */ 00294 00295 /** 00296 * @brief Initialize the USART mode according to the specified 00297 * parameters in the USART_InitTypeDef and initialize the associated handle. 00298 * @param husart USART handle. 00299 * @retval HAL status 00300 */ 00301 HAL_StatusTypeDef HAL_USART_Init(USART_HandleTypeDef *husart) 00302 { 00303 /* Check the USART handle allocation */ 00304 if (husart == NULL) 00305 { 00306 return HAL_ERROR; 00307 } 00308 00309 /* Check the parameters */ 00310 assert_param(IS_USART_INSTANCE(husart->Instance)); 00311 00312 if (husart->State == HAL_USART_STATE_RESET) 00313 { 00314 /* Allocate lock resource and initialize it */ 00315 husart->Lock = HAL_UNLOCKED; 00316 00317 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 00318 USART_InitCallbacksToDefault(husart); 00319 00320 if (husart->MspInitCallback == NULL) 00321 { 00322 husart->MspInitCallback = HAL_USART_MspInit; 00323 } 00324 00325 /* Init the low level hardware */ 00326 husart->MspInitCallback(husart); 00327 #else 00328 /* Init the low level hardware : GPIO, CLOCK */ 00329 HAL_USART_MspInit(husart); 00330 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 00331 } 00332 00333 husart->State = HAL_USART_STATE_BUSY; 00334 00335 /* Disable the Peripheral */ 00336 __HAL_USART_DISABLE(husart); 00337 00338 /* Set the Usart Communication parameters */ 00339 if (USART_SetConfig(husart) == HAL_ERROR) 00340 { 00341 return HAL_ERROR; 00342 } 00343 00344 /* In Synchronous mode, the following bits must be kept cleared: 00345 - LINEN bit in the USART_CR2 register 00346 - HDSEL, SCEN and IREN bits in the USART_CR3 register.*/ 00347 husart->Instance->CR2 &= ~USART_CR2_LINEN; 00348 husart->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN); 00349 00350 /* Enable the Peripheral */ 00351 __HAL_USART_ENABLE(husart); 00352 00353 /* TEACK and/or REACK to check before moving husart->State to Ready */ 00354 return (USART_CheckIdleState(husart)); 00355 } 00356 00357 /** 00358 * @brief DeInitialize the USART peripheral. 00359 * @param husart USART handle. 00360 * @retval HAL status 00361 */ 00362 HAL_StatusTypeDef HAL_USART_DeInit(USART_HandleTypeDef *husart) 00363 { 00364 /* Check the USART handle allocation */ 00365 if (husart == NULL) 00366 { 00367 return HAL_ERROR; 00368 } 00369 00370 /* Check the parameters */ 00371 assert_param(IS_USART_INSTANCE(husart->Instance)); 00372 00373 husart->State = HAL_USART_STATE_BUSY; 00374 00375 husart->Instance->CR1 = 0x0U; 00376 husart->Instance->CR2 = 0x0U; 00377 husart->Instance->CR3 = 0x0U; 00378 00379 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 00380 if (husart->MspDeInitCallback == NULL) 00381 { 00382 husart->MspDeInitCallback = HAL_USART_MspDeInit; 00383 } 00384 /* DeInit the low level hardware */ 00385 husart->MspDeInitCallback(husart); 00386 #else 00387 /* DeInit the low level hardware */ 00388 HAL_USART_MspDeInit(husart); 00389 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 00390 00391 husart->ErrorCode = HAL_USART_ERROR_NONE; 00392 husart->State = HAL_USART_STATE_RESET; 00393 00394 /* Process Unlock */ 00395 __HAL_UNLOCK(husart); 00396 00397 return HAL_OK; 00398 } 00399 00400 /** 00401 * @brief Initialize the USART MSP. 00402 * @param husart USART handle. 00403 * @retval None 00404 */ 00405 __weak void HAL_USART_MspInit(USART_HandleTypeDef *husart) 00406 { 00407 /* Prevent unused argument(s) compilation warning */ 00408 UNUSED(husart); 00409 00410 /* NOTE : This function should not be modified, when the callback is needed, 00411 the HAL_USART_MspInit can be implemented in the user file 00412 */ 00413 } 00414 00415 /** 00416 * @brief DeInitialize the USART MSP. 00417 * @param husart USART handle. 00418 * @retval None 00419 */ 00420 __weak void HAL_USART_MspDeInit(USART_HandleTypeDef *husart) 00421 { 00422 /* Prevent unused argument(s) compilation warning */ 00423 UNUSED(husart); 00424 00425 /* NOTE : This function should not be modified, when the callback is needed, 00426 the HAL_USART_MspDeInit can be implemented in the user file 00427 */ 00428 } 00429 00430 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 00431 /** 00432 * @brief Register a User USART Callback 00433 * To be used instead of the weak predefined callback 00434 * @param husart usart handle 00435 * @param CallbackID ID of the callback to be registered 00436 * This parameter can be one of the following values: 00437 * @arg @ref HAL_USART_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID 00438 * @arg @ref HAL_USART_TX_COMPLETE_CB_ID Tx Complete Callback ID 00439 * @arg @ref HAL_USART_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID 00440 * @arg @ref HAL_USART_RX_COMPLETE_CB_ID Rx Complete Callback ID 00441 * @arg @ref HAL_USART_TX_RX_COMPLETE_CB_ID Rx Complete Callback ID 00442 * @arg @ref HAL_USART_ERROR_CB_ID Error Callback ID 00443 * @arg @ref HAL_USART_ABORT_COMPLETE_CB_ID Abort Complete Callback ID 00444 * @arg @ref HAL_USART_RX_FIFO_FULL_CB_ID Rx Fifo Full Callback ID 00445 * @arg @ref HAL_USART_TX_FIFO_EMPTY_CB_ID Tx Fifo Empty Callback ID 00446 * @arg @ref HAL_USART_MSPINIT_CB_ID MspInit Callback ID 00447 * @arg @ref HAL_USART_MSPDEINIT_CB_ID MspDeInit Callback ID 00448 * @param pCallback pointer to the Callback function 00449 * @retval HAL status 00450 + */ 00451 HAL_StatusTypeDef HAL_USART_RegisterCallback(USART_HandleTypeDef *husart, HAL_USART_CallbackIDTypeDef CallbackID, pUSART_CallbackTypeDef pCallback) 00452 { 00453 HAL_StatusTypeDef status = HAL_OK; 00454 00455 if (pCallback == NULL) 00456 { 00457 /* Update the error code */ 00458 husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK; 00459 00460 return HAL_ERROR; 00461 } 00462 /* Process locked */ 00463 __HAL_LOCK(husart); 00464 00465 if (husart->State == HAL_USART_STATE_READY) 00466 { 00467 switch (CallbackID) 00468 { 00469 case HAL_USART_TX_HALFCOMPLETE_CB_ID : 00470 husart->TxHalfCpltCallback = pCallback; 00471 break; 00472 00473 case HAL_USART_TX_COMPLETE_CB_ID : 00474 husart->TxCpltCallback = pCallback; 00475 break; 00476 00477 case HAL_USART_RX_HALFCOMPLETE_CB_ID : 00478 husart->RxHalfCpltCallback = pCallback; 00479 break; 00480 00481 case HAL_USART_RX_COMPLETE_CB_ID : 00482 husart->RxCpltCallback = pCallback; 00483 break; 00484 00485 case HAL_USART_TX_RX_COMPLETE_CB_ID : 00486 husart->TxRxCpltCallback = pCallback; 00487 break; 00488 00489 case HAL_USART_ERROR_CB_ID : 00490 husart->ErrorCallback = pCallback; 00491 break; 00492 00493 case HAL_USART_ABORT_COMPLETE_CB_ID : 00494 husart->AbortCpltCallback = pCallback; 00495 break; 00496 00497 #if defined(USART_CR1_FIFOEN) 00498 case HAL_USART_RX_FIFO_FULL_CB_ID : 00499 husart->RxFifoFullCallback = pCallback; 00500 break; 00501 00502 case HAL_USART_TX_FIFO_EMPTY_CB_ID : 00503 husart->TxFifoEmptyCallback = pCallback; 00504 break; 00505 #endif 00506 00507 case HAL_USART_MSPINIT_CB_ID : 00508 husart->MspInitCallback = pCallback; 00509 break; 00510 00511 case HAL_USART_MSPDEINIT_CB_ID : 00512 husart->MspDeInitCallback = pCallback; 00513 break; 00514 00515 default : 00516 /* Update the error code */ 00517 husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK; 00518 00519 /* Return error status */ 00520 status = HAL_ERROR; 00521 break; 00522 } 00523 } 00524 else if (husart->State == HAL_USART_STATE_RESET) 00525 { 00526 switch (CallbackID) 00527 { 00528 case HAL_USART_MSPINIT_CB_ID : 00529 husart->MspInitCallback = pCallback; 00530 break; 00531 00532 case HAL_USART_MSPDEINIT_CB_ID : 00533 husart->MspDeInitCallback = pCallback; 00534 break; 00535 00536 default : 00537 /* Update the error code */ 00538 husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK; 00539 00540 /* Return error status */ 00541 status = HAL_ERROR; 00542 break; 00543 } 00544 } 00545 else 00546 { 00547 /* Update the error code */ 00548 husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK; 00549 00550 /* Return error status */ 00551 status = HAL_ERROR; 00552 } 00553 00554 /* Release Lock */ 00555 __HAL_UNLOCK(husart); 00556 00557 return status; 00558 } 00559 00560 /** 00561 * @brief Unregister an UART Callback 00562 * UART callaback is redirected to the weak predefined callback 00563 * @param husart uart handle 00564 * @param CallbackID ID of the callback to be unregistered 00565 * This parameter can be one of the following values: 00566 * @arg @ref HAL_USART_TX_HALFCOMPLETE_CB_ID Tx Half Complete Callback ID 00567 * @arg @ref HAL_USART_TX_COMPLETE_CB_ID Tx Complete Callback ID 00568 * @arg @ref HAL_USART_RX_HALFCOMPLETE_CB_ID Rx Half Complete Callback ID 00569 * @arg @ref HAL_USART_RX_COMPLETE_CB_ID Rx Complete Callback ID 00570 * @arg @ref HAL_USART_TX_RX_COMPLETE_CB_ID Rx Complete Callback ID 00571 * @arg @ref HAL_USART_ERROR_CB_ID Error Callback ID 00572 * @arg @ref HAL_USART_ABORT_COMPLETE_CB_ID Abort Complete Callback ID 00573 * @arg @ref HAL_USART_RX_FIFO_FULL_CB_ID Rx Fifo Full Callback ID 00574 * @arg @ref HAL_USART_TX_FIFO_EMPTY_CB_ID Tx Fifo Empty Callback ID 00575 * @arg @ref HAL_USART_MSPINIT_CB_ID MspInit Callback ID 00576 * @arg @ref HAL_USART_MSPDEINIT_CB_ID MspDeInit Callback ID 00577 * @retval HAL status 00578 */ 00579 HAL_StatusTypeDef HAL_USART_UnRegisterCallback(USART_HandleTypeDef *husart, HAL_USART_CallbackIDTypeDef CallbackID) 00580 { 00581 HAL_StatusTypeDef status = HAL_OK; 00582 00583 /* Process locked */ 00584 __HAL_LOCK(husart); 00585 00586 if (HAL_USART_STATE_READY == husart->State) 00587 { 00588 switch (CallbackID) 00589 { 00590 case HAL_USART_TX_HALFCOMPLETE_CB_ID : 00591 husart->TxHalfCpltCallback = HAL_USART_TxHalfCpltCallback; /* Legacy weak TxHalfCpltCallback */ 00592 break; 00593 00594 case HAL_USART_TX_COMPLETE_CB_ID : 00595 husart->TxCpltCallback = HAL_USART_TxCpltCallback; /* Legacy weak TxCpltCallback */ 00596 break; 00597 00598 case HAL_USART_RX_HALFCOMPLETE_CB_ID : 00599 husart->RxHalfCpltCallback = HAL_USART_RxHalfCpltCallback; /* Legacy weak RxHalfCpltCallback */ 00600 break; 00601 00602 case HAL_USART_RX_COMPLETE_CB_ID : 00603 husart->RxCpltCallback = HAL_USART_RxCpltCallback; /* Legacy weak RxCpltCallback */ 00604 break; 00605 00606 case HAL_USART_TX_RX_COMPLETE_CB_ID : 00607 husart->TxRxCpltCallback = HAL_USART_TxRxCpltCallback; /* Legacy weak TxRxCpltCallback */ 00608 break; 00609 00610 case HAL_USART_ERROR_CB_ID : 00611 husart->ErrorCallback = HAL_USART_ErrorCallback; /* Legacy weak ErrorCallback */ 00612 break; 00613 00614 case HAL_USART_ABORT_COMPLETE_CB_ID : 00615 husart->AbortCpltCallback = HAL_USART_AbortCpltCallback; /* Legacy weak AbortCpltCallback */ 00616 break; 00617 00618 #if defined(USART_CR1_FIFOEN) 00619 case HAL_USART_RX_FIFO_FULL_CB_ID : 00620 husart->RxFifoFullCallback = HAL_USARTEx_RxFifoFullCallback; /* Legacy weak RxFifoFullCallback */ 00621 break; 00622 00623 case HAL_USART_TX_FIFO_EMPTY_CB_ID : 00624 husart->TxFifoEmptyCallback = HAL_USARTEx_TxFifoEmptyCallback; /* Legacy weak TxFifoEmptyCallback */ 00625 break; 00626 #endif 00627 00628 case HAL_USART_MSPINIT_CB_ID : 00629 husart->MspInitCallback = HAL_USART_MspInit; /* Legacy weak MspInitCallback */ 00630 break; 00631 00632 case HAL_USART_MSPDEINIT_CB_ID : 00633 husart->MspDeInitCallback = HAL_USART_MspDeInit; /* Legacy weak MspDeInitCallback */ 00634 break; 00635 00636 default : 00637 /* Update the error code */ 00638 husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK; 00639 00640 /* Return error status */ 00641 status = HAL_ERROR; 00642 break; 00643 } 00644 } 00645 else if (HAL_USART_STATE_RESET == husart->State) 00646 { 00647 switch (CallbackID) 00648 { 00649 case HAL_USART_MSPINIT_CB_ID : 00650 husart->MspInitCallback = HAL_USART_MspInit; 00651 break; 00652 00653 case HAL_USART_MSPDEINIT_CB_ID : 00654 husart->MspDeInitCallback = HAL_USART_MspDeInit; 00655 break; 00656 00657 default : 00658 /* Update the error code */ 00659 husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK; 00660 00661 /* Return error status */ 00662 status = HAL_ERROR; 00663 break; 00664 } 00665 } 00666 else 00667 { 00668 /* Update the error code */ 00669 husart->ErrorCode |= HAL_USART_ERROR_INVALID_CALLBACK; 00670 00671 /* Return error status */ 00672 status = HAL_ERROR; 00673 } 00674 00675 /* Release Lock */ 00676 __HAL_UNLOCK(husart); 00677 00678 return status; 00679 } 00680 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 00681 00682 00683 /** 00684 * @} 00685 */ 00686 00687 /** @defgroup USART_Exported_Functions_Group2 IO operation functions 00688 * @brief USART Transmit and Receive functions 00689 * 00690 @verbatim 00691 =============================================================================== 00692 ##### IO operation functions ##### 00693 =============================================================================== 00694 [..] This subsection provides a set of functions allowing to manage the USART synchronous 00695 data transfers. 00696 00697 [..] The USART supports master mode only: it cannot receive or send data related to an input 00698 clock (SCLK is always an output). 00699 00700 (#) There are two modes of transfer: 00701 (++) Blocking mode: The communication is performed in polling mode. 00702 The HAL status of all data processing is returned by the same function 00703 after finishing transfer. 00704 (++) No-Blocking mode: The communication is performed using Interrupts 00705 or DMA, These API's return the HAL status. 00706 The end of the data processing will be indicated through the 00707 dedicated USART IRQ when using Interrupt mode or the DMA IRQ when 00708 using DMA mode. 00709 The HAL_USART_TxCpltCallback(), HAL_USART_RxCpltCallback() and HAL_USART_TxRxCpltCallback() user callbacks 00710 will be executed respectively at the end of the transmit or Receive process 00711 The HAL_USART_ErrorCallback()user callback will be executed when a communication error is detected 00712 00713 (#) Blocking mode API's are : 00714 (++) HAL_USART_Transmit()in simplex mode 00715 (++) HAL_USART_Receive() in full duplex receive only 00716 (++) HAL_USART_TransmitReceive() in full duplex mode 00717 00718 (#) Non-Blocking mode API's with Interrupt are : 00719 (++) HAL_USART_Transmit_IT()in simplex mode 00720 (++) HAL_USART_Receive_IT() in full duplex receive only 00721 (++) HAL_USART_TransmitReceive_IT()in full duplex mode 00722 (++) HAL_USART_IRQHandler() 00723 00724 (#) No-Blocking mode API's with DMA are : 00725 (++) HAL_USART_Transmit_DMA()in simplex mode 00726 (++) HAL_USART_Receive_DMA() in full duplex receive only 00727 (++) HAL_USART_TransmitReceive_DMA() in full duplex mode 00728 (++) HAL_USART_DMAPause() 00729 (++) HAL_USART_DMAResume() 00730 (++) HAL_USART_DMAStop() 00731 00732 (#) A set of Transfer Complete Callbacks are provided in Non_Blocking mode: 00733 (++) HAL_USART_TxCpltCallback() 00734 (++) HAL_USART_RxCpltCallback() 00735 (++) HAL_USART_TxHalfCpltCallback() 00736 (++) HAL_USART_RxHalfCpltCallback() 00737 (++) HAL_USART_ErrorCallback() 00738 (++) HAL_USART_TxRxCpltCallback() 00739 00740 (#) Non-Blocking mode transfers could be aborted using Abort API's : 00741 (+) HAL_USART_Abort() 00742 (+) HAL_USART_Abort_IT() 00743 00744 (#) For Abort services based on interrupts (HAL_USART_Abort_IT), a Abort Complete Callbacks is provided: 00745 (+) HAL_USART_AbortCpltCallback() 00746 00747 (#) In Non-Blocking mode transfers, possible errors are split into 2 categories. 00748 Errors are handled as follows : 00749 (+) Error is considered as Recoverable and non blocking : Transfer could go till end, but error severity is 00750 to be evaluated by user : this concerns Frame Error, Parity Error or Noise Error in Interrupt mode reception . 00751 Received character is then retrieved and stored in Rx buffer, Error code is set to allow user to identify error type, 00752 and HAL_USART_ErrorCallback() user callback is executed. Transfer is kept ongoing on USART side. 00753 If user wants to abort it, Abort services should be called by user. 00754 (+) Error is considered as Blocking : Transfer could not be completed properly and is aborted. 00755 This concerns Overrun Error In Interrupt mode reception and all errors in DMA mode. 00756 Error code is set to allow user to identify error type, and HAL_USART_ErrorCallback() user callback is executed. 00757 00758 @endverbatim 00759 * @{ 00760 */ 00761 00762 /** 00763 * @brief Simplex send an amount of data in blocking mode. 00764 * @param husart USART handle. 00765 * @param pTxData Pointer to data buffer. 00766 * @param Size Amount of data to be sent. 00767 * @param Timeout Timeout duration. 00768 * @retval HAL status 00769 */ 00770 HAL_StatusTypeDef HAL_USART_Transmit(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size, uint32_t Timeout) 00771 { 00772 uint16_t *tmp; 00773 uint32_t tickstart = 0U; 00774 00775 if (husart->State == HAL_USART_STATE_READY) 00776 { 00777 if ((pTxData == NULL) || (Size == 0U)) 00778 { 00779 return HAL_ERROR; 00780 } 00781 00782 /* Process Locked */ 00783 __HAL_LOCK(husart); 00784 00785 husart->ErrorCode = HAL_USART_ERROR_NONE; 00786 husart->State = HAL_USART_STATE_BUSY_TX; 00787 00788 /* Init tickstart for timeout managment*/ 00789 tickstart = HAL_GetTick(); 00790 00791 husart->TxXferSize = Size; 00792 husart->TxXferCount = Size; 00793 00794 /* Check the remaining data to be sent */ 00795 while (husart->TxXferCount > 0U) 00796 { 00797 if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK) 00798 { 00799 return HAL_TIMEOUT; 00800 } 00801 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 00802 { 00803 tmp = (uint16_t *) pTxData; 00804 husart->Instance->TDR = (*tmp & (uint16_t)0x01FF); 00805 pTxData += 2U; 00806 } 00807 else 00808 { 00809 husart->Instance->TDR = (*pTxData++ & (uint8_t)0xFF); 00810 } 00811 00812 husart->TxXferCount--; 00813 } 00814 00815 if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, tickstart, Timeout) != HAL_OK) 00816 { 00817 return HAL_TIMEOUT; 00818 } 00819 00820 /* Clear Transmission Complete Flag */ 00821 __HAL_USART_CLEAR_FLAG(husart, USART_CLEAR_TCF); 00822 00823 /* Clear overrun flag and discard the received data */ 00824 __HAL_USART_CLEAR_OREFLAG(husart); 00825 __HAL_USART_SEND_REQ(husart, USART_RXDATA_FLUSH_REQUEST); 00826 __HAL_USART_SEND_REQ(husart, USART_TXDATA_FLUSH_REQUEST); 00827 00828 /* At end of Tx process, restore husart->State to Ready */ 00829 husart->State = HAL_USART_STATE_READY; 00830 00831 /* Process Unlocked */ 00832 __HAL_UNLOCK(husart); 00833 00834 return HAL_OK; 00835 } 00836 else 00837 { 00838 return HAL_BUSY; 00839 } 00840 } 00841 00842 /** 00843 * @brief Receive an amount of data in blocking mode. 00844 * @note To receive synchronous data, dummy data are simultaneously transmitted. 00845 * @param husart USART handle. 00846 * @param pRxData Pointer to data buffer. 00847 * @param Size Amount of data to be received. 00848 * @param Timeout Timeout duration. 00849 * @retval HAL status 00850 */ 00851 HAL_StatusTypeDef HAL_USART_Receive(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size, uint32_t Timeout) 00852 { 00853 uint16_t *tmp; 00854 uint16_t uhMask; 00855 uint32_t tickstart = 0U; 00856 00857 if (husart->State == HAL_USART_STATE_READY) 00858 { 00859 if ((pRxData == NULL) || (Size == 0U)) 00860 { 00861 return HAL_ERROR; 00862 } 00863 00864 /* Process Locked */ 00865 __HAL_LOCK(husart); 00866 00867 husart->ErrorCode = HAL_USART_ERROR_NONE; 00868 husart->State = HAL_USART_STATE_BUSY_RX; 00869 00870 /* Init tickstart for timeout managment*/ 00871 tickstart = HAL_GetTick(); 00872 00873 husart->RxXferSize = Size; 00874 husart->RxXferCount = Size; 00875 00876 /* Computation of USART mask to apply to RDR register */ 00877 USART_MASK_COMPUTATION(husart); 00878 uhMask = husart->Mask; 00879 00880 /* as long as data have to be received */ 00881 while (husart->RxXferCount > 0U) 00882 { 00883 #if defined(USART_CR2_SLVEN) 00884 if (husart->SlaveMode == USART_SLAVEMODE_DISABLE) 00885 #endif 00886 { 00887 /* Wait until TXE flag is set to send dummy byte in order to generate the 00888 * clock for the slave to send data. 00889 * Whatever the frame length (7, 8 or 9-bit long), the same dummy value 00890 * can be written for all the cases. */ 00891 if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK) 00892 { 00893 return HAL_TIMEOUT; 00894 } 00895 husart->Instance->TDR = (USART_DUMMY_DATA & (uint16_t)0x0FF); 00896 } 00897 00898 /* Wait for RXNE Flag */ 00899 if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK) 00900 { 00901 return HAL_TIMEOUT; 00902 } 00903 00904 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 00905 { 00906 tmp = (uint16_t *) pRxData ; 00907 *tmp = (uint16_t)(husart->Instance->RDR & uhMask); 00908 pRxData += 2U; 00909 } 00910 else 00911 { 00912 *pRxData++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask); 00913 } 00914 00915 husart->RxXferCount--; 00916 00917 } 00918 00919 #if defined(USART_CR2_SLVEN) 00920 /* Clear SPI slave underrun flag and discard transmit data */ 00921 if (husart->SlaveMode == USART_SLAVEMODE_ENABLE) 00922 { 00923 __HAL_USART_CLEAR_UDRFLAG(husart); 00924 __HAL_USART_SEND_REQ(husart, USART_TXDATA_FLUSH_REQUEST); 00925 } 00926 #endif 00927 00928 /* At end of Rx process, restore husart->State to Ready */ 00929 husart->State = HAL_USART_STATE_READY; 00930 00931 /* Process Unlocked */ 00932 __HAL_UNLOCK(husart); 00933 00934 return HAL_OK; 00935 } 00936 else 00937 { 00938 return HAL_BUSY; 00939 } 00940 } 00941 00942 /** 00943 * @brief Full-Duplex Send and Receive an amount of data in blocking mode. 00944 * @param husart USART handle. 00945 * @param pTxData pointer to TX data buffer. 00946 * @param pRxData pointer to RX data buffer. 00947 * @param Size amount of data to be sent (same amount to be received). 00948 * @param Timeout Timeout duration. 00949 * @retval HAL status 00950 */ 00951 HAL_StatusTypeDef HAL_USART_TransmitReceive(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout) 00952 { 00953 uint16_t *tmp; 00954 uint16_t uhMask; 00955 uint32_t tickstart = 0U; 00956 00957 if (husart->State == HAL_USART_STATE_READY) 00958 { 00959 if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0U)) 00960 { 00961 return HAL_ERROR; 00962 } 00963 00964 /* Process Locked */ 00965 __HAL_LOCK(husart); 00966 00967 husart->ErrorCode = HAL_USART_ERROR_NONE; 00968 husart->State = HAL_USART_STATE_BUSY_RX; 00969 00970 /* Init tickstart for timeout managment*/ 00971 tickstart = HAL_GetTick(); 00972 00973 husart->RxXferSize = Size; 00974 husart->TxXferSize = Size; 00975 husart->TxXferCount = Size; 00976 husart->RxXferCount = Size; 00977 00978 /* Computation of USART mask to apply to RDR register */ 00979 USART_MASK_COMPUTATION(husart); 00980 uhMask = husart->Mask; 00981 00982 #if defined(USART_CR2_SLVEN) 00983 if ((husart->SlaveMode == USART_SLAVEMODE_ENABLE) || (husart->TxXferCount == 0x01U)) 00984 #else 00985 if (husart->TxXferCount == 0x01U) 00986 #endif 00987 { 00988 /* Wait until TXE flag is set to send data */ 00989 if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK) 00990 { 00991 return HAL_TIMEOUT; 00992 } 00993 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 00994 { 00995 tmp = (uint16_t *) pTxData; 00996 husart->Instance->TDR = (*tmp & uhMask); 00997 pTxData += 2U; 00998 } 00999 else 01000 { 01001 husart->Instance->TDR = (*pTxData++ & (uint8_t)uhMask); 01002 } 01003 01004 husart->TxXferCount--; 01005 } 01006 01007 /* Check the remain data to be sent */ 01008 while ((husart->TxXferCount > 0U) || (husart->RxXferCount > 0U)) 01009 { 01010 if (husart->TxXferCount > 0U) 01011 { 01012 /* Wait until TXE flag is set to send data */ 01013 if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TXE, RESET, tickstart, Timeout) != HAL_OK) 01014 { 01015 return HAL_TIMEOUT; 01016 } 01017 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 01018 { 01019 tmp = (uint16_t *) pTxData; 01020 husart->Instance->TDR = (*tmp & uhMask); 01021 pTxData += 2U; 01022 } 01023 else 01024 { 01025 husart->Instance->TDR = (*pTxData++ & (uint8_t)uhMask); 01026 } 01027 01028 husart->TxXferCount--; 01029 } 01030 01031 if (husart->RxXferCount > 0U) 01032 { 01033 /* Wait for RXNE Flag */ 01034 if (USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, tickstart, Timeout) != HAL_OK) 01035 { 01036 return HAL_TIMEOUT; 01037 } 01038 01039 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 01040 { 01041 tmp = (uint16_t *) pRxData ; 01042 *tmp = (uint16_t)(husart->Instance->RDR & uhMask); 01043 pRxData += 2U; 01044 } 01045 else 01046 { 01047 *pRxData++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask); 01048 } 01049 01050 husart->RxXferCount--; 01051 } 01052 } 01053 01054 /* At end of TxRx process, restore husart->State to Ready */ 01055 husart->State = HAL_USART_STATE_READY; 01056 01057 /* Process Unlocked */ 01058 __HAL_UNLOCK(husart); 01059 01060 return HAL_OK; 01061 } 01062 else 01063 { 01064 return HAL_BUSY; 01065 } 01066 } 01067 01068 /** 01069 * @brief Send an amount of data in interrupt mode. 01070 * @param husart USART handle. 01071 * @param pTxData pointer to data buffer. 01072 * @param Size amount of data to be sent. 01073 * @retval HAL status 01074 */ 01075 HAL_StatusTypeDef HAL_USART_Transmit_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size) 01076 { 01077 if (husart->State == HAL_USART_STATE_READY) 01078 { 01079 if ((pTxData == NULL) || (Size == 0U)) 01080 { 01081 return HAL_ERROR; 01082 } 01083 01084 /* Process Locked */ 01085 __HAL_LOCK(husart); 01086 01087 husart->pTxBuffPtr = pTxData; 01088 husart->TxXferSize = Size; 01089 husart->TxXferCount = Size; 01090 husart->TxISR = NULL; 01091 01092 husart->ErrorCode = HAL_USART_ERROR_NONE; 01093 husart->State = HAL_USART_STATE_BUSY_TX; 01094 01095 /* The USART Error Interrupts: (Frame error, noise error, overrun error) 01096 are not managed by the USART Transmit Process to avoid the overrun interrupt 01097 when the usart mode is configured for transmit and receive "USART_MODE_TX_RX" 01098 to benefit for the frame error and noise interrupts the usart mode should be 01099 configured only for transmit "USART_MODE_TX" */ 01100 01101 #if defined(USART_CR1_FIFOEN) 01102 /* Configure Tx interrupt processing */ 01103 if (husart->FifoMode == USART_FIFOMODE_ENABLE) 01104 { 01105 /* Set the Tx ISR function pointer according to the data word length */ 01106 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 01107 { 01108 husart->TxISR = USART_TxISR_16BIT_FIFOEN; 01109 } 01110 else 01111 { 01112 husart->TxISR = USART_TxISR_8BIT_FIFOEN; 01113 } 01114 01115 /* Process Unlocked */ 01116 __HAL_UNLOCK(husart); 01117 01118 /* Enable the TX FIFO threshold interrupt */ 01119 __HAL_USART_ENABLE_IT(husart, USART_IT_TXFT); 01120 } 01121 else 01122 #endif 01123 { 01124 /* Set the Tx ISR function pointer according to the data word length */ 01125 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 01126 { 01127 husart->TxISR = USART_TxISR_16BIT; 01128 } 01129 else 01130 { 01131 husart->TxISR = USART_TxISR_8BIT; 01132 } 01133 01134 /* Process Unlocked */ 01135 __HAL_UNLOCK(husart); 01136 01137 /* Enable the USART Transmit Data Register Empty Interrupt */ 01138 __HAL_USART_ENABLE_IT(husart, USART_IT_TXE); 01139 } 01140 01141 return HAL_OK; 01142 } 01143 else 01144 { 01145 return HAL_BUSY; 01146 } 01147 } 01148 01149 /** 01150 * @brief Receive an amount of data in blocking mode. 01151 * @note To receive synchronous data, dummy data are simultaneously transmitted. 01152 * @param husart USART handle. 01153 * @param pRxData pointer to data buffer. 01154 * @param Size amount of data to be received. 01155 * @retval HAL status 01156 */ 01157 HAL_StatusTypeDef HAL_USART_Receive_IT(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size) 01158 { 01159 #if defined(USART_CR1_FIFOEN) 01160 uint8_t nb_dummy_data; 01161 #endif 01162 01163 if (husart->State == HAL_USART_STATE_READY) 01164 { 01165 if ((pRxData == NULL) || (Size == 0U)) 01166 { 01167 return HAL_ERROR; 01168 } 01169 01170 /* Process Locked */ 01171 __HAL_LOCK(husart); 01172 01173 husart->pRxBuffPtr = pRxData; 01174 husart->RxXferSize = Size; 01175 husart->RxXferCount = Size; 01176 husart->RxISR = NULL; 01177 01178 USART_MASK_COMPUTATION(husart); 01179 01180 husart->ErrorCode = HAL_USART_ERROR_NONE; 01181 husart->State = HAL_USART_STATE_BUSY_RX; 01182 01183 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */ 01184 SET_BIT(husart->Instance->CR3, USART_CR3_EIE); 01185 01186 #if defined(USART_CR1_FIFOEN) 01187 /* Configure Rx interrupt processing */ 01188 if ((husart->FifoMode == USART_FIFOMODE_ENABLE) && (Size >= husart->NbRxDataToProcess)) 01189 { 01190 /* Set the Rx ISR function pointer according to the data word length */ 01191 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 01192 { 01193 husart->RxISR = USART_RxISR_16BIT_FIFOEN; 01194 } 01195 else 01196 { 01197 husart->RxISR = USART_RxISR_8BIT_FIFOEN; 01198 } 01199 01200 /* Process Unlocked */ 01201 __HAL_UNLOCK(husart); 01202 01203 /* Enable the USART Parity Error interrupt and RX FIFO Threshold interrupt */ 01204 SET_BIT(husart->Instance->CR1, USART_CR1_PEIE); 01205 SET_BIT(husart->Instance->CR3, USART_CR3_RXFTIE); 01206 } 01207 else 01208 #endif 01209 { 01210 /* Set the Rx ISR function pointer according to the data word length */ 01211 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 01212 { 01213 husart->RxISR = USART_RxISR_16BIT; 01214 } 01215 else 01216 { 01217 husart->RxISR = USART_RxISR_8BIT; 01218 } 01219 01220 /* Process Unlocked */ 01221 __HAL_UNLOCK(husart); 01222 01223 /* Enable the USART Parity Error and Data Register not empty Interrupts */ 01224 #if defined(USART_CR1_FIFOEN) 01225 SET_BIT(husart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE_RXFNEIE); 01226 #else 01227 SET_BIT(husart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE); 01228 #endif 01229 } 01230 01231 #if defined(USART_CR2_SLVEN) 01232 if (husart->SlaveMode == USART_SLAVEMODE_DISABLE) 01233 #endif 01234 { 01235 /* Send dummy data in order to generate the clock for the Slave to send the next data. 01236 When FIFO mode is disabled only one data must be transferred. 01237 When FIFO mode is enabled data must be transmitted until the RX FIFO reaches its threshold. 01238 */ 01239 #if defined(USART_CR1_FIFOEN) 01240 if ((husart->FifoMode == USART_FIFOMODE_ENABLE) && (Size >= husart->NbRxDataToProcess)) 01241 { 01242 for (nb_dummy_data = husart->NbRxDataToProcess ; nb_dummy_data > 0U ; nb_dummy_data--) 01243 { 01244 husart->Instance->TDR = (USART_DUMMY_DATA & (uint16_t)0x00FF); 01245 } 01246 } 01247 else 01248 #endif 01249 { 01250 husart->Instance->TDR = (USART_DUMMY_DATA & (uint16_t)0x00FF); 01251 } 01252 } 01253 01254 return HAL_OK; 01255 } 01256 else 01257 { 01258 return HAL_BUSY; 01259 } 01260 } 01261 01262 /** 01263 * @brief Full-Duplex Send and Receive an amount of data in interrupt mode. 01264 * @param husart USART handle. 01265 * @param pTxData pointer to TX data buffer. 01266 * @param pRxData pointer to RX data buffer. 01267 * @param Size amount of data to be sent (same amount to be received). 01268 * @retval HAL status 01269 */ 01270 HAL_StatusTypeDef HAL_USART_TransmitReceive_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size) 01271 { 01272 01273 if (husart->State == HAL_USART_STATE_READY) 01274 { 01275 if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0U)) 01276 { 01277 return HAL_ERROR; 01278 } 01279 01280 /* Process Locked */ 01281 __HAL_LOCK(husart); 01282 01283 husart->pRxBuffPtr = pRxData; 01284 husart->RxXferSize = Size; 01285 husart->RxXferCount = Size; 01286 husart->pTxBuffPtr = pTxData; 01287 husart->TxXferSize = Size; 01288 husart->TxXferCount = Size; 01289 01290 /* Computation of USART mask to apply to RDR register */ 01291 USART_MASK_COMPUTATION(husart); 01292 01293 husart->ErrorCode = HAL_USART_ERROR_NONE; 01294 husart->State = HAL_USART_STATE_BUSY_TX_RX; 01295 01296 #if defined(USART_CR1_FIFOEN) 01297 /* Configure TxRx interrupt processing */ 01298 if ((husart->FifoMode == USART_FIFOMODE_ENABLE) && (Size >= husart->NbRxDataToProcess)) 01299 { 01300 /* Set the Rx ISR function pointer according to the data word length */ 01301 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 01302 { 01303 husart->TxISR = USART_TxISR_16BIT_FIFOEN; 01304 husart->RxISR = USART_RxISR_16BIT_FIFOEN; 01305 } 01306 else 01307 { 01308 husart->TxISR = USART_TxISR_8BIT_FIFOEN; 01309 husart->RxISR = USART_RxISR_8BIT_FIFOEN; 01310 } 01311 01312 /* Process Locked */ 01313 __HAL_UNLOCK(husart); 01314 01315 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */ 01316 SET_BIT(husart->Instance->CR3, USART_CR3_EIE); 01317 01318 /* Enable the USART Parity Error interrupt */ 01319 SET_BIT(husart->Instance->CR1, USART_CR1_PEIE); 01320 01321 /* Enable the TX and RX FIFO Threshold interrupts */ 01322 SET_BIT(husart->Instance->CR3, (USART_CR3_TXFTIE | USART_CR3_RXFTIE)); 01323 } 01324 else 01325 #endif 01326 { 01327 if ((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE)) 01328 { 01329 husart->TxISR = USART_TxISR_16BIT; 01330 husart->RxISR = USART_RxISR_16BIT; 01331 } 01332 else 01333 { 01334 husart->TxISR = USART_TxISR_8BIT; 01335 husart->RxISR = USART_RxISR_8BIT; 01336 } 01337 01338 /* Process Locked */ 01339 __HAL_UNLOCK(husart); 01340 01341 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */ 01342 SET_BIT(husart->Instance->CR3, USART_CR3_EIE); 01343 01344 /* Enable the USART Parity Error and USART Data Register not empty Interrupts */ 01345 #if defined(USART_CR1_FIFOEN) 01346 SET_BIT(husart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE_RXFNEIE); 01347 #else 01348 SET_BIT(husart->Instance->CR1, USART_CR1_PEIE | USART_CR1_RXNEIE); 01349 #endif 01350 01351 /* Enable the USART Transmit Data Register Empty Interrupt */ 01352 #if defined(USART_CR1_FIFOEN) 01353 SET_BIT(husart->Instance->CR1, USART_CR1_TXEIE_TXFNFIE); 01354 #else 01355 SET_BIT(husart->Instance->CR1, USART_CR1_TXEIE); 01356 #endif 01357 } 01358 01359 return HAL_OK; 01360 } 01361 else 01362 { 01363 return HAL_BUSY; 01364 } 01365 } 01366 01367 /** 01368 * @brief Send an amount of data in DMA mode. 01369 * @param husart USART handle. 01370 * @param pTxData pointer to data buffer. 01371 * @param Size amount of data to be sent. 01372 * @retval HAL status 01373 */ 01374 HAL_StatusTypeDef HAL_USART_Transmit_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size) 01375 { 01376 uint32_t *tmp; 01377 01378 if (husart->State == HAL_USART_STATE_READY) 01379 { 01380 if ((pTxData == NULL) || (Size == 0U)) 01381 { 01382 return HAL_ERROR; 01383 } 01384 01385 /* Process Locked */ 01386 __HAL_LOCK(husart); 01387 01388 husart->pTxBuffPtr = pTxData; 01389 husart->TxXferSize = Size; 01390 husart->TxXferCount = Size; 01391 01392 husart->ErrorCode = HAL_USART_ERROR_NONE; 01393 husart->State = HAL_USART_STATE_BUSY_TX; 01394 01395 /* Set the USART DMA transfer complete callback */ 01396 husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt; 01397 01398 /* Set the USART DMA Half transfer complete callback */ 01399 husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt; 01400 01401 /* Set the DMA error callback */ 01402 husart->hdmatx->XferErrorCallback = USART_DMAError; 01403 01404 /* Enable the USART transmit DMA channel */ 01405 tmp = (uint32_t *)&pTxData; 01406 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t *)tmp, (uint32_t)&husart->Instance->TDR, Size); 01407 01408 /* Clear the TC flag in the ICR register */ 01409 __HAL_USART_CLEAR_FLAG(husart, USART_CLEAR_TCF); 01410 01411 /* Process Unlocked */ 01412 __HAL_UNLOCK(husart); 01413 01414 /* Enable the DMA transfer for transmit request by setting the DMAT bit 01415 in the USART CR3 register */ 01416 SET_BIT(husart->Instance->CR3, USART_CR3_DMAT); 01417 01418 return HAL_OK; 01419 } 01420 else 01421 { 01422 return HAL_BUSY; 01423 } 01424 } 01425 01426 /** 01427 * @brief Receive an amount of data in DMA mode. 01428 * @note When the USART parity is enabled (PCE = 1), the received data contain 01429 * the parity bit (MSB position). 01430 * @note The USART DMA transmit channel must be configured in order to generate the clock for the slave. 01431 * @param husart USART handle. 01432 * @param pRxData pointer to data buffer. 01433 * @param Size amount of data to be received. 01434 * @retval HAL status 01435 */ 01436 HAL_StatusTypeDef HAL_USART_Receive_DMA(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size) 01437 { 01438 uint32_t *tmp; 01439 01440 /* Check that a Rx process is not already ongoing */ 01441 if (husart->State == HAL_USART_STATE_READY) 01442 { 01443 if ((pRxData == NULL) || (Size == 0U)) 01444 { 01445 return HAL_ERROR; 01446 } 01447 01448 /* Process Locked */ 01449 __HAL_LOCK(husart); 01450 01451 husart->pRxBuffPtr = pRxData; 01452 husart->RxXferSize = Size; 01453 husart->pTxBuffPtr = pRxData; 01454 husart->TxXferSize = Size; 01455 01456 husart->ErrorCode = HAL_USART_ERROR_NONE; 01457 husart->State = HAL_USART_STATE_BUSY_RX; 01458 01459 /* Set the USART DMA Rx transfer complete callback */ 01460 husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt; 01461 01462 /* Set the USART DMA Half transfer complete callback */ 01463 husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt; 01464 01465 /* Set the USART DMA Rx transfer error callback */ 01466 husart->hdmarx->XferErrorCallback = USART_DMAError; 01467 01468 /* Enable the USART receive DMA channel */ 01469 tmp = (uint32_t *)&pRxData; 01470 HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->RDR, *(uint32_t *)tmp, Size); 01471 01472 #if defined(USART_CR2_SLVEN) 01473 if (husart->SlaveMode == USART_SLAVEMODE_DISABLE) 01474 #endif 01475 { 01476 /* Enable the USART transmit DMA channel: the transmit channel is used in order 01477 to generate in the non-blocking mode the clock to the slave device, 01478 this mode isn't a simplex receive mode but a full-duplex receive mode */ 01479 01480 /* Set the USART DMA Tx Complete and Error callback to Null */ 01481 husart->hdmatx->XferErrorCallback = NULL; 01482 husart->hdmatx->XferHalfCpltCallback = NULL; 01483 husart->hdmatx->XferCpltCallback = NULL; 01484 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t *)tmp, (uint32_t)&husart->Instance->TDR, Size); 01485 } 01486 01487 /* Process Unlocked */ 01488 __HAL_UNLOCK(husart); 01489 01490 /* Enable the USART Parity Error Interrupt */ 01491 SET_BIT(husart->Instance->CR1, USART_CR1_PEIE); 01492 01493 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */ 01494 SET_BIT(husart->Instance->CR3, USART_CR3_EIE); 01495 01496 /* Enable the DMA transfer for the receiver request by setting the DMAR bit 01497 in the USART CR3 register */ 01498 SET_BIT(husart->Instance->CR3, USART_CR3_DMAR); 01499 01500 /* Enable the DMA transfer for transmit request by setting the DMAT bit 01501 in the USART CR3 register */ 01502 SET_BIT(husart->Instance->CR3, USART_CR3_DMAT); 01503 01504 return HAL_OK; 01505 } 01506 else 01507 { 01508 return HAL_BUSY; 01509 } 01510 } 01511 01512 /** 01513 * @brief Full-Duplex Transmit Receive an amount of data in non-blocking mode. 01514 * @note When the USART parity is enabled (PCE = 1) the data received contain the parity bit. 01515 * @param husart USART handle. 01516 * @param pTxData pointer to TX data buffer. 01517 * @param pRxData pointer to RX data buffer. 01518 * @param Size amount of data to be received/sent. 01519 * @retval HAL status 01520 */ 01521 HAL_StatusTypeDef HAL_USART_TransmitReceive_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size) 01522 { 01523 uint32_t *tmp; 01524 01525 if (husart->State == HAL_USART_STATE_READY) 01526 { 01527 if ((pTxData == NULL) || (pRxData == NULL) || (Size == 0U)) 01528 { 01529 return HAL_ERROR; 01530 } 01531 01532 /* Process Locked */ 01533 __HAL_LOCK(husart); 01534 01535 husart->pRxBuffPtr = pRxData; 01536 husart->RxXferSize = Size; 01537 husart->pTxBuffPtr = pTxData; 01538 husart->TxXferSize = Size; 01539 01540 husart->ErrorCode = HAL_USART_ERROR_NONE; 01541 husart->State = HAL_USART_STATE_BUSY_TX_RX; 01542 01543 /* Set the USART DMA Rx transfer complete callback */ 01544 husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt; 01545 01546 /* Set the USART DMA Half transfer complete callback */ 01547 husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt; 01548 01549 /* Set the USART DMA Tx transfer complete callback */ 01550 husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt; 01551 01552 /* Set the USART DMA Half transfer complete callback */ 01553 husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt; 01554 01555 /* Set the USART DMA Tx transfer error callback */ 01556 husart->hdmatx->XferErrorCallback = USART_DMAError; 01557 01558 /* Set the USART DMA Rx transfer error callback */ 01559 husart->hdmarx->XferErrorCallback = USART_DMAError; 01560 01561 /* Enable the USART receive DMA channel */ 01562 tmp = (uint32_t *)&pRxData; 01563 HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->RDR, *(uint32_t *)tmp, Size); 01564 01565 /* Enable the USART transmit DMA channel */ 01566 tmp = (uint32_t *)&pTxData; 01567 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t *)tmp, (uint32_t)&husart->Instance->TDR, Size); 01568 01569 /* Process Unlocked */ 01570 __HAL_UNLOCK(husart); 01571 01572 /* Enable the USART Parity Error Interrupt */ 01573 SET_BIT(husart->Instance->CR1, USART_CR1_PEIE); 01574 01575 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */ 01576 SET_BIT(husart->Instance->CR3, USART_CR3_EIE); 01577 01578 /* Clear the TC flag in the ICR register */ 01579 __HAL_USART_CLEAR_FLAG(husart, USART_CLEAR_TCF); 01580 01581 /* Enable the DMA transfer for the receiver request by setting the DMAR bit 01582 in the USART CR3 register */ 01583 SET_BIT(husart->Instance->CR3, USART_CR3_DMAR); 01584 01585 /* Enable the DMA transfer for transmit request by setting the DMAT bit 01586 in the USART CR3 register */ 01587 SET_BIT(husart->Instance->CR3, USART_CR3_DMAT); 01588 01589 return HAL_OK; 01590 } 01591 else 01592 { 01593 return HAL_BUSY; 01594 } 01595 } 01596 01597 /** 01598 * @brief Pause the DMA Transfer. 01599 * @param husart USART handle. 01600 * @retval HAL status 01601 */ 01602 HAL_StatusTypeDef HAL_USART_DMAPause(USART_HandleTypeDef *husart) 01603 { 01604 /* Process Locked */ 01605 __HAL_LOCK(husart); 01606 01607 if ((husart->State == HAL_USART_STATE_BUSY_TX) && 01608 (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT))) 01609 { 01610 /* Disable the USART DMA Tx request */ 01611 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT); 01612 } 01613 else if ((husart->State == HAL_USART_STATE_BUSY_RX) || 01614 (husart->State == HAL_USART_STATE_BUSY_TX_RX)) 01615 { 01616 if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT)) 01617 { 01618 /* Disable the USART DMA Tx request */ 01619 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT); 01620 } 01621 if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR)) 01622 { 01623 /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */ 01624 CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE); 01625 CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE); 01626 01627 /* Disable the USART DMA Rx request */ 01628 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR); 01629 } 01630 } 01631 01632 /* Process Unlocked */ 01633 __HAL_UNLOCK(husart); 01634 01635 return HAL_OK; 01636 } 01637 01638 /** 01639 * @brief Resume the DMA Transfer. 01640 * @param husart USART handle. 01641 * @retval HAL status 01642 */ 01643 HAL_StatusTypeDef HAL_USART_DMAResume(USART_HandleTypeDef *husart) 01644 { 01645 /* Process Locked */ 01646 __HAL_LOCK(husart); 01647 01648 if (husart->State == HAL_USART_STATE_BUSY_TX) 01649 { 01650 /* Enable the USART DMA Tx request */ 01651 SET_BIT(husart->Instance->CR3, USART_CR3_DMAT); 01652 } 01653 else if ((husart->State == HAL_USART_STATE_BUSY_RX) || 01654 (husart->State == HAL_USART_STATE_BUSY_TX_RX)) 01655 { 01656 /* Clear the Overrun flag before resuming the Rx transfer*/ 01657 __HAL_USART_CLEAR_FLAG(husart, USART_CLEAR_OREF); 01658 01659 /* Reenable PE and ERR (Frame error, noise error, overrun error) interrupts */ 01660 SET_BIT(husart->Instance->CR1, USART_CR1_PEIE); 01661 SET_BIT(husart->Instance->CR3, USART_CR3_EIE); 01662 01663 /* Enable the USART DMA Rx request before the DMA Tx request */ 01664 SET_BIT(husart->Instance->CR3, USART_CR3_DMAR); 01665 01666 /* Enable the USART DMA Tx request */ 01667 SET_BIT(husart->Instance->CR3, USART_CR3_DMAT); 01668 } 01669 01670 /* Process Unlocked */ 01671 __HAL_UNLOCK(husart); 01672 01673 return HAL_OK; 01674 } 01675 01676 /** 01677 * @brief Stop the DMA Transfer. 01678 * @param husart USART handle. 01679 * @retval HAL status 01680 */ 01681 HAL_StatusTypeDef HAL_USART_DMAStop(USART_HandleTypeDef *husart) 01682 { 01683 /* The Lock is not implemented on this API to allow the user application 01684 to call the HAL USART API under callbacks HAL_USART_TxCpltCallback() / HAL_USART_RxCpltCallback() / 01685 HAL_USART_TxHalfCpltCallback / HAL_USART_RxHalfCpltCallback: 01686 indeed, when HAL_DMA_Abort() API is called, the DMA TX/RX Transfer or Half Transfer complete 01687 interrupt is generated if the DMA transfer interruption occurs at the middle or at the end of 01688 the stream and the corresponding call back is executed. */ 01689 01690 /* Disable the USART Tx/Rx DMA requests */ 01691 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT); 01692 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR); 01693 01694 /* Abort the USART DMA tx channel */ 01695 if (husart->hdmatx != NULL) 01696 { 01697 HAL_DMA_Abort(husart->hdmatx); 01698 } 01699 /* Abort the USART DMA rx channel */ 01700 if (husart->hdmarx != NULL) 01701 { 01702 HAL_DMA_Abort(husart->hdmarx); 01703 } 01704 01705 USART_EndTransfer(husart); 01706 husart->State = HAL_USART_STATE_READY; 01707 01708 return HAL_OK; 01709 } 01710 01711 /** 01712 * @brief Abort ongoing transfers (blocking mode). 01713 * @param husart USART handle. 01714 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode. 01715 * This procedure performs following operations : 01716 * - Disable USART Interrupts (Tx and Rx) 01717 * - Disable the DMA transfer in the peripheral register (if enabled) 01718 * - Abort DMA transfer by calling HAL_DMA_Abort (in case of transfer in DMA mode) 01719 * - Set handle State to READY 01720 * @note This procedure is executed in blocking mode : when exiting function, Abort is considered as completed. 01721 * @retval HAL status 01722 */ 01723 HAL_StatusTypeDef HAL_USART_Abort(USART_HandleTypeDef *husart) 01724 { 01725 #if defined(USART_CR1_FIFOEN) 01726 /* Disable TXEIE, TCIE, RXNE, RXFT, TXFT, PE and ERR (Frame error, noise error, overrun error) interrupts */ 01727 CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE_RXFNEIE | USART_CR1_PEIE | USART_CR1_TXEIE_TXFNFIE | USART_CR1_TCIE)); 01728 CLEAR_BIT(husart->Instance->CR3, (USART_CR3_EIE | USART_CR3_RXFTIE | USART_CR3_TXFTIE)); 01729 #else 01730 CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE)); 01731 CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE); 01732 #endif 01733 01734 /* Disable the USART DMA Tx request if enabled */ 01735 if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT)) 01736 { 01737 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT); 01738 01739 /* Abort the USART DMA Tx channel : use blocking DMA Abort API (no callback) */ 01740 if (husart->hdmatx != NULL) 01741 { 01742 /* Set the USART DMA Abort callback to Null. 01743 No call back execution at end of DMA abort procedure */ 01744 husart->hdmatx->XferAbortCallback = NULL; 01745 01746 HAL_DMA_Abort(husart->hdmatx); 01747 } 01748 } 01749 01750 /* Disable the USART DMA Rx request if enabled */ 01751 if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR)) 01752 { 01753 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR); 01754 01755 /* Abort the USART DMA Rx channel : use blocking DMA Abort API (no callback) */ 01756 if (husart->hdmarx != NULL) 01757 { 01758 /* Set the USART DMA Abort callback to Null. 01759 No call back execution at end of DMA abort procedure */ 01760 husart->hdmarx->XferAbortCallback = NULL; 01761 01762 HAL_DMA_Abort(husart->hdmarx); 01763 } 01764 } 01765 01766 /* Reset Tx and Rx transfer counters */ 01767 husart->TxXferCount = 0U; 01768 husart->RxXferCount = 0U; 01769 01770 /* Clear the Error flags in the ICR register */ 01771 __HAL_USART_CLEAR_FLAG(husart, USART_CLEAR_OREF | USART_CLEAR_NEF | USART_CLEAR_PEF | USART_CLEAR_FEF); 01772 01773 #if defined(USART_CR1_FIFOEN) 01774 /* Flush the whole TX FIFO (if needed) */ 01775 if (husart->FifoMode == USART_FIFOMODE_ENABLE) 01776 { 01777 __HAL_USART_SEND_REQ(husart, USART_TXDATA_FLUSH_REQUEST); 01778 } 01779 #endif 01780 01781 /* Discard the received data */ 01782 __HAL_USART_SEND_REQ(husart, USART_RXDATA_FLUSH_REQUEST); 01783 01784 /* Restore husart->State to Ready */ 01785 husart->State = HAL_USART_STATE_READY; 01786 01787 /* Reset Handle ErrorCode to No Error */ 01788 husart->ErrorCode = HAL_USART_ERROR_NONE; 01789 01790 return HAL_OK; 01791 } 01792 01793 /** 01794 * @brief Abort ongoing transfers (Interrupt mode). 01795 * @param husart USART handle. 01796 * @note This procedure could be used for aborting any ongoing transfer started in Interrupt or DMA mode. 01797 * This procedure performs following operations : 01798 * - Disable USART Interrupts (Tx and Rx) 01799 * - Disable the DMA transfer in the peripheral register (if enabled) 01800 * - Abort DMA transfer by calling HAL_DMA_Abort_IT (in case of transfer in DMA mode) 01801 * - Set handle State to READY 01802 * - At abort completion, call user abort complete callback 01803 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be 01804 * considered as completed only when user abort complete callback is executed (not when exiting function). 01805 * @retval HAL status 01806 */ 01807 HAL_StatusTypeDef HAL_USART_Abort_IT(USART_HandleTypeDef *husart) 01808 { 01809 uint32_t abortcplt = 1U; 01810 01811 #if defined(USART_CR1_FIFOEN) 01812 /* Disable TXEIE, TCIE, RXNE, RXFT, TXFT, PE and ERR (Frame error, noise error, overrun error) interrupts */ 01813 CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE_RXFNEIE | USART_CR1_PEIE | USART_CR1_TXEIE_TXFNFIE | USART_CR1_TCIE)); 01814 CLEAR_BIT(husart->Instance->CR3, (USART_CR3_EIE | USART_CR3_RXFTIE | USART_CR3_TXFTIE)); 01815 #else 01816 CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE)); 01817 CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE); 01818 #endif 01819 01820 /* If DMA Tx and/or DMA Rx Handles are associated to USART Handle, DMA Abort complete callbacks should be initialised 01821 before any call to DMA Abort functions */ 01822 /* DMA Tx Handle is valid */ 01823 if (husart->hdmatx != NULL) 01824 { 01825 /* Set DMA Abort Complete callback if USART DMA Tx request if enabled. 01826 Otherwise, set it to NULL */ 01827 if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT)) 01828 { 01829 husart->hdmatx->XferAbortCallback = USART_DMATxAbortCallback; 01830 } 01831 else 01832 { 01833 husart->hdmatx->XferAbortCallback = NULL; 01834 } 01835 } 01836 /* DMA Rx Handle is valid */ 01837 if (husart->hdmarx != NULL) 01838 { 01839 /* Set DMA Abort Complete callback if USART DMA Rx request if enabled. 01840 Otherwise, set it to NULL */ 01841 if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR)) 01842 { 01843 husart->hdmarx->XferAbortCallback = USART_DMARxAbortCallback; 01844 } 01845 else 01846 { 01847 husart->hdmarx->XferAbortCallback = NULL; 01848 } 01849 } 01850 01851 /* Disable the USART DMA Tx request if enabled */ 01852 if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAT)) 01853 { 01854 /* Disable DMA Tx at USART level */ 01855 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT); 01856 01857 /* Abort the USART DMA Tx channel : use non blocking DMA Abort API (callback) */ 01858 if (husart->hdmatx != NULL) 01859 { 01860 /* USART Tx DMA Abort callback has already been initialised : 01861 will lead to call HAL_USART_AbortCpltCallback() at end of DMA abort procedure */ 01862 01863 /* Abort DMA TX */ 01864 if (HAL_DMA_Abort_IT(husart->hdmatx) != HAL_OK) 01865 { 01866 husart->hdmatx->XferAbortCallback = NULL; 01867 } 01868 else 01869 { 01870 abortcplt = 0U; 01871 } 01872 } 01873 } 01874 01875 /* Disable the USART DMA Rx request if enabled */ 01876 if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR)) 01877 { 01878 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR); 01879 01880 /* Abort the USART DMA Rx channel : use non blocking DMA Abort API (callback) */ 01881 if (husart->hdmarx != NULL) 01882 { 01883 /* USART Rx DMA Abort callback has already been initialised : 01884 will lead to call HAL_USART_AbortCpltCallback() at end of DMA abort procedure */ 01885 01886 /* Abort DMA RX */ 01887 if (HAL_DMA_Abort_IT(husart->hdmarx) != HAL_OK) 01888 { 01889 husart->hdmarx->XferAbortCallback = NULL; 01890 abortcplt = 1U; 01891 } 01892 else 01893 { 01894 abortcplt = 0U; 01895 } 01896 } 01897 } 01898 01899 /* if no DMA abort complete callback execution is required => call user Abort Complete callback */ 01900 if (abortcplt == 1U) 01901 { 01902 /* Reset Tx and Rx transfer counters */ 01903 husart->TxXferCount = 0U; 01904 husart->RxXferCount = 0U; 01905 01906 /* Reset errorCode */ 01907 husart->ErrorCode = HAL_USART_ERROR_NONE; 01908 01909 /* Clear the Error flags in the ICR register */ 01910 __HAL_USART_CLEAR_FLAG(husart, USART_CLEAR_OREF | USART_CLEAR_NEF | USART_CLEAR_PEF | USART_CLEAR_FEF); 01911 01912 #if defined(USART_CR1_FIFOEN) 01913 /* Flush the whole TX FIFO (if needed) */ 01914 if (husart->FifoMode == USART_FIFOMODE_ENABLE) 01915 { 01916 __HAL_USART_SEND_REQ(husart, USART_TXDATA_FLUSH_REQUEST); 01917 } 01918 #endif 01919 01920 /* Discard the received data */ 01921 __HAL_USART_SEND_REQ(husart, USART_RXDATA_FLUSH_REQUEST); 01922 01923 /* Restore husart->State to Ready */ 01924 husart->State = HAL_USART_STATE_READY; 01925 01926 /* As no DMA to be aborted, call directly user Abort complete callback */ 01927 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 01928 /* Call registered Abort Complete Callback */ 01929 husart->AbortCpltCallback(husart); 01930 #else 01931 /* Call legacy weak Abort Complete Callback */ 01932 HAL_USART_AbortCpltCallback(husart); 01933 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 01934 } 01935 01936 return HAL_OK; 01937 } 01938 01939 /** 01940 * @brief Handle USART interrupt request. 01941 * @param husart USART handle. 01942 * @retval None 01943 */ 01944 void HAL_USART_IRQHandler(USART_HandleTypeDef *husart) 01945 { 01946 uint32_t isrflags = READ_REG(husart->Instance->ISR); 01947 uint32_t cr1its = READ_REG(husart->Instance->CR1); 01948 uint32_t cr3its = READ_REG(husart->Instance->CR3); 01949 01950 uint32_t errorflags; 01951 01952 /* If no error occurs */ 01953 #if defined(USART_CR2_SLVEN) 01954 errorflags = (isrflags & (uint32_t)(USART_ISR_PE | USART_ISR_FE | USART_ISR_ORE | USART_ISR_NE | USART_ISR_UDR)); 01955 #else 01956 errorflags = (isrflags & (uint32_t)(USART_ISR_PE | USART_ISR_FE | USART_ISR_ORE | USART_ISR_NE)); 01957 #endif 01958 if (errorflags == RESET) 01959 { 01960 /* USART in mode Receiver ---------------------------------------------------*/ 01961 #if defined(USART_CR1_FIFOEN) 01962 if (((isrflags & USART_ISR_RXNE_RXFNE) != RESET) 01963 && (((cr1its & USART_CR1_RXNEIE_RXFNEIE) != RESET) 01964 || ((cr3its & USART_CR3_RXFTIE) != RESET))) 01965 #else 01966 if (((isrflags & USART_ISR_RXNE) != RESET) 01967 && ((cr1its & USART_CR1_RXNEIE) != RESET)) 01968 #endif 01969 { 01970 if (husart->RxISR != NULL) 01971 { 01972 husart->RxISR(husart); 01973 } 01974 return; 01975 } 01976 } 01977 01978 /* If some errors occur */ 01979 #if defined(USART_CR1_FIFOEN) 01980 if ((errorflags != RESET) 01981 && (((cr3its & (USART_CR3_RXFTIE | USART_CR3_EIE)) != RESET) 01982 || ((cr1its & (USART_CR1_RXNEIE_RXFNEIE | USART_CR1_PEIE)) != RESET))) 01983 #else 01984 if ((errorflags != RESET) 01985 && (((cr3its & USART_CR3_EIE) != RESET) 01986 || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET))) 01987 #endif 01988 { 01989 /* USART parity error interrupt occurred -------------------------------------*/ 01990 if (((isrflags & USART_ISR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET)) 01991 { 01992 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_PEF); 01993 01994 husart->ErrorCode |= HAL_USART_ERROR_PE; 01995 } 01996 01997 /* USART frame error interrupt occurred --------------------------------------*/ 01998 if (((isrflags & USART_ISR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET)) 01999 { 02000 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_FEF); 02001 02002 husart->ErrorCode |= HAL_USART_ERROR_FE; 02003 } 02004 02005 /* USART noise error interrupt occurred --------------------------------------*/ 02006 if (((isrflags & USART_ISR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET)) 02007 { 02008 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_NEF); 02009 02010 husart->ErrorCode |= HAL_USART_ERROR_NE; 02011 } 02012 02013 /* USART Over-Run interrupt occurred -----------------------------------------*/ 02014 #if defined(USART_CR1_FIFOEN) 02015 if (((isrflags & USART_ISR_ORE) != RESET) 02016 && (((cr1its & USART_CR1_RXNEIE_RXFNEIE) != RESET) || 02017 ((cr3its & (USART_CR3_RXFTIE | USART_CR3_EIE)) != RESET))) 02018 #else 02019 if (((isrflags & USART_ISR_ORE) != RESET) 02020 && (((cr1its & USART_CR1_RXNEIE) != RESET) || 02021 ((cr3its & USART_CR3_EIE) != RESET))) 02022 #endif 02023 { 02024 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_OREF); 02025 02026 husart->ErrorCode |= HAL_USART_ERROR_ORE; 02027 } 02028 02029 #if defined(USART_CR2_SLVEN) 02030 /* USART SPI slave underrun error interrupt occurred -------------------------*/ 02031 if (((isrflags & USART_ISR_UDR) != RESET) && ((cr3its & USART_CR3_EIE) != RESET)) 02032 { 02033 /* Ignore SPI slave underrun errors when reception is going on */ 02034 if (husart->State == HAL_USART_STATE_BUSY_RX) 02035 { 02036 __HAL_USART_CLEAR_UDRFLAG(husart); 02037 return; 02038 } 02039 else 02040 { 02041 __HAL_USART_CLEAR_UDRFLAG(husart); 02042 husart->ErrorCode |= HAL_USART_ERROR_UDR; 02043 } 02044 } 02045 #endif 02046 02047 /* Call USART Error Call back function if need be --------------------------*/ 02048 if (husart->ErrorCode != HAL_USART_ERROR_NONE) 02049 { 02050 /* USART in mode Receiver ---------------------------------------------------*/ 02051 #if defined(USART_CR1_FIFOEN) 02052 if (((isrflags & USART_ISR_RXNE_RXFNE) != RESET) 02053 && (((cr1its & USART_CR1_RXNEIE_RXFNEIE) != RESET) 02054 || ((cr3its & USART_CR3_RXFTIE) != RESET))) 02055 #else 02056 if (((isrflags & USART_ISR_RXNE) != RESET) 02057 && ((cr1its & USART_CR1_RXNEIE) != RESET)) 02058 #endif 02059 { 02060 if (husart->RxISR != NULL) 02061 { 02062 husart->RxISR(husart); 02063 } 02064 } 02065 02066 /* If Overrun error occurs, or if any error occurs in DMA mode reception, 02067 consider error as blocking */ 02068 if (((husart->ErrorCode & HAL_USART_ERROR_ORE) != RESET) || 02069 (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR))) 02070 { 02071 /* Blocking error : transfer is aborted 02072 Set the USART state ready to be able to start again the process, 02073 Disable Interrupts, and disable DMA requests, if ongoing */ 02074 USART_EndTransfer(husart); 02075 02076 /* Disable the USART DMA Rx request if enabled */ 02077 if (HAL_IS_BIT_SET(husart->Instance->CR3, USART_CR3_DMAR)) 02078 { 02079 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR | USART_CR3_DMAR); 02080 02081 /* Abort the USART DMA Tx channel */ 02082 if (husart->hdmatx != NULL) 02083 { 02084 /* Set the USART Tx DMA Abort callback to NULL : no callback 02085 executed at end of DMA abort procedure */ 02086 husart->hdmatx->XferAbortCallback = NULL; 02087 02088 /* Abort DMA TX */ 02089 HAL_DMA_Abort_IT(husart->hdmatx); 02090 } 02091 02092 /* Abort the USART DMA Rx channel */ 02093 if (husart->hdmarx != NULL) 02094 { 02095 /* Set the USART Rx DMA Abort callback : 02096 will lead to call HAL_USART_ErrorCallback() at end of DMA abort procedure */ 02097 husart->hdmarx->XferAbortCallback = USART_DMAAbortOnError; 02098 02099 /* Abort DMA RX */ 02100 if (HAL_DMA_Abort_IT(husart->hdmarx) != HAL_OK) 02101 { 02102 /* Call Directly husart->hdmarx->XferAbortCallback function in case of error */ 02103 husart->hdmarx->XferAbortCallback(husart->hdmarx); 02104 } 02105 } 02106 else 02107 { 02108 /* Call user error callback */ 02109 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02110 /* Call registered Error Callback */ 02111 husart->ErrorCallback(husart); 02112 #else 02113 /* Call legacy weak Error Callback */ 02114 HAL_USART_ErrorCallback(husart); 02115 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02116 } 02117 } 02118 else 02119 { 02120 /* Call user error callback */ 02121 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02122 /* Call registered Error Callback */ 02123 husart->ErrorCallback(husart); 02124 #else 02125 /* Call legacy weak Error Callback */ 02126 HAL_USART_ErrorCallback(husart); 02127 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02128 } 02129 } 02130 else 02131 { 02132 /* Non Blocking error : transfer could go on. 02133 Error is notified to user through user error callback */ 02134 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02135 /* Call registered Error Callback */ 02136 husart->ErrorCallback(husart); 02137 #else 02138 /* Call legacy weak Error Callback */ 02139 HAL_USART_ErrorCallback(husart); 02140 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02141 husart->ErrorCode = HAL_USART_ERROR_NONE; 02142 } 02143 } 02144 return; 02145 02146 } /* End if some error occurs */ 02147 02148 02149 /* USART in mode Transmitter ------------------------------------------------*/ 02150 #if defined(USART_CR1_FIFOEN) 02151 if (((isrflags & USART_ISR_TXE_TXFNF) != RESET) 02152 && (((cr1its & USART_CR1_TXEIE_TXFNFIE) != RESET) 02153 || ((cr3its & USART_CR3_TXFTIE) != RESET))) 02154 #else 02155 if (((isrflags & USART_ISR_TXE) != RESET) 02156 && ((cr1its & USART_CR1_TXEIE) != RESET)) 02157 #endif 02158 { 02159 if (husart->TxISR != NULL) 02160 { 02161 husart->TxISR(husart); 02162 } 02163 return; 02164 } 02165 02166 /* USART in mode Transmitter (transmission end) -----------------------------*/ 02167 if (((isrflags & USART_ISR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET)) 02168 { 02169 USART_EndTransmit_IT(husart); 02170 return; 02171 } 02172 02173 #if defined(USART_CR1_FIFOEN) 02174 /* USART TX Fifo Empty occurred ----------------------------------------------*/ 02175 if (((isrflags & USART_ISR_TXFE) != RESET) && ((cr1its & USART_CR1_TXFEIE) != RESET)) 02176 { 02177 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02178 /* Call registered Tx Fifo Empty Callback */ 02179 husart->TxFifoEmptyCallback(husart); 02180 #else 02181 /* Call legacy weak Tx Fifo Empty Callback */ 02182 HAL_USARTEx_TxFifoEmptyCallback(husart); 02183 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02184 return; 02185 } 02186 02187 /* USART RX Fifo Full occurred ----------------------------------------------*/ 02188 if (((isrflags & USART_ISR_RXFF) != RESET) && ((cr1its & USART_CR1_RXFFIE) != RESET)) 02189 { 02190 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02191 /* Call registered Rx Fifo Full Callback */ 02192 husart->RxFifoFullCallback(husart); 02193 #else 02194 /* Call legacy weak Rx Fifo Full Callback */ 02195 HAL_USARTEx_RxFifoFullCallback(husart); 02196 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02197 return; 02198 } 02199 #endif 02200 } 02201 02202 /** 02203 * @brief Tx Transfer completed callback. 02204 * @param husart USART handle. 02205 * @retval None 02206 */ 02207 __weak void HAL_USART_TxCpltCallback(USART_HandleTypeDef *husart) 02208 { 02209 /* Prevent unused argument(s) compilation warning */ 02210 UNUSED(husart); 02211 02212 /* NOTE : This function should not be modified, when the callback is needed, 02213 the HAL_USART_TxCpltCallback can be implemented in the user file. 02214 */ 02215 } 02216 02217 /** 02218 * @brief Tx Half Transfer completed callback. 02219 * @param husart USART handle. 02220 * @retval None 02221 */ 02222 __weak void HAL_USART_TxHalfCpltCallback(USART_HandleTypeDef *husart) 02223 { 02224 /* Prevent unused argument(s) compilation warning */ 02225 UNUSED(husart); 02226 02227 /* NOTE: This function should not be modified, when the callback is needed, 02228 the HAL_USART_TxHalfCpltCallback can be implemented in the user file. 02229 */ 02230 } 02231 02232 /** 02233 * @brief Rx Transfer completed callback. 02234 * @param husart USART handle. 02235 * @retval None 02236 */ 02237 __weak void HAL_USART_RxCpltCallback(USART_HandleTypeDef *husart) 02238 { 02239 /* Prevent unused argument(s) compilation warning */ 02240 UNUSED(husart); 02241 02242 /* NOTE: This function should not be modified, when the callback is needed, 02243 the HAL_USART_RxCpltCallback can be implemented in the user file. 02244 */ 02245 } 02246 02247 /** 02248 * @brief Rx Half Transfer completed callback. 02249 * @param husart USART handle. 02250 * @retval None 02251 */ 02252 __weak void HAL_USART_RxHalfCpltCallback(USART_HandleTypeDef *husart) 02253 { 02254 /* Prevent unused argument(s) compilation warning */ 02255 UNUSED(husart); 02256 02257 /* NOTE : This function should not be modified, when the callback is needed, 02258 the HAL_USART_RxHalfCpltCallback can be implemented in the user file 02259 */ 02260 } 02261 02262 /** 02263 * @brief Tx/Rx Transfers completed callback for the non-blocking process. 02264 * @param husart USART handle. 02265 * @retval None 02266 */ 02267 __weak void HAL_USART_TxRxCpltCallback(USART_HandleTypeDef *husart) 02268 { 02269 /* Prevent unused argument(s) compilation warning */ 02270 UNUSED(husart); 02271 02272 /* NOTE : This function should not be modified, when the callback is needed, 02273 the HAL_USART_TxRxCpltCallback can be implemented in the user file 02274 */ 02275 } 02276 02277 /** 02278 * @brief USART error callback. 02279 * @param husart USART handle. 02280 * @retval None 02281 */ 02282 __weak void HAL_USART_ErrorCallback(USART_HandleTypeDef *husart) 02283 { 02284 /* Prevent unused argument(s) compilation warning */ 02285 UNUSED(husart); 02286 02287 /* NOTE : This function should not be modified, when the callback is needed, 02288 the HAL_USART_ErrorCallback can be implemented in the user file. 02289 */ 02290 } 02291 02292 /** 02293 * @brief USART Abort Complete callback. 02294 * @param husart USART handle. 02295 * @retval None 02296 */ 02297 __weak void HAL_USART_AbortCpltCallback(USART_HandleTypeDef *husart) 02298 { 02299 /* Prevent unused argument(s) compilation warning */ 02300 UNUSED(husart); 02301 02302 /* NOTE : This function should not be modified, when the callback is needed, 02303 the HAL_USART_AbortCpltCallback can be implemented in the user file. 02304 */ 02305 } 02306 02307 /** 02308 * @} 02309 */ 02310 02311 /** @defgroup USART_Exported_Functions_Group4 Peripheral State and Error functions 02312 * @brief USART Peripheral State and Error functions 02313 * 02314 @verbatim 02315 ============================================================================== 02316 ##### Peripheral State and Error functions ##### 02317 ============================================================================== 02318 [..] 02319 This subsection provides functions allowing to : 02320 (+) Return the USART handle state 02321 (+) Return the USART handle error code 02322 02323 @endverbatim 02324 * @{ 02325 */ 02326 02327 02328 /** 02329 * @brief Return the USART handle state. 02330 * @param husart pointer to a USART_HandleTypeDef structure that contains 02331 * the configuration information for the specified USART. 02332 * @retval USART handle state 02333 */ 02334 HAL_USART_StateTypeDef HAL_USART_GetState(USART_HandleTypeDef *husart) 02335 { 02336 return husart->State; 02337 } 02338 02339 /** 02340 * @brief Return the USART error code. 02341 * @param husart pointer to a USART_HandleTypeDef structure that contains 02342 * the configuration information for the specified USART. 02343 * @retval USART handle Error Code 02344 */ 02345 uint32_t HAL_USART_GetError(USART_HandleTypeDef *husart) 02346 { 02347 return husart->ErrorCode; 02348 } 02349 02350 /** 02351 * @} 02352 */ 02353 02354 /** 02355 * @} 02356 */ 02357 02358 /** @defgroup USART_Private_Functions USART Private Functions 02359 * @{ 02360 */ 02361 02362 /** 02363 * @brief Initialize the callbacks to their default values. 02364 * @param husart USART handle. 02365 * @retval none 02366 */ 02367 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02368 void USART_InitCallbacksToDefault(USART_HandleTypeDef *husart) 02369 { 02370 /* Init the USART Callback settings */ 02371 husart->TxHalfCpltCallback = HAL_USART_TxHalfCpltCallback; /* Legacy weak TxHalfCpltCallback */ 02372 husart->TxCpltCallback = HAL_USART_TxCpltCallback; /* Legacy weak TxCpltCallback */ 02373 husart->RxHalfCpltCallback = HAL_USART_RxHalfCpltCallback; /* Legacy weak RxHalfCpltCallback */ 02374 husart->RxCpltCallback = HAL_USART_RxCpltCallback; /* Legacy weak RxCpltCallback */ 02375 husart->TxRxCpltCallback = HAL_USART_TxRxCpltCallback; /* Legacy weak TxRxCpltCallback */ 02376 husart->ErrorCallback = HAL_USART_ErrorCallback; /* Legacy weak ErrorCallback */ 02377 husart->AbortCpltCallback = HAL_USART_AbortCpltCallback; /* Legacy weak AbortCpltCallback */ 02378 #if defined(USART_CR1_FIFOEN) 02379 husart->RxFifoFullCallback = HAL_USARTEx_RxFifoFullCallback; /* Legacy weak RxFifoFullCallback */ 02380 husart->TxFifoEmptyCallback = HAL_USARTEx_TxFifoEmptyCallback; /* Legacy weak TxFifoEmptyCallback */ 02381 #endif 02382 } 02383 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02384 02385 /** 02386 * @brief End ongoing transfer on USART peripheral (following error detection or Transfer completion). 02387 * @param husart USART handle. 02388 * @retval None 02389 */ 02390 static void USART_EndTransfer(USART_HandleTypeDef *husart) 02391 { 02392 #if defined(USART_CR1_FIFOEN) 02393 /* Disable TXEIE, TCIE, RXNE, RXFT, TXFT, PE and ERR (Frame error, noise error, overrun error) interrupts */ 02394 CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE_RXFNEIE | USART_CR1_PEIE | USART_CR1_TXEIE_TXFNFIE | USART_CR1_TCIE)); 02395 CLEAR_BIT(husart->Instance->CR3, (USART_CR3_EIE | USART_CR3_RXFTIE | USART_CR3_TXFTIE)); 02396 #else 02397 /* Disable TXEIE, TCIE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts */ 02398 CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE | USART_CR1_TXEIE | USART_CR1_TCIE)); 02399 CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE); 02400 #endif 02401 02402 /* At end of process, restore husart->State to Ready */ 02403 husart->State = HAL_USART_STATE_READY; 02404 } 02405 02406 /** 02407 * @brief DMA USART transmit process complete callback. 02408 * @param hdma DMA handle. 02409 * @retval None 02410 */ 02411 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma) 02412 { 02413 USART_HandleTypeDef *husart = (USART_HandleTypeDef *)(hdma->Parent); 02414 02415 /* DMA Normal mode */ 02416 if (HAL_IS_BIT_CLR(hdma->Instance->CCR, DMA_CCR_CIRC)) 02417 { 02418 husart->TxXferCount = 0U; 02419 02420 if (husart->State == HAL_USART_STATE_BUSY_TX) 02421 { 02422 /* Disable the DMA transfer for transmit request by resetting the DMAT bit 02423 in the USART CR3 register */ 02424 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT); 02425 02426 /* Enable the USART Transmit Complete Interrupt */ 02427 __HAL_USART_ENABLE_IT(husart, USART_IT_TC); 02428 } 02429 } 02430 /* DMA Circular mode */ 02431 else 02432 { 02433 if (husart->State == HAL_USART_STATE_BUSY_TX) 02434 { 02435 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02436 /* Call registered Tx Complete Callback */ 02437 husart->TxCpltCallback(husart); 02438 #else 02439 /* Call legacy weak Tx Complete Callback */ 02440 HAL_USART_TxCpltCallback(husart); 02441 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02442 } 02443 } 02444 } 02445 02446 /** 02447 * @brief DMA USART transmit process half complete callback. 02448 * @param hdma DMA handle. 02449 * @retval None 02450 */ 02451 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma) 02452 { 02453 USART_HandleTypeDef *husart = (USART_HandleTypeDef *)(hdma->Parent); 02454 02455 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02456 /* Call registered Tx Half Complete Callback */ 02457 husart->TxHalfCpltCallback(husart); 02458 #else 02459 /* Call legacy weak Tx Half Complete Callback */ 02460 HAL_USART_TxHalfCpltCallback(husart); 02461 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02462 } 02463 02464 /** 02465 * @brief DMA USART receive process complete callback. 02466 * @param hdma DMA handle. 02467 * @retval None 02468 */ 02469 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma) 02470 { 02471 USART_HandleTypeDef *husart = (USART_HandleTypeDef *)(hdma->Parent); 02472 02473 /* DMA Normal mode */ 02474 if (HAL_IS_BIT_CLR(hdma->Instance->CCR, DMA_CCR_CIRC)) 02475 { 02476 husart->RxXferCount = 0U; 02477 02478 /* Disable PE and ERR (Frame error, noise error, overrun error) interrupts */ 02479 CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE); 02480 CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE); 02481 02482 /* Disable the DMA RX transfer for the receiver request by resetting the DMAR bit 02483 in USART CR3 register */ 02484 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAR); 02485 /* similarly, disable the DMA TX transfer that was started to provide the 02486 clock to the slave device */ 02487 CLEAR_BIT(husart->Instance->CR3, USART_CR3_DMAT); 02488 02489 if (husart->State == HAL_USART_STATE_BUSY_RX) 02490 { 02491 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02492 /* Call registered Rx Complete Callback */ 02493 husart->RxCpltCallback(husart); 02494 #else 02495 /* Call legacy weak Rx Complete Callback */ 02496 HAL_USART_RxCpltCallback(husart); 02497 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02498 } 02499 /* The USART state is HAL_USART_STATE_BUSY_TX_RX */ 02500 else 02501 { 02502 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02503 /* Call registered Tx Rx Complete Callback */ 02504 husart->TxRxCpltCallback(husart); 02505 #else 02506 /* Call legacy weak Tx Rx Complete Callback */ 02507 HAL_USART_TxRxCpltCallback(husart); 02508 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02509 } 02510 husart->State = HAL_USART_STATE_READY; 02511 } 02512 /* DMA circular mode */ 02513 else 02514 { 02515 if (husart->State == HAL_USART_STATE_BUSY_RX) 02516 { 02517 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02518 /* Call registered Rx Complete Callback */ 02519 husart->RxCpltCallback(husart); 02520 #else 02521 /* Call legacy weak Rx Complete Callback */ 02522 HAL_USART_RxCpltCallback(husart); 02523 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02524 } 02525 /* The USART state is HAL_USART_STATE_BUSY_TX_RX */ 02526 else 02527 { 02528 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02529 /* Call registered Tx Rx Complete Callback */ 02530 husart->TxRxCpltCallback(husart); 02531 #else 02532 /* Call legacy weak Tx Rx Complete Callback */ 02533 HAL_USART_TxRxCpltCallback(husart); 02534 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02535 } 02536 } 02537 } 02538 02539 /** 02540 * @brief DMA USART receive process half complete callback. 02541 * @param hdma DMA handle. 02542 * @retval None 02543 */ 02544 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma) 02545 { 02546 USART_HandleTypeDef *husart = (USART_HandleTypeDef *)(hdma->Parent); 02547 02548 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02549 /* Call registered Rx Half Complete Callback */ 02550 husart->RxHalfCpltCallback(husart); 02551 #else 02552 /* Call legacy weak Rx Half Complete Callback */ 02553 HAL_USART_RxHalfCpltCallback(husart); 02554 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02555 } 02556 02557 /** 02558 * @brief DMA USART communication error callback. 02559 * @param hdma DMA handle. 02560 * @retval None 02561 */ 02562 static void USART_DMAError(DMA_HandleTypeDef *hdma) 02563 { 02564 USART_HandleTypeDef *husart = (USART_HandleTypeDef *)(hdma->Parent); 02565 02566 husart->RxXferCount = 0U; 02567 husart->TxXferCount = 0U; 02568 USART_EndTransfer(husart); 02569 02570 husart->ErrorCode |= HAL_USART_ERROR_DMA; 02571 husart->State = HAL_USART_STATE_READY; 02572 02573 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02574 /* Call registered Error Callback */ 02575 husart->ErrorCallback(husart); 02576 #else 02577 /* Call legacy weak Error Callback */ 02578 HAL_USART_ErrorCallback(husart); 02579 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02580 } 02581 02582 /** 02583 * @brief DMA USART communication abort callback, when initiated by HAL services on Error 02584 * (To be called at end of DMA Abort procedure following error occurrence). 02585 * @param hdma DMA handle. 02586 * @retval None 02587 */ 02588 static void USART_DMAAbortOnError(DMA_HandleTypeDef *hdma) 02589 { 02590 USART_HandleTypeDef *husart = (USART_HandleTypeDef *)(hdma->Parent); 02591 husart->RxXferCount = 0U; 02592 husart->TxXferCount = 0U; 02593 02594 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02595 /* Call registered Error Callback */ 02596 husart->ErrorCallback(husart); 02597 #else 02598 /* Call legacy weak Error Callback */ 02599 HAL_USART_ErrorCallback(husart); 02600 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02601 } 02602 02603 /** 02604 * @brief DMA USART Tx communication abort callback, when initiated by user 02605 * (To be called at end of DMA Tx Abort procedure following user abort request). 02606 * @note When this callback is executed, User Abort complete call back is called only if no 02607 * Abort still ongoing for Rx DMA Handle. 02608 * @param hdma DMA handle. 02609 * @retval None 02610 */ 02611 static void USART_DMATxAbortCallback(DMA_HandleTypeDef *hdma) 02612 { 02613 USART_HandleTypeDef *husart = (USART_HandleTypeDef *)(hdma->Parent); 02614 02615 husart->hdmatx->XferAbortCallback = NULL; 02616 02617 /* Check if an Abort process is still ongoing */ 02618 if (husart->hdmarx != NULL) 02619 { 02620 if (husart->hdmarx->XferAbortCallback != NULL) 02621 { 02622 return; 02623 } 02624 } 02625 02626 /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */ 02627 husart->TxXferCount = 0U; 02628 husart->RxXferCount = 0U; 02629 02630 /* Reset errorCode */ 02631 husart->ErrorCode = HAL_USART_ERROR_NONE; 02632 02633 /* Clear the Error flags in the ICR register */ 02634 __HAL_USART_CLEAR_FLAG(husart, USART_CLEAR_OREF | USART_CLEAR_NEF | USART_CLEAR_PEF | USART_CLEAR_FEF); 02635 02636 /* Restore husart->State to Ready */ 02637 husart->State = HAL_USART_STATE_READY; 02638 02639 /* Call user Abort complete callback */ 02640 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02641 /* Call registered Abort Complete Callback */ 02642 husart->AbortCpltCallback(husart); 02643 #else 02644 /* Call legacy weak Abort Complete Callback */ 02645 HAL_USART_AbortCpltCallback(husart); 02646 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02647 02648 } 02649 02650 02651 /** 02652 * @brief DMA USART Rx communication abort callback, when initiated by user 02653 * (To be called at end of DMA Rx Abort procedure following user abort request). 02654 * @note When this callback is executed, User Abort complete call back is called only if no 02655 * Abort still ongoing for Tx DMA Handle. 02656 * @param hdma DMA handle. 02657 * @retval None 02658 */ 02659 static void USART_DMARxAbortCallback(DMA_HandleTypeDef *hdma) 02660 { 02661 USART_HandleTypeDef *husart = (USART_HandleTypeDef *)(hdma->Parent); 02662 02663 husart->hdmarx->XferAbortCallback = NULL; 02664 02665 /* Check if an Abort process is still ongoing */ 02666 if (husart->hdmatx != NULL) 02667 { 02668 if (husart->hdmatx->XferAbortCallback != NULL) 02669 { 02670 return; 02671 } 02672 } 02673 02674 /* No Abort process still ongoing : All DMA channels are aborted, call user Abort Complete callback */ 02675 husart->TxXferCount = 0U; 02676 husart->RxXferCount = 0U; 02677 02678 /* Reset errorCode */ 02679 husart->ErrorCode = HAL_USART_ERROR_NONE; 02680 02681 /* Clear the Error flags in the ICR register */ 02682 __HAL_USART_CLEAR_FLAG(husart, USART_CLEAR_OREF | USART_CLEAR_NEF | USART_CLEAR_PEF | USART_CLEAR_FEF); 02683 02684 /* Restore husart->State to Ready */ 02685 husart->State = HAL_USART_STATE_READY; 02686 02687 /* Call user Abort complete callback */ 02688 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 02689 /* Call registered Abort Complete Callback */ 02690 husart->AbortCpltCallback(husart); 02691 #else 02692 /* Call legacy weak Abort Complete Callback */ 02693 HAL_USART_AbortCpltCallback(husart); 02694 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 02695 } 02696 02697 02698 /** 02699 * @brief Handle USART Communication Timeout. 02700 * @param husart USART handle. 02701 * @param Flag Specifies the USART flag to check. 02702 * @param Status the Flag status (SET or RESET). 02703 * @param Tickstart Tick start value 02704 * @param Timeout timeout duration. 02705 * @retval HAL status 02706 */ 02707 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Tickstart, uint32_t Timeout) 02708 { 02709 /* Wait until flag is set */ 02710 while ((__HAL_USART_GET_FLAG(husart, Flag) ? SET : RESET) == Status) 02711 { 02712 /* Check for the Timeout */ 02713 if (Timeout != HAL_MAX_DELAY) 02714 { 02715 if ((Timeout == 0U) || ((HAL_GetTick() - Tickstart) > Timeout)) 02716 { 02717 husart->State = HAL_USART_STATE_READY; 02718 02719 /* Process Unlocked */ 02720 __HAL_UNLOCK(husart); 02721 02722 return HAL_TIMEOUT; 02723 } 02724 } 02725 } 02726 return HAL_OK; 02727 } 02728 02729 /** 02730 * @brief Configure the USART peripheral. 02731 * @param husart USART handle. 02732 * @retval HAL status 02733 */ 02734 static HAL_StatusTypeDef USART_SetConfig(USART_HandleTypeDef *husart) 02735 { 02736 uint32_t tmpreg = 0x0U; 02737 USART_ClockSourceTypeDef clocksource = USART_CLOCKSOURCE_UNDEFINED; 02738 HAL_StatusTypeDef ret = HAL_OK; 02739 uint16_t brrtemp = 0x0000; 02740 uint32_t usartdiv = 0x00000000; 02741 02742 /* Check the parameters */ 02743 assert_param(IS_USART_POLARITY(husart->Init.CLKPolarity)); 02744 assert_param(IS_USART_PHASE(husart->Init.CLKPhase)); 02745 assert_param(IS_USART_LASTBIT(husart->Init.CLKLastBit)); 02746 assert_param(IS_USART_BAUDRATE(husart->Init.BaudRate)); 02747 assert_param(IS_USART_WORD_LENGTH(husart->Init.WordLength)); 02748 assert_param(IS_USART_STOPBITS(husart->Init.StopBits)); 02749 assert_param(IS_USART_PARITY(husart->Init.Parity)); 02750 assert_param(IS_USART_MODE(husart->Init.Mode)); 02751 #if defined(USART_PRESC_PRESCALER) 02752 assert_param(IS_USART_PRESCALER(husart->Init.ClockPrescaler)); 02753 #endif 02754 02755 /*-------------------------- USART CR1 Configuration -----------------------*/ 02756 /* Clear M, PCE, PS, TE and RE bits and configure 02757 * the USART Word Length, Parity and Mode: 02758 * set the M bits according to husart->Init.WordLength value 02759 * set PCE and PS bits according to husart->Init.Parity value 02760 * set TE and RE bits according to husart->Init.Mode value 02761 * force OVER8 to 1 to allow to reach the maximum speed (Fclock/8) */ 02762 tmpreg = (uint32_t)husart->Init.WordLength | husart->Init.Parity | husart->Init.Mode | USART_CR1_OVER8; 02763 MODIFY_REG(husart->Instance->CR1, USART_CR1_FIELDS, tmpreg); 02764 02765 /*---------------------------- USART CR2 Configuration ---------------------*/ 02766 /* Clear and configure the USART Clock, CPOL, CPHA, LBCL STOP and SLVEN bits: 02767 * set CPOL bit according to husart->Init.CLKPolarity value 02768 * set CPHA bit according to husart->Init.CLKPhase value 02769 * set LBCL bit according to husart->Init.CLKLastBit value (used in SPI master mode only) 02770 * set STOP[13:12] bits according to husart->Init.StopBits value */ 02771 tmpreg = 0U; 02772 tmpreg = (uint32_t)(USART_CLOCK_ENABLE); 02773 tmpreg |= (uint32_t)husart->Init.CLKLastBit; 02774 tmpreg |= ((uint32_t)husart->Init.CLKPolarity | (uint32_t)husart->Init.CLKPhase); 02775 tmpreg |= (uint32_t)husart->Init.StopBits; 02776 MODIFY_REG(husart->Instance->CR2, USART_CR2_FIELDS, tmpreg); 02777 02778 #if defined(USART_PRESC_PRESCALER) 02779 /*-------------------------- USART PRESC Configuration -----------------------*/ 02780 /* Configure 02781 * - USART Clock Prescaler : set PRESCALER according to husart->Init.ClockPrescaler value */ 02782 MODIFY_REG(husart->Instance->PRESC, USART_PRESC_PRESCALER, husart->Init.ClockPrescaler); 02783 #endif 02784 02785 /*-------------------------- USART BRR Configuration -----------------------*/ 02786 /* BRR is filled-up according to OVER8 bit setting which is forced to 1 */ 02787 USART_GETCLOCKSOURCE(husart, clocksource); 02788 02789 switch (clocksource) 02790 { 02791 case USART_CLOCKSOURCE_PCLK1: 02792 #if defined(USART_PRESC_PRESCALER) 02793 usartdiv = (uint32_t)(USART_DIV_SAMPLING8(HAL_RCC_GetPCLK1Freq(), husart->Init.BaudRate, husart->Init.ClockPrescaler)); 02794 #else 02795 usartdiv = (uint32_t)(USART_DIV_SAMPLING8(HAL_RCC_GetPCLK1Freq(), husart->Init.BaudRate)); 02796 #endif 02797 break; 02798 case USART_CLOCKSOURCE_PCLK2: 02799 #if defined(USART_PRESC_PRESCALER) 02800 usartdiv = (uint32_t)(USART_DIV_SAMPLING8(HAL_RCC_GetPCLK2Freq(), husart->Init.BaudRate, husart->Init.ClockPrescaler)); 02801 #else 02802 usartdiv = (uint32_t)(USART_DIV_SAMPLING8(HAL_RCC_GetPCLK2Freq(), husart->Init.BaudRate)); 02803 #endif 02804 break; 02805 case USART_CLOCKSOURCE_HSI: 02806 #if defined(USART_PRESC_PRESCALER) 02807 usartdiv = (uint32_t)(USART_DIV_SAMPLING8(HSI_VALUE, husart->Init.BaudRate, husart->Init.ClockPrescaler)); 02808 #else 02809 usartdiv = (uint32_t)(USART_DIV_SAMPLING8(HSI_VALUE, husart->Init.BaudRate)); 02810 #endif 02811 break; 02812 case USART_CLOCKSOURCE_SYSCLK: 02813 #if defined(USART_PRESC_PRESCALER) 02814 usartdiv = (uint32_t)(USART_DIV_SAMPLING8(HAL_RCC_GetSysClockFreq(), husart->Init.BaudRate, husart->Init.ClockPrescaler)); 02815 #else 02816 usartdiv = (uint32_t)(USART_DIV_SAMPLING8(HAL_RCC_GetSysClockFreq(), husart->Init.BaudRate)); 02817 #endif 02818 break; 02819 case USART_CLOCKSOURCE_LSE: 02820 #if defined(USART_PRESC_PRESCALER) 02821 usartdiv = (uint32_t)(USART_DIV_SAMPLING8(LSE_VALUE, husart->Init.BaudRate, husart->Init.ClockPrescaler)); 02822 #else 02823 usartdiv = (uint32_t)(USART_DIV_SAMPLING8(LSE_VALUE, husart->Init.BaudRate)); 02824 #endif 02825 break; 02826 case USART_CLOCKSOURCE_UNDEFINED: 02827 default: 02828 ret = HAL_ERROR; 02829 break; 02830 } 02831 02832 /* USARTDIV must be greater than or equal to 0d16 and smaller than or equal to ffff */ 02833 if ((usartdiv >= USART_BRR_MIN) && (usartdiv <= USART_BRR_MAX)) 02834 { 02835 brrtemp = (uint16_t)(usartdiv & 0xFFF0U); 02836 brrtemp |= (uint16_t)((usartdiv & (uint16_t)0x000FU) >> 1U); 02837 husart->Instance->BRR = brrtemp; 02838 } 02839 else 02840 { 02841 ret = HAL_ERROR; 02842 } 02843 02844 #if defined(USART_CR1_FIFOEN) 02845 /* Initialize the number of data to process during RX/TX ISR execution */ 02846 husart->NbTxDataToProcess = 1U; 02847 husart->NbRxDataToProcess = 1U; 02848 #endif 02849 02850 /* Clear ISR function pointers */ 02851 husart->RxISR = NULL; 02852 husart->TxISR = NULL; 02853 02854 return ret; 02855 } 02856 02857 /** 02858 * @brief Check the USART Idle State. 02859 * @param husart USART handle. 02860 * @retval HAL status 02861 */ 02862 static HAL_StatusTypeDef USART_CheckIdleState(USART_HandleTypeDef *husart) 02863 { 02864 uint32_t tickstart = 0U; 02865 02866 /* Initialize the USART ErrorCode */ 02867 husart->ErrorCode = HAL_USART_ERROR_NONE; 02868 02869 /* Init tickstart for timeout managment*/ 02870 tickstart = HAL_GetTick(); 02871 02872 /* Check if the Transmitter is enabled */ 02873 if ((husart->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE) 02874 { 02875 /* Wait until TEACK flag is set */ 02876 if (USART_WaitOnFlagUntilTimeout(husart, USART_ISR_TEACK, RESET, tickstart, USART_TEACK_REACK_TIMEOUT) != HAL_OK) 02877 { 02878 /* Timeout occurred */ 02879 return HAL_TIMEOUT; 02880 } 02881 } 02882 /* Check if the Receiver is enabled */ 02883 if ((husart->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE) 02884 { 02885 /* Wait until REACK flag is set */ 02886 if (USART_WaitOnFlagUntilTimeout(husart, USART_ISR_REACK, RESET, tickstart, USART_TEACK_REACK_TIMEOUT) != HAL_OK) 02887 { 02888 /* Timeout occurred */ 02889 return HAL_TIMEOUT; 02890 } 02891 } 02892 02893 /* Initialize the USART state*/ 02894 husart->State = HAL_USART_STATE_READY; 02895 02896 /* Process Unlocked */ 02897 __HAL_UNLOCK(husart); 02898 02899 return HAL_OK; 02900 } 02901 02902 /** 02903 * @brief Simplex send an amount of data in non-blocking mode. 02904 * @note Function called under interruption only, once 02905 * interruptions have been enabled by HAL_USART_Transmit_IT(). 02906 * @note The USART errors are not managed to avoid the overrun error. 02907 * @note ISR function executed when FIFO mode is disabled and when the 02908 * data word length is less than 9 bits long. 02909 * @param husart USART handle. 02910 * @retval None 02911 */ 02912 static void USART_TxISR_8BIT(USART_HandleTypeDef *husart) 02913 { 02914 /* Check that a Tx process is ongoing */ 02915 if ((husart->State == HAL_USART_STATE_BUSY_TX) || 02916 (husart->State == HAL_USART_STATE_BUSY_TX_RX)) 02917 { 02918 if (husart->TxXferCount == 0U) 02919 { 02920 /* Disable the USART Transmit data register empty interrupt */ 02921 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE); 02922 02923 /* Enable the USART Transmit Complete Interrupt */ 02924 __HAL_USART_ENABLE_IT(husart, USART_IT_TC); 02925 } 02926 else 02927 { 02928 husart->Instance->TDR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0xFF); 02929 husart->TxXferCount--; 02930 } 02931 } 02932 } 02933 02934 /** 02935 * @brief Simplex send an amount of data in non-blocking mode. 02936 * @note Function called under interruption only, once 02937 * interruptions have been enabled by HAL_USART_Transmit_IT(). 02938 * @note The USART errors are not managed to avoid the overrun error. 02939 * @note ISR function executed when FIFO mode is disabled and when the 02940 * data word length is 9 bits long. 02941 * @param husart USART handle. 02942 * @retval None 02943 */ 02944 static void USART_TxISR_16BIT(USART_HandleTypeDef *husart) 02945 { 02946 uint16_t *tmp; 02947 02948 if ((husart->State == HAL_USART_STATE_BUSY_TX) || 02949 (husart->State == HAL_USART_STATE_BUSY_TX_RX)) 02950 { 02951 if (husart->TxXferCount == 0U) 02952 { 02953 /* Disable the USART Transmit data register empty interrupt */ 02954 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE); 02955 02956 /* Enable the USART Transmit Complete Interrupt */ 02957 __HAL_USART_ENABLE_IT(husart, USART_IT_TC); 02958 } 02959 else 02960 { 02961 tmp = (uint16_t *) husart->pTxBuffPtr; 02962 husart->Instance->TDR = (*tmp & (uint16_t)0x01FF); 02963 husart->pTxBuffPtr += 2U; 02964 husart->TxXferCount--; 02965 } 02966 } 02967 } 02968 02969 #if defined(USART_CR1_FIFOEN) 02970 /** 02971 * @brief Simplex send an amount of data in non-blocking mode. 02972 * @note Function called under interruption only, once 02973 * interruptions have been enabled by HAL_USART_Transmit_IT(). 02974 * @note The USART errors are not managed to avoid the overrun error. 02975 * @note ISR function executed when FIFO mode is enabled and when the 02976 * data word length is less than 9 bits long. 02977 * @param husart USART handle. 02978 * @retval None 02979 */ 02980 static void USART_TxISR_8BIT_FIFOEN(USART_HandleTypeDef *husart) 02981 { 02982 uint8_t nb_tx_data; 02983 /* Check that a Tx process is ongoing */ 02984 if ((husart->State == HAL_USART_STATE_BUSY_TX) || 02985 (husart->State == HAL_USART_STATE_BUSY_TX_RX)) 02986 { 02987 for (nb_tx_data = husart->NbTxDataToProcess ; nb_tx_data > 0U ; nb_tx_data--) 02988 { 02989 if (husart->TxXferCount == 0U) 02990 { 02991 /* Disable the TX FIFO threshold interrupt */ 02992 __HAL_USART_DISABLE_IT(husart, USART_IT_TXFT); 02993 02994 /* Enable the USART Transmit Complete Interrupt */ 02995 __HAL_USART_ENABLE_IT(husart, USART_IT_TC); 02996 02997 break; /* force exit loop */ 02998 } 02999 else if (__HAL_USART_GET_FLAG(husart, USART_FLAG_TXFNF) == SET) 03000 { 03001 husart->Instance->TDR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0xFF); 03002 husart->TxXferCount--; 03003 } 03004 } 03005 } 03006 } 03007 03008 /** 03009 * @brief Simplex send an amount of data in non-blocking mode. 03010 * @note Function called under interruption only, once 03011 * interruptions have been enabled by HAL_USART_Transmit_IT(). 03012 * @note The USART errors are not managed to avoid the overrun error. 03013 * @note ISR function executed when FIFO mode is enabled and when the 03014 * data word length is 9 bits long. 03015 * @param husart USART handle. 03016 * @retval None 03017 */ 03018 static void USART_TxISR_16BIT_FIFOEN(USART_HandleTypeDef *husart) 03019 { 03020 uint16_t *tmp; 03021 uint8_t nb_tx_data; 03022 03023 /* Check that a Tx process is ongoing */ 03024 if ((husart->State == HAL_USART_STATE_BUSY_TX) || 03025 (husart->State == HAL_USART_STATE_BUSY_TX_RX)) 03026 { 03027 for (nb_tx_data = husart->NbTxDataToProcess ; nb_tx_data > 0U ; nb_tx_data--) 03028 { 03029 if (husart->TxXferCount == 0U) 03030 { 03031 /* Disable the TX FIFO threshold interrupt */ 03032 __HAL_USART_DISABLE_IT(husart, USART_IT_TXFT); 03033 03034 /* Enable the USART Transmit Complete Interrupt */ 03035 __HAL_USART_ENABLE_IT(husart, USART_IT_TC); 03036 03037 break; /* force exit loop */ 03038 } 03039 else if (__HAL_USART_GET_FLAG(husart, USART_FLAG_TXFNF) == SET) 03040 { 03041 tmp = (uint16_t *) husart->pTxBuffPtr; 03042 husart->Instance->TDR = (*tmp & (uint16_t)0x01FF); 03043 husart->pTxBuffPtr += 2U; 03044 husart->TxXferCount--; 03045 } 03046 } 03047 } 03048 } 03049 #endif 03050 03051 /** 03052 * @brief Wraps up transmission in non-blocking mode. 03053 * @param husart Pointer to a USART_HandleTypeDef structure that contains 03054 * the configuration information for the specified USART module. 03055 * @retval None 03056 */ 03057 static void USART_EndTransmit_IT(USART_HandleTypeDef *husart) 03058 { 03059 /* Disable the USART Transmit Complete Interrupt */ 03060 __HAL_USART_DISABLE_IT(husart, USART_IT_TC); 03061 03062 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */ 03063 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR); 03064 03065 /* Clear TxISR function pointer */ 03066 husart->TxISR = NULL; 03067 03068 if (husart->State == HAL_USART_STATE_BUSY_TX) 03069 { 03070 /* Clear overrun flag and discard the received data */ 03071 __HAL_USART_CLEAR_OREFLAG(husart); 03072 __HAL_USART_SEND_REQ(husart, USART_RXDATA_FLUSH_REQUEST); 03073 03074 /* Tx process is completed, restore husart->State to Ready */ 03075 husart->State = HAL_USART_STATE_READY; 03076 03077 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 03078 /* Call registered Tx Complete Callback */ 03079 husart->TxCpltCallback(husart); 03080 #else 03081 /* Call legacy weak Tx Complete Callback */ 03082 HAL_USART_TxCpltCallback(husart); 03083 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 03084 } 03085 else if (husart->RxXferCount == 0U) 03086 { 03087 /* TxRx process is completed, restore husart->State to Ready */ 03088 husart->State = HAL_USART_STATE_READY; 03089 03090 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 03091 /* Call registered Tx Rx Complete Callback */ 03092 husart->TxRxCpltCallback(husart); 03093 #else 03094 /* Call legacy weak Tx Rx Complete Callback */ 03095 HAL_USART_TxRxCpltCallback(husart); 03096 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 03097 } 03098 } 03099 03100 03101 /** 03102 * @brief Simplex receive an amount of data in non-blocking mode. 03103 * @note Function called under interruption only, once 03104 * interruptions have been enabled by HAL_USART_Receive_IT(). 03105 * @note ISR function executed when FIFO mode is disabled and when the 03106 * data word length is less than 9 bits long. 03107 * @param husart USART handle 03108 * @retval None 03109 */ 03110 static void USART_RxISR_8BIT(USART_HandleTypeDef *husart) 03111 { 03112 uint16_t uhMask = husart->Mask; 03113 03114 if ((husart->State == HAL_USART_STATE_BUSY_RX) || 03115 (husart->State == HAL_USART_STATE_BUSY_TX_RX)) 03116 { 03117 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask); 03118 03119 if (--husart->RxXferCount == 0U) 03120 { 03121 /* Disable the USART Parity Error Interrupt and RXNE interrupt*/ 03122 #if defined(USART_CR1_FIFOEN) 03123 CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE_RXFNEIE | USART_CR1_PEIE)); 03124 #else 03125 CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE)); 03126 #endif 03127 03128 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */ 03129 CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE); 03130 03131 /* Clear RxISR function pointer */ 03132 husart->RxISR = NULL; 03133 03134 if (husart->State == HAL_USART_STATE_BUSY_RX) 03135 { 03136 #if defined(USART_CR2_SLVEN) 03137 /* Clear SPI slave underrun flag and discard transmit data */ 03138 if (husart->SlaveMode == USART_SLAVEMODE_ENABLE) 03139 { 03140 __HAL_USART_CLEAR_UDRFLAG(husart); 03141 __HAL_USART_SEND_REQ(husart, USART_TXDATA_FLUSH_REQUEST); 03142 } 03143 #endif 03144 03145 /* Rx process is completed, restore husart->State to Ready */ 03146 husart->State = HAL_USART_STATE_READY; 03147 03148 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 03149 /* Call registered Rx Complete Callback */ 03150 husart->RxCpltCallback(husart); 03151 #else 03152 /* Call legacy weak Rx Complete Callback */ 03153 HAL_USART_RxCpltCallback(husart); 03154 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 03155 } 03156 else if ((husart->TxXferCount == 0U) && 03157 (READ_BIT(husart->Instance->CR1, USART_CR1_TCIE) != USART_CR1_TCIE)) 03158 { 03159 /* TxRx process is completed, restore husart->State to Ready */ 03160 husart->State = HAL_USART_STATE_READY; 03161 03162 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 03163 /* Call registered Tx Rx Complete Callback */ 03164 husart->TxRxCpltCallback(husart); 03165 #else 03166 /* Call legacy weak Tx Rx Complete Callback */ 03167 HAL_USART_TxRxCpltCallback(husart); 03168 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 03169 } 03170 } 03171 #if defined(USART_CR2_SLVEN) 03172 else if ((husart->State == HAL_USART_STATE_BUSY_RX) && 03173 (husart->SlaveMode == USART_SLAVEMODE_DISABLE)) 03174 #else 03175 else if (husart->State == HAL_USART_STATE_BUSY_RX) 03176 #endif 03177 { 03178 /* Send dummy byte in order to generate the clock for the Slave to Send the next data */ 03179 husart->Instance->TDR = (USART_DUMMY_DATA & (uint16_t)0x00FF); 03180 } 03181 } 03182 } 03183 03184 /** 03185 * @brief Simplex receive an amount of data in non-blocking mode. 03186 * @note Function called under interruption only, once 03187 * interruptions have been enabled by HAL_USART_Receive_IT(). 03188 * @note ISR function executed when FIFO mode is disabled and when the 03189 * data word length is 9 bits long. 03190 * @param husart USART handle 03191 * @retval None 03192 */ 03193 static void USART_RxISR_16BIT(USART_HandleTypeDef *husart) 03194 { 03195 uint16_t *tmp; 03196 uint16_t uhMask = husart->Mask; 03197 03198 if ((husart->State == HAL_USART_STATE_BUSY_RX) || 03199 (husart->State == HAL_USART_STATE_BUSY_TX_RX)) 03200 { 03201 tmp = (uint16_t *) husart->pRxBuffPtr; 03202 *tmp = (uint16_t)(husart->Instance->RDR & uhMask); 03203 husart->pRxBuffPtr += 2U; 03204 03205 if (--husart->RxXferCount == 0U) 03206 { 03207 /* Disable the USART Parity Error Interrupt and RXNE interrupt*/ 03208 #if defined(USART_CR1_FIFOEN) 03209 CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE_RXFNEIE | USART_CR1_PEIE)); 03210 #else 03211 CLEAR_BIT(husart->Instance->CR1, (USART_CR1_RXNEIE | USART_CR1_PEIE)); 03212 #endif 03213 03214 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */ 03215 CLEAR_BIT(husart->Instance->CR3, USART_CR3_EIE); 03216 03217 /* Clear RxISR function pointer */ 03218 husart->RxISR = NULL; 03219 03220 if (husart->State == HAL_USART_STATE_BUSY_RX) 03221 { 03222 #if defined(USART_CR2_SLVEN) 03223 /* Clear SPI slave underrun flag and discard transmit data */ 03224 if (husart->SlaveMode == USART_SLAVEMODE_ENABLE) 03225 { 03226 __HAL_USART_CLEAR_UDRFLAG(husart); 03227 __HAL_USART_SEND_REQ(husart, USART_TXDATA_FLUSH_REQUEST); 03228 } 03229 #endif 03230 03231 /* Rx process is completed, restore husart->State to Ready */ 03232 husart->State = HAL_USART_STATE_READY; 03233 03234 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 03235 /* Call registered Rx Complete Callback */ 03236 husart->RxCpltCallback(husart); 03237 #else 03238 /* Call legacy weak Rx Complete Callback */ 03239 HAL_USART_RxCpltCallback(husart); 03240 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 03241 } 03242 else if ((husart->TxXferCount == 0U) && 03243 (READ_BIT(husart->Instance->CR1, USART_CR1_TCIE) != USART_CR1_TCIE)) 03244 { 03245 /* TxRx process is completed, restore husart->State to Ready */ 03246 husart->State = HAL_USART_STATE_READY; 03247 03248 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 03249 /* Call registered Tx Rx Complete Callback */ 03250 husart->TxRxCpltCallback(husart); 03251 #else 03252 /* Call legacy weak Tx Rx Complete Callback */ 03253 HAL_USART_TxRxCpltCallback(husart); 03254 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 03255 } 03256 } 03257 #if defined(USART_CR2_SLVEN) 03258 else if ((husart->State == HAL_USART_STATE_BUSY_RX) && 03259 (husart->SlaveMode == USART_SLAVEMODE_DISABLE)) 03260 #else 03261 else if (husart->State == HAL_USART_STATE_BUSY_RX) 03262 #endif 03263 { 03264 /* Send dummy byte in order to generate the clock for the Slave to Send the next data */ 03265 husart->Instance->TDR = (USART_DUMMY_DATA & (uint16_t)0x00FF); 03266 } 03267 } 03268 } 03269 03270 #if defined(USART_CR1_FIFOEN) 03271 /** 03272 * @brief Simplex receive an amount of data in non-blocking mode. 03273 * @note Function called under interruption only, once 03274 * interruptions have been enabled by HAL_USART_Receive_IT(). 03275 * @note ISR function executed when FIFO mode is enabled and when the 03276 * data word length is less than 9 bits long. 03277 * @param husart USART handle 03278 * @retval None 03279 */ 03280 static void USART_RxISR_8BIT_FIFOEN(USART_HandleTypeDef *husart) 03281 { 03282 uint16_t uhMask = husart->Mask; 03283 uint8_t nb_rx_data; 03284 03285 /* Check that a Rx process is ongoing */ 03286 if ((husart->State == HAL_USART_STATE_BUSY_RX) || 03287 (husart->State == HAL_USART_STATE_BUSY_TX_RX)) 03288 { 03289 for (nb_rx_data = husart->NbRxDataToProcess ; nb_rx_data > 0U ; nb_rx_data--) 03290 { 03291 if (__HAL_USART_GET_FLAG(husart, USART_FLAG_RXFNE) == SET) 03292 { 03293 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask); 03294 03295 if (--husart->RxXferCount == 0U) 03296 { 03297 /* Disable the USART Parity Error Interrupt */ 03298 CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE); 03299 03300 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) and RX FIFO Threshold interrupt */ 03301 CLEAR_BIT(husart->Instance->CR3, (USART_CR3_EIE | USART_CR3_RXFTIE)); 03302 03303 /* Clear RxISR function pointer */ 03304 husart->RxISR = NULL; 03305 03306 if (husart->State == HAL_USART_STATE_BUSY_RX) 03307 { 03308 #if defined(USART_CR2_SLVEN) 03309 /* Clear SPI slave underrun flag and discard transmit data */ 03310 if (husart->SlaveMode == USART_SLAVEMODE_ENABLE) 03311 { 03312 __HAL_USART_CLEAR_UDRFLAG(husart); 03313 __HAL_USART_SEND_REQ(husart, USART_TXDATA_FLUSH_REQUEST); 03314 } 03315 #endif 03316 03317 /* Rx process is completed, restore husart->State to Ready */ 03318 husart->State = HAL_USART_STATE_READY; 03319 03320 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 03321 /* Call registered Rx Complete Callback */ 03322 husart->RxCpltCallback(husart); 03323 #else 03324 /* Call legacy weak Rx Complete Callback */ 03325 HAL_USART_RxCpltCallback(husart); 03326 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 03327 } 03328 else if ((husart->TxXferCount == 0U) && 03329 (READ_BIT(husart->Instance->CR1, USART_CR1_TCIE) != USART_CR1_TCIE)) 03330 { 03331 /* TxRx process is completed, restore husart->State to Ready */ 03332 husart->State = HAL_USART_STATE_READY; 03333 03334 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 03335 /* Call registered Tx Rx Complete Callback */ 03336 husart->TxRxCpltCallback(husart); 03337 #else 03338 /* Call legacy weak Tx Rx Complete Callback */ 03339 HAL_USART_TxRxCpltCallback(husart); 03340 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 03341 } 03342 } 03343 #if defined(USART_CR2_SLVEN) 03344 else if ((husart->State == HAL_USART_STATE_BUSY_RX) && 03345 (husart->SlaveMode == USART_SLAVEMODE_DISABLE)) 03346 #else 03347 else if (husart->State == HAL_USART_STATE_BUSY_RX) 03348 #endif 03349 { 03350 /* Send dummy byte in order to generate the clock for the Slave to Send the next data */ 03351 husart->Instance->TDR = (USART_DUMMY_DATA & (uint16_t)0x00FF); 03352 } 03353 } 03354 } 03355 03356 /* When remaining number of bytes to receive is less than the RX FIFO 03357 threshold, next incoming frames are processed as if FIFO mode was 03358 disabled (i.e. one interrupt per received frame). 03359 */ 03360 if (((husart->RxXferCount != 0U)) && (husart->RxXferCount < husart->NbRxDataToProcess)) 03361 { 03362 /* Disable the USART RXFT interrupt*/ 03363 CLEAR_BIT(husart->Instance->CR3, USART_CR3_RXFTIE); 03364 03365 /* Update the RxISR function pointer */ 03366 husart->RxISR = USART_RxISR_8BIT; 03367 03368 /* Enable the USART Data Register Not Empty interrupt */ 03369 SET_BIT(husart->Instance->CR1, USART_CR1_RXNEIE_RXFNEIE); 03370 03371 #if defined(USART_CR2_SLVEN) 03372 if ((husart->State == HAL_USART_STATE_BUSY_TX_RX) && 03373 (husart->SlaveMode == USART_SLAVEMODE_DISABLE) && 03374 (husart->TxXferCount == 0U)) 03375 #else 03376 if ((husart->State == HAL_USART_STATE_BUSY_TX_RX) && 03377 (husart->TxXferCount == 0U)) 03378 #endif 03379 { 03380 /* Send dummy byte in order to generate the clock for the Slave to Send the next data */ 03381 husart->Instance->TDR = (USART_DUMMY_DATA & (uint16_t)0x00FF); 03382 } 03383 } 03384 } 03385 else 03386 { 03387 /* Clear RXNE interrupt flag */ 03388 __HAL_USART_SEND_REQ(husart, USART_RXDATA_FLUSH_REQUEST); 03389 } 03390 } 03391 03392 /** 03393 * @brief Simplex receive an amount of data in non-blocking mode. 03394 * @note Function called under interruption only, once 03395 * interruptions have been enabled by HAL_USART_Receive_IT(). 03396 * @note ISR function executed when FIFO mode is enabled and when the 03397 * data word length is 9 bits long. 03398 * @param husart USART handle 03399 * @retval None 03400 */ 03401 static void USART_RxISR_16BIT_FIFOEN(USART_HandleTypeDef *husart) 03402 { 03403 uint16_t *tmp; 03404 uint16_t uhMask = husart->Mask; 03405 uint8_t nb_rx_data; 03406 03407 /* Check that a Tx process is ongoing */ 03408 if ((husart->State == HAL_USART_STATE_BUSY_RX) || 03409 (husart->State == HAL_USART_STATE_BUSY_TX_RX)) 03410 { 03411 for (nb_rx_data = husart->NbRxDataToProcess ; nb_rx_data > 0U ; nb_rx_data--) 03412 { 03413 if (__HAL_USART_GET_FLAG(husart, USART_FLAG_RXFNE) == SET) 03414 { 03415 tmp = (uint16_t *) husart->pRxBuffPtr; 03416 *tmp = (uint16_t)(husart->Instance->RDR & uhMask); 03417 husart->pRxBuffPtr += 2U; 03418 03419 if (--husart->RxXferCount == 0U) 03420 { 03421 /* Disable the USART Parity Error Interrupt */ 03422 CLEAR_BIT(husart->Instance->CR1, USART_CR1_PEIE); 03423 03424 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) and RX FIFO Threshold interrupt */ 03425 CLEAR_BIT(husart->Instance->CR3, (USART_CR3_EIE | USART_CR3_RXFTIE)); 03426 03427 /* Clear RxISR function pointer */ 03428 husart->RxISR = NULL; 03429 03430 if (husart->State == HAL_USART_STATE_BUSY_RX) 03431 { 03432 #if defined(USART_CR2_SLVEN) 03433 /* Clear SPI slave underrun flag and discard transmit data */ 03434 if (husart->SlaveMode == USART_SLAVEMODE_ENABLE) 03435 { 03436 __HAL_USART_CLEAR_UDRFLAG(husart); 03437 __HAL_USART_SEND_REQ(husart, USART_TXDATA_FLUSH_REQUEST); 03438 } 03439 #endif 03440 03441 /* Rx process is completed, restore husart->State to Ready */ 03442 husart->State = HAL_USART_STATE_READY; 03443 03444 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 03445 /* Call registered Rx Complete Callback */ 03446 husart->RxCpltCallback(husart); 03447 #else 03448 /* Call legacy weak Rx Complete Callback */ 03449 HAL_USART_RxCpltCallback(husart); 03450 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 03451 } 03452 else if ((husart->TxXferCount == 0U) && 03453 (READ_BIT(husart->Instance->CR1, USART_CR1_TCIE) != USART_CR1_TCIE)) 03454 { 03455 /* TxRx process is completed, restore husart->State to Ready */ 03456 husart->State = HAL_USART_STATE_READY; 03457 03458 #if (USE_HAL_USART_REGISTER_CALLBACKS == 1) 03459 /* Call registered Tx Rx Complete Callback */ 03460 husart->TxRxCpltCallback(husart); 03461 #else 03462 /* Call legacy weak Tx Rx Complete Callback */ 03463 HAL_USART_TxRxCpltCallback(husart); 03464 #endif /* USE_HAL_USART_REGISTER_CALLBACKS */ 03465 } 03466 } 03467 #if defined(USART_CR2_SLVEN) 03468 else if ((husart->State == HAL_USART_STATE_BUSY_RX) && 03469 (husart->SlaveMode == USART_SLAVEMODE_DISABLE)) 03470 #else 03471 else if (husart->State == HAL_USART_STATE_BUSY_RX) 03472 #endif 03473 { 03474 /* Send dummy byte in order to generate the clock for the Slave to Send the next data */ 03475 husart->Instance->TDR = (USART_DUMMY_DATA & (uint16_t)0x00FF); 03476 } 03477 } 03478 } 03479 03480 /* When remaining number of bytes to receive is less than the RX FIFO 03481 threshold, next incoming frames are processed as if FIFO mode was 03482 disabled (i.e. one interrupt per received frame). 03483 */ 03484 if (((husart->RxXferCount != 0U)) && (husart->RxXferCount < husart->NbRxDataToProcess)) 03485 { 03486 /* Disable the USART RXFT interrupt*/ 03487 CLEAR_BIT(husart->Instance->CR3, USART_CR3_RXFTIE); 03488 03489 /* Update the RxISR function pointer */ 03490 husart->RxISR = USART_RxISR_16BIT; 03491 03492 /* Enable the USART Data Register Not Empty interrupt */ 03493 SET_BIT(husart->Instance->CR1, USART_CR1_RXNEIE_RXFNEIE); 03494 03495 #if defined(USART_CR2_SLVEN) 03496 if ((husart->State == HAL_USART_STATE_BUSY_TX_RX) && 03497 (husart->SlaveMode == USART_SLAVEMODE_DISABLE) && 03498 (husart->TxXferCount == 0U)) 03499 #else 03500 if ((husart->State == HAL_USART_STATE_BUSY_TX_RX) && 03501 (husart->TxXferCount == 0U)) 03502 #endif 03503 { 03504 /* Send dummy byte in order to generate the clock for the Slave to Send the next data */ 03505 husart->Instance->TDR = (USART_DUMMY_DATA & (uint16_t)0x00FF); 03506 } 03507 } 03508 } 03509 else 03510 { 03511 /* Clear RXNE interrupt flag */ 03512 __HAL_USART_SEND_REQ(husart, USART_RXDATA_FLUSH_REQUEST); 03513 } 03514 } 03515 #endif 03516 03517 /** 03518 * @} 03519 */ 03520 03521 #endif /* HAL_USART_MODULE_ENABLED */ 03522 /** 03523 * @} 03524 */ 03525 03526 /** 03527 * @} 03528 */ 03529 03530 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/