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