]> git.gir.st - tmk_keyboard.git/blob - tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_STM/TARGET_STM32F0/stm32f0xx_hal_uart.c
git://git.gir.st / tmk_keyboard.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Squashed 'tmk_core/' changes from 7967731..b9e0ea0
[tmk_keyboard.git] / tool / mbed / mbed-sdk / libraries / mbed / targets / cmsis / TARGET_STM / TARGET_STM32F0 / stm32f0xx_hal_uart.c
1 /**
2 ******************************************************************************
3 * @file stm32f0xx_hal_uart.c
4 * @author MCD Application Team
5 * @version V1.2.0
6 * @date 11-December-2014
7 * @brief UART HAL module driver.
8 * This file provides firmware functions to manage the following
9 * functionalities of the Universal Asynchronous Receiver Transmitter (UART) peripheral:
10 * + Initialization and de-initialization functions
11 * + IO operation functions
12 * + Peripheral Control functions
13 * + Peripheral State and Errors functions
14 @verbatim
15 ===============================================================================
16 ##### How to use this driver #####
17 ================================================================================
18 [..]
19 The UART HAL driver can be used as follows:
20
21 (#) Declare a UART_HandleTypeDef handle structure.
22
23 (#) Initialize the UART low level resources by implementing the HAL_UART_MspInit ()API:
24 (##) Enable the USARTx interface clock.
25 (##) UART pins configuration:
26 (+++) Enable the clock for the UART GPIOs.
27 (+++) Configure these UART pins as alternate function pull-up.
28 (##) NVIC configuration if you need to use interrupt process (HAL_UART_Transmit_IT()
29 and HAL_UART_Receive_IT() APIs):
30 (+++) Configure the USARTx interrupt priority.
31 (+++) Enable the NVIC USART IRQ handle.
32 (##) DMA Configuration if you need to use DMA process (HAL_UART_Transmit_DMA()
33 and HAL_UART_Receive_DMA() APIs):
34 (+++) Declare a DMA handle structure for the Tx/Rx channel.
35 (+++) Enable the DMAx interface clock.
36 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
37 (+++) Configure the DMA Tx/Rx channel.
38 (+++) Associate the initilalized DMA handle to the UART DMA Tx/Rx handle.
39 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
40
41 (#) Program the Baud Rate, Word Length , Stop Bit, Parity, Hardware
42 flow control and Mode(Receiver/Transmitter) in the huart Init structure.
43
44 (#) If required, program UART advanced features (TX/RX pins swap, auto Baud rate detection,...)
45 in the huart AdvancedInit structure.
46
47 (#) For the UART asynchronous mode, initialize the UART registers by calling
48 the HAL_UART_Init() API.
49
50 (#) For the UART Half duplex mode, initialize the UART registers by calling
51 the HAL_HalfDuplex_Init() API.
52
53 (#) For the UART Multiprocessor mode, initialize the UART registers
54 by calling the HAL_MultiProcessor_Init() API.
55
56 (#) For the UART RS485 Driver Enabled mode, initialize the UART registers
57 by calling the HAL_RS485Ex_Init() API.
58
59 [..]
60 (@) The specific UART interrupts (Transmission complete interrupt,
61 RXNE interrupt and Error Interrupts) will be managed using the macros
62 __HAL_UART_ENABLE_IT() and __HAL_UART_DISABLE_IT() inside the transmit and receive process.
63
64 [..]
65 (@) These APIs(HAL_UART_Init(), HAL_HalfDuplex_Init(), HAL_MultiProcessor_Init(),
66 also configure also the low level Hardware GPIO, CLOCK, CORTEX...etc) by
67 calling the customed HAL_UART_MspInit() API.
68
69 Three operation modes are available within this driver :
70
71 *** Polling mode IO operation ***
72 =================================
73 [..]
74 (+) Send an amount of data in blocking mode using HAL_UART_Transmit()
75 (+) Receive an amount of data in blocking mode using HAL_UART_Receive()
76
77 *** Interrupt mode IO operation ***
78 ===================================
79 [..]
80 (+) Send an amount of data in non blocking mode using HAL_UART_Transmit_IT()
81 (+) At transmission end of half transfer HAL_UART_TxHalfCpltCallback is executed and user can
82 add his own code by customization of function pointer HAL_UART_TxHalfCpltCallback
83 (+) At transmission end of transfer HAL_UART_TxCpltCallback is executed and user can
84 add his own code by customization of function pointer HAL_UART_TxCpltCallback
85 (+) Receive an amount of data in non blocking mode using HAL_UART_Receive_IT()
86 (+) At reception end of half transfer HAL_UART_RxHalfCpltCallback is executed and user can
87 add his own code by customization of function pointer HAL_UART_RxHalfCpltCallback
88 (+) At reception end of transfer HAL_UART_RxCpltCallback is executed and user can
89 add his own code by customization of function pointer HAL_UART_RxCpltCallback
90 (+) In case of transfer Error, HAL_UART_ErrorCallback() function is executed and user can
91 add his own code by customization of function pointer HAL_UART_ErrorCallback
92
93 *** DMA mode IO operation ***
94 ==============================
95 [..]
96 (+) Send an amount of data in non blocking mode (DMA) using HAL_UART_Transmit_DMA()
97 (+) At transmission end of half transfer HAL_UART_TxHalfCpltCallback is executed and user can
98 add his own code by customization of function pointer HAL_UART_TxHalfCpltCallback
99 (+) At transmission end of transfer HAL_UART_TxCpltCallback is executed and user can
100 add his own code by customization of function pointer HAL_UART_TxCpltCallback
101 (+) Receive an amount of data in non blocking mode (DMA) using HAL_UART_Receive_DMA()
102 (+) At reception end of half transfer HAL_UART_RxHalfCpltCallback is executed and user can
103 add his own code by customization of function pointer HAL_UART_RxHalfCpltCallback
104 (+) At reception end of transfer HAL_UART_RxCpltCallback is executed and user can
105 add his own code by customization of function pointer HAL_UART_RxCpltCallback
106 (+) In case of transfer Error, HAL_UART_ErrorCallback() function is executed and user can
107 add his own code by customization of function pointer HAL_UART_ErrorCallback
108 (+) Pause the DMA Transfer using HAL_UART_DMAPause()
109 (+) Resume the DMA Transfer using HAL_UART_DMAResume()
110 (+) Stop the DMA Transfer using HAL_UART_DMAStop()
111
112 *** UART HAL driver macros list ***
113 =============================================
114 [..]
115 Below the list of most used macros in UART HAL driver.
116
117 (+) __HAL_UART_ENABLE: Enable the UART peripheral
118 (+) __HAL_UART_DISABLE: Disable the UART peripheral
119 (+) __HAL_UART_GET_FLAG : Check whether the specified UART flag is set or not
120 (+) __HAL_UART_CLEAR_FLAG : Clear the specified UART pending flag
121 (+) __HAL_UART_ENABLE_IT: Enable the specified UART interrupt
122 (+) __HAL_UART_DISABLE_IT: Disable the specified UART interrupt
123
124 [..]
125 (@) You can refer to the UART HAL driver header file for more useful macros
126
127 @endverbatim
128 ******************************************************************************
129 * @attention
130 *
131 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
132 *
133 * Redistribution and use in source and binary forms, with or without modification,
134 * are permitted provided that the following conditions are met:
135 * 1. Redistributions of source code must retain the above copyright notice,
136 * this list of conditions and the following disclaimer.
137 * 2. Redistributions in binary form must reproduce the above copyright notice,
138 * this list of conditions and the following disclaimer in the documentation
139 * and/or other materials provided with the distribution.
140 * 3. Neither the name of STMicroelectronics nor the names of its contributors
141 * may be used to endorse or promote products derived from this software
142 * without specific prior written permission.
143 *
144 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
145 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
146 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
147 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
148 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
149 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
150 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
151 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
152 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
153 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
154 *
155 ******************************************************************************
156 */
157
158 /* Includes ------------------------------------------------------------------*/
159 #include "stm32f0xx_hal.h"
160
161 /** @addtogroup STM32F0xx_HAL_Driver
162 * @{
163 */
164
165 /** @defgroup UART UART HAL module driver
166 * @brief HAL UART module driver
167 * @{
168 */
169 #ifdef HAL_UART_MODULE_ENABLED
170
171 /* Private typedef -----------------------------------------------------------*/
172 /* Private define ------------------------------------------------------------*/
173 /** @defgroup UART_Private_Constants UART Private Constants
174 * @{
175 */
176 #define HAL_UART_TXDMA_TIMEOUTVALUE 22000
177 #define UART_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE | USART_CR1_PS | \
178 USART_CR1_TE | USART_CR1_RE | USART_CR1_OVER8))
179 /**
180 * @}
181 */
182
183 /* Private macro -------------------------------------------------------------*/
184 /* Private variables ---------------------------------------------------------*/
185 /* Private function prototypes -----------------------------------------------*/
186 /** @addtogroup UART_Private_Functions UART Private Functions
187 * @{
188 */
189 static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma);
190 static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma);
191 static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
192 static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma);
193 static void UART_DMAError(DMA_HandleTypeDef *hdma);
194 /**
195 * @}
196 */
197
198 /* Exported functions ---------------------------------------------------------*/
199
200 /** @defgroup UART_Exported_Functions UART Exported Functions
201 * @{
202 */
203
204 /** @defgroup UART_Exported_Functions_Group1 Initialization and de-initialization functions
205 * @brief Initialization and Configuration functions
206 *
207 @verbatim
208 ===============================================================================
209 ##### Initialization and Configuration functions #####
210 ===============================================================================
211 [..]
212 This subsection provides a set of functions allowing to initialize the USARTx or the UARTy
213 in asynchronous mode.
214 (+) For the asynchronous mode only these parameters can be configured:
215 (++) Baud Rate
216 (++) Word Length
217 (++) Stop Bit
218 (++) Parity: If the parity is enabled, then the MSB bit of the data written
219 in the data register is transmitted but is changed by the parity bit.
220 Depending on the frame length defined by the M bit (8-bits or 9-bits),
221 the possible UART frame formats are as listed in the following table:
222 |-----------|-----------|---------------------------------------|
223 | M1M0 bits | PCE bit | UART frame |
224 |-----------------------|---------------------------------------|
225 | 00 | 0 | | SB | 8-bit data | STB | |
226 |-----------|-----------|---------------------------------------|
227 | 00 | 1 | | SB | 7-bit data | PB | STB | |
228 |-----------|-----------|---------------------------------------|
229 | 01 | 0 | | SB | 9-bit data | STB | |
230 |-----------|-----------|---------------------------------------|
231 | 01 | 1 | | SB | 8-bit data | PB | STB | |
232 +---------------------------------------------------------------+
233 | 10 | 0 | | SB | 7-bit data | STB | |
234 |-----------|-----------|---------------------------------------|
235 | 10 | 1 | | SB | 6-bit data | PB | STB | |
236 +---------------------------------------------------------------+
237 (++) Hardware flow control
238 (++) Receiver/transmitter modes
239 (++) Over Sampling Method
240 (++) One-Bit Sampling Method
241 (+) For the asynchronous mode, the following advanced features can be configured as well:
242 (++) TX and/or RX pin level inversion
243 (++) data logical level inversion
244 (++) RX and TX pins swap
245 (++) RX overrun detection disabling
246 (++) DMA disabling on RX error
247 (++) MSB first on communication line
248 (++) auto Baud rate detection
249 [..]
250 The HAL_UART_Init(), HAL_HalfDuplex_Init() and HAL_MultiProcessor_Init()
251 API follow respectively the UART asynchronous, UART Half duplex and multiprocessor
252 configuration procedures (details for the procedures are available in reference manual).
253
254 @endverbatim
255 * @{
256 */
257
258 /**
259 * @brief Initializes the UART mode according to the specified
260 * parameters in the UART_InitTypeDef and creates the associated handle .
261 * @param huart: uart handle
262 * @retval HAL status
263 */
264 HAL_StatusTypeDef HAL_UART_Init(UART_HandleTypeDef *huart)
265 {
266 /* Check the UART handle allocation */
267 if(huart == NULL)
268 {
269 return HAL_ERROR;
270 }
271
272 if(huart->Init.HwFlowCtl != UART_HWCONTROL_NONE)
273 {
274 /* Check the parameters */
275 assert_param(IS_UART_HWFLOW_INSTANCE(huart->Instance));
276 }
277 else
278 {
279 /* Check the parameters */
280 assert_param(IS_UART_INSTANCE(huart->Instance));
281 }
282
283 if(huart->State == HAL_UART_STATE_RESET)
284 {
285 /* Init the low level hardware : GPIO, CLOCK */
286 HAL_UART_MspInit(huart);
287 }
288
289 huart->State = HAL_UART_STATE_BUSY;
290
291 /* Disable the Peripheral */
292 __HAL_UART_DISABLE(huart);
293
294 /* Set the UART Communication parameters */
295 if (UART_SetConfig(huart) == HAL_ERROR)
296 {
297 return HAL_ERROR;
298 }
299
300 if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)
301 {
302 UART_AdvFeatureConfig(huart);
303 }
304
305 /* In asynchronous mode, the following bits must be kept cleared:
306 - LINEN and CLKEN bits in the USART_CR2 register,
307 - SCEN, HDSEL and IREN bits in the USART_CR3 register.*/
308 huart->Instance->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN);
309 huart->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN);
310
311 /* Enable the Peripheral */
312 __HAL_UART_ENABLE(huart);
313
314 /* TEACK and/or REACK to check before moving huart->State to Ready */
315 return (UART_CheckIdleState(huart));
316 }
317
318 /**
319 * @brief Initializes the half-duplex mode according to the specified
320 * parameters in the UART_InitTypeDef and creates the associated handle .
321 * @param huart: uart handle
322 * @retval HAL status
323 */
324 HAL_StatusTypeDef HAL_HalfDuplex_Init(UART_HandleTypeDef *huart)
325 {
326 /* Check the UART handle allocation */
327 if(huart == NULL)
328 {
329 return HAL_ERROR;
330 }
331
332 /* Check UART instance */
333 assert_param(IS_UART_HALFDUPLEX_INSTANCE(huart->Instance));
334
335 if(huart->State == HAL_UART_STATE_RESET)
336 {
337 /* Init the low level hardware : GPIO, CLOCK */
338 HAL_UART_MspInit(huart);
339 }
340
341 huart->State = HAL_UART_STATE_BUSY;
342
343 /* Disable the Peripheral */
344 __HAL_UART_DISABLE(huart);
345
346 /* Set the UART Communication parameters */
347 if (UART_SetConfig(huart) == HAL_ERROR)
348 {
349 return HAL_ERROR;
350 }
351
352 if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)
353 {
354 UART_AdvFeatureConfig(huart);
355 }
356
357 /* In half-duplex mode, the following bits must be kept cleared:
358 - LINEN and CLKEN bits in the USART_CR2 register,
359 - SCEN and IREN bits in the USART_CR3 register.*/
360 huart->Instance->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN);
361 huart->Instance->CR3 &= ~(USART_CR3_IREN | USART_CR3_SCEN);
362
363 /* Enable the Half-Duplex mode by setting the HDSEL bit in the CR3 register */
364 huart->Instance->CR3 |= USART_CR3_HDSEL;
365
366 /* Enable the Peripheral */
367 __HAL_UART_ENABLE(huart);
368
369 /* TEACK and/or REACK to check before moving huart->State to Ready */
370 return (UART_CheckIdleState(huart));
371 }
372
373
374 /**
375 * @brief Initializes the multiprocessor mode according to the specified
376 * parameters in the UART_InitTypeDef and creates the associated handle.
377 * @param huart: UART handle
378 * @param Address: UART node address (4-, 6-, 7- or 8-bit long)
379 * @param WakeUpMethod: specifies the UART wakeup method.
380 * This parameter can be one of the following values:
381 * @arg UART_WAKEUPMETHOD_IDLELINE: WakeUp by an idle line detection
382 * @arg UART_WAKEUPMETHOD_ADDRESSMARK: WakeUp by an address mark
383 * @note If the user resorts to idle line detection wake up, the Address parameter
384 * is useless and ignored by the initialization function.
385 * @note If the user resorts to address mark wake up, the address length detection
386 * is configured by default to 4 bits only. For the UART to be able to
387 * manage 6-, 7- or 8-bit long addresses detection, the API
388 * HAL_MultiProcessorEx_AddressLength_Set() must be called after
389 * HAL_MultiProcessor_Init().
390 * @retval HAL status
391 */
392 HAL_StatusTypeDef HAL_MultiProcessor_Init(UART_HandleTypeDef *huart, uint8_t Address, uint32_t WakeUpMethod)
393 {
394 /* Check the UART handle allocation */
395 if(huart == NULL)
396 {
397 return HAL_ERROR;
398 }
399
400 /* Check the wake up method parameter */
401 assert_param(IS_UART_WAKEUPMETHOD(WakeUpMethod));
402
403 if(huart->State == HAL_UART_STATE_RESET)
404 {
405 /* Init the low level hardware : GPIO, CLOCK */
406 HAL_UART_MspInit(huart);
407 }
408
409 huart->State = HAL_UART_STATE_BUSY;
410
411 /* Disable the Peripheral */
412 __HAL_UART_DISABLE(huart);
413
414 /* Set the UART Communication parameters */
415 if (UART_SetConfig(huart) == HAL_ERROR)
416 {
417 return HAL_ERROR;
418 }
419
420 if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT)
421 {
422 UART_AdvFeatureConfig(huart);
423 }
424
425 /* In multiprocessor mode, the following bits must be kept cleared:
426 - LINEN and CLKEN bits in the USART_CR2 register,
427 - SCEN, HDSEL and IREN bits in the USART_CR3 register. */
428 huart->Instance->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN);
429 huart->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN);
430
431 if (WakeUpMethod == UART_WAKEUPMETHOD_ADDRESSMARK)
432 {
433 /* If address mark wake up method is chosen, set the USART address node */
434 MODIFY_REG(huart->Instance->CR2, USART_CR2_ADD, ((uint32_t)Address << UART_CR2_ADDRESS_LSB_POS));
435 }
436
437 /* Set the wake up method by setting the WAKE bit in the CR1 register */
438 MODIFY_REG(huart->Instance->CR1, USART_CR1_WAKE, WakeUpMethod);
439
440 /* Enable the Peripheral */
441 __HAL_UART_ENABLE(huart);
442
443 /* TEACK and/or REACK to check before moving huart->State to Ready */
444 return (UART_CheckIdleState(huart));
445 }
446
447 /**
448 * @brief DeInitializes the UART peripheral
449 * @param huart: uart handle
450 * @retval HAL status
451 */
452 HAL_StatusTypeDef HAL_UART_DeInit(UART_HandleTypeDef *huart)
453 {
454 /* Check the UART handle allocation */
455 if(huart == NULL)
456 {
457 return HAL_ERROR;
458 }
459
460 /* Check the parameters */
461 assert_param(IS_UART_INSTANCE(huart->Instance));
462
463 huart->State = HAL_UART_STATE_BUSY;
464
465 /* Disable the Peripheral */
466 __HAL_UART_DISABLE(huart);
467
468 huart->Instance->CR1 = 0x0;
469 huart->Instance->CR2 = 0x0;
470 huart->Instance->CR3 = 0x0;
471
472 /* DeInit the low level hardware */
473 HAL_UART_MspDeInit(huart);
474
475 huart->ErrorCode = HAL_UART_ERROR_NONE;
476 huart->State = HAL_UART_STATE_RESET;
477
478 /* Process Unlock */
479 __HAL_UNLOCK(huart);
480
481 return HAL_OK;
482 }
483
484 /**
485 * @brief UART MSP Init
486 * @param huart: uart handle
487 * @retval None
488 */
489 __weak void HAL_UART_MspInit(UART_HandleTypeDef *huart)
490 {
491 /* NOTE : This function should not be modified, when the callback is needed,
492 the HAL_UART_MspInit can be implemented in the user file
493 */
494 }
495
496 /**
497 * @brief UART MSP DeInit
498 * @param huart: uart handle
499 * @retval None
500 */
501 __weak void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)
502 {
503 /* NOTE : This function should not be modified, when the callback is needed,
504 the HAL_UART_MspDeInit could be implemented in the user file
505 */
506 }
507
508 /**
509 * @}
510 */
511
512 /** @defgroup UART_Exported_Functions_Group2 IO operation functions
513 * @brief UART Transmit and Receive functions
514 *
515 @verbatim
516 ==============================================================================
517 ##### IO operation functions #####
518 ==============================================================================
519 [..]
520 This subsection provides a set of functions allowing to manage the UART asynchronous
521 and Half duplex data transfers.
522
523 (#) There are two mode of transfer:
524 (++) Blocking mode: The communication is performed in polling mode.
525 The HAL status of all data processing is returned by the same function
526 after finishing transfer.
527 (++) No-Blocking mode: The communication is performed using Interrupts
528 or DMA, These APIs return the HAL status.
529 The end of the data processing will be indicated through the
530 dedicated UART IRQ when using Interrupt mode or the DMA IRQ when
531 using DMA mode.
532 The HAL_UART_TxCpltCallback(), HAL_UART_RxCpltCallback() user callbacks
533 will be executed respectivelly at the end of the transmit or Receive process
534 The HAL_UART_ErrorCallback()user callback will be executed when a communication error is detected
535
536 (#) Blocking mode APIs are :
537 (++) HAL_UART_Transmit()
538 (++) HAL_UART_Receive()
539
540 (#) Non Blocking mode APIs with Interrupt are :
541 (++) HAL_UART_Transmit_IT()
542 (++) HAL_UART_Receive_IT()
543 (++) HAL_UART_IRQHandler()
544 (++) UART_Transmit_IT()
545 (++) UART_Receive_IT()
546
547 (#) Non Blocking mode APIs with DMA are :
548 (++) HAL_UART_Transmit_DMA()
549 (++) HAL_UART_Receive_DMA()
550 (++) HAL_UART_DMAPause()
551 (++) HAL_UART_DMAResume()
552 (++) HAL_UART_DMAStop()
553
554 (#) A set of Transfer Complete Callbacks are provided in non blocking mode:
555 (++) HAL_UART_TxHalfCpltCallback()
556 (++) HAL_UART_TxCpltCallback()
557 (++) HAL_UART_RxHalfCpltCallback()
558 (++) HAL_UART_RxCpltCallback()
559 (++) HAL_UART_ErrorCallback()
560
561 [..]
562 (@) In the Half duplex communication, it is forbidden to run the transmit
563 and receive process in parallel, the UART state HAL_UART_STATE_BUSY_TX_RX can't be useful.
564
565 @endverbatim
566 * @{
567 */
568
569 /**
570 * @brief Send an amount of data in blocking mode
571 * @param huart: uart handle
572 * @param pData: pointer to data buffer
573 * @param Size: amount of data to be sent
574 * @param Timeout : Timeout duration
575 * @retval HAL status
576 */
577 HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
578 {
579 uint16_t* tmp;
580
581 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_RX))
582 {
583 if((pData == NULL ) || (Size == 0))
584 {
585 return HAL_ERROR;
586 }
587
588 /* Process Locked */
589 __HAL_LOCK(huart);
590
591 huart->ErrorCode = HAL_UART_ERROR_NONE;
592 /* Check if a non-blocking receive process is ongoing or not */
593 if(huart->State == HAL_UART_STATE_BUSY_RX)
594 {
595 huart->State = HAL_UART_STATE_BUSY_TX_RX;
596 }
597 else
598 {
599 huart->State = HAL_UART_STATE_BUSY_TX;
600 }
601
602 huart->TxXferSize = Size;
603 huart->TxXferCount = Size;
604 while(huart->TxXferCount > 0)
605 {
606 huart->TxXferCount--;
607 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TXE, RESET, Timeout) != HAL_OK)
608 {
609 return HAL_TIMEOUT;
610 }
611 if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
612 {
613 tmp = (uint16_t*) pData;
614 huart->Instance->TDR = (*tmp & (uint16_t)0x01FF);
615 pData += 2;
616 }
617 else
618 {
619 huart->Instance->TDR = (*pData++ & (uint8_t)0xFF);
620 }
621 }
622 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, Timeout) != HAL_OK)
623 {
624 return HAL_TIMEOUT;
625 }
626 /* Check if a non-blocking receive Process is ongoing or not */
627 if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
628 {
629 huart->State = HAL_UART_STATE_BUSY_RX;
630 }
631 else
632 {
633 huart->State = HAL_UART_STATE_READY;
634 }
635
636 /* Process Unlocked */
637 __HAL_UNLOCK(huart);
638
639 return HAL_OK;
640 }
641 else
642 {
643 return HAL_BUSY;
644 }
645 }
646
647 /**
648 * @brief Receive an amount of data in blocking mode
649 * @param huart: uart handle
650 * @param pData: pointer to data buffer
651 * @param Size: amount of data to be received
652 * @param Timeout : Timeout duration
653 * @retval HAL status
654 */
655 HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)
656 {
657 uint16_t* tmp;
658 uint16_t uhMask;
659
660 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_TX))
661 {
662 if((pData == NULL ) || (Size == 0))
663 {
664 return HAL_ERROR;
665 }
666
667 /* Process Locked */
668 __HAL_LOCK(huart);
669
670 huart->ErrorCode = HAL_UART_ERROR_NONE;
671 /* Check if a non-blocking transmit process is ongoing or not */
672 if(huart->State == HAL_UART_STATE_BUSY_TX)
673 {
674 huart->State = HAL_UART_STATE_BUSY_TX_RX;
675 }
676 else
677 {
678 huart->State = HAL_UART_STATE_BUSY_RX;
679 }
680
681 huart->RxXferSize = Size;
682 huart->RxXferCount = Size;
683
684 /* Computation of UART mask to apply to RDR register */
685 __HAL_UART_MASK_COMPUTATION(huart);
686 uhMask = huart->Mask;
687
688 /* as long as data have to be received */
689 while(huart->RxXferCount > 0)
690 {
691 huart->RxXferCount--;
692 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_RXNE, RESET, Timeout) != HAL_OK)
693 {
694 return HAL_TIMEOUT;
695 }
696 if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
697 {
698 tmp = (uint16_t*) pData ;
699 *tmp = (uint16_t)(huart->Instance->RDR & uhMask);
700 pData +=2;
701 }
702 else
703 {
704 *pData++ = (uint8_t)(huart->Instance->RDR & (uint8_t)uhMask);
705 }
706 }
707
708 /* Check if a non-blocking transmit Process is ongoing or not */
709 if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
710 {
711 huart->State = HAL_UART_STATE_BUSY_TX;
712 }
713 else
714 {
715 huart->State = HAL_UART_STATE_READY;
716 }
717 /* Process Unlocked */
718 __HAL_UNLOCK(huart);
719
720 return HAL_OK;
721 }
722 else
723 {
724 return HAL_BUSY;
725 }
726 }
727
728 /**
729 * @brief Send an amount of data in interrupt mode
730 * @param huart: uart handle
731 * @param pData: pointer to data buffer
732 * @param Size: amount of data to be sent
733 * @retval HAL status
734 */
735 HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
736 {
737 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_RX))
738 {
739 if((pData == NULL ) || (Size == 0))
740 {
741 return HAL_ERROR;
742 }
743
744 /* Process Locked */
745 __HAL_LOCK(huart);
746
747 huart->pTxBuffPtr = pData;
748 huart->TxXferSize = Size;
749 huart->TxXferCount = Size;
750
751 huart->ErrorCode = HAL_UART_ERROR_NONE;
752 /* Check if a receive process is ongoing or not */
753 if(huart->State == HAL_UART_STATE_BUSY_RX)
754 {
755 huart->State = HAL_UART_STATE_BUSY_TX_RX;
756 }
757 else
758 {
759 huart->State = HAL_UART_STATE_BUSY_TX;
760 }
761
762 /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
763 __HAL_UART_ENABLE_IT(huart, UART_IT_ERR);
764
765 /* Process Unlocked */
766 __HAL_UNLOCK(huart);
767
768 /* Enable the UART Transmit Data Register Empty Interrupt */
769 __HAL_UART_ENABLE_IT(huart, UART_IT_TXE);
770
771 return HAL_OK;
772 }
773 else
774 {
775 return HAL_BUSY;
776 }
777 }
778
779 /**
780 * @brief Receive an amount of data in interrupt mode
781 * @param huart: uart handle
782 * @param pData: pointer to data buffer
783 * @param Size: amount of data to be received
784 * @retval HAL status
785 */
786 HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
787 {
788 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_TX))
789 {
790 if((pData == NULL ) || (Size == 0))
791 {
792 return HAL_ERROR;
793 }
794
795 /* Process Locked */
796 __HAL_LOCK(huart);
797
798 huart->pRxBuffPtr = pData;
799 huart->RxXferSize = Size;
800 huart->RxXferCount = Size;
801
802 /* Computation of UART mask to apply to RDR register */
803 __HAL_UART_MASK_COMPUTATION(huart);
804
805 huart->ErrorCode = HAL_UART_ERROR_NONE;
806 /* Check if a transmit process is ongoing or not */
807 if(huart->State == HAL_UART_STATE_BUSY_TX)
808 {
809 huart->State = HAL_UART_STATE_BUSY_TX_RX;
810 }
811 else
812 {
813 huart->State = HAL_UART_STATE_BUSY_RX;
814 }
815
816 /* Enable the UART Parity Error Interrupt */
817 __HAL_UART_ENABLE_IT(huart, UART_IT_PE);
818
819 /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
820 __HAL_UART_ENABLE_IT(huart, UART_IT_ERR);
821
822 /* Process Unlocked */
823 __HAL_UNLOCK(huart);
824
825 /* Enable the UART Data Register not empty Interrupt */
826 __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
827
828 return HAL_OK;
829 }
830 else
831 {
832 return HAL_BUSY;
833 }
834 }
835
836 /**
837 * @brief Send an amount of data in DMA mode
838 * @param huart: uart handle
839 * @param pData: pointer to data buffer
840 * @param Size: amount of data to be sent
841 * @retval HAL status
842 */
843 HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
844 {
845 uint32_t *tmp;
846
847 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_RX))
848 {
849 if((pData == NULL ) || (Size == 0))
850 {
851 return HAL_ERROR;
852 }
853
854 /* Process Locked */
855 __HAL_LOCK(huart);
856
857 huart->pTxBuffPtr = pData;
858 huart->TxXferSize = Size;
859 huart->TxXferCount = Size;
860
861 huart->ErrorCode = HAL_UART_ERROR_NONE;
862 /* Check if a receive process is ongoing or not */
863 if(huart->State == HAL_UART_STATE_BUSY_RX)
864 {
865 huart->State = HAL_UART_STATE_BUSY_TX_RX;
866 }
867 else
868 {
869 huart->State = HAL_UART_STATE_BUSY_TX;
870 }
871
872 /* Set the UART DMA transfer complete callback */
873 huart->hdmatx->XferCpltCallback = UART_DMATransmitCplt;
874
875 /* Set the UART DMA Half transfer complete callback */
876 huart->hdmatx->XferHalfCpltCallback = UART_DMATxHalfCplt;
877
878 /* Set the DMA error callback */
879 huart->hdmatx->XferErrorCallback = UART_DMAError;
880
881 /* Enable the UART transmit DMA channel */
882 tmp = (uint32_t*)&pData;
883 HAL_DMA_Start_IT(huart->hdmatx, *(uint32_t*)tmp, (uint32_t)&huart->Instance->TDR, Size);
884
885 /* Enable the DMA transfer for transmit request by setting the DMAT bit
886 in the UART CR3 register */
887 huart->Instance->CR3 |= USART_CR3_DMAT;
888
889 /* Process Unlocked */
890 __HAL_UNLOCK(huart);
891
892 return HAL_OK;
893 }
894 else
895 {
896 return HAL_BUSY;
897 }
898 }
899
900 /**
901 * @brief Receive an amount of data in DMA mode
902 * @param huart: uart handle
903 * @param pData: pointer to data buffer
904 * @param Size: amount of data to be received
905 * @note When the UART parity is enabled (PCE = 1), the received data contain
906 * the parity bit (MSB position)
907 * @retval HAL status
908 */
909 HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
910 {
911 uint32_t *tmp;
912
913 if((huart->State == HAL_UART_STATE_READY) || (huart->State == HAL_UART_STATE_BUSY_TX))
914 {
915 if((pData == NULL ) || (Size == 0))
916 {
917 return HAL_ERROR;
918 }
919
920 /* Process Locked */
921 __HAL_LOCK(huart);
922
923 huart->pRxBuffPtr = pData;
924 huart->RxXferSize = Size;
925
926 huart->ErrorCode = HAL_UART_ERROR_NONE;
927 /* Check if a transmit process is ongoing or not */
928 if(huart->State == HAL_UART_STATE_BUSY_TX)
929 {
930 huart->State = HAL_UART_STATE_BUSY_TX_RX;
931 }
932 else
933 {
934 huart->State = HAL_UART_STATE_BUSY_RX;
935 }
936
937 /* Set the UART DMA transfer complete callback */
938 huart->hdmarx->XferCpltCallback = UART_DMAReceiveCplt;
939
940 /* Set the UART DMA Half transfer complete callback */
941 huart->hdmarx->XferHalfCpltCallback = UART_DMARxHalfCplt;
942
943 /* Set the DMA error callback */
944 huart->hdmarx->XferErrorCallback = UART_DMAError;
945
946 /* Enable the DMA channel */
947 tmp = (uint32_t*)&pData;
948 HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->RDR, *(uint32_t*)tmp, Size);
949
950 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
951 in the UART CR3 register */
952 huart->Instance->CR3 |= USART_CR3_DMAR;
953
954 /* Process Unlocked */
955 __HAL_UNLOCK(huart);
956
957 return HAL_OK;
958 }
959 else
960 {
961 return HAL_BUSY;
962 }
963 }
964
965 /**
966 * @brief Pauses the DMA Transfer.
967 * @param huart: UART handle
968 * @retval None
969 */
970 HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart)
971 {
972 /* Process Locked */
973 __HAL_LOCK(huart);
974
975 if(huart->State == HAL_UART_STATE_BUSY_TX)
976 {
977 /* Disable the UART DMA Tx request */
978 huart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
979 }
980 else if(huart->State == HAL_UART_STATE_BUSY_RX)
981 {
982 /* Disable the UART DMA Rx request */
983 huart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
984 }
985 else if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
986 {
987 /* Disable the UART DMA Tx request */
988 huart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAT);
989 /* Disable the UART DMA Rx request */
990 huart->Instance->CR3 &= (uint32_t)(~USART_CR3_DMAR);
991 }
992
993 /* Process Unlocked */
994 __HAL_UNLOCK(huart);
995
996 return HAL_OK;
997 }
998
999 /**
1000 * @brief Resumes the DMA Transfer.
1001 * @param huart: UART handle
1002 * @retval None
1003 */
1004 HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart)
1005 {
1006 /* Process Locked */
1007 __HAL_LOCK(huart);
1008
1009 if(huart->State == HAL_UART_STATE_BUSY_TX)
1010 {
1011 /* Enable the UART DMA Tx request */
1012 huart->Instance->CR3 |= USART_CR3_DMAT;
1013 }
1014 else if(huart->State == HAL_UART_STATE_BUSY_RX)
1015 {
1016 /* Enable the UART DMA Rx request */
1017 huart->Instance->CR3 |= USART_CR3_DMAR;
1018 }
1019 else if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
1020 {
1021 /* Enable the UART DMA Rx request before the DMA Tx request */
1022 huart->Instance->CR3 |= USART_CR3_DMAR;
1023 /* Enable the UART DMA Tx request */
1024 huart->Instance->CR3 |= USART_CR3_DMAT;
1025 }
1026
1027 /* If the UART peripheral is still not enabled, enable it */
1028 if ((huart->Instance->CR1 & USART_CR1_UE) == 0)
1029 {
1030 /* Enable UART peripheral */
1031 __HAL_UART_ENABLE(huart);
1032 }
1033
1034 /* TEACK and/or REACK to check before moving huart->State to Ready */
1035 return (UART_CheckIdleState(huart));
1036 }
1037
1038 /**
1039 * @brief Stops the DMA Transfer.
1040 * @param huart: UART handle
1041 * @retval None
1042 */
1043 HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart)
1044 {
1045 /* Process Locked */
1046 __HAL_LOCK(huart);
1047
1048 /* Disable the UART Tx/Rx DMA requests */
1049 huart->Instance->CR3 &= ~USART_CR3_DMAT;
1050 huart->Instance->CR3 &= ~USART_CR3_DMAR;
1051
1052 /* Abort the UART DMA tx channel */
1053 if(huart->hdmatx != NULL)
1054 {
1055 HAL_DMA_Abort(huart->hdmatx);
1056 }
1057 /* Abort the UART DMA rx channel */
1058 if(huart->hdmarx != NULL)
1059 {
1060 HAL_DMA_Abort(huart->hdmarx);
1061 }
1062
1063 /* Disable UART peripheral */
1064 __HAL_UART_DISABLE(huart);
1065
1066 huart->State = HAL_UART_STATE_READY;
1067
1068 /* Process Unlocked */
1069 __HAL_UNLOCK(huart);
1070
1071 return HAL_OK;
1072 }
1073
1074 /**
1075 * @brief Tx Transfer completed callbacks
1076 * @param huart: uart handle
1077 * @retval None
1078 */
1079 __weak void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
1080 {
1081 /* NOTE : This function should not be modified, when the callback is needed,
1082 the HAL_UART_TxCpltCallback can be implemented in the user file
1083 */
1084 }
1085
1086 /**
1087 * @brief Tx Half Transfer completed callbacks.
1088 * @param huart: UART handle
1089 * @retval None
1090 */
1091 __weak void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)
1092 {
1093 /* NOTE: This function should not be modified, when the callback is needed,
1094 the HAL_UART_TxHalfCpltCallback can be implemented in the user file
1095 */
1096 }
1097
1098 /**
1099 * @brief Rx Transfer completed callbacks
1100 * @param huart: uart handle
1101 * @retval None
1102 */
1103 __weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
1104 {
1105 /* NOTE : This function should not be modified, when the callback is needed,
1106 the HAL_UART_RxCpltCallback can be implemented in the user file
1107 */
1108 }
1109
1110 /**
1111 * @brief Rx Half Transfer completed callbacks.
1112 * @param huart: UART handle
1113 * @retval None
1114 */
1115 __weak void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
1116 {
1117 /* NOTE: This function should not be modified, when the callback is needed,
1118 the HAL_UART_RxHalfCpltCallback can be implemented in the user file
1119 */
1120 }
1121
1122 /**
1123 * @brief UART error callbacks
1124 * @param huart: uart handle
1125 * @retval None
1126 */
1127 __weak void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
1128 {
1129 /* NOTE : This function should not be modified, when the callback is needed,
1130 the HAL_UART_ErrorCallback can be implemented in the user file
1131 */
1132 }
1133
1134 /**
1135 * @}
1136 */
1137
1138 /** @defgroup UART_Exported_Functions_Group3 Peripheral Control functions
1139 * @brief UART control functions
1140 *
1141 @verbatim
1142 ===============================================================================
1143 ##### Peripheral Control functions #####
1144 ===============================================================================
1145 [..]
1146 This subsection provides a set of functions allowing to control the UART.
1147 (+) HAL_UART_GetState() API is helpful to check in run-time the state of the UART peripheral.
1148 (+) HAL_MultiProcessor_EnableMuteMode() API enables mute mode
1149 (+) HAL_MultiProcessor_DisableMuteMode() API disables mute mode
1150 (+) HAL_MultiProcessor_EnterMuteMode() API enters mute mode
1151 (+) HAL_MultiProcessor_EnableMuteMode() API enables mute mode
1152 (+) HAL_UART_EnableStopMode() API enables the UART to wake up the MCU from stop mode
1153 (+) HAL_UART_DisableStopMode() API disables the above functionality
1154 (+) UART_SetConfig() API configures the UART peripheral
1155 (+) UART_AdvFeatureConfig() API optionally configures the UART advanced features
1156 (+) UART_CheckIdleState() API ensures that TEACK and/or REACK are set after initialization
1157 (+) UART_Wakeup_AddressConfig() API configures the wake-up from stop mode parameters
1158 (+) HAL_HalfDuplex_EnableTransmitter() API disables receiver and enables transmitter
1159 (+) HAL_HalfDuplex_EnableReceiver() API disables transmitter and enables receiver
1160 @endverbatim
1161 * @{
1162 */
1163
1164 /**
1165 * @brief Enable UART in mute mode (doesn't mean UART enters mute mode;
1166 * to enter mute mode, HAL_MultiProcessor_EnterMuteMode() API must be called)
1167 * @param huart: UART handle
1168 * @retval HAL status
1169 */
1170 HAL_StatusTypeDef HAL_MultiProcessor_EnableMuteMode(UART_HandleTypeDef *huart)
1171 {
1172 /* Process Locked */
1173 __HAL_LOCK(huart);
1174
1175 huart->State = HAL_UART_STATE_BUSY;
1176
1177 /* Enable USART mute mode by setting the MME bit in the CR1 register */
1178 huart->Instance->CR1 |= USART_CR1_MME;
1179
1180 huart->State = HAL_UART_STATE_READY;
1181
1182 return (UART_CheckIdleState(huart));
1183 }
1184
1185 /**
1186 * @brief Disable UART mute mode (doesn't mean it actually wakes up the software,
1187 * as it may not have been in mute mode at this very moment).
1188 * @param huart: uart handle
1189 * @retval HAL status
1190 */
1191 HAL_StatusTypeDef HAL_MultiProcessor_DisableMuteMode(UART_HandleTypeDef *huart)
1192 {
1193 /* Process Locked */
1194 __HAL_LOCK(huart);
1195
1196 huart->State = HAL_UART_STATE_BUSY;
1197
1198 /* Disable USART mute mode by clearing the MME bit in the CR1 register */
1199 huart->Instance->CR1 &= ~(USART_CR1_MME);
1200
1201 huart->State = HAL_UART_STATE_READY;
1202
1203 return (UART_CheckIdleState(huart));
1204 }
1205
1206 /**
1207 * @brief Enter UART mute mode (means UART actually enters mute mode).
1208 * To exit from mute mode, HAL_MultiProcessor_DisableMuteMode() API must be called.
1209 * @param huart: uart handle
1210 * @retval HAL status
1211 */
1212 void HAL_MultiProcessor_EnterMuteMode(UART_HandleTypeDef *huart)
1213 {
1214 __HAL_UART_SEND_REQ(huart, UART_MUTE_MODE_REQUEST);
1215 }
1216
1217 /**
1218 * @brief Enables the UART transmitter and disables the UART receiver.
1219 * @param huart: UART handle
1220 * @retval HAL status
1221 * @retval None
1222 */
1223 HAL_StatusTypeDef HAL_HalfDuplex_EnableTransmitter(UART_HandleTypeDef *huart)
1224 {
1225 /* Process Locked */
1226 __HAL_LOCK(huart);
1227 huart->State = HAL_UART_STATE_BUSY;
1228
1229 /* Clear TE and RE bits */
1230 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TE | USART_CR1_RE));
1231 /* Enable the USART's transmit interface by setting the TE bit in the USART CR1 register */
1232 SET_BIT(huart->Instance->CR1, USART_CR1_TE);
1233
1234 huart->State = HAL_UART_STATE_READY;
1235 /* Process Unlocked */
1236 __HAL_UNLOCK(huart);
1237
1238 return HAL_OK;
1239 }
1240
1241 /**
1242 * @brief Enables the UART receiver and disables the UART transmitter.
1243 * @param huart: UART handle
1244 * @retval HAL status
1245 */
1246 HAL_StatusTypeDef HAL_HalfDuplex_EnableReceiver(UART_HandleTypeDef *huart)
1247 {
1248 /* Process Locked */
1249 __HAL_LOCK(huart);
1250 huart->State = HAL_UART_STATE_BUSY;
1251
1252 /* Clear TE and RE bits */
1253 CLEAR_BIT(huart->Instance->CR1, (USART_CR1_TE | USART_CR1_RE));
1254 /* Enable the USART's receive interface by setting the RE bit in the USART CR1 register */
1255 SET_BIT(huart->Instance->CR1, USART_CR1_RE);
1256
1257 huart->State = HAL_UART_STATE_READY;
1258 /* Process Unlocked */
1259 __HAL_UNLOCK(huart);
1260
1261 return HAL_OK;
1262 }
1263
1264 /**
1265 * @}
1266 */
1267
1268 /** @defgroup UART_Exported_Functions_Group4 Peripheral State and Errors functions
1269 * @{
1270 */
1271
1272 /**
1273 * @brief return the UART state
1274 * @param huart: uart handle
1275 * @retval HAL state
1276 */
1277 HAL_UART_StateTypeDef HAL_UART_GetState(UART_HandleTypeDef *huart)
1278 {
1279 return huart->State;
1280 }
1281
1282 /**
1283 * @brief Return the UART error code
1284 * @param huart : pointer to a UART_HandleTypeDef structure that contains
1285 * the configuration information for the specified UART.
1286 * @retval UART Error Code
1287 */
1288 uint32_t HAL_UART_GetError(UART_HandleTypeDef *huart)
1289 {
1290 return huart->ErrorCode;
1291 }
1292
1293 /**
1294 * @}
1295 */
1296
1297 /**
1298 * @}
1299 */
1300
1301 /** @defgroup UART_Private_Functions UART Private Functions
1302 * @{
1303 */
1304
1305 /**
1306 * @brief Send an amount of data in interrupt mode
1307 * Function called under interruption only, once
1308 * interruptions have been enabled by HAL_UART_Transmit_IT()
1309 * @param huart: UART handle
1310 * @retval HAL status
1311 */
1312 HAL_StatusTypeDef UART_Transmit_IT(UART_HandleTypeDef *huart)
1313 {
1314 uint16_t* tmp;
1315
1316 if ((huart->State == HAL_UART_STATE_BUSY_TX) || (huart->State == HAL_UART_STATE_BUSY_TX_RX))
1317 {
1318
1319 if(huart->TxXferCount == 0)
1320 {
1321 /* Disable the UART Transmit Data Register Empty Interrupt */
1322 __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
1323
1324 /* Enable the UART Transmit Complete Interrupt */
1325 __HAL_UART_ENABLE_IT(huart, UART_IT_TC);
1326
1327 return HAL_OK;
1328 }
1329 else
1330 {
1331 if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
1332 {
1333 tmp = (uint16_t*) huart->pTxBuffPtr;
1334 huart->Instance->TDR = (*tmp & (uint16_t)0x01FF);
1335 huart->pTxBuffPtr += 2;
1336 }
1337 else
1338 {
1339 huart->Instance->TDR = (uint8_t)(*huart->pTxBuffPtr++ & (uint8_t)0xFF);
1340 }
1341
1342 huart->TxXferCount--;
1343
1344 return HAL_OK;
1345 }
1346 }
1347 else
1348 {
1349 return HAL_BUSY;
1350 }
1351 }
1352
1353 /**
1354 * @brief Receive an amount of data in interrupt mode
1355 * Function called under interruption only, once
1356 * interruptions have been enabled by HAL_UART_Receive_IT()
1357 * @param huart: UART handle
1358 * @retval HAL status
1359 */
1360 HAL_StatusTypeDef UART_Receive_IT(UART_HandleTypeDef *huart)
1361 {
1362 uint16_t* tmp;
1363 uint16_t uhMask = huart->Mask;
1364
1365 if((huart->State == HAL_UART_STATE_BUSY_RX) || (huart->State == HAL_UART_STATE_BUSY_TX_RX))
1366 {
1367
1368 if ((huart->Init.WordLength == UART_WORDLENGTH_9B) && (huart->Init.Parity == UART_PARITY_NONE))
1369 {
1370 tmp = (uint16_t*) huart->pRxBuffPtr ;
1371 *tmp = (uint16_t)(huart->Instance->RDR & uhMask);
1372 huart->pRxBuffPtr +=2;
1373 }
1374 else
1375 {
1376 *huart->pRxBuffPtr++ = (uint8_t)(huart->Instance->RDR & (uint8_t)uhMask);
1377 }
1378
1379 if(--huart->RxXferCount == 0)
1380 {
1381 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
1382
1383 /* Check if a transmit Process is ongoing or not */
1384 if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
1385 {
1386 huart->State = HAL_UART_STATE_BUSY_TX;
1387 }
1388 else
1389 {
1390 /* Disable the UART Parity Error Interrupt */
1391 __HAL_UART_DISABLE_IT(huart, UART_IT_PE);
1392
1393 /* Disable the UART Error Interrupt: (Frame error, noise error, overrun error) */
1394 __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
1395
1396 huart->State = HAL_UART_STATE_READY;
1397 }
1398
1399 HAL_UART_RxCpltCallback(huart);
1400
1401 return HAL_OK;
1402 }
1403
1404 return HAL_OK;
1405 }
1406 else
1407 {
1408 return HAL_BUSY;
1409 }
1410 }
1411
1412 /**
1413 * @brief Check the UART Idle State
1414 * @param huart: uart handle
1415 * @retval HAL status
1416 */
1417 HAL_StatusTypeDef UART_CheckIdleState(UART_HandleTypeDef *huart)
1418 {
1419 /* Initialize the UART ErrorCode */
1420 huart->ErrorCode = HAL_UART_ERROR_NONE;
1421
1422 /* Check if the Transmitter is enabled */
1423 if((huart->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
1424 {
1425 /* Wait until TEACK flag is set */
1426 if(UART_WaitOnFlagUntilTimeout(huart, USART_ISR_TEACK, RESET, HAL_UART_TIMEOUT_VALUE) != HAL_OK)
1427 {
1428 /* Timeout Occured */
1429 return HAL_TIMEOUT;
1430 }
1431 }
1432 /* Check if the Receiver is enabled */
1433 if((huart->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
1434 {
1435 /* Wait until REACK flag is set */
1436 if(UART_WaitOnFlagUntilTimeout(huart, USART_ISR_REACK, RESET, HAL_UART_TIMEOUT_VALUE) != HAL_OK)
1437 {
1438 /* Timeout Occured */
1439 return HAL_TIMEOUT;
1440 }
1441 }
1442
1443 /* Initialize the UART State */
1444 huart->State= HAL_UART_STATE_READY;
1445
1446 /* Process Unlocked */
1447 __HAL_UNLOCK(huart);
1448
1449 return HAL_OK;
1450 }
1451
1452 /**
1453 * @brief This function handles UART Communication Timeout.
1454 * @param huart: UART handle
1455 * @param Flag: specifies the UART flag to check.
1456 * @param Status: The new Flag status (SET or RESET).
1457 * @param Timeout: Timeout duration
1458 * @retval HAL status
1459 */
1460 HAL_StatusTypeDef UART_WaitOnFlagUntilTimeout(UART_HandleTypeDef *huart, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
1461 {
1462 uint32_t tickstart = HAL_GetTick();
1463
1464 /* Wait until flag is set */
1465 if(Status == RESET)
1466 {
1467 while(__HAL_UART_GET_FLAG(huart, Flag) == RESET)
1468 {
1469 /* Check for the Timeout */
1470 if(Timeout != HAL_MAX_DELAY)
1471 {
1472 if((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
1473 {
1474 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
1475 __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
1476 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
1477 __HAL_UART_DISABLE_IT(huart, UART_IT_PE);
1478 __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
1479
1480 huart->State = HAL_UART_STATE_READY;
1481
1482 /* Process Unlocked */
1483 __HAL_UNLOCK(huart);
1484
1485 return HAL_TIMEOUT;
1486 }
1487 }
1488 }
1489 }
1490 else
1491 {
1492 while(__HAL_UART_GET_FLAG(huart, Flag) != RESET)
1493 {
1494 /* Check for the Timeout */
1495 if(Timeout != HAL_MAX_DELAY)
1496 {
1497 if((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
1498 {
1499 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
1500 __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
1501 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
1502 __HAL_UART_DISABLE_IT(huart, UART_IT_PE);
1503 __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
1504
1505 huart->State = HAL_UART_STATE_READY;
1506
1507 /* Process Unlocked */
1508 __HAL_UNLOCK(huart);
1509
1510 return HAL_TIMEOUT;
1511 }
1512 }
1513 }
1514 }
1515 return HAL_OK;
1516 }
1517
1518 /**
1519 * @brief DMA UART transmit process complete callback
1520 * @param hdma: DMA handle
1521 * @retval None
1522 */
1523 static void UART_DMATransmitCplt(DMA_HandleTypeDef *hdma)
1524 {
1525 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1526 huart->TxXferCount = 0;
1527
1528 /* Disable the DMA transfer for transmit request by setting the DMAT bit
1529 in the UART CR3 register */
1530 huart->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DMAT);
1531
1532 /* Wait for UART TC Flag */
1533 if(UART_WaitOnFlagUntilTimeout(huart, UART_FLAG_TC, RESET, HAL_UART_TXDMA_TIMEOUTVALUE) != HAL_OK)
1534 {
1535 /* Timeout Occured */
1536 huart->State = HAL_UART_STATE_TIMEOUT;
1537 HAL_UART_ErrorCallback(huart);
1538 }
1539 else
1540 {
1541 /* No Timeout */
1542 /* Check if a receive process is ongoing or not */
1543 if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
1544 {
1545 huart->State = HAL_UART_STATE_BUSY_RX;
1546 }
1547 else
1548 {
1549 huart->State = HAL_UART_STATE_READY;
1550 }
1551 HAL_UART_TxCpltCallback(huart);
1552 }
1553 }
1554
1555 /**
1556 * @brief DMA UART transmit process half complete callback
1557 * @param hdma : DMA handle
1558 * @retval None
1559 */
1560 static void UART_DMATxHalfCplt(DMA_HandleTypeDef *hdma)
1561 {
1562 UART_HandleTypeDef* huart = (UART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
1563
1564 HAL_UART_TxHalfCpltCallback(huart);
1565 }
1566
1567 /**
1568 * @brief DMA UART receive process complete callback
1569 * @param hdma: DMA handle
1570 * @retval None
1571 */
1572 static void UART_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
1573 {
1574 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1575 huart->RxXferCount = 0;
1576
1577 /* Disable the DMA transfer for the receiver request by setting the DMAR bit
1578 in the UART CR3 register */
1579 huart->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_DMAR);
1580
1581 /* Check if a transmit Process is ongoing or not */
1582 if(huart->State == HAL_UART_STATE_BUSY_TX_RX)
1583 {
1584 huart->State = HAL_UART_STATE_BUSY_TX;
1585 }
1586 else
1587 {
1588 huart->State = HAL_UART_STATE_READY;
1589 }
1590 HAL_UART_RxCpltCallback(huart);
1591 }
1592
1593 /**
1594 * @brief DMA UART receive process half complete callback
1595 * @param hdma : DMA handle
1596 * @retval None
1597 */
1598 static void UART_DMARxHalfCplt(DMA_HandleTypeDef *hdma)
1599 {
1600 UART_HandleTypeDef* huart = (UART_HandleTypeDef*)((DMA_HandleTypeDef*)hdma)->Parent;
1601
1602 HAL_UART_RxHalfCpltCallback(huart);
1603 }
1604
1605 /**
1606 * @brief DMA UART communication error callback
1607 * @param hdma: DMA handle
1608 * @retval None
1609 */
1610 static void UART_DMAError(DMA_HandleTypeDef *hdma)
1611 {
1612 UART_HandleTypeDef* huart = ( UART_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
1613 huart->RxXferCount = 0;
1614 huart->TxXferCount = 0;
1615 huart->State= HAL_UART_STATE_READY;
1616 huart->ErrorCode |= HAL_UART_ERROR_DMA;
1617 HAL_UART_ErrorCallback(huart);
1618 }
1619
1620 /**
1621 * @brief Configure the UART peripheral
1622 * @param huart: uart handle
1623 * @retval None
1624 */
1625 HAL_StatusTypeDef UART_SetConfig(UART_HandleTypeDef *huart)
1626 {
1627 uint32_t tmpreg = 0x00000000;
1628 UART_ClockSourceTypeDef clocksource = UART_CLOCKSOURCE_UNDEFINED;
1629 uint16_t brrtemp = 0x0000;
1630 uint16_t usartdiv = 0x0000;
1631 HAL_StatusTypeDef ret = HAL_OK;
1632
1633 /* Check the parameters */
1634 assert_param(IS_UART_BAUDRATE(huart->Init.BaudRate));
1635 assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength));
1636 assert_param(IS_UART_STOPBITS(huart->Init.StopBits));
1637 assert_param(IS_UART_PARITY(huart->Init.Parity));
1638 assert_param(IS_UART_MODE(huart->Init.Mode));
1639 assert_param(IS_UART_HARDWARE_FLOW_CONTROL(huart->Init.HwFlowCtl));
1640 assert_param(IS_UART_ONEBIT_SAMPLING(huart->Init.OneBitSampling));
1641
1642
1643 /*-------------------------- USART CR1 Configuration -----------------------*/
1644 /* Clear M, PCE, PS, TE, RE and OVER8 bits and configure
1645 * the UART Word Length, Parity, Mode and oversampling:
1646 * set the M bits according to huart->Init.WordLength value
1647 * set PCE and PS bits according to huart->Init.Parity value
1648 * set TE and RE bits according to huart->Init.Mode value
1649 * set OVER8 bit according to huart->Init.OverSampling value */
1650 tmpreg = (uint32_t)huart->Init.WordLength | huart->Init.Parity | huart->Init.Mode | huart->Init.OverSampling ;
1651 MODIFY_REG(huart->Instance->CR1, UART_CR1_FIELDS, tmpreg);
1652
1653 /*-------------------------- USART CR2 Configuration -----------------------*/
1654 /* Configure the UART Stop Bits: Set STOP[13:12] bits according
1655 * to huart->Init.StopBits value */
1656 MODIFY_REG(huart->Instance->CR2, USART_CR2_STOP, huart->Init.StopBits);
1657
1658 /*-------------------------- USART CR3 Configuration -----------------------*/
1659 /* Configure
1660 * - UART HardWare Flow Control: set CTSE and RTSE bits according
1661 * to huart->Init.HwFlowCtl value
1662 * - one-bit sampling method versus three samples' majority rule according
1663 * to huart->Init.OneBitSampling */
1664 tmpreg = (uint32_t)huart->Init.HwFlowCtl | huart->Init.OneBitSampling ;
1665 MODIFY_REG(huart->Instance->CR3, (USART_CR3_RTSE | USART_CR3_CTSE | USART_CR3_ONEBIT), tmpreg);
1666
1667 /*-------------------------- USART BRR Configuration -----------------------*/
1668 __HAL_UART_GETCLOCKSOURCE(huart, clocksource);
1669
1670 /* Check the Over Sampling to set Baud Rate Register */
1671 if (huart->Init.OverSampling == UART_OVERSAMPLING_8)
1672 {
1673 switch (clocksource)
1674 {
1675 case UART_CLOCKSOURCE_PCLK1:
1676 usartdiv = (uint16_t)(__DIV_SAMPLING8(HAL_RCC_GetPCLK1Freq(), huart->Init.BaudRate));
1677 break;
1678 case UART_CLOCKSOURCE_HSI:
1679 usartdiv = (uint16_t)(__DIV_SAMPLING8(HSI_VALUE, huart->Init.BaudRate));
1680 break;
1681 case UART_CLOCKSOURCE_SYSCLK:
1682 usartdiv = (uint16_t)(__DIV_SAMPLING8(HAL_RCC_GetSysClockFreq(), huart->Init.BaudRate));
1683 break;
1684 case UART_CLOCKSOURCE_LSE:
1685 usartdiv = (uint16_t)(__DIV_SAMPLING8(LSE_VALUE, huart->Init.BaudRate));
1686 break;
1687 case UART_CLOCKSOURCE_UNDEFINED:
1688 default:
1689 ret = HAL_ERROR;
1690 break;
1691 }
1692
1693 brrtemp = usartdiv & 0xFFF0;
1694 brrtemp |= (uint16_t) ((usartdiv & (uint16_t)0x000F) >> 1U);
1695 huart->Instance->BRR = brrtemp;
1696 }
1697 else
1698 {
1699 switch (clocksource)
1700 {
1701 case UART_CLOCKSOURCE_PCLK1:
1702 huart->Instance->BRR = (uint16_t)(__DIV_SAMPLING16(HAL_RCC_GetPCLK1Freq(), huart->Init.BaudRate));
1703 break;
1704 case UART_CLOCKSOURCE_HSI:
1705 huart->Instance->BRR = (uint16_t)(__DIV_SAMPLING16(HSI_VALUE, huart->Init.BaudRate));
1706 break;
1707 case UART_CLOCKSOURCE_SYSCLK:
1708 huart->Instance->BRR = (uint16_t)(__DIV_SAMPLING16(HAL_RCC_GetSysClockFreq(), huart->Init.BaudRate));
1709 break;
1710 case UART_CLOCKSOURCE_LSE:
1711 huart->Instance->BRR = (uint16_t)(__DIV_SAMPLING16(LSE_VALUE, huart->Init.BaudRate));
1712 break;
1713 case UART_CLOCKSOURCE_UNDEFINED:
1714 default:
1715 ret = HAL_ERROR;
1716 break;
1717 }
1718 }
1719
1720 return ret;
1721
1722 }
1723
1724 /**
1725 * @brief Configure the UART peripheral advanced feautures
1726 * @param huart: uart handle
1727 * @retval None
1728 */
1729 void UART_AdvFeatureConfig(UART_HandleTypeDef *huart)
1730 {
1731 /* Check whether the set of advanced features to configure is properly set */
1732 assert_param(IS_UART_ADVFEATURE_INIT(huart->AdvancedInit.AdvFeatureInit));
1733
1734 /* if required, configure TX pin active level inversion */
1735 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_TXINVERT_INIT))
1736 {
1737 assert_param(IS_UART_ADVFEATURE_TXINV(huart->AdvancedInit.TxPinLevelInvert));
1738 MODIFY_REG(huart->Instance->CR2, USART_CR2_TXINV, huart->AdvancedInit.TxPinLevelInvert);
1739 }
1740
1741 /* if required, configure RX pin active level inversion */
1742 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_RXINVERT_INIT))
1743 {
1744 assert_param(IS_UART_ADVFEATURE_RXINV(huart->AdvancedInit.RxPinLevelInvert));
1745 MODIFY_REG(huart->Instance->CR2, USART_CR2_RXINV, huart->AdvancedInit.RxPinLevelInvert);
1746 }
1747
1748 /* if required, configure data inversion */
1749 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_DATAINVERT_INIT))
1750 {
1751 assert_param(IS_UART_ADVFEATURE_DATAINV(huart->AdvancedInit.DataInvert));
1752 MODIFY_REG(huart->Instance->CR2, USART_CR2_DATAINV, huart->AdvancedInit.DataInvert);
1753 }
1754
1755 /* if required, configure RX/TX pins swap */
1756 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_SWAP_INIT))
1757 {
1758 assert_param(IS_UART_ADVFEATURE_SWAP(huart->AdvancedInit.Swap));
1759 MODIFY_REG(huart->Instance->CR2, USART_CR2_SWAP, huart->AdvancedInit.Swap);
1760 }
1761
1762 /* if required, configure RX overrun detection disabling */
1763 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_RXOVERRUNDISABLE_INIT))
1764 {
1765 assert_param(IS_UART_OVERRUN(huart->AdvancedInit.OverrunDisable));
1766 MODIFY_REG(huart->Instance->CR3, USART_CR3_OVRDIS, huart->AdvancedInit.OverrunDisable);
1767 }
1768
1769 /* if required, configure DMA disabling on reception error */
1770 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_DMADISABLEONERROR_INIT))
1771 {
1772 assert_param(IS_UART_ADVFEATURE_DMAONRXERROR(huart->AdvancedInit.DMADisableonRxError));
1773 MODIFY_REG(huart->Instance->CR3, USART_CR3_DDRE, huart->AdvancedInit.DMADisableonRxError);
1774 }
1775
1776 /* if required, configure auto Baud rate detection scheme */
1777 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_AUTOBAUDRATE_INIT))
1778 {
1779 assert_param(IS_USART_AUTOBAUDRATE_DETECTION_INSTANCE(huart->Instance));
1780 assert_param(IS_UART_ADVFEATURE_AUTOBAUDRATE(huart->AdvancedInit.AutoBaudRateEnable));
1781 MODIFY_REG(huart->Instance->CR2, USART_CR2_ABREN, huart->AdvancedInit.AutoBaudRateEnable);
1782 /* set auto Baudrate detection parameters if detection is enabled */
1783 if (huart->AdvancedInit.AutoBaudRateEnable == UART_ADVFEATURE_AUTOBAUDRATE_ENABLE)
1784 {
1785 assert_param(IS_UART_ADVFEATURE_AUTOBAUDRATEMODE(huart->AdvancedInit.AutoBaudRateMode));
1786 MODIFY_REG(huart->Instance->CR2, USART_CR2_ABRMODE, huart->AdvancedInit.AutoBaudRateMode);
1787 }
1788 }
1789
1790 /* if required, configure MSB first on communication line */
1791 if (HAL_IS_BIT_SET(huart->AdvancedInit.AdvFeatureInit, UART_ADVFEATURE_MSBFIRST_INIT))
1792 {
1793 assert_param(IS_UART_ADVFEATURE_MSBFIRST(huart->AdvancedInit.MSBFirst));
1794 MODIFY_REG(huart->Instance->CR2, USART_CR2_MSBFIRST, huart->AdvancedInit.MSBFirst);
1795 }
1796 }
1797
1798 /**
1799 * @}
1800 */
1801
1802 #endif /* HAL_UART_MODULE_ENABLED */
1803 /**
1804 * @}
1805 */
1806
1807 /**
1808 * @}
1809 */
1810
1811 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
custom keymap for my minivan; forked from http://github.com/evangs/tmk_keyboard
Imprint / Impressum