2 ******************************************************************************
\r
3 * @file stm32f7xx_hal_usart.c
\r
4 * @author MCD Application Team
\r
6 * @date 06-March-2015
\r
7 * @brief USART HAL module driver.
\r
9 * This file provides firmware functions to manage the following
\r
10 * functionalities of the Universal Synchronous/Asynchronous Receiver Transmitter
\r
11 * Peripheral (USART).
\r
12 * + Initialization and de-initialization functions
\r
13 * + IO operation functions
\r
14 * + Peripheral Control functions
\r
17 ===============================================================================
\r
18 ##### How to use this driver #####
\r
19 ===============================================================================
\r
21 The USART HAL driver can be used as follows:
\r
23 (#) Declare a USART_HandleTypeDef handle structure.
\r
24 (#) Initialize the USART low level resources by implement the HAL_USART_MspInit ()API:
\r
25 (##) Enable the USARTx interface clock.
\r
26 (##) USART pins configuration:
\r
27 (+) Enable the clock for the USART GPIOs.
\r
28 (+) Configure these USART pins as alternate function pull-up.
\r
29 (##) NVIC configuration if you need to use interrupt process (HAL_USART_Transmit_IT(),
\r
30 HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):
\r
31 (+) Configure the USARTx interrupt priority.
\r
32 (+) Enable the NVIC USART IRQ handle.
\r
33 (@) The specific USART interrupts (Transmission complete interrupt,
\r
34 RXNE interrupt and Error Interrupts) will be managed using the macros
\r
35 __HAL_USART_ENABLE_IT() and __HAL_USART_DISABLE_IT() inside the transmit and receive process.
\r
36 (##) DMA Configuration if you need to use DMA process (HAL_USART_Transmit_DMA()
\r
37 HAL_USART_Receive_IT() and HAL_USART_TransmitReceive_IT() APIs):
\r
38 (+) Declare a DMA handle structure for the Tx/Rx stream.
\r
39 (+) Enable the DMAx interface clock.
\r
40 (+) Configure the declared DMA handle structure with the required Tx/Rx parameters.
\r
41 (+) Configure the DMA Tx/Rx Stream.
\r
42 (+) Associate the initialized DMA handle to the USART DMA Tx/Rx handle.
\r
43 (+) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx Stream.
\r
45 (#) Program the Baud Rate, Word Length, Stop Bit, Parity, Hardware
\r
46 flow control and Mode(Receiver/Transmitter) in the husart Init structure.
\r
48 (#) Initialize the USART registers by calling the HAL_USART_Init() API:
\r
49 (+) These API's configures also the low level Hardware GPIO, CLOCK, CORTEX...etc)
\r
50 by calling the customed HAL_USART_MspInit(&husart) API.
\r
53 ******************************************************************************
\r
56 * <h2><center>© COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
\r
58 * Redistribution and use in source and binary forms, with or without modification,
\r
59 * are permitted provided that the following conditions are met:
\r
60 * 1. Redistributions of source code must retain the above copyright notice,
\r
61 * this list of conditions and the following disclaimer.
\r
62 * 2. Redistributions in binary form must reproduce the above copyright notice,
\r
63 * this list of conditions and the following disclaimer in the documentation
\r
64 * and/or other materials provided with the distribution.
\r
65 * 3. Neither the name of STMicroelectronics nor the names of its contributors
\r
66 * may be used to endorse or promote products derived from this software
\r
67 * without specific prior written permission.
\r
69 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
\r
70 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
\r
71 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
\r
72 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
\r
73 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
\r
74 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
\r
75 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
\r
76 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
\r
77 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
\r
78 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\r
80 ******************************************************************************
\r
83 /* Includes ------------------------------------------------------------------*/
\r
84 #include "stm32f7xx_hal.h"
\r
86 /** @addtogroup STM32F7xx_HAL_Driver
\r
90 /** @defgroup USART USART
\r
91 * @brief HAL USART Synchronous module driver
\r
95 #ifdef HAL_USART_MODULE_ENABLED
\r
97 /* Private typedef -----------------------------------------------------------*/
\r
98 /* Private define ------------------------------------------------------------*/
\r
99 /** @addtogroup USART_Private_Constants
\r
102 #define DUMMY_DATA ((uint16_t) 0xFFFF)
\r
103 #define TEACK_REACK_TIMEOUT ((uint32_t) 1000)
\r
104 #define USART_TXDMA_TIMEOUTVALUE 22000
\r
105 #define USART_TIMEOUT_VALUE 22000
\r
106 #define USART_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | \
\r
107 USART_CR1_TE | USART_CR1_RE | USART_CR1_OVER8))
\r
108 #define USART_CR2_FIELDS ((uint32_t)(USART_CR2_CPHA | USART_CR2_CPOL | \
\r
109 USART_CR2_CLKEN | USART_CR2_LBCL | USART_CR2_STOP))
\r
113 /* Private macro -------------------------------------------------------------*/
\r
114 /* Private variables ---------------------------------------------------------*/
\r
115 /* Private function prototypes -----------------------------------------------*/
\r
116 /* Private functions ---------------------------------------------------------*/
\r
117 /** @addtogroup USART_Private_Functions
\r
120 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma);
\r
121 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
\r
122 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
\r
123 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
\r
124 static void USART_DMAError(DMA_HandleTypeDef *hdma);
\r
125 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
\r
126 static HAL_StatusTypeDef USART_SetConfig(USART_HandleTypeDef *husart);
\r
127 static HAL_StatusTypeDef USART_CheckIdleState(USART_HandleTypeDef *husart);
\r
128 static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart);
\r
129 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart);
\r
130 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart);
\r
135 /* Exported functions --------------------------------------------------------*/
\r
137 /** @defgroup USART_Exported_Functions USART Exported Functions
\r
141 /** @defgroup USART_Exported_Functions_Group1 USART Initialization and de-initialization functions
\r
142 * @brief Initialization and Configuration functions
\r
145 ===============================================================================
\r
146 ##### Initialization and Configuration functions #####
\r
147 ===============================================================================
\r
149 This subsection provides a set of functions allowing to initialize the USART
\r
150 in asynchronous and in synchronous modes.
\r
151 (+) For the asynchronous mode only these parameters can be configured:
\r
155 (++) Parity: If the parity is enabled, then the MSB bit of the data written
\r
156 in the data register is transmitted but is changed by the parity bit.
\r
157 Depending on the frame length defined by the M1 and M0 bits (7-bit,
\r
158 8-bit or 9-bit), the possible USART frame formats are as listed in the
\r
161 +---------------------------------------------------------------+
\r
162 | M1M0 bits | PCE bit | USART frame |
\r
163 |-----------------------|---------------------------------------|
\r
164 | 10 | 0 | | SB | 7-bit data | STB | |
\r
165 |-----------|-----------|---------------------------------------|
\r
166 | 10 | 1 | | SB | 6-bit data | PB | STB | |
\r
167 +---------------------------------------------------------------+
\r
168 (++) USART polarity
\r
171 (++) Receiver/transmitter modes
\r
174 The HAL_USART_Init() function follows the USART synchronous configuration
\r
175 procedure (details for the procedure are available in reference manual).
\r
182 * @brief Initializes the USART mode according to the specified
\r
183 * parameters in the USART_InitTypeDef and create the associated handle.
\r
184 * @param husart: USART handle
\r
185 * @retval HAL status
\r
187 HAL_StatusTypeDef HAL_USART_Init(USART_HandleTypeDef *husart)
\r
189 /* Check the USART handle allocation */
\r
195 /* Check the parameters */
\r
196 assert_param(IS_USART_INSTANCE(husart->Instance));
\r
198 if(husart->State == HAL_USART_STATE_RESET)
\r
200 /* Init the low level hardware : GPIO, CLOCK */
\r
201 HAL_USART_MspInit(husart);
\r
204 husart->State = HAL_USART_STATE_BUSY;
\r
206 /* Disable the Peripheral */
\r
207 __HAL_USART_DISABLE(husart);
\r
209 /* Set the Usart Communication parameters */
\r
210 if (USART_SetConfig(husart) == HAL_ERROR)
\r
215 /* In Synchronous mode, the following bits must be kept cleared:
\r
216 - LINEN bit in the USART_CR2 register
\r
217 - HDSEL, SCEN and IREN bits in the USART_CR3 register.*/
\r
218 husart->Instance->CR2 &= ~USART_CR2_LINEN;
\r
219 husart->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN);
\r
221 /* Enable the Peripheral */
\r
222 __HAL_USART_ENABLE(husart);
\r
224 /* TEACK and/or REACK to check before moving husart->State to Ready */
\r
225 return (USART_CheckIdleState(husart));
\r
229 * @brief DeInitializes the USART peripheral
\r
230 * @param husart: USART handle
\r
231 * @retval HAL status
\r
233 HAL_StatusTypeDef HAL_USART_DeInit(USART_HandleTypeDef *husart)
\r
235 /* Check the USART handle allocation */
\r
241 /* Check the parameters */
\r
242 assert_param(IS_USART_INSTANCE(husart->Instance));
\r
244 husart->State = HAL_USART_STATE_BUSY;
\r
246 husart->Instance->CR1 = 0x0;
\r
247 husart->Instance->CR2 = 0x0;
\r
248 husart->Instance->CR3 = 0x0;
\r
250 /* DeInit the low level hardware */
\r
251 HAL_USART_MspDeInit(husart);
\r
253 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
254 husart->State = HAL_USART_STATE_RESET;
\r
256 /* Process Unlock */
\r
257 __HAL_UNLOCK(husart);
\r
263 * @brief USART MSP Init
\r
264 * @param husart: USART handle
\r
267 __weak void HAL_USART_MspInit(USART_HandleTypeDef *husart)
\r
269 /* NOTE : This function should not be modified, when the callback is needed,
\r
270 the HAL_USART_MspInit can be implemented in the user file
\r
275 * @brief USART MSP DeInit
\r
276 * @param husart: USART handle
\r
279 __weak void HAL_USART_MspDeInit(USART_HandleTypeDef *husart)
\r
281 /* NOTE : This function should not be modified, when the callback is needed,
\r
282 the HAL_USART_MspDeInit can be implemented in the user file
\r
290 /** @defgroup USART_Exported_Functions_Group2 IO operation functions
\r
291 * @brief USART Transmit and Receive functions
\r
294 ===============================================================================
\r
295 ##### IO operation functions #####
\r
296 ===============================================================================
\r
297 This subsection provides a set of functions allowing to manage the USART synchronous
\r
300 [..] The USART supports master mode only: it cannot receive or send data related to an input
\r
301 clock (SCLK is always an output).
\r
303 (#) There are two mode of transfer:
\r
304 (+) Blocking mode: The communication is performed in polling mode.
\r
305 The HAL status of all data processing is returned by the same function
\r
306 after finishing transfer.
\r
307 (+) No-Blocking mode: The communication is performed using Interrupts
\r
308 or DMA, These API's return the HAL status.
\r
309 The end of the data processing will be indicated through the
\r
310 dedicated USART IRQ when using Interrupt mode or the DMA IRQ when
\r
312 The HAL_USART_TxCpltCallback(), HAL_USART_RxCpltCallback() and HAL_USART_TxRxCpltCallback() user callbacks
\r
313 will be executed respectively at the end of the transmit or Receive process
\r
314 The HAL_USART_ErrorCallback()user callback will be executed when a communication error is detected
\r
316 (#) Blocking mode API's are :
\r
317 (+) HAL_USART_Transmit()in simplex mode
\r
318 (+) HAL_USART_Receive() in full duplex receive only
\r
319 (+) HAL_USART_TransmitReceive() in full duplex mode
\r
321 (#) Non-Blocking mode API's with Interrupt are :
\r
322 (+) HAL_USART_Transmit_IT()in simplex mode
\r
323 (+) HAL_USART_Receive_IT() in full duplex receive only
\r
324 (+) HAL_USART_TransmitReceive_IT()in full duplex mode
\r
325 (+) HAL_USART_IRQHandler()
\r
327 (#) No-Blocking mode functions with DMA are :
\r
328 (+) HAL_USART_Transmit_DMA()in simplex mode
\r
329 (+) HAL_USART_Receive_DMA() in full duplex receive only
\r
330 (+) HAL_USART_TransmitReceive_DMA() in full duplex mode
\r
331 (+) HAL_USART_DMAPause()
\r
332 (+) HAL_USART_DMAResume()
\r
333 (+) HAL_USART_DMAStop()
\r
335 (#) A set of Transfer Complete Callbacks are provided in No_Blocking mode:
\r
336 (+) HAL_USART_TxCpltCallback()
\r
337 (+) HAL_USART_RxCpltCallback()
\r
338 (+) HAL_USART_TxHalfCpltCallback()
\r
339 (+) HAL_USART_RxHalfCpltCallback()
\r
340 (+) HAL_USART_ErrorCallback()
\r
341 (+) HAL_USART_TxRxCpltCallback()
\r
348 * @brief Simplex Send an amount of data in blocking mode
\r
349 * @param husart: USART handle
\r
350 * @param pTxData: pointer to data buffer
\r
351 * @param Size: amount of data to be sent
\r
352 * @param Timeout : Timeout duration
\r
353 * @retval HAL status
\r
355 HAL_StatusTypeDef HAL_USART_Transmit(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size, uint32_t Timeout)
\r
359 if(husart->State == HAL_USART_STATE_READY)
\r
361 if((pTxData == NULL) || (Size == 0))
\r
366 /* Process Locked */
\r
367 __HAL_LOCK(husart);
\r
369 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
370 husart->State = HAL_USART_STATE_BUSY_TX;
\r
372 husart->TxXferSize = Size;
\r
373 husart->TxXferCount = Size;
\r
375 /* Check the remaining data to be sent */
\r
376 while(husart->TxXferCount > 0)
\r
378 husart->TxXferCount--;
\r
379 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, Timeout) != HAL_OK)
\r
381 return HAL_TIMEOUT;
\r
383 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
\r
385 tmp = (uint16_t*) pTxData;
\r
386 husart->Instance->TDR = (*tmp & (uint16_t)0x01FF);
\r
391 husart->Instance->TDR = (*pTxData++ & (uint8_t)0xFF);
\r
395 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, Timeout) != HAL_OK)
\r
397 return HAL_TIMEOUT;
\r
400 husart->State = HAL_USART_STATE_READY;
\r
402 /* Process Unlocked */
\r
403 __HAL_UNLOCK(husart);
\r
414 * @brief Receive an amount of data in blocking mode
\r
415 * @note To receive synchronous data, dummy data are simultaneously transmitted
\r
416 * @param husart: USART handle
\r
417 * @param pRxData: pointer to data buffer
\r
418 * @param Size: amount of data to be received
\r
419 * @param Timeout : Timeout duration
\r
420 * @retval HAL status
\r
422 HAL_StatusTypeDef HAL_USART_Receive(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
\r
427 if(husart->State == HAL_USART_STATE_READY)
\r
429 if((pRxData == NULL) || (Size == 0))
\r
433 /* Process Locked */
\r
434 __HAL_LOCK(husart);
\r
436 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
437 husart->State = HAL_USART_STATE_BUSY_RX;
\r
439 husart->RxXferSize = Size;
\r
440 husart->RxXferCount = Size;
\r
442 /* Computation of USART mask to apply to RDR register */
\r
443 __HAL_USART_MASK_COMPUTATION(husart);
\r
444 uhMask = husart->Mask;
\r
446 /* as long as data have to be received */
\r
447 while(husart->RxXferCount > 0)
\r
449 husart->RxXferCount--;
\r
451 /* Wait until TC flag is set to send dummy byte in order to generate the
\r
452 * clock for the slave to send data.
\r
453 * Whatever the frame length (7, 8 or 9-bit long), the same dummy value
\r
454 * can be written for all the cases. */
\r
455 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, Timeout) != HAL_OK)
\r
457 return HAL_TIMEOUT;
\r
459 husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x0FF);
\r
461 /* Wait for RXNE Flag */
\r
462 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, Timeout) != HAL_OK)
\r
464 return HAL_TIMEOUT;
\r
467 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
\r
469 tmp = (uint16_t*) pRxData ;
\r
470 *tmp = (uint16_t)(husart->Instance->RDR & uhMask);
\r
475 *pRxData++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);
\r
479 husart->State = HAL_USART_STATE_READY;
\r
481 /* Process Unlocked */
\r
482 __HAL_UNLOCK(husart);
\r
493 * @brief Full-Duplex Send and Receive an amount of data in blocking mode
\r
494 * @param husart: USART handle
\r
495 * @param pTxData: pointer to TX data buffer
\r
496 * @param pRxData: pointer to RX data buffer
\r
497 * @param Size: amount of data to be sent (same amount to be received)
\r
498 * @param Timeout : Timeout duration
\r
499 * @retval HAL status
\r
501 HAL_StatusTypeDef HAL_USART_TransmitReceive(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout)
\r
506 if(husart->State == HAL_USART_STATE_READY)
\r
508 if((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
\r
512 /* Process Locked */
\r
513 __HAL_LOCK(husart);
\r
515 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
516 husart->State = HAL_USART_STATE_BUSY_RX;
\r
518 husart->RxXferSize = Size;
\r
519 husart->TxXferSize = Size;
\r
520 husart->TxXferCount = Size;
\r
521 husart->RxXferCount = Size;
\r
523 /* Computation of USART mask to apply to RDR register */
\r
524 __HAL_USART_MASK_COMPUTATION(husart);
\r
525 uhMask = husart->Mask;
\r
527 /* Check the remain data to be sent */
\r
528 while(husart->TxXferCount > 0)
\r
530 husart->TxXferCount--;
\r
531 husart->RxXferCount--;
\r
533 /* Wait until TC flag is set to send data */
\r
534 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, Timeout) != HAL_OK)
\r
536 return HAL_TIMEOUT;
\r
538 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
\r
540 tmp = (uint16_t*) pTxData;
\r
541 husart->Instance->TDR = (*tmp & uhMask);
\r
546 husart->Instance->TDR = (*pTxData++ & (uint8_t)uhMask);
\r
549 /* Wait for RXNE Flag */
\r
550 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_RXNE, RESET, Timeout) != HAL_OK)
\r
552 return HAL_TIMEOUT;
\r
555 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
\r
557 tmp = (uint16_t*) pRxData ;
\r
558 *tmp = (uint16_t)(husart->Instance->RDR & uhMask);
\r
563 *pRxData++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);
\r
567 husart->State = HAL_USART_STATE_READY;
\r
569 /* Process Unlocked */
\r
570 __HAL_UNLOCK(husart);
\r
581 * @brief Send an amount of data in interrupt mode
\r
582 * @param husart: USART handle
\r
583 * @param pTxData: pointer to data buffer
\r
584 * @param Size: amount of data to be sent
\r
585 * @retval HAL status
\r
587 HAL_StatusTypeDef HAL_USART_Transmit_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size)
\r
589 if(husart->State == HAL_USART_STATE_READY)
\r
591 if((pTxData == NULL ) || (Size == 0))
\r
596 /* Process Locked */
\r
597 __HAL_LOCK(husart);
\r
599 husart->pTxBuffPtr = pTxData;
\r
600 husart->TxXferSize = Size;
\r
601 husart->TxXferCount = Size;
\r
603 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
604 husart->State = HAL_USART_STATE_BUSY_TX;
\r
606 /* The USART Error Interrupts: (Frame error, noise error, overrun error)
\r
607 are not managed by the USART Transmit Process to avoid the overrun interrupt
\r
608 when the usart mode is configured for transmit and receive "USART_MODE_TX_RX"
\r
609 to benefit for the frame error and noise interrupts the usart mode should be
\r
610 configured only for transmit "USART_MODE_TX" */
\r
612 /* Process Unlocked */
\r
613 __HAL_UNLOCK(husart);
\r
615 /* Enable the USART Transmit Data Register Empty Interrupt */
\r
616 __HAL_USART_ENABLE_IT(husart, USART_IT_TXE);
\r
627 * @brief Receive an amount of data in blocking mode
\r
628 * To receive synchronous data, dummy data are simultaneously transmitted
\r
629 * @param husart: USART handle
\r
630 * @param pRxData: pointer to data buffer
\r
631 * @param Size: amount of data to be received
\r
632 * @retval HAL status
\r
634 HAL_StatusTypeDef HAL_USART_Receive_IT(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)
\r
636 if(husart->State == HAL_USART_STATE_READY)
\r
638 if((pRxData == NULL ) || (Size == 0))
\r
642 /* Process Locked */
\r
643 __HAL_LOCK(husart);
\r
645 husart->pRxBuffPtr = pRxData;
\r
646 husart->RxXferSize = Size;
\r
647 husart->RxXferCount = Size;
\r
649 __HAL_USART_MASK_COMPUTATION(husart);
\r
651 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
652 husart->State = HAL_USART_STATE_BUSY_RX;
\r
654 /* Enable the USART Parity Error Interrupt */
\r
655 __HAL_USART_ENABLE_IT(husart, USART_IT_PE);
\r
657 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
\r
658 __HAL_USART_ENABLE_IT(husart, USART_IT_ERR);
\r
660 /* Enable the USART Data Register not empty Interrupt */
\r
661 __HAL_USART_ENABLE_IT(husart, USART_IT_RXNE);
\r
663 /* Process Unlocked */
\r
664 __HAL_UNLOCK(husart);
\r
667 /* Send dummy byte in order to generate the clock for the Slave to send the next data */
\r
668 if(husart->Init.WordLength == USART_WORDLENGTH_9B)
\r
670 husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x01FF);
\r
674 husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x00FF);
\r
686 * @brief Full-Duplex Send and Receive an amount of data in interrupt mode
\r
687 * @param husart: USART handle
\r
688 * @param pTxData: pointer to TX data buffer
\r
689 * @param pRxData: pointer to RX data buffer
\r
690 * @param Size: amount of data to be sent (same amount to be received)
\r
691 * @retval HAL status
\r
693 HAL_StatusTypeDef HAL_USART_TransmitReceive_IT(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
\r
696 if(husart->State == HAL_USART_STATE_READY)
\r
698 if((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
\r
702 /* Process Locked */
\r
703 __HAL_LOCK(husart);
\r
705 husart->pRxBuffPtr = pRxData;
\r
706 husart->RxXferSize = Size;
\r
707 husart->RxXferCount = Size;
\r
708 husart->pTxBuffPtr = pTxData;
\r
709 husart->TxXferSize = Size;
\r
710 husart->TxXferCount = Size;
\r
712 /* Computation of USART mask to apply to RDR register */
\r
713 __HAL_USART_MASK_COMPUTATION(husart);
\r
715 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
716 husart->State = HAL_USART_STATE_BUSY_TX_RX;
\r
718 /* Enable the USART Data Register not empty Interrupt */
\r
719 __HAL_USART_ENABLE_IT(husart, USART_IT_RXNE);
\r
721 /* Enable the USART Parity Error Interrupt */
\r
722 __HAL_USART_ENABLE_IT(husart, USART_IT_PE);
\r
724 /* Enable the USART Error Interrupt: (Frame error, noise error, overrun error) */
\r
725 __HAL_USART_ENABLE_IT(husart, USART_IT_ERR);
\r
727 /* Process Unlocked */
\r
728 __HAL_UNLOCK(husart);
\r
730 /* Enable the USART Transmit Data Register Empty Interrupt */
\r
731 __HAL_USART_ENABLE_IT(husart, USART_IT_TXE);
\r
743 * @brief Send an amount of data in DMA mode
\r
744 * @param husart: USART handle
\r
745 * @param pTxData: pointer to data buffer
\r
746 * @param Size: amount of data to be sent
\r
747 * @retval HAL status
\r
749 HAL_StatusTypeDef HAL_USART_Transmit_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint16_t Size)
\r
753 if(husart->State == HAL_USART_STATE_READY)
\r
755 if((pTxData == NULL ) || (Size == 0))
\r
759 /* Process Locked */
\r
760 __HAL_LOCK(husart);
\r
762 husart->pTxBuffPtr = pTxData;
\r
763 husart->TxXferSize = Size;
\r
764 husart->TxXferCount = Size;
\r
766 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
767 husart->State = HAL_USART_STATE_BUSY_TX;
\r
769 /* Set the USART DMA transfer complete callback */
\r
770 husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;
\r
772 /* Set the USART DMA Half transfer complete callback */
\r
773 husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;
\r
775 /* Set the DMA error callback */
\r
776 husart->hdmatx->XferErrorCallback = USART_DMAError;
\r
778 /* Enable the USART transmit DMA channel */
\r
779 tmp = (uint32_t*)&pTxData;
\r
780 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->TDR, Size);
\r
783 /* Clear the TC flag in the SR register by writing 0 to it */
\r
784 __HAL_USART_CLEAR_IT(husart, USART_FLAG_TC);
\r
786 /* Enable the DMA transfer for transmit request by setting the DMAT bit
\r
787 in the USART CR3 register */
\r
788 husart->Instance->CR3 |= USART_CR3_DMAT;
\r
790 /* Process Unlocked */
\r
791 __HAL_UNLOCK(husart);
\r
802 * @brief Receive an amount of data in DMA mode
\r
803 * @param husart: USART handle
\r
804 * @param pRxData: pointer to data buffer
\r
805 * @param Size: amount of data to be received
\r
806 * @note When the USART parity is enabled (PCE = 1), the received data contain
\r
807 * the parity bit (MSB position)
\r
808 * @retval HAL status
\r
809 * @note The USART DMA transmit stream must be configured in order to generate the clock for the slave.
\r
811 HAL_StatusTypeDef HAL_USART_Receive_DMA(USART_HandleTypeDef *husart, uint8_t *pRxData, uint16_t Size)
\r
815 if(husart->State == HAL_USART_STATE_READY)
\r
817 if((pRxData == NULL ) || (Size == 0))
\r
822 /* Process Locked */
\r
823 __HAL_LOCK(husart);
\r
825 husart->pRxBuffPtr = pRxData;
\r
826 husart->RxXferSize = Size;
\r
827 husart->pTxBuffPtr = pRxData;
\r
828 husart->TxXferSize = Size;
\r
830 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
831 husart->State = HAL_USART_STATE_BUSY_RX;
\r
833 /* Set the USART DMA Rx transfer complete callback */
\r
834 husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;
\r
836 /* Set the USART DMA Half transfer complete callback */
\r
837 husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;
\r
839 /* Set the USART DMA Rx transfer error callback */
\r
840 husart->hdmarx->XferErrorCallback = USART_DMAError;
\r
842 /* Enable the USART receive DMA channel */
\r
843 tmp = (uint32_t*)&pRxData;
\r
844 HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->RDR, *(uint32_t*)tmp, Size);
\r
846 /* Enable the USART transmit DMA channel: the transmit stream is used in order
\r
847 to generate in the non-blocking mode the clock to the slave device,
\r
848 this mode isn't a simplex receive mode but a full-duplex receive mode */
\r
849 tmp = (uint32_t*)&pRxData;
\r
850 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->TDR, Size);
\r
852 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
\r
853 in the USART CR3 register */
\r
854 husart->Instance->CR3 |= USART_CR3_DMAR;
\r
856 /* Enable the DMA transfer for transmit request by setting the DMAT bit
\r
857 in the USART CR3 register */
\r
858 husart->Instance->CR3 |= USART_CR3_DMAT;
\r
860 /* Process Unlocked */
\r
861 __HAL_UNLOCK(husart);
\r
872 * @brief Full-Duplex Transmit Receive an amount of data in non blocking mode
\r
873 * @param husart: USART handle
\r
874 * @param pTxData: pointer to TX data buffer
\r
875 * @param pRxData: pointer to RX data buffer
\r
876 * @param Size: amount of data to be received/sent
\r
877 * @note When the USART parity is enabled (PCE = 1) the data received contain the parity bit.
\r
878 * @retval HAL status
\r
880 HAL_StatusTypeDef HAL_USART_TransmitReceive_DMA(USART_HandleTypeDef *husart, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size)
\r
884 if(husart->State == HAL_USART_STATE_READY)
\r
886 if((pTxData == NULL) || (pRxData == NULL) || (Size == 0))
\r
890 /* Process Locked */
\r
891 __HAL_LOCK(husart);
\r
893 husart->pRxBuffPtr = pRxData;
\r
894 husart->RxXferSize = Size;
\r
895 husart->pTxBuffPtr = pTxData;
\r
896 husart->TxXferSize = Size;
\r
898 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
899 husart->State = HAL_USART_STATE_BUSY_TX_RX;
\r
901 /* Set the USART DMA Rx transfer complete callback */
\r
902 husart->hdmarx->XferCpltCallback = USART_DMAReceiveCplt;
\r
904 /* Set the USART DMA Half transfer complete callback */
\r
905 husart->hdmarx->XferHalfCpltCallback = USART_DMARxHalfCplt;
\r
907 /* Set the USART DMA Tx transfer complete callback */
\r
908 husart->hdmatx->XferCpltCallback = USART_DMATransmitCplt;
\r
910 /* Set the USART DMA Half transfer complete callback */
\r
911 husart->hdmatx->XferHalfCpltCallback = USART_DMATxHalfCplt;
\r
913 /* Set the USART DMA Tx transfer error callback */
\r
914 husart->hdmatx->XferErrorCallback = USART_DMAError;
\r
916 /* Set the USART DMA Rx transfer error callback */
\r
917 husart->hdmarx->XferErrorCallback = USART_DMAError;
\r
919 /* Enable the USART receive DMA channel */
\r
920 tmp = (uint32_t*)&pRxData;
\r
921 HAL_DMA_Start_IT(husart->hdmarx, (uint32_t)&husart->Instance->RDR, *(uint32_t*)tmp, Size);
\r
923 /* Enable the USART transmit DMA channel */
\r
924 tmp = (uint32_t*)&pTxData;
\r
925 HAL_DMA_Start_IT(husart->hdmatx, *(uint32_t*)tmp, (uint32_t)&husart->Instance->TDR, Size);
\r
927 /* Clear the TC flag in the SR register by writing 0 to it */
\r
928 __HAL_USART_CLEAR_IT(husart, USART_FLAG_TC);
\r
930 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
\r
931 in the USART CR3 register */
\r
932 husart->Instance->CR3 |= USART_CR3_DMAR;
\r
934 /* Enable the DMA transfer for transmit request by setting the DMAT bit
\r
935 in the USART CR3 register */
\r
936 husart->Instance->CR3 |= USART_CR3_DMAT;
\r
938 /* Process Unlocked */
\r
939 __HAL_UNLOCK(husart);
\r
950 * @brief Pauses the DMA Transfer.
\r
951 * @param husart: USART handle
\r
954 HAL_StatusTypeDef HAL_USART_DMAPause(USART_HandleTypeDef *husart)
\r
956 /* Process Locked */
\r
957 __HAL_LOCK(husart);
\r
959 if(husart->State == HAL_USART_STATE_BUSY_TX)
\r
961 /* Disable the USART DMA Tx request */
\r
962 husart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
\r
964 else if(husart->State == HAL_USART_STATE_BUSY_RX)
\r
966 /* Disable the USART DMA Rx request */
\r
967 husart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
\r
969 else if(husart->State == HAL_USART_STATE_BUSY_TX_RX)
\r
971 /* Disable the USART DMA Tx request */
\r
972 husart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
\r
973 /* Disable the USART DMA Rx request */
\r
974 husart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
\r
977 /* Process Unlocked */
\r
978 __HAL_UNLOCK(husart);
\r
984 * @brief Resumes the DMA Transfer.
\r
985 * @param husart: USART handle
\r
988 HAL_StatusTypeDef HAL_USART_DMAResume(USART_HandleTypeDef *husart)
\r
990 /* Process Locked */
\r
991 __HAL_LOCK(husart);
\r
993 if(husart->State == HAL_USART_STATE_BUSY_TX)
\r
995 /* Enable the USART DMA Tx request */
\r
996 husart->Instance->CR3 |= USART_CR3_DMAT;
\r
998 else if(husart->State == HAL_USART_STATE_BUSY_RX)
\r
1000 /* Enable the USART DMA Rx request */
\r
1001 husart->Instance->CR3 |= USART_CR3_DMAR;
\r
1003 else if(husart->State == HAL_USART_STATE_BUSY_TX_RX)
\r
1005 /* Enable the USART DMA Rx request before the DMA Tx request */
\r
1006 husart->Instance->CR3 |= USART_CR3_DMAR;
\r
1007 /* Enable the USART DMA Tx request */
\r
1008 husart->Instance->CR3 |= USART_CR3_DMAT;
\r
1011 /* If the USART peripheral is still not enabled, enable it */
\r
1012 if((husart->Instance->CR1 & USART_CR1_UE) == 0)
\r
1014 /* Enable USART peripheral */
\r
1015 __HAL_USART_ENABLE(husart);
\r
1018 /* Process Unlocked */
\r
1019 __HAL_UNLOCK(husart);
\r
1025 * @brief Stops the DMA Transfer.
\r
1026 * @param husart: USART handle
\r
1029 HAL_StatusTypeDef HAL_USART_DMAStop(USART_HandleTypeDef *husart)
\r
1031 /* Process Locked */
\r
1032 __HAL_LOCK(husart);
\r
1034 /* Disable the USART Tx/Rx DMA requests */
\r
1035 husart->Instance->CR3 &= ~USART_CR3_DMAT;
\r
1036 husart->Instance->CR3 &= ~USART_CR3_DMAR;
\r
1038 /* Abort the USART DMA tx Stream */
\r
1039 if(husart->hdmatx != NULL)
\r
1041 HAL_DMA_Abort(husart->hdmatx);
\r
1043 /* Abort the USART DMA rx Stream */
\r
1044 if(husart->hdmarx != NULL)
\r
1046 HAL_DMA_Abort(husart->hdmarx);
\r
1049 /* Disable USART peripheral */
\r
1050 __HAL_USART_DISABLE(husart);
\r
1052 husart->State = HAL_USART_STATE_READY;
\r
1054 /* Process Unlocked */
\r
1055 __HAL_UNLOCK(husart);
\r
1061 * @brief This function handles USART interrupt request.
\r
1062 * @param husart: USART handle
\r
1065 void HAL_USART_IRQHandler(USART_HandleTypeDef *husart)
\r
1068 /* USART parity error interrupt occurred ------------------------------------*/
\r
1069 if((__HAL_USART_GET_IT(husart, USART_IT_PE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_PE) != RESET))
\r
1071 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_PEF);
\r
1072 husart->ErrorCode |= HAL_USART_ERROR_PE;
\r
1073 /* Set the USART state ready to be able to start again the process */
\r
1074 husart->State = HAL_USART_STATE_READY;
\r
1077 /* USART frame error interrupt occurred -------------------------------------*/
\r
1078 if((__HAL_USART_GET_IT(husart, USART_IT_FE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))
\r
1080 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_FEF);
\r
1081 husart->ErrorCode |= HAL_USART_ERROR_FE;
\r
1082 /* Set the USART state ready to be able to start again the process */
\r
1083 husart->State = HAL_USART_STATE_READY;
\r
1086 /* USART noise error interrupt occurred -------------------------------------*/
\r
1087 if((__HAL_USART_GET_IT(husart, USART_IT_NE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))
\r
1089 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_NEF);
\r
1090 husart->ErrorCode |= HAL_USART_ERROR_NE;
\r
1091 /* Set the USART state ready to be able to start again the process */
\r
1092 husart->State = HAL_USART_STATE_READY;
\r
1095 /* USART Over-Run interrupt occurred ----------------------------------------*/
\r
1096 if((__HAL_USART_GET_IT(husart, USART_IT_ORE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_ERR) != RESET))
\r
1098 __HAL_USART_CLEAR_IT(husart, USART_CLEAR_OREF);
\r
1099 husart->ErrorCode |= HAL_USART_ERROR_ORE;
\r
1100 /* Set the USART state ready to be able to start again the process */
\r
1101 husart->State = HAL_USART_STATE_READY;
\r
1104 /* Call USART Error Call back function if need be --------------------------*/
\r
1105 if(husart->ErrorCode != HAL_USART_ERROR_NONE)
\r
1107 HAL_USART_ErrorCallback(husart);
\r
1110 /* USART in mode Receiver --------------------------------------------------*/
\r
1111 if((__HAL_USART_GET_IT(husart, USART_IT_RXNE) != RESET) && (__HAL_USART_GET_IT_SOURCE(husart, USART_IT_RXNE) != RESET))
\r
1113 if(husart->State == HAL_USART_STATE_BUSY_RX)
\r
1115 USART_Receive_IT(husart);
\r
1119 USART_TransmitReceive_IT(husart);
\r
1123 /* USART in mode Transmitter -----------------------------------------------*/
\r
1124 if((__HAL_USART_GET_IT(husart, USART_IT_TXE) != RESET) &&(__HAL_USART_GET_IT_SOURCE(husart, USART_IT_TXE) != RESET))
\r
1126 if(husart->State == HAL_USART_STATE_BUSY_TX)
\r
1128 USART_Transmit_IT(husart);
\r
1132 USART_TransmitReceive_IT(husart);
\r
1139 * @brief Tx Transfer completed callbacks
\r
1140 * @param husart: USART handle
\r
1143 __weak void HAL_USART_TxCpltCallback(USART_HandleTypeDef *husart)
\r
1145 /* NOTE : This function should not be modified, when the callback is needed,
\r
1146 the HAL_USART_TxCpltCallback can be implemented in the user file
\r
1151 * @brief Tx Half Transfer completed callbacks.
\r
1152 * @param husart: USART handle
\r
1155 __weak void HAL_USART_TxHalfCpltCallback(USART_HandleTypeDef *husart)
\r
1157 /* NOTE: This function should not be modified, when the callback is needed,
\r
1158 the HAL_USART_TxHalfCpltCallback can be implemented in the user file
\r
1163 * @brief Rx Transfer completed callbacks.
\r
1164 * @param husart: USART handle
\r
1167 __weak void HAL_USART_RxCpltCallback(USART_HandleTypeDef *husart)
\r
1169 /* NOTE: This function should not be modified, when the callback is needed,
\r
1170 the HAL_USART_RxCpltCallback can be implemented in the user file
\r
1175 * @brief Rx Half Transfer completed callbacks
\r
1176 * @param husart: usart handle
\r
1179 __weak void HAL_USART_RxHalfCpltCallback(USART_HandleTypeDef *husart)
\r
1181 /* NOTE : This function should not be modified, when the callback is needed,
\r
1182 the HAL_USART_RxHalfCpltCallback can be implemented in the user file
\r
1187 * @brief Tx/Rx Transfers completed callback for the non-blocking process
\r
1188 * @param husart: USART handle
\r
1191 __weak void HAL_USART_TxRxCpltCallback(USART_HandleTypeDef *husart)
\r
1193 /* NOTE : This function should not be modified, when the callback is needed,
\r
1194 the HAL_USART_TxRxCpltCallback can be implemented in the user file
\r
1199 * @brief USART error callbacks
\r
1200 * @param husart: USART handle
\r
1203 __weak void HAL_USART_ErrorCallback(USART_HandleTypeDef *husart)
\r
1205 /* NOTE : This function should not be modified, when the callback is needed,
\r
1206 the HAL_USART_ErrorCallback can be implemented in the user file
\r
1214 /** @defgroup USART_Exported_Functions_Group3 Peripheral State and Errors functions
\r
1215 * @brief USART State and Errors functions
\r
1218 ==============================================================================
\r
1219 ##### Peripheral State and Errors functions #####
\r
1220 ==============================================================================
\r
1222 This subsection provides a set of functions allowing to return the State of
\r
1223 USART communication
\r
1224 process, return Peripheral Errors occurred during communication process
\r
1225 (+) HAL_USART_GetState() API can be helpful to check in run-time the state
\r
1226 of the USART peripheral.
\r
1227 (+) HAL_USART_GetError() check in run-time errors that could be occurred during
\r
1234 * @brief return the USART state
\r
1235 * @param husart: USART handle
\r
1236 * @retval HAL state
\r
1238 HAL_USART_StateTypeDef HAL_USART_GetState(USART_HandleTypeDef *husart)
\r
1240 return husart->State;
\r
1244 * @brief Return the USART error code
\r
1245 * @param husart : pointer to a USART_HandleTypeDef structure that contains
\r
1246 * the configuration information for the specified USART.
\r
1247 * @retval USART Error Code
\r
1249 uint32_t HAL_USART_GetError(USART_HandleTypeDef *husart)
\r
1251 return husart->ErrorCode;
\r
1260 * @brief Simplex Send an amount of data in non-blocking mode.
\r
1261 * @note Function called under interruption only, once
\r
1262 * interruptions have been enabled by HAL_USART_Transmit_IT().
\r
1263 * @param husart: USART handle
\r
1264 * @retval HAL status
\r
1265 * @note The USART errors are not managed to avoid the overrun error.
\r
1267 static HAL_StatusTypeDef USART_Transmit_IT(USART_HandleTypeDef *husart)
\r
1271 if(husart->State == HAL_USART_STATE_BUSY_TX)
\r
1274 if(husart->TxXferCount == 0)
\r
1276 /* Disable the USART Transmit Complete Interrupt */
\r
1277 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
\r
1279 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
\r
1280 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
\r
1282 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, USART_TIMEOUT_VALUE) != HAL_OK)
\r
1284 return HAL_TIMEOUT;
\r
1286 husart->State = HAL_USART_STATE_READY;
\r
1288 HAL_USART_TxCpltCallback(husart);
\r
1294 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
\r
1296 tmp = (uint16_t*) husart->pTxBuffPtr;
\r
1297 husart->Instance->TDR = (*tmp & (uint16_t)0x01FF);
\r
1298 husart->pTxBuffPtr += 2;
\r
1302 husart->Instance->TDR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)0xFF);
\r
1305 husart->TxXferCount--;
\r
1317 * @brief Simplex Receive an amount of data in non-blocking mode.
\r
1318 * Function called under interruption only, once
\r
1319 * interruptions have been enabled by HAL_USART_Receive_IT()
\r
1320 * @param husart: USART handle
\r
1321 * @retval HAL status
\r
1323 static HAL_StatusTypeDef USART_Receive_IT(USART_HandleTypeDef *husart)
\r
1326 uint16_t uhMask = husart->Mask;
\r
1328 if(husart->State == HAL_USART_STATE_BUSY_RX)
\r
1331 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
\r
1333 tmp = (uint16_t*) husart->pRxBuffPtr;
\r
1334 *tmp = (uint16_t)(husart->Instance->RDR & uhMask);
\r
1335 husart->pRxBuffPtr += 2;
\r
1339 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);
\r
1341 /* Send dummy byte in order to generate the clock for the Slave to Send the next data */
\r
1342 husart->Instance->TDR = (DUMMY_DATA & (uint16_t)0x00FF);
\r
1344 if(--husart->RxXferCount == 0)
\r
1346 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
\r
1348 /* Disable the USART Parity Error Interrupt */
\r
1349 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
\r
1351 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
\r
1352 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
\r
1354 husart->State = HAL_USART_STATE_READY;
\r
1356 HAL_USART_RxCpltCallback(husart);
\r
1370 * @brief Full-Duplex Send receive an amount of data in full-duplex mode (non-blocking).
\r
1371 * Function called under interruption only, once
\r
1372 * interruptions have been enabled by HAL_USART_TransmitReceive_IT()
\r
1373 * @param husart: USART handle
\r
1374 * @retval HAL status
\r
1376 static HAL_StatusTypeDef USART_TransmitReceive_IT(USART_HandleTypeDef *husart)
\r
1379 uint16_t uhMask = husart->Mask;
\r
1381 if(husart->State == HAL_USART_STATE_BUSY_TX_RX)
\r
1383 if(husart->TxXferCount != 0x00)
\r
1385 if(__HAL_USART_GET_FLAG(husart, USART_FLAG_TXE) != RESET)
\r
1387 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
\r
1389 tmp = (uint16_t*) husart->pTxBuffPtr;
\r
1390 husart->Instance->TDR = (uint16_t)(*tmp & uhMask);
\r
1391 husart->pTxBuffPtr += 2;
\r
1395 husart->Instance->TDR = (uint8_t)(*husart->pTxBuffPtr++ & (uint8_t)uhMask);
\r
1397 husart->TxXferCount--;
\r
1399 /* Check the latest data transmitted */
\r
1400 if(husart->TxXferCount == 0)
\r
1402 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
\r
1407 if(husart->RxXferCount != 0x00)
\r
1409 if(__HAL_USART_GET_FLAG(husart, USART_FLAG_RXNE) != RESET)
\r
1411 if((husart->Init.WordLength == USART_WORDLENGTH_9B) && (husart->Init.Parity == USART_PARITY_NONE))
\r
1413 tmp = (uint16_t*) husart->pRxBuffPtr;
\r
1414 *tmp = (uint16_t)(husart->Instance->RDR & uhMask);
\r
1415 husart->pRxBuffPtr += 2;
\r
1419 *husart->pRxBuffPtr++ = (uint8_t)(husart->Instance->RDR & (uint8_t)uhMask);
\r
1421 husart->RxXferCount--;
\r
1425 /* Check the latest data received */
\r
1426 if(husart->RxXferCount == 0)
\r
1428 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
\r
1430 /* Disable the USART Parity Error Interrupt */
\r
1431 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
\r
1433 /* Disable the USART Error Interrupt: (Frame error, noise error, overrun error) */
\r
1434 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
\r
1436 husart->State = HAL_USART_STATE_READY;
\r
1438 HAL_USART_TxRxCpltCallback(husart);
\r
1452 * @brief This function handles USART Communication Timeout.
\r
1453 * @param husart: USART handle
\r
1454 * @param Flag: specifies the USART flag to check.
\r
1455 * @param Status: The new Flag status (SET or RESET).
\r
1456 * @param Timeout: Timeout duration
\r
1457 * @retval HAL status
\r
1459 static HAL_StatusTypeDef USART_WaitOnFlagUntilTimeout(USART_HandleTypeDef *husart, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
\r
1461 uint32_t tickstart = HAL_GetTick();
\r
1463 /* Wait until flag is set */
\r
1464 if(Status == RESET)
\r
1466 while(__HAL_USART_GET_FLAG(husart, Flag) == RESET)
\r
1468 /* Check for the Timeout */
\r
1469 if(Timeout != HAL_MAX_DELAY)
\r
1471 if((Timeout == 0)||((HAL_GetTick()-tickstart) >= Timeout))
\r
1473 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
\r
1474 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
\r
1475 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
\r
1476 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
\r
1477 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
\r
1479 husart->State= HAL_USART_STATE_TIMEOUT;
\r
1481 /* Process Unlocked */
\r
1482 __HAL_UNLOCK(husart);
\r
1484 return HAL_TIMEOUT;
\r
1491 while(__HAL_USART_GET_FLAG(husart, Flag) != RESET)
\r
1493 /* Check for the Timeout */
\r
1494 if(Timeout != HAL_MAX_DELAY)
\r
1496 if((Timeout == 0)||((HAL_GetTick()-tickstart) >= Timeout))
\r
1498 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
\r
1499 __HAL_USART_DISABLE_IT(husart, USART_IT_TXE);
\r
1500 __HAL_USART_DISABLE_IT(husart, USART_IT_RXNE);
\r
1501 __HAL_USART_DISABLE_IT(husart, USART_IT_PE);
\r
1502 __HAL_USART_DISABLE_IT(husart, USART_IT_ERR);
\r
1504 husart->State= HAL_USART_STATE_TIMEOUT;
\r
1506 /* Process Unlocked */
\r
1507 __HAL_UNLOCK(husart);
\r
1509 return HAL_TIMEOUT;
\r
1519 * @brief DMA USART transmit process complete callback
\r
1520 * @param hdma: DMA handle
\r
1523 static void USART_DMATransmitCplt(DMA_HandleTypeDef *hdma)
\r
1525 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
\r
1527 husart->TxXferCount = 0;
\r
1529 if(husart->State == HAL_USART_STATE_BUSY_TX)
\r
1531 /* Wait for USART TC Flag */
\r
1532 if(USART_WaitOnFlagUntilTimeout(husart, USART_FLAG_TC, RESET, USART_TXDMA_TIMEOUTVALUE) != HAL_OK)
\r
1534 /* Timeout occurred */
\r
1535 husart->State = HAL_USART_STATE_TIMEOUT;
\r
1536 HAL_USART_ErrorCallback(husart);
\r
1541 /* Disable the DMA transfer for transmit request by setting the DMAT bit
\r
1542 in the USART CR3 register */
\r
1543 husart->Instance->CR3 &= ~(USART_CR3_DMAT);
\r
1544 husart->State= HAL_USART_STATE_READY;
\r
1547 /* the usart state is HAL_USART_STATE_BUSY_TX_RX*/
\r
1550 husart->State= HAL_USART_STATE_BUSY_RX;
\r
1551 HAL_USART_TxCpltCallback(husart);
\r
1557 * @brief DMA USART transmit process half complete callback
\r
1558 * @param hdma : DMA handle
\r
1561 static void USART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
\r
1563 USART_HandleTypeDef* husart = (USART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
1565 HAL_USART_TxHalfCpltCallback(husart);
\r
1569 * @brief DMA USART receive process complete callback
\r
1570 * @param hdma: DMA handle
\r
1573 static void USART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
\r
1575 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
\r
1577 husart->RxXferCount = 0;
\r
1579 /* Disable the DMA RX transfer for the receiver request by resetting the DMAR bit
\r
1580 in USART CR3 register */
\r
1581 husart->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DMAR);
\r
1582 /* similarly, disable the DMA TX transfer that was started to provide the
\r
1583 clock to the slave device */
\r
1584 husart->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DMAT);
\r
1586 husart->State= HAL_USART_STATE_READY;
\r
1588 HAL_USART_RxCpltCallback(husart);
\r
1592 * @brief DMA USART receive process half complete callback
\r
1593 * @param hdma : DMA handle
\r
1596 static void USART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
\r
1598 USART_HandleTypeDef* husart = (USART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
\r
1600 HAL_USART_RxHalfCpltCallback(husart);
\r
1604 * @brief DMA USART communication error callback
\r
1605 * @param hdma: DMA handle
\r
1608 static void USART_DMAError(DMA_HandleTypeDef *hdma)
\r
1610 USART_HandleTypeDef* husart = ( USART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
\r
1612 husart->RxXferCount = 0;
\r
1613 husart->TxXferCount = 0;
\r
1614 husart->ErrorCode |= HAL_USART_ERROR_DMA;
\r
1615 husart->State= HAL_USART_STATE_READY;
\r
1617 HAL_USART_ErrorCallback(husart);
\r
1621 * @brief Configure the USART peripheral
\r
1622 * @param husart: USART handle
\r
1625 static HAL_StatusTypeDef USART_SetConfig(USART_HandleTypeDef *husart)
\r
1627 uint32_t tmpreg = 0x0;
\r
1628 USART_ClockSourceTypeDef clocksource = USART_CLOCKSOURCE_UNDEFINED;
\r
1629 HAL_StatusTypeDef ret = HAL_OK;
\r
1631 /* Check the parameters */
\r
1632 assert_param(IS_USART_POLARITY(husart->Init.CLKPolarity));
\r
1633 assert_param(IS_USART_PHASE(husart->Init.CLKPhase));
\r
1634 assert_param(IS_USART_LASTBIT(husart->Init.CLKLastBit));
\r
1635 assert_param(IS_USART_BAUDRATE(husart->Init.BaudRate));
\r
1636 assert_param(IS_USART_WORD_LENGTH(husart->Init.WordLength));
\r
1637 assert_param(IS_USART_STOPBITS(husart->Init.StopBits));
\r
1638 assert_param(IS_USART_PARITY(husart->Init.Parity));
\r
1639 assert_param(IS_USART_MODE(husart->Init.Mode));
\r
1640 assert_param(IS_USART_OVERSAMPLING(husart->Init.OverSampling));
\r
1643 /*-------------------------- USART CR1 Configuration -----------------------*/
\r
1644 /* Clear M, PCE, PS, TE and RE bits and configure
\r
1645 * the USART Word Length, Parity, Mode and OverSampling:
\r
1646 * set the M bits according to husart->Init.WordLength value
\r
1647 * set PCE and PS bits according to husart->Init.Parity value
\r
1648 * set TE and RE bits according to husart->Init.Mode value
\r
1649 * force OVER8 to 1 to allow to reach the maximum speed (Fclock/8) */
\r
1650 tmpreg = (uint32_t)husart->Init.WordLength | husart->Init.Parity | husart->Init.Mode | USART_CR1_OVER8;
\r
1651 MODIFY_REG(husart->Instance->CR1, USART_CR1_FIELDS, tmpreg);
\r
1653 /*---------------------------- USART CR2 Configuration ---------------------*/
\r
1654 /* Clear and configure the USART Clock, CPOL, CPHA, LBCL and STOP bits:
\r
1655 * set CPOL bit according to husart->Init.CLKPolarity value
\r
1656 * set CPHA bit according to husart->Init.CLKPhase value
\r
1657 * set LBCL bit according to husart->Init.CLKLastBit value
\r
1658 * set STOP[13:12] bits according to husart->Init.StopBits value */
\r
1659 tmpreg = (uint32_t)(USART_CLOCK_ENABLE);
\r
1660 tmpreg |= ((uint32_t)husart->Init.CLKPolarity | (uint32_t)husart->Init.CLKPhase);
\r
1661 tmpreg |= ((uint32_t)husart->Init.CLKLastBit | (uint32_t)husart->Init.StopBits);
\r
1662 MODIFY_REG(husart->Instance->CR2, USART_CR2_FIELDS, tmpreg);
\r
1664 /*-------------------------- USART CR3 Configuration -----------------------*/
\r
1665 /* no CR3 register configuration */
\r
1667 /*-------------------------- USART BRR Configuration -----------------------*/
\r
1668 /* BRR is filled-up according to OVER8 bit setting which is forced to 1 */
\r
1669 USART_GETCLOCKSOURCE(husart, clocksource);
\r
1670 switch (clocksource)
\r
1672 case USART_CLOCKSOURCE_PCLK1:
\r
1673 husart->Instance->BRR = (uint16_t)(2*HAL_RCC_GetPCLK1Freq() / husart->Init.BaudRate);
\r
1675 case USART_CLOCKSOURCE_PCLK2:
\r
1676 husart->Instance->BRR = (uint16_t)(2*HAL_RCC_GetPCLK2Freq() / husart->Init.BaudRate);
\r
1678 case USART_CLOCKSOURCE_HSI:
\r
1679 husart->Instance->BRR = (uint16_t)(2*HSI_VALUE / husart->Init.BaudRate);
\r
1681 case USART_CLOCKSOURCE_SYSCLK:
\r
1682 husart->Instance->BRR = (uint16_t)(2*HAL_RCC_GetSysClockFreq() / husart->Init.BaudRate);
\r
1684 case USART_CLOCKSOURCE_LSE:
\r
1685 husart->Instance->BRR = (uint16_t)(2*LSE_VALUE / husart->Init.BaudRate);
\r
1687 case USART_CLOCKSOURCE_UNDEFINED:
\r
1697 * @brief Check the USART Idle State
\r
1698 * @param husart: USART handle
\r
1699 * @retval HAL status
\r
1701 static HAL_StatusTypeDef USART_CheckIdleState(USART_HandleTypeDef *husart)
\r
1703 /* Initialize the USART ErrorCode */
\r
1704 husart->ErrorCode = HAL_USART_ERROR_NONE;
\r
1706 /* Check if the Transmitter is enabled */
\r
1707 if((husart->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
\r
1709 /* Wait until TEACK flag is set */
\r
1710 if(USART_WaitOnFlagUntilTimeout(husart, USART_ISR_TEACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
\r
1712 husart->State= HAL_USART_STATE_TIMEOUT;
\r
1713 return HAL_TIMEOUT;
\r
1716 /* Check if the Receiver is enabled */
\r
1717 if((husart->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
\r
1719 /* Wait until REACK flag is set */
\r
1720 if(USART_WaitOnFlagUntilTimeout(husart, USART_ISR_REACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
\r
1722 husart->State= HAL_USART_STATE_TIMEOUT;
\r
1723 return HAL_TIMEOUT;
\r
1727 /* Initialize the USART state*/
\r
1728 husart->State= HAL_USART_STATE_READY;
\r
1730 /* Process Unlocked */
\r
1731 __HAL_UNLOCK(husart);
\r
1740 #endif /* HAL_USART_MODULE_ENABLED */
\r
1749 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
\r