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