]> git.gir.st - tmk_keyboard.git/blob - tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_STM/TARGET_STM32F0/stm32f0xx_hal_irda.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_irda.c
1 /**
2 ******************************************************************************
3 * @file stm32f0xx_hal_irda.c
4 * @author MCD Application Team
5 * @version V1.2.0
6 * @date 11-December-2014
7 * @brief IRDA HAL module driver.
8 * This file provides firmware functions to manage the following
9 * functionalities of the IrDA (Infrared Data Association) Peripheral
10 * (IRDA)
11 * + Initialization and de-initialization function
12 * + IO operation function
13 * + Peripheral Control function
14 *
15 *
16 @verbatim
17 ===============================================================================
18 ##### How to use this driver #####
19 ===============================================================================
20 [..]
21 The IRDA HAL driver can be used as follows:
22
23 (#) Declare a IRDA_HandleTypeDef handle structure.
24 (#) Initialize the IRDA low level resources by implementing the HAL_IRDA_MspInit() API:
25 (##) Enable the USARTx interface clock.
26 (##) IRDA pins configuration:
27 (+++) Enable the clock for the IRDA GPIOs.
28 (+++) Configure these IRDA pins as alternate function pull-up.
29 (##) NVIC configuration if you need to use interrupt process (HAL_IRDA_Transmit_IT()
30 and HAL_IRDA_Receive_IT() APIs):
31 (+++) Configure the USARTx interrupt priority.
32 (+++) Enable the NVIC USART IRQ handle.
33 (##) DMA Configuration if you need to use DMA process (HAL_IRDA_Transmit_DMA()
34 and HAL_IRDA_Receive_DMA() APIs):
35 (+++) Declare a DMA handle structure for the Tx/Rx channel.
36 (+++) Enable the DMAx interface clock.
37 (+++) Configure the declared DMA handle structure with the required Tx/Rx parameters.
38 (+++) Configure the DMA Tx/Rx channel.
39 (+++) Associate the initilalized DMA handle to the IRDA DMA Tx/Rx handle.
40 (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx/Rx channel.
41
42 (#) Program the Baud Rate, Word Length and Parity and Mode(Receiver/Transmitter),
43 the normal or low power mode and the clock prescaler in the hirda Init structure.
44
45 (#) Initialize the IRDA registers by calling the HAL_IRDA_Init() API:
46 (++) This API configures also the low level Hardware (GPIO, CLOCK, CORTEX...etc)
47 by calling the customed HAL_IRDA_MspInit() API.
48
49 -@@- The specific IRDA interrupts (Transmission complete interrupt,
50 RXNE interrupt and Error Interrupts) will be managed using the macros
51 __HAL_IRDA_ENABLE_IT() and __HAL_IRDA_DISABLE_IT() inside the transmit and receive process.
52
53 (#) Three operation modes are available within this driver :
54
55 *** Polling mode IO operation ***
56 =================================
57 [..]
58 (+) Send an amount of data in blocking mode using HAL_IRDA_Transmit()
59 (+) Receive an amount of data in blocking mode using HAL_IRDA_Receive()
60
61 *** Interrupt mode IO operation ***
62 ===================================
63 [..]
64 (+) Send an amount of data in non blocking mode using HAL_IRDA_Transmit_IT()
65 (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
66 add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
67 (+) Receive an amount of data in non blocking mode using HAL_IRDA_Receive_IT()
68 (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
69 add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
70 (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
71 add his own code by customization of function pointer HAL_IRDA_ErrorCallback
72
73 *** DMA mode IO operation ***
74 ==============================
75 [..]
76 (+) Send an amount of data in non blocking mode (DMA) using HAL_IRDA_Transmit_DMA()
77 (+) At transmission end of transfer HAL_IRDA_TxCpltCallback is executed and user can
78 add his own code by customization of function pointer HAL_IRDA_TxCpltCallback
79 (+) Receive an amount of data in non blocking mode (DMA) using HAL_IRDA_Receive_DMA()
80 (+) At reception end of transfer HAL_IRDA_RxCpltCallback is executed and user can
81 add his own code by customization of function pointer HAL_IRDA_RxCpltCallback
82 (+) In case of transfer Error, HAL_IRDA_ErrorCallback() function is executed and user can
83 add his own code by customization of function pointer HAL_IRDA_ErrorCallback
84
85 *** IRDA HAL driver macros list ***
86 ====================================
87 [..]
88 Below the list of most used macros in IRDA HAL driver.
89
90 (+) __HAL_IRDA_ENABLE: Enable the IRDA peripheral
91 (+) __HAL_IRDA_DISABLE: Disable the IRDA peripheral
92 (+) __HAL_IRDA_GET_FLAG : Check whether the specified IRDA flag is set or not
93 (+) __HAL_IRDA_CLEAR_FLAG : Clear the specified IRDA pending flag
94 (+) __HAL_IRDA_ENABLE_IT: Enable the specified IRDA interrupt
95 (+) __HAL_IRDA_DISABLE_IT: Disable the specified IRDA interrupt
96
97 [..]
98 (@) You can refer to the IRDA HAL driver header file for more useful macros
99
100 @endverbatim
101 ******************************************************************************
102 * @attention
103 *
104 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
105 *
106 * Redistribution and use in source and binary forms, with or without modification,
107 * are permitted provided that the following conditions are met:
108 * 1. Redistributions of source code must retain the above copyright notice,
109 * this list of conditions and the following disclaimer.
110 * 2. Redistributions in binary form must reproduce the above copyright notice,
111 * this list of conditions and the following disclaimer in the documentation
112 * and/or other materials provided with the distribution.
113 * 3. Neither the name of STMicroelectronics nor the names of its contributors
114 * may be used to endorse or promote products derived from this software
115 * without specific prior written permission.
116 *
117 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
118 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
119 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
120 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
121 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
122 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
123 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
124 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
125 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
126 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
127 *
128 ******************************************************************************
129 */
130
131 /* Includes ------------------------------------------------------------------*/
132 #include "stm32f0xx_hal.h"
133
134 #ifdef HAL_IRDA_MODULE_ENABLED
135
136 #if !defined(STM32F030x6) && !defined(STM32F030x8) && !defined(STM32F070x6) && !defined(STM32F070xB) && !defined(STM32F030xC)
137
138 /** @addtogroup STM32F0xx_HAL_Driver
139 * @{
140 */
141
142 /** @defgroup IRDA IRDA HAL module driver
143 * @brief HAL IRDA module driver
144 * @{
145 */
146
147 /* Private typedef -----------------------------------------------------------*/
148 /* Private define ------------------------------------------------------------*/
149 /** @defgroup IRDA_Private_Constants IRDA Private Constants
150 * @{
151 */
152 #define TEACK_REACK_TIMEOUT 1000
153 #define IRDA_TXDMA_TIMEOUTVALUE 22000
154 #define IRDA_TIMEOUT_VALUE 22000
155 #define IRDA_CR1_FIELDS ((uint32_t)(USART_CR1_M | USART_CR1_PCE \
156 | USART_CR1_PS | USART_CR1_TE | USART_CR1_RE))
157 /**
158 * @}
159 */
160
161 /* Private macro -------------------------------------------------------------*/
162 /* Private variables ---------------------------------------------------------*/
163 /* Private function prototypes -----------------------------------------------*/
164 /** @defgroup IRDA_Private_Functions IRDA Private Functions
165 * @{
166 */
167 static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma);
168 static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
169 static void IRDA_DMAError(DMA_HandleTypeDef *hdma);
170 static HAL_StatusTypeDef IRDA_SetConfig(IRDA_HandleTypeDef *hirda);
171 static HAL_StatusTypeDef IRDA_CheckIdleState(IRDA_HandleTypeDef *hirda);
172 static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout);
173 static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda);
174 static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda);
175 static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda);
176 /**
177 * @}
178 */
179 /* Exported functions ---------------------------------------------------------*/
180
181 /** @defgroup IRDA_Exported_Functions IRDA Exported Functions
182 * @{
183 */
184
185 /** @defgroup IRDA_Exported_Functions_Group1 Initialization and de-initialization functions
186 * @brief Initialization and Configuration functions
187 *
188 @verbatim
189 ==============================================================================
190 ##### Initialization and Configuration functions #####
191 ==============================================================================
192 [..]
193 This subsection provides a set of functions allowing to initialize the USARTx
194 in IRDA mode.
195 (+) For the asynchronous mode only these parameters can be configured:
196 (++) Baud Rate
197 (++) Word Length
198 (++) Parity: If the parity is enabled, then the MSB bit of the data written
199 in the data register is transmitted but is changed by the parity bit.
200 Depending on the frame length defined by the M bit (8-bits or 9-bits)
201 or by the M1 and M0 bits (7-bit, 8-bit or 9-bit),
202 the possible IRDA frame formats are as listed in the following table:
203 +---------------------------------------------------------------+
204 | M bit | PCE bit | IRDA frame |
205 |-----------|-----------|---------------------------------------|
206 | 0 | 0 | | SB | 8-bit data | STB | |
207 |-----------|-----------|---------------------------------------|
208 | 0 | 1 | | SB | 7-bit data | PB | STB | |
209 |-----------|-----------|---------------------------------------|
210 | 1 | 0 | | SB | 9-bit data | STB | |
211 |-----------|-----------|---------------------------------------|
212 | 1 | 1 | | SB | 8-bit data | PB | STB | |
213 +---------------------------------------------------------------+
214 | M1M0 bits | PCE bit | IRDA frame |
215 |-----------------------|---------------------------------------|
216 | 10 | 0 | | SB | 7-bit data | STB | |
217 |-----------|-----------|---------------------------------------|
218 | 10 | 1 | | SB | 6-bit data | PB | STB | |
219 +---------------------------------------------------------------+
220
221 (++) Power mode
222 (++) Prescaler setting
223 (++) Receiver/transmitter modes
224
225 [..]
226 The HAL_IRDA_Init() function follows IRDA configuration procedures
227 (details for the procedures are available in reference manual).
228
229 @endverbatim
230 * @{
231 */
232
233 /**
234 * @brief Initializes the IRDA mode according to the specified
235 * parameters in the IRDA_InitTypeDef and creates the associated handle .
236 * @param hirda: IRDA handle
237 * @retval HAL status
238 */
239 HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda)
240 {
241 /* Check the IRDA handle allocation */
242 if(hirda == NULL)
243 {
244 return HAL_ERROR;
245 }
246
247 /* Check the USART/UART associated to the IRDA handle */
248 assert_param(IS_IRDA_INSTANCE(hirda->Instance));
249
250 if(hirda->State == HAL_IRDA_STATE_RESET)
251 {
252 /* Init the low level hardware : GPIO, CLOCK */
253 HAL_IRDA_MspInit(hirda);
254 }
255
256 hirda->State = HAL_IRDA_STATE_BUSY;
257
258 /* Disable the Peripheral to update the configuration registers */
259 __HAL_IRDA_DISABLE(hirda);
260
261 /* Set the IRDA Communication parameters */
262 if (IRDA_SetConfig(hirda) == HAL_ERROR)
263 {
264 return HAL_ERROR;
265 }
266
267 /* In IRDA mode, the following bits must be kept cleared:
268 - LINEN, STOP and CLKEN bits in the USART_CR2 register,
269 - SCEN and HDSEL bits in the USART_CR3 register.*/
270 hirda->Instance->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN | USART_CR2_STOP);
271 hirda->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL);
272
273 /* set the UART/USART in IRDA mode */
274 hirda->Instance->CR3 |= USART_CR3_IREN;
275
276 /* Enable the Peripheral */
277 __HAL_IRDA_ENABLE(hirda);
278
279 /* TEACK and/or REACK to check before moving hirda->State to Ready */
280 return (IRDA_CheckIdleState(hirda));
281 }
282
283 /**
284 * @brief DeInitializes the IRDA peripheral
285 * @param hirda: IRDA handle
286 * @retval HAL status
287 */
288 HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda)
289 {
290 /* Check the IRDA handle allocation */
291 if(hirda == NULL)
292 {
293 return HAL_ERROR;
294 }
295
296 /* Check the USART/UART associated to the IRDA handle */
297 assert_param(IS_IRDA_INSTANCE(hirda->Instance));
298
299 hirda->State = HAL_IRDA_STATE_BUSY;
300
301 /* DeInit the low level hardware */
302 HAL_IRDA_MspDeInit(hirda);
303 /* Disable the Peripheral */
304 __HAL_IRDA_DISABLE(hirda);
305
306 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
307 hirda->State = HAL_IRDA_STATE_RESET;
308
309 /* Process Unlock */
310 __HAL_UNLOCK(hirda);
311
312 return HAL_OK;
313 }
314
315 /**
316 * @brief IRDA MSP Init
317 * @param hirda: IRDA handle
318 * @retval None
319 */
320 __weak void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda)
321 {
322 /* NOTE : This function should not be modified, when the callback is needed,
323 the HAL_IRDA_MspInit can be implemented in the user file
324 */
325 }
326
327 /**
328 * @brief IRDA MSP DeInit
329 * @param hirda: IRDA handle
330 * @retval None
331 */
332 __weak void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda)
333 {
334 /* NOTE : This function should not be modified, when the callback is needed,
335 the HAL_IRDA_MspDeInit can be implemented in the user file
336 */
337 }
338
339 /**
340 * @}
341 */
342
343 /** @defgroup IRDA_Exported_Functions_Group2 IO operation functions
344 * @brief IRDA Transmit and Receive functions
345 *
346 @verbatim
347 ===============================================================================
348 ##### IO operation functions #####
349 ===============================================================================
350 [..]
351 This subsection provides a set of functions allowing to manage the IRDA data transfers.
352
353 [..]
354 IrDA is a half duplex communication protocol. If the Transmitter is busy, any data
355 on the IrDA receive line will be ignored by the IrDA decoder and if the Receiver
356 is busy, data on the TX from the USART to IrDA will not be encoded by IrDA.
357 While receiving data, transmission should be avoided as the data to be transmitted
358 could be corrupted.
359
360 (#) There are two modes of transfer:
361 (++) Blocking mode: The communication is performed in polling mode.
362 The HAL status of all data processing is returned by the same function
363 after finishing transfer.
364 (++) Non Blocking mode: The communication is performed using Interrupts
365 or DMA, these API s return the HAL status.
366 The end of the data processing will be indicated through the
367 dedicated IRDA IRQ when using Interrupt mode or the DMA IRQ when
368 using DMA mode.
369 The HAL_IRDA_TxCpltCallback(), HAL_IRDA_RxCpltCallback() user callbacks
370 will be executed respectivelly at the end of the Transmit or Receive process
371 The HAL_IRDA_ErrorCallback() user callback will be executed when a communication error is detected
372
373 (#) Blocking mode API s are :
374 (++) HAL_IRDA_Transmit()
375 (++) HAL_IRDA_Receive()
376
377 (#) Non Blocking mode API s with Interrupt are :
378 (++) HAL_IRDA_Transmit_IT()
379 (++) HAL_IRDA_Receive_IT()
380 (++) HAL_IRDA_IRQHandler()
381 (++) IRDA_Transmit_IT()
382 (++) IRDA_Receive_IT()
383
384 (#) Non Blocking mode functions with DMA are :
385 (++) HAL_IRDA_Transmit_DMA()
386 (++) HAL_IRDA_Receive_DMA()
387
388 (#) A set of Transfer Complete Callbacks are provided in Non Blocking mode:
389 (++) HAL_IRDA_TxCpltCallback()
390 (++) HAL_IRDA_RxCpltCallback()
391 (++) HAL_IRDA_ErrorCallback()
392
393 @endverbatim
394 * @{
395 */
396
397 /**
398 * @brief Send an amount of data in blocking mode
399 * @param hirda: IRDA handle
400 * @param pData: pointer to data buffer
401 * @param Size: amount of data to be sent
402 * @param Timeout: Duration of the timeout
403 * @retval HAL status
404 */
405 HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)
406 {
407 uint16_t* tmp;
408
409 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_RX))
410 {
411 if((pData == NULL) || (Size == 0))
412 {
413 return HAL_ERROR;
414 }
415
416 /* Process Locked */
417 __HAL_LOCK(hirda);
418 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
419
420 if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
421 {
422 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
423 }
424 else
425 {
426 hirda->State = HAL_IRDA_STATE_BUSY_TX;
427 }
428
429 hirda->TxXferSize = Size;
430 hirda->TxXferCount = Size;
431 while(hirda->TxXferCount > 0)
432 {
433 hirda->TxXferCount--;
434
435 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TXE, RESET, Timeout) != HAL_OK)
436 {
437 return HAL_TIMEOUT;
438 }
439 if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
440 {
441 tmp = (uint16_t*) pData;
442 hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF);
443 pData += 2;
444 }
445 else
446 {
447 hirda->Instance->TDR = (*pData++ & (uint8_t)0xFF);
448 }
449 }
450
451 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_TC, RESET, Timeout) != HAL_OK)
452 {
453 return HAL_TIMEOUT;
454 }
455
456 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
457 {
458 hirda->State = HAL_IRDA_STATE_BUSY_RX;
459 }
460 else
461 {
462 hirda->State = HAL_IRDA_STATE_READY;
463 }
464
465 /* Process Unlocked */
466 __HAL_UNLOCK(hirda);
467
468 return HAL_OK;
469 }
470 else
471 {
472 return HAL_BUSY;
473 }
474 }
475
476 /**
477 * @brief Receive an amount of data in blocking mode
478 * @param hirda: IRDA handle
479 * @param pData: pointer to data buffer
480 * @param Size: amount of data to be received
481 * @param Timeout: Duration of the timeout
482 * @retval HAL status
483 */
484 HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout)
485 {
486 uint16_t* tmp;
487 uint16_t uhMask;
488
489 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_TX))
490 {
491 if((pData == NULL) || (Size == 0))
492 {
493 return HAL_ERROR;
494 }
495
496 /* Process Locked */
497 __HAL_LOCK(hirda);
498 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
499
500 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
501 {
502 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
503 }
504 else
505 {
506 hirda->State = HAL_IRDA_STATE_BUSY_RX;
507 }
508
509 hirda->RxXferSize = Size;
510 hirda->RxXferCount = Size;
511
512 /* Computation of the mask to apply to the RDR register
513 of the UART associated to the IRDA */
514 __HAL_IRDA_MASK_COMPUTATION(hirda);
515 uhMask = hirda->Mask;
516
517 /* Check data remaining to be received */
518 while(hirda->RxXferCount > 0)
519 {
520 hirda->RxXferCount--;
521
522 if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_FLAG_RXNE, RESET, Timeout) != HAL_OK)
523 {
524 return HAL_TIMEOUT;
525 }
526 if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
527 {
528 tmp = (uint16_t*) pData ;
529 *tmp = (uint16_t)(hirda->Instance->RDR & uhMask);
530 pData +=2;
531 }
532 else
533 {
534 *pData++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask);
535 }
536 }
537
538 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
539 {
540 hirda->State = HAL_IRDA_STATE_BUSY_TX;
541 }
542 else
543 {
544 hirda->State = HAL_IRDA_STATE_READY;
545 }
546
547 /* Process Unlocked */
548 __HAL_UNLOCK(hirda);
549
550 return HAL_OK;
551 }
552 else
553 {
554 return HAL_BUSY;
555 }
556 }
557
558 /**
559 * @brief Send an amount of data in interrupt mode
560 * @param hirda: IRDA handle
561 * @param pData: pointer to data buffer
562 * @param Size: amount of data to be sent
563 * @retval HAL status
564 */
565 HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
566 {
567 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_RX))
568 {
569 if((pData == NULL) || (Size == 0))
570 {
571 return HAL_ERROR;
572 }
573
574 /* Process Locked */
575 __HAL_LOCK(hirda);
576
577 hirda->pTxBuffPtr = pData;
578 hirda->TxXferSize = Size;
579 hirda->TxXferCount = Size;
580
581 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
582 if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
583 {
584 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
585 }
586 else
587 {
588 hirda->State = HAL_IRDA_STATE_BUSY_TX;
589 }
590
591 /* Enable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
592 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_ERR);
593
594 /* Process Unlocked */
595 __HAL_UNLOCK(hirda);
596
597 /* Enable the IRDA Transmit Data Register Empty Interrupt */
598 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TXE);
599
600 return HAL_OK;
601 }
602 else
603 {
604 return HAL_BUSY;
605 }
606 }
607
608 /**
609 * @brief Receive an amount of data in interrupt mode
610 * @param hirda: IRDA handle
611 * @param pData: pointer to data buffer
612 * @param Size: amount of data to be received
613 * @retval HAL status
614 */
615 HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
616 {
617 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_TX))
618 {
619 if((pData == NULL) || (Size == 0))
620 {
621 return HAL_ERROR;
622 }
623
624 /* Process Locked */
625 __HAL_LOCK(hirda);
626
627 hirda->pRxBuffPtr = pData;
628 hirda->RxXferSize = Size;
629 hirda->RxXferCount = Size;
630
631 /* Computation of the mask to apply to the RDR register
632 of the UART associated to the IRDA */
633 __HAL_IRDA_MASK_COMPUTATION(hirda);
634
635 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
636 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
637 {
638 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
639 }
640 else
641 {
642 hirda->State = HAL_IRDA_STATE_BUSY_RX;
643 }
644
645 /* Enable the IRDA Parity Error Interrupt */
646 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_PE);
647
648 /* Enable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
649 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_ERR);
650
651 /* Process Unlocked */
652 __HAL_UNLOCK(hirda);
653
654 /* Enable the IRDA Data Register not empty Interrupt */
655 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_RXNE);
656
657 return HAL_OK;
658 }
659 else
660 {
661 return HAL_BUSY;
662 }
663 }
664
665 /**
666 * @brief Send an amount of data in DMA mode
667 * @param hirda: IRDA handle
668 * @param pData: pointer to data buffer
669 * @param Size: amount of data to be sent
670 * @retval HAL status
671 */
672 HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
673 {
674 uint32_t *tmp;
675
676 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_RX))
677 {
678 if((pData == NULL) || (Size == 0))
679 {
680 return HAL_ERROR;
681 }
682
683 /* Process Locked */
684 __HAL_LOCK(hirda);
685
686 hirda->pTxBuffPtr = pData;
687 hirda->TxXferSize = Size;
688 hirda->TxXferCount = Size;
689
690 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
691
692 if(hirda->State == HAL_IRDA_STATE_BUSY_RX)
693 {
694 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
695 }
696 else
697 {
698 hirda->State = HAL_IRDA_STATE_BUSY_TX;
699 }
700
701 /* Set the IRDA DMA transfer complete callback */
702 hirda->hdmatx->XferCpltCallback = IRDA_DMATransmitCplt;
703
704 /* Set the DMA error callback */
705 hirda->hdmatx->XferErrorCallback = IRDA_DMAError;
706
707 /* Enable the IRDA transmit DMA channel */
708 tmp = (uint32_t*)&pData;
709 HAL_DMA_Start_IT(hirda->hdmatx, *(uint32_t*)tmp, (uint32_t)&hirda->Instance->TDR, Size);
710
711 /* Enable the DMA transfer for transmit request by setting the DMAT bit
712 in the IRDA CR3 register */
713 hirda->Instance->CR3 |= USART_CR3_DMAT;
714
715 /* Process Unlocked */
716 __HAL_UNLOCK(hirda);
717
718 return HAL_OK;
719 }
720 else
721 {
722 return HAL_BUSY;
723 }
724 }
725
726 /**
727 * @brief Receive an amount of data in DMA mode
728 * @param hirda: IRDA handle
729 * @param pData: pointer to data buffer
730 * @param Size: amount of data to be received
731 * @note When the IRDA parity is enabled (PCE = 1), the received data contain
732 * the parity bit (MSB position)
733 * @retval HAL status
734 */
735 HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size)
736 {
737 uint32_t *tmp;
738
739 if ((hirda->State == HAL_IRDA_STATE_READY) || (hirda->State == HAL_IRDA_STATE_BUSY_TX))
740 {
741 if((pData == NULL) || (Size == 0))
742 {
743 return HAL_ERROR;
744 }
745
746 /* Process Locked */
747 __HAL_LOCK(hirda);
748
749 hirda->pRxBuffPtr = pData;
750 hirda->RxXferSize = Size;
751
752 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
753 if(hirda->State == HAL_IRDA_STATE_BUSY_TX)
754 {
755 hirda->State = HAL_IRDA_STATE_BUSY_TX_RX;
756 }
757 else
758 {
759 hirda->State = HAL_IRDA_STATE_BUSY_RX;
760 }
761
762 /* Set the IRDA DMA transfer complete callback */
763 hirda->hdmarx->XferCpltCallback = IRDA_DMAReceiveCplt;
764
765 /* Set the DMA error callback */
766 hirda->hdmarx->XferErrorCallback = IRDA_DMAError;
767
768 /* Enable the DMA channel */
769 tmp = (uint32_t*)&pData;
770 HAL_DMA_Start_IT(hirda->hdmarx, (uint32_t)&hirda->Instance->RDR, *(uint32_t*)tmp, Size);
771
772 /* Enable the DMA transfer for the receiver request by setting the DMAR bit
773 in the IRDA CR3 register */
774 hirda->Instance->CR3 |= USART_CR3_DMAR;
775
776 /* Process Unlocked */
777 __HAL_UNLOCK(hirda);
778
779 return HAL_OK;
780 }
781 else
782 {
783 return HAL_BUSY;
784 }
785 }
786
787 /**
788 * @brief This function handles IRDA interrupt request.
789 * @param hirda: IRDA handle
790 * @retval None
791 */
792 void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda)
793 {
794 /* IRDA parity error interrupt occurred -------------------------------------*/
795 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_PE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_PE) != RESET))
796 {
797 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_PEF);
798
799 hirda->ErrorCode |= HAL_IRDA_ERROR_PE;
800 /* Set the IRDA state ready to be able to start again the process */
801 hirda->State = HAL_IRDA_STATE_READY;
802 }
803
804 /* IRDA frame error interrupt occured --------------------------------------*/
805 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_FE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
806 {
807 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_FEF);
808
809 hirda->ErrorCode |= HAL_IRDA_ERROR_FE;
810 /* Set the IRDA state ready to be able to start again the process */
811 hirda->State = HAL_IRDA_STATE_READY;
812 }
813
814 /* IRDA noise error interrupt occured --------------------------------------*/
815 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_NE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
816 {
817 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_NEF);
818
819 hirda->ErrorCode |= HAL_IRDA_ERROR_NE;
820 /* Set the IRDA state ready to be able to start again the process */
821 hirda->State = HAL_IRDA_STATE_READY;
822 }
823
824 /* IRDA Over-Run interrupt occured -----------------------------------------*/
825 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_ORE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR) != RESET))
826 {
827 __HAL_IRDA_CLEAR_IT(hirda, IRDA_CLEAR_OREF);
828
829 hirda->ErrorCode |= HAL_IRDA_ERROR_ORE;
830 /* Set the IRDA state ready to be able to start again the process */
831 hirda->State = HAL_IRDA_STATE_READY;
832 }
833
834 /* Call IRDA Error Call back function if need be --------------------------*/
835 if(hirda->ErrorCode != HAL_IRDA_ERROR_NONE)
836 {
837 HAL_IRDA_ErrorCallback(hirda);
838 }
839
840 /* IRDA in mode Receiver ---------------------------------------------------*/
841 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_RXNE) != RESET) && (__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_RXNE) != RESET))
842 {
843 IRDA_Receive_IT(hirda);
844 /* Clear RXNE interrupt flag */
845 __HAL_IRDA_SEND_REQ(hirda, IRDA_RXDATA_FLUSH_REQUEST);
846 }
847
848
849 /* IRDA in mode Transmitter ------------------------------------------------*/
850 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_TXE) != RESET) &&(__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TXE) != RESET))
851 {
852 IRDA_Transmit_IT(hirda);
853 }
854
855 /* IRDA in mode Transmitter (transmission end) -----------------------------*/
856 if((__HAL_IRDA_GET_IT(hirda, IRDA_IT_TC) != RESET) &&(__HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TC) != RESET))
857 {
858 IRDA_EndTransmit_IT(hirda);
859 }
860
861 }
862 /**
863 * @}
864 */
865
866 /**
867 * @}
868 */
869
870 /** @addtogroup IRDA_Private_Functions IRDA Private Functions
871 * @{
872 */
873
874 /**
875 * @brief DMA IRDA Tx transfer completed callback
876 * @param hdma: DMA handle
877 * @retval None
878 */
879 static void IRDA_DMATransmitCplt(DMA_HandleTypeDef *hdma)
880 {
881 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
882 hirda->TxXferCount = 0;
883
884 /* Disable the DMA transfer for transmit request by resetting the DMAT bit
885 in the IRDA CR3 register */
886 hirda->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_DMAT);
887
888 /* Enable the IRDA Transmit Complete Interrupt */
889 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC);
890 }
891
892 /**
893 * @brief DMA IRDA Rx Transfer completed callback
894 * @param hdma: DMA handle
895 * @retval None
896 */
897 static void IRDA_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
898 {
899 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
900 hirda->RxXferCount = 0;
901
902 /* Disable the DMA transfer for the receiver request by resetting the DMAR bit
903 in the IRDA CR3 register */
904 hirda->Instance->CR3 &= (uint16_t)~((uint16_t)USART_CR3_DMAR);
905
906 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
907 {
908 hirda->State = HAL_IRDA_STATE_BUSY_TX;
909 }
910 else
911 {
912 hirda->State = HAL_IRDA_STATE_READY;
913 }
914
915 HAL_IRDA_RxCpltCallback(hirda);
916 }
917
918 /**
919 * @brief DMA IRDA communication error callback
920 * @param hdma: DMA handle
921 * @retval None
922 */
923 static void IRDA_DMAError(DMA_HandleTypeDef *hdma)
924 {
925 IRDA_HandleTypeDef* hirda = ( IRDA_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent;
926 hirda->RxXferCount = 0;
927 hirda->TxXferCount = 0;
928 hirda->State= HAL_IRDA_STATE_READY;
929 hirda->ErrorCode |= HAL_IRDA_ERROR_DMA;
930 HAL_IRDA_ErrorCallback(hirda);
931 }
932 /**
933 * @}
934 */
935
936 /** @addtogroup IRDA_Exported_Functions IRDA Exported Functions
937 * @{
938 */
939
940 /** @addtogroup IRDA_Exported_Functions_Group2 IO operation functions
941 * @{
942 */
943
944 /**
945 * @brief Tx Transfer completed callback
946 * @param hirda: irda handle
947 * @retval None
948 */
949 __weak void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda)
950 {
951 /* NOTE : This function should not be modified, when the callback is needed,
952 the HAL_IRDA_TxCpltCallback can be implemented in the user file
953 */
954 }
955
956 /**
957 * @brief Rx Transfer completed callback
958 * @param hirda: irda handle
959 * @retval None
960 */
961 __weak void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda)
962 {
963 /* NOTE : This function should not be modified, when the callback is needed,
964 the HAL_IRDA_TxCpltCallback can be implemented in the user file
965 */
966 }
967
968 /**
969 * @brief IRDA error callback
970 * @param hirda: IRDA handle
971 * @retval None
972 */
973 __weak void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda)
974 {
975 /* NOTE : This function should not be modified, when the callback is needed,
976 the HAL_IRDA_ErrorCallback can be implemented in the user file
977 */
978 }
979
980 /**
981 * @}
982 */
983
984 /**
985 * @}
986 */
987
988 /** @addtogroup IRDA_Private_Functions IRDA Private Functions
989 * @{
990 */
991
992 /**
993 * @brief Receive an amount of data in non blocking mode.
994 * Function called under interruption only, once
995 * interruptions have been enabled by HAL_IRDA_Transmit_IT()
996 * @param hirda: IRDA handle
997 * @retval HAL status
998 */
999 static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda)
1000 {
1001 uint16_t* tmp;
1002
1003 if((hirda->State == HAL_IRDA_STATE_BUSY_TX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX))
1004 {
1005
1006 if(hirda->TxXferCount == 0)
1007 {
1008 /* Disable the IRDA Transmit Data Register Empty Interrupt */
1009 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
1010
1011 /* Enable the IRDA Transmit Complete Interrupt */
1012 __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC);
1013
1014 return HAL_OK;
1015 }
1016 else
1017 {
1018 if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
1019 {
1020 tmp = (uint16_t*) hirda->pTxBuffPtr;
1021 hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF);
1022 hirda->pTxBuffPtr += 2;
1023 }
1024 else
1025 {
1026 hirda->Instance->TDR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0xFF);
1027 }
1028 hirda->TxXferCount--;
1029
1030 return HAL_OK;
1031 }
1032 }
1033 else
1034 {
1035 return HAL_BUSY;
1036 }
1037 }
1038
1039 /**
1040 * @brief Wraps up transmission in non blocking mode.
1041 * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains
1042 * the configuration information for the specified IRDA module.
1043 * @retval HAL status
1044 */
1045 static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda)
1046 {
1047 /* Disable the IRDA Transmit Complete Interrupt */
1048 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TC);
1049
1050 /* Check if a receive process is ongoing or not */
1051 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
1052 {
1053 hirda->State = HAL_IRDA_STATE_BUSY_RX;
1054 }
1055 else
1056 {
1057 /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
1058 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
1059
1060 hirda->State = HAL_IRDA_STATE_READY;
1061 }
1062
1063 HAL_IRDA_TxCpltCallback(hirda);
1064
1065 return HAL_OK;
1066 }
1067
1068
1069 /**
1070 * @brief Receive an amount of data in non blocking mode.
1071 * Function called under interruption only, once
1072 * interruptions have been enabled by HAL_IRDA_Receive_IT()
1073 * @param hirda: IRDA handle
1074 * @retval HAL status
1075 */
1076 static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda)
1077 {
1078 uint16_t* tmp;
1079 uint16_t uhMask = hirda->Mask;
1080
1081 if ((hirda->State == HAL_IRDA_STATE_BUSY_RX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX))
1082 {
1083
1084 if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE))
1085 {
1086 tmp = (uint16_t*) hirda->pRxBuffPtr ;
1087 *tmp = (uint16_t)(hirda->Instance->RDR & uhMask);
1088 hirda->pRxBuffPtr +=2;
1089 }
1090 else
1091 {
1092 *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask);
1093 }
1094
1095 if(--hirda->RxXferCount == 0)
1096 {
1097 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
1098
1099 if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)
1100 {
1101 hirda->State = HAL_IRDA_STATE_BUSY_TX;
1102 }
1103 else
1104 {
1105 /* Disable the IRDA Parity Error Interrupt */
1106 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
1107
1108 /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */
1109 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
1110
1111 hirda->State = HAL_IRDA_STATE_READY;
1112 }
1113
1114 HAL_IRDA_RxCpltCallback(hirda);
1115
1116 return HAL_OK;
1117 }
1118
1119 return HAL_OK;
1120 }
1121 else
1122 {
1123 return HAL_BUSY;
1124 }
1125 }
1126
1127 /**
1128 * @}
1129 */
1130
1131 /** @addtogroup IRDA_Exported_Functions IRDA Exported Functions
1132 * @{
1133 */
1134
1135 /** @defgroup IRDA_Exported_Functions_Group3 Peripheral State and Errors functions
1136 * @brief IRDA control functions
1137 *
1138 @verbatim
1139 ===============================================================================
1140 ##### Peripheral Control functions #####
1141 ===============================================================================
1142 [..]
1143 This subsection provides a set of functions allowing to control the IRDA.
1144 (+) HAL_IRDA_GetState() API can be helpful to check in run-time the state of the IRDA peripheral.
1145 (+) IRDA_SetConfig() API is used to configure the IRDA communications parameters.
1146 @endverbatim
1147 * @{
1148 */
1149
1150 /**
1151 * @brief return the IRDA state
1152 * @param hirda: irda handle
1153 * @retval HAL state
1154 */
1155 HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda)
1156 {
1157 return hirda->State;
1158 }
1159
1160 /**
1161 * @brief Return the IRDA error code
1162 * @param hirda : pointer to a IRDA_HandleTypeDef structure that contains
1163 * the configuration information for the specified IRDA.
1164 * @retval IRDA Error Code
1165 */
1166 uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda)
1167 {
1168 return hirda->ErrorCode;
1169 }
1170
1171 /**
1172 * @}
1173 */
1174
1175 /**
1176 * @}
1177 */
1178
1179 /** @addtogroup IRDA_Private_Functions IRDA Private Functions
1180 * @{
1181 */
1182
1183 /**
1184 * @brief Configure the IRDA peripheral
1185 * @param hirda: irda handle
1186 * @retval None
1187 */
1188 static HAL_StatusTypeDef IRDA_SetConfig(IRDA_HandleTypeDef *hirda)
1189 {
1190 uint32_t tmpreg = 0x00000000;
1191 IRDA_ClockSourceTypeDef clocksource = IRDA_CLOCKSOURCE_UNDEFINED;
1192 HAL_StatusTypeDef ret = HAL_OK;
1193
1194 /* Check the communication parameters */
1195 assert_param(IS_IRDA_BAUDRATE(hirda->Init.BaudRate));
1196 assert_param(IS_IRDA_WORD_LENGTH(hirda->Init.WordLength));
1197 assert_param(IS_IRDA_PARITY(hirda->Init.Parity));
1198 assert_param(IS_IRDA_TX_RX_MODE(hirda->Init.Mode));
1199 assert_param(IS_IRDA_PRESCALER(hirda->Init.Prescaler));
1200 assert_param(IS_IRDA_POWERMODE(hirda->Init.PowerMode));
1201
1202 /*-------------------------- USART CR1 Configuration -----------------------*/
1203 /* Configure the IRDA Word Length, Parity and transfer Mode:
1204 Set the M bits according to hirda->Init.WordLength value
1205 Set PCE and PS bits according to hirda->Init.Parity value
1206 Set TE and RE bits according to hirda->Init.Mode value */
1207 tmpreg = (uint32_t)hirda->Init.WordLength | hirda->Init.Parity | hirda->Init.Mode ;
1208
1209 MODIFY_REG(hirda->Instance->CR1, IRDA_CR1_FIELDS, tmpreg);
1210
1211 /*-------------------------- USART CR3 Configuration -----------------------*/
1212 MODIFY_REG(hirda->Instance->CR3, USART_CR3_IRLP, hirda->Init.PowerMode);
1213
1214 /*-------------------------- USART GTPR Configuration ----------------------*/
1215 MODIFY_REG(hirda->Instance->GTPR, USART_GTPR_PSC, hirda->Init.Prescaler);
1216
1217 /*-------------------------- USART BRR Configuration -----------------------*/
1218 __HAL_IRDA_GETCLOCKSOURCE(hirda, clocksource);
1219 switch (clocksource)
1220 {
1221 case IRDA_CLOCKSOURCE_PCLK1:
1222 hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetPCLK1Freq() / hirda->Init.BaudRate);
1223 break;
1224 case IRDA_CLOCKSOURCE_HSI:
1225 hirda->Instance->BRR = (uint16_t)(HSI_VALUE / hirda->Init.BaudRate);
1226 break;
1227 case IRDA_CLOCKSOURCE_SYSCLK:
1228 hirda->Instance->BRR = (uint16_t)(HAL_RCC_GetSysClockFreq() / hirda->Init.BaudRate);
1229 break;
1230 case IRDA_CLOCKSOURCE_LSE:
1231 hirda->Instance->BRR = (uint16_t)(LSE_VALUE / hirda->Init.BaudRate);
1232 break;
1233 case IRDA_CLOCKSOURCE_UNDEFINED:
1234 default:
1235 ret = HAL_ERROR;
1236 break;
1237 }
1238
1239 return ret;
1240 }
1241
1242 /**
1243 * @brief Check the IRDA Idle State
1244 * @param hirda: IRDA handle
1245 * @retval HAL status
1246 */
1247 static HAL_StatusTypeDef IRDA_CheckIdleState(IRDA_HandleTypeDef *hirda)
1248 {
1249
1250 /* Initialize the IRDA ErrorCode */
1251 hirda->ErrorCode = HAL_IRDA_ERROR_NONE;
1252
1253 /* Check if the Transmitter is enabled */
1254 if((hirda->Instance->CR1 & USART_CR1_TE) == USART_CR1_TE)
1255 {
1256 /* Wait until TEACK flag is set */
1257 if(IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_TEACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
1258 {
1259 /* Timeout Occured */
1260 return HAL_TIMEOUT;
1261 }
1262 }
1263 /* Check if the Receiver is enabled */
1264 if((hirda->Instance->CR1 & USART_CR1_RE) == USART_CR1_RE)
1265 {
1266 if(IRDA_WaitOnFlagUntilTimeout(hirda, USART_ISR_REACK, RESET, TEACK_REACK_TIMEOUT) != HAL_OK)
1267 {
1268 /* Timeout Occured */
1269 return HAL_TIMEOUT;
1270 }
1271 }
1272
1273 /* Initialize the IRDA state*/
1274 hirda->State= HAL_IRDA_STATE_READY;
1275 /* Process Unlocked */
1276 __HAL_UNLOCK(hirda);
1277
1278 return HAL_OK;
1279 }
1280
1281 /**
1282 * @brief Handle IRDA Communication Timeout.
1283 * @param hirda: IRDA handle
1284 * @param Flag: specifies the IRDA flag to check.
1285 * @param Status: the flag status (SET or RESET). The function is locked in a while loop as long as the flag remains set to Status.
1286 * @param Timeout: Timeout duration
1287 * @retval HAL status
1288 */
1289 static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout)
1290 {
1291 uint32_t tickstart = HAL_GetTick();
1292
1293 /* Wait until flag is set */
1294 if(Status == RESET)
1295 {
1296 while(__HAL_IRDA_GET_FLAG(hirda, Flag) == RESET)
1297 {
1298 /* Check for the Timeout */
1299 if(Timeout != HAL_MAX_DELAY)
1300 {
1301 if((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
1302 {
1303 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
1304 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
1305 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
1306 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
1307 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
1308
1309 hirda->State= HAL_IRDA_STATE_READY;
1310
1311 /* Process Unlocked */
1312 __HAL_UNLOCK(hirda);
1313
1314 return HAL_TIMEOUT;
1315 }
1316 }
1317 }
1318 }
1319 else
1320 {
1321 while(__HAL_IRDA_GET_FLAG(hirda, Flag) != RESET)
1322 {
1323 /* Check for the Timeout */
1324 if(Timeout != HAL_MAX_DELAY)
1325 {
1326 if((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
1327 {
1328 /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */
1329 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE);
1330 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE);
1331 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE);
1332 __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR);
1333
1334 hirda->State= HAL_IRDA_STATE_READY;
1335
1336 /* Process Unlocked */
1337 __HAL_UNLOCK(hirda);
1338
1339 return HAL_TIMEOUT;
1340 }
1341 }
1342 }
1343 }
1344 return HAL_OK;
1345 }
1346
1347 /**
1348 * @}
1349 */
1350
1351 /**
1352 * @}
1353 */
1354
1355 /**
1356 * @}
1357 */
1358
1359 #endif /* !defined(STM32F030x6) && !defined(STM32F030x8)&& !defined(STM32F070x6) && !defined(STM32F070xB) && !defined(STM32F030xC) */
1360
1361 #endif /* HAL_IRDA_MODULE_ENABLED */
1362
1363 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
custom keymap for my minivan; forked from http://github.com/evangs/tmk_keyboard
Imprint / Impressum