Mercurial > public > ostc4

comparison Common/Drivers/STM32F4xx_HAL_DRIVER_v120/Src/stm32f4xx_hal_usart.c @ 38:5f11787b4f42

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