source: trunk/firmware/Drivers/STM32G0xx_HAL_Driver/Inc/stm32g0xx_hal_irda.h

Last change on this file was 6, checked in by f.jahn, 8 months ago
File size: 41.8 KB
Line 
1/**
2 ******************************************************************************
3 * @file stm32g0xx_hal_irda.h
4 * @author MCD Application Team
5 * @brief Header file of IRDA HAL module.
6 ******************************************************************************
7 * @attention
8 *
9 * <h2><center>&copy; Copyright (c) 2018 STMicroelectronics.
10 * All rights reserved.</center></h2>
11 *
12 * This software component is licensed by ST under BSD 3-Clause license,
13 * the "License"; You may not use this file except in compliance with the
14 * License. You may obtain a copy of the License at:
15 * opensource.org/licenses/BSD-3-Clause
16 *
17 ******************************************************************************
18 */
19
20/* Define to prevent recursive inclusion -------------------------------------*/
21#ifndef STM32G0xx_HAL_IRDA_H
22#define STM32G0xx_HAL_IRDA_H
23
24#ifdef __cplusplus
25extern "C" {
26#endif
27
28/* Includes ------------------------------------------------------------------*/
29#include "stm32g0xx_hal_def.h"
30
31/** @addtogroup STM32G0xx_HAL_Driver
32 * @{
33 */
34
35/** @addtogroup IRDA
36 * @{
37 */
38
39/* Exported types ------------------------------------------------------------*/
40/** @defgroup IRDA_Exported_Types IRDA Exported Types
41 * @{
42 */
43
44/**
45 * @brief IRDA Init Structure definition
46 */
47typedef struct
48{
49 uint32_t BaudRate; /*!< This member configures the IRDA communication baud rate.
50 The baud rate register is computed using the following formula:
51 Baud Rate Register = ((usart_ker_ckpres) / ((hirda->Init.BaudRate)))
52 where usart_ker_ckpres is the IRDA input clock divided by a prescaler */
53
54 uint32_t WordLength; /*!< Specifies the number of data bits transmitted or received in a frame.
55 This parameter can be a value of @ref IRDAEx_Word_Length */
56
57 uint32_t Parity; /*!< Specifies the parity mode.
58 This parameter can be a value of @ref IRDA_Parity
59 @note When parity is enabled, the computed parity is inserted
60 at the MSB position of the transmitted data (9th bit when
61 the word length is set to 9 data bits; 8th bit when the
62 word length is set to 8 data bits). */
63
64 uint32_t Mode; /*!< Specifies whether the Receive or Transmit mode is enabled or disabled.
65 This parameter can be a value of @ref IRDA_Transfer_Mode */
66
67 uint8_t Prescaler; /*!< Specifies the Prescaler value for dividing the UART/USART source clock
68 to achieve low-power frequency.
69 @note Prescaler value 0 is forbidden */
70
71 uint16_t PowerMode; /*!< Specifies the IRDA power mode.
72 This parameter can be a value of @ref IRDA_Low_Power */
73
74 uint32_t ClockPrescaler; /*!< Specifies the prescaler value used to divide the IRDA clock source.
75 This parameter can be a value of @ref IRDA_ClockPrescaler. */
76
77} IRDA_InitTypeDef;
78
79/**
80 * @brief HAL IRDA State definition
81 * @note HAL IRDA State value is a combination of 2 different substates: gState and RxState (see @ref IRDA_State_Definition).
82 * - gState contains IRDA state information related to global Handle management
83 * and also information related to Tx operations.
84 * gState value coding follow below described bitmap :
85 * b7-b6 Error information
86 * 00 : No Error
87 * 01 : (Not Used)
88 * 10 : Timeout
89 * 11 : Error
90 * b5 Peripheral initialization status
91 * 0 : Reset (Peripheral not initialized)
92 * 1 : Init done (Peripheral not initialized. HAL IRDA Init function already called)
93 * b4-b3 (not used)
94 * xx : Should be set to 00
95 * b2 Intrinsic process state
96 * 0 : Ready
97 * 1 : Busy (Peripheral busy with some configuration or internal operations)
98 * b1 (not used)
99 * x : Should be set to 0
100 * b0 Tx state
101 * 0 : Ready (no Tx operation ongoing)
102 * 1 : Busy (Tx operation ongoing)
103 * - RxState contains information related to Rx operations.
104 * RxState value coding follow below described bitmap :
105 * b7-b6 (not used)
106 * xx : Should be set to 00
107 * b5 Peripheral initialization status
108 * 0 : Reset (Peripheral not initialized)
109 * 1 : Init done (Peripheral not initialized)
110 * b4-b2 (not used)
111 * xxx : Should be set to 000
112 * b1 Rx state
113 * 0 : Ready (no Rx operation ongoing)
114 * 1 : Busy (Rx operation ongoing)
115 * b0 (not used)
116 * x : Should be set to 0.
117 */
118typedef uint32_t HAL_IRDA_StateTypeDef;
119
120/**
121 * @brief IRDA clock sources definition
122 */
123typedef enum
124{
125 IRDA_CLOCKSOURCE_PCLK1 = 0x00U, /*!< PCLK1 clock source */
126 IRDA_CLOCKSOURCE_HSI = 0x02U, /*!< HSI clock source */
127 IRDA_CLOCKSOURCE_SYSCLK = 0x04U, /*!< SYSCLK clock source */
128 IRDA_CLOCKSOURCE_LSE = 0x10U, /*!< LSE clock source */
129 IRDA_CLOCKSOURCE_UNDEFINED = 0x20U /*!< Undefined clock source */
130} IRDA_ClockSourceTypeDef;
131
132/**
133 * @brief IRDA handle Structure definition
134 */
135#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
136typedef struct __IRDA_HandleTypeDef
137#else
138typedef struct
139#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
140{
141 USART_TypeDef *Instance; /*!< USART registers base address */
142
143 IRDA_InitTypeDef Init; /*!< IRDA communication parameters */
144
145 uint8_t *pTxBuffPtr; /*!< Pointer to IRDA Tx transfer Buffer */
146
147 uint16_t TxXferSize; /*!< IRDA Tx Transfer size */
148
149 __IO uint16_t TxXferCount; /*!< IRDA Tx Transfer Counter */
150
151 uint8_t *pRxBuffPtr; /*!< Pointer to IRDA Rx transfer Buffer */
152
153 uint16_t RxXferSize; /*!< IRDA Rx Transfer size */
154
155 __IO uint16_t RxXferCount; /*!< IRDA Rx Transfer Counter */
156
157 uint16_t Mask; /*!< USART RX RDR register mask */
158
159 DMA_HandleTypeDef *hdmatx; /*!< IRDA Tx DMA Handle parameters */
160
161 DMA_HandleTypeDef *hdmarx; /*!< IRDA Rx DMA Handle parameters */
162
163 HAL_LockTypeDef Lock; /*!< Locking object */
164
165 __IO HAL_IRDA_StateTypeDef gState; /*!< IRDA state information related to global Handle management
166 and also related to Tx operations.
167 This parameter can be a value of @ref HAL_IRDA_StateTypeDef */
168
169 __IO HAL_IRDA_StateTypeDef RxState; /*!< IRDA state information related to Rx operations.
170 This parameter can be a value of @ref HAL_IRDA_StateTypeDef */
171
172 uint32_t ErrorCode; /*!< IRDA Error code */
173
174#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
175 void (* TxHalfCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Tx Half Complete Callback */
176
177 void (* TxCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Tx Complete Callback */
178
179 void (* RxHalfCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Rx Half Complete Callback */
180
181 void (* RxCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Rx Complete Callback */
182
183 void (* ErrorCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Error Callback */
184
185 void (* AbortCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Abort Complete Callback */
186
187 void (* AbortTransmitCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Abort Transmit Complete Callback */
188
189 void (* AbortReceiveCpltCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Abort Receive Complete Callback */
190
191
192 void (* MspInitCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Msp Init callback */
193
194 void (* MspDeInitCallback)(struct __IRDA_HandleTypeDef *hirda); /*!< IRDA Msp DeInit callback */
195#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
196
197} IRDA_HandleTypeDef;
198
199#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
200/**
201 * @brief HAL IRDA Callback ID enumeration definition
202 */
203typedef enum
204{
205 HAL_IRDA_TX_HALFCOMPLETE_CB_ID = 0x00U, /*!< IRDA Tx Half Complete Callback ID */
206 HAL_IRDA_TX_COMPLETE_CB_ID = 0x01U, /*!< IRDA Tx Complete Callback ID */
207 HAL_IRDA_RX_HALFCOMPLETE_CB_ID = 0x02U, /*!< IRDA Rx Half Complete Callback ID */
208 HAL_IRDA_RX_COMPLETE_CB_ID = 0x03U, /*!< IRDA Rx Complete Callback ID */
209 HAL_IRDA_ERROR_CB_ID = 0x04U, /*!< IRDA Error Callback ID */
210 HAL_IRDA_ABORT_COMPLETE_CB_ID = 0x05U, /*!< IRDA Abort Complete Callback ID */
211 HAL_IRDA_ABORT_TRANSMIT_COMPLETE_CB_ID = 0x06U, /*!< IRDA Abort Transmit Complete Callback ID */
212 HAL_IRDA_ABORT_RECEIVE_COMPLETE_CB_ID = 0x07U, /*!< IRDA Abort Receive Complete Callback ID */
213
214 HAL_IRDA_MSPINIT_CB_ID = 0x08U, /*!< IRDA MspInit callback ID */
215 HAL_IRDA_MSPDEINIT_CB_ID = 0x09U /*!< IRDA MspDeInit callback ID */
216
217} HAL_IRDA_CallbackIDTypeDef;
218
219/**
220 * @brief HAL IRDA Callback pointer definition
221 */
222typedef void (*pIRDA_CallbackTypeDef)(IRDA_HandleTypeDef *hirda); /*!< pointer to an IRDA callback function */
223
224#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
225
226/**
227 * @}
228 */
229
230/* Exported constants --------------------------------------------------------*/
231/** @defgroup IRDA_Exported_Constants IRDA Exported Constants
232 * @{
233 */
234
235/** @defgroup IRDA_State_Definition IRDA State Code Definition
236 * @{
237 */
238#define HAL_IRDA_STATE_RESET 0x00000000U /*!< Peripheral is not initialized
239 Value is allowed for gState and RxState */
240#define HAL_IRDA_STATE_READY 0x00000020U /*!< Peripheral Initialized and ready for use
241 Value is allowed for gState and RxState */
242#define HAL_IRDA_STATE_BUSY 0x00000024U /*!< An internal process is ongoing
243 Value is allowed for gState only */
244#define HAL_IRDA_STATE_BUSY_TX 0x00000021U /*!< Data Transmission process is ongoing
245 Value is allowed for gState only */
246#define HAL_IRDA_STATE_BUSY_RX 0x00000022U /*!< Data Reception process is ongoing
247 Value is allowed for RxState only */
248#define HAL_IRDA_STATE_BUSY_TX_RX 0x00000023U /*!< Data Transmission and Reception process is ongoing
249 Not to be used for neither gState nor RxState.
250 Value is result of combination (Or) between gState and RxState values */
251#define HAL_IRDA_STATE_TIMEOUT 0x000000A0U /*!< Timeout state
252 Value is allowed for gState only */
253#define HAL_IRDA_STATE_ERROR 0x000000E0U /*!< Error
254 Value is allowed for gState only */
255/**
256 * @}
257 */
258
259/** @defgroup IRDA_Error_Definition IRDA Error Code Definition
260 * @{
261 */
262#define HAL_IRDA_ERROR_NONE ((uint32_t)0x00000000U) /*!< No error */
263#define HAL_IRDA_ERROR_PE ((uint32_t)0x00000001U) /*!< Parity error */
264#define HAL_IRDA_ERROR_NE ((uint32_t)0x00000002U) /*!< Noise error */
265#define HAL_IRDA_ERROR_FE ((uint32_t)0x00000004U) /*!< frame error */
266#define HAL_IRDA_ERROR_ORE ((uint32_t)0x00000008U) /*!< Overrun error */
267#define HAL_IRDA_ERROR_DMA ((uint32_t)0x00000010U) /*!< DMA transfer error */
268#define HAL_IRDA_ERROR_BUSY ((uint32_t)0x00000020U) /*!< Busy Error */
269#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
270#define HAL_IRDA_ERROR_INVALID_CALLBACK ((uint32_t)0x00000040U) /*!< Invalid Callback error */
271#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
272/**
273 * @}
274 */
275
276/** @defgroup IRDA_Parity IRDA Parity
277 * @{
278 */
279#define IRDA_PARITY_NONE 0x00000000U /*!< No parity */
280#define IRDA_PARITY_EVEN USART_CR1_PCE /*!< Even parity */
281#define IRDA_PARITY_ODD (USART_CR1_PCE | USART_CR1_PS) /*!< Odd parity */
282/**
283 * @}
284 */
285
286/** @defgroup IRDA_Transfer_Mode IRDA Transfer Mode
287 * @{
288 */
289#define IRDA_MODE_RX USART_CR1_RE /*!< RX mode */
290#define IRDA_MODE_TX USART_CR1_TE /*!< TX mode */
291#define IRDA_MODE_TX_RX (USART_CR1_TE |USART_CR1_RE) /*!< RX and TX mode */
292/**
293 * @}
294 */
295
296/** @defgroup IRDA_Low_Power IRDA Low Power
297 * @{
298 */
299#define IRDA_POWERMODE_NORMAL 0x00000000U /*!< IRDA normal power mode */
300#define IRDA_POWERMODE_LOWPOWER USART_CR3_IRLP /*!< IRDA low power mode */
301/**
302 * @}
303 */
304
305/** @defgroup IRDA_ClockPrescaler Clock Prescaler
306 * @{
307 */
308#define IRDA_PRESCALER_DIV1 0x00000000U /*!< fclk_pres = fclk */
309#define IRDA_PRESCALER_DIV2 0x00000001U /*!< fclk_pres = fclk/2 */
310#define IRDA_PRESCALER_DIV4 0x00000002U /*!< fclk_pres = fclk/4 */
311#define IRDA_PRESCALER_DIV6 0x00000003U /*!< fclk_pres = fclk/6 */
312#define IRDA_PRESCALER_DIV8 0x00000004U /*!< fclk_pres = fclk/8 */
313#define IRDA_PRESCALER_DIV10 0x00000005U /*!< fclk_pres = fclk/10 */
314#define IRDA_PRESCALER_DIV12 0x00000006U /*!< fclk_pres = fclk/12 */
315#define IRDA_PRESCALER_DIV16 0x00000007U /*!< fclk_pres = fclk/16 */
316#define IRDA_PRESCALER_DIV32 0x00000008U /*!< fclk_pres = fclk/32 */
317#define IRDA_PRESCALER_DIV64 0x00000009U /*!< fclk_pres = fclk/64 */
318#define IRDA_PRESCALER_DIV128 0x0000000AU /*!< fclk_pres = fclk/128 */
319#define IRDA_PRESCALER_DIV256 0x0000000BU /*!< fclk_pres = fclk/256 */
320/**
321 * @}
322 */
323
324/** @defgroup IRDA_State IRDA State
325 * @{
326 */
327#define IRDA_STATE_DISABLE 0x00000000U /*!< IRDA disabled */
328#define IRDA_STATE_ENABLE USART_CR1_UE /*!< IRDA enabled */
329/**
330 * @}
331 */
332
333/** @defgroup IRDA_Mode IRDA Mode
334 * @{
335 */
336#define IRDA_MODE_DISABLE 0x00000000U /*!< Associated UART disabled in IRDA mode */
337#define IRDA_MODE_ENABLE USART_CR3_IREN /*!< Associated UART enabled in IRDA mode */
338/**
339 * @}
340 */
341
342/** @defgroup IRDA_One_Bit IRDA One Bit Sampling
343 * @{
344 */
345#define IRDA_ONE_BIT_SAMPLE_DISABLE 0x00000000U /*!< One-bit sampling disabled */
346#define IRDA_ONE_BIT_SAMPLE_ENABLE USART_CR3_ONEBIT /*!< One-bit sampling enabled */
347/**
348 * @}
349 */
350
351/** @defgroup IRDA_DMA_Tx IRDA DMA Tx
352 * @{
353 */
354#define IRDA_DMA_TX_DISABLE 0x00000000U /*!< IRDA DMA TX disabled */
355#define IRDA_DMA_TX_ENABLE USART_CR3_DMAT /*!< IRDA DMA TX enabled */
356/**
357 * @}
358 */
359
360/** @defgroup IRDA_DMA_Rx IRDA DMA Rx
361 * @{
362 */
363#define IRDA_DMA_RX_DISABLE 0x00000000U /*!< IRDA DMA RX disabled */
364#define IRDA_DMA_RX_ENABLE USART_CR3_DMAR /*!< IRDA DMA RX enabled */
365/**
366 * @}
367 */
368
369/** @defgroup IRDA_Request_Parameters IRDA Request Parameters
370 * @{
371 */
372#define IRDA_AUTOBAUD_REQUEST USART_RQR_ABRRQ /*!< Auto-Baud Rate Request */
373#define IRDA_RXDATA_FLUSH_REQUEST USART_RQR_RXFRQ /*!< Receive Data flush Request */
374#define IRDA_TXDATA_FLUSH_REQUEST USART_RQR_TXFRQ /*!< Transmit data flush Request */
375/**
376 * @}
377 */
378
379/** @defgroup IRDA_Flags IRDA Flags
380 * Elements values convention: 0xXXXX
381 * - 0xXXXX : Flag mask in the ISR register
382 * @{
383 */
384#define IRDA_FLAG_REACK USART_ISR_REACK /*!< IRDA receive enable acknowledge flag */
385#define IRDA_FLAG_TEACK USART_ISR_TEACK /*!< IRDA transmit enable acknowledge flag */
386#define IRDA_FLAG_BUSY USART_ISR_BUSY /*!< IRDA busy flag */
387#define IRDA_FLAG_ABRF USART_ISR_ABRF /*!< IRDA auto Baud rate flag */
388#define IRDA_FLAG_ABRE USART_ISR_ABRE /*!< IRDA auto Baud rate error */
389#define IRDA_FLAG_TXE USART_ISR_TXE_TXFNF /*!< IRDA transmit data register empty */
390#define IRDA_FLAG_TC USART_ISR_TC /*!< IRDA transmission complete */
391#define IRDA_FLAG_RXNE USART_ISR_RXNE_RXFNE /*!< IRDA read data register not empty */
392#define IRDA_FLAG_ORE USART_ISR_ORE /*!< IRDA overrun error */
393#define IRDA_FLAG_NE USART_ISR_NE /*!< IRDA noise error */
394#define IRDA_FLAG_FE USART_ISR_FE /*!< IRDA frame error */
395#define IRDA_FLAG_PE USART_ISR_PE /*!< IRDA parity error */
396/**
397 * @}
398 */
399
400/** @defgroup IRDA_Interrupt_definition IRDA Interrupts Definition
401 * Elements values convention: 0000ZZZZ0XXYYYYYb
402 * - YYYYY : Interrupt source position in the XX register (5bits)
403 * - XX : Interrupt source register (2bits)
404 * - 01: CR1 register
405 * - 10: CR2 register
406 * - 11: CR3 register
407 * - ZZZZ : Flag position in the ISR register(4bits)
408 * @{
409 */
410#define IRDA_IT_PE 0x0028U /*!< IRDA Parity error interruption */
411#define IRDA_IT_TXE 0x0727U /*!< IRDA Transmit data register empty interruption */
412#define IRDA_IT_TC 0x0626U /*!< IRDA Transmission complete interruption */
413#define IRDA_IT_RXNE 0x0525U /*!< IRDA Read data register not empty interruption */
414#define IRDA_IT_IDLE 0x0424U /*!< IRDA Idle interruption */
415
416/* Elements values convention: 000000000XXYYYYYb
417 - YYYYY : Interrupt source position in the XX register (5bits)
418 - XX : Interrupt source register (2bits)
419 - 01: CR1 register
420 - 10: CR2 register
421 - 11: CR3 register */
422#define IRDA_IT_ERR 0x0060U /*!< IRDA Error interruption */
423
424/* Elements values convention: 0000ZZZZ00000000b
425 - ZZZZ : Flag position in the ISR register(4bits) */
426#define IRDA_IT_ORE 0x0300U /*!< IRDA Overrun error interruption */
427#define IRDA_IT_NE 0x0200U /*!< IRDA Noise error interruption */
428#define IRDA_IT_FE 0x0100U /*!< IRDA Frame error interruption */
429/**
430 * @}
431 */
432
433/** @defgroup IRDA_IT_CLEAR_Flags IRDA Interruption Clear Flags
434 * @{
435 */
436#define IRDA_CLEAR_PEF USART_ICR_PECF /*!< Parity Error Clear Flag */
437#define IRDA_CLEAR_FEF USART_ICR_FECF /*!< Framing Error Clear Flag */
438#define IRDA_CLEAR_NEF USART_ICR_NECF /*!< Noise Error detected Clear Flag */
439#define IRDA_CLEAR_OREF USART_ICR_ORECF /*!< OverRun Error Clear Flag */
440#define IRDA_CLEAR_IDLEF USART_ICR_IDLECF /*!< IDLE line detected Clear Flag */
441#define IRDA_CLEAR_TCF USART_ICR_TCCF /*!< Transmission Complete Clear Flag */
442/**
443 * @}
444 */
445
446/** @defgroup IRDA_Interruption_Mask IRDA interruptions flags mask
447 * @{
448 */
449#define IRDA_IT_MASK 0x001FU /*!< IRDA Interruptions flags mask */
450#define IRDA_CR_MASK 0x00E0U /*!< IRDA control register mask */
451#define IRDA_CR_POS 5U /*!< IRDA control register position */
452#define IRDA_ISR_MASK 0x1F00U /*!< IRDA ISR register mask */
453#define IRDA_ISR_POS 8U /*!< IRDA ISR register position */
454/**
455 * @}
456 */
457
458/**
459 * @}
460 */
461
462/* Exported macros -----------------------------------------------------------*/
463/** @defgroup IRDA_Exported_Macros IRDA Exported Macros
464 * @{
465 */
466
467/** @brief Reset IRDA handle state.
468 * @param __HANDLE__ IRDA handle.
469 * @retval None
470 */
471#if USE_HAL_IRDA_REGISTER_CALLBACKS == 1
472#define __HAL_IRDA_RESET_HANDLE_STATE(__HANDLE__) do{ \
473 (__HANDLE__)->gState = HAL_IRDA_STATE_RESET; \
474 (__HANDLE__)->RxState = HAL_IRDA_STATE_RESET; \
475 (__HANDLE__)->MspInitCallback = NULL; \
476 (__HANDLE__)->MspDeInitCallback = NULL; \
477 } while(0U)
478#else
479#define __HAL_IRDA_RESET_HANDLE_STATE(__HANDLE__) do{ \
480 (__HANDLE__)->gState = HAL_IRDA_STATE_RESET; \
481 (__HANDLE__)->RxState = HAL_IRDA_STATE_RESET; \
482 } while(0U)
483#endif /*USE_HAL_IRDA_REGISTER_CALLBACKS */
484
485/** @brief Flush the IRDA DR register.
486 * @param __HANDLE__ specifies the IRDA Handle.
487 * @retval None
488 */
489#define __HAL_IRDA_FLUSH_DRREGISTER(__HANDLE__) \
490 do{ \
491 SET_BIT((__HANDLE__)->Instance->RQR, IRDA_RXDATA_FLUSH_REQUEST); \
492 SET_BIT((__HANDLE__)->Instance->RQR, IRDA_TXDATA_FLUSH_REQUEST); \
493 } while(0U)
494
495/** @brief Clear the specified IRDA pending flag.
496 * @param __HANDLE__ specifies the IRDA Handle.
497 * @param __FLAG__ specifies the flag to check.
498 * This parameter can be any combination of the following values:
499 * @arg @ref IRDA_CLEAR_PEF
500 * @arg @ref IRDA_CLEAR_FEF
501 * @arg @ref IRDA_CLEAR_NEF
502 * @arg @ref IRDA_CLEAR_OREF
503 * @arg @ref IRDA_CLEAR_TCF
504 * @arg @ref IRDA_CLEAR_IDLEF
505 * @retval None
506 */
507#define __HAL_IRDA_CLEAR_FLAG(__HANDLE__, __FLAG__) ((__HANDLE__)->Instance->ICR = (__FLAG__))
508
509/** @brief Clear the IRDA PE pending flag.
510 * @param __HANDLE__ specifies the IRDA Handle.
511 * @retval None
512 */
513#define __HAL_IRDA_CLEAR_PEFLAG(__HANDLE__) __HAL_IRDA_CLEAR_FLAG((__HANDLE__), IRDA_CLEAR_PEF)
514
515
516/** @brief Clear the IRDA FE pending flag.
517 * @param __HANDLE__ specifies the IRDA Handle.
518 * @retval None
519 */
520#define __HAL_IRDA_CLEAR_FEFLAG(__HANDLE__) __HAL_IRDA_CLEAR_FLAG((__HANDLE__), IRDA_CLEAR_FEF)
521
522/** @brief Clear the IRDA NE pending flag.
523 * @param __HANDLE__ specifies the IRDA Handle.
524 * @retval None
525 */
526#define __HAL_IRDA_CLEAR_NEFLAG(__HANDLE__) __HAL_IRDA_CLEAR_FLAG((__HANDLE__), IRDA_CLEAR_NEF)
527
528/** @brief Clear the IRDA ORE pending flag.
529 * @param __HANDLE__ specifies the IRDA Handle.
530 * @retval None
531 */
532#define __HAL_IRDA_CLEAR_OREFLAG(__HANDLE__) __HAL_IRDA_CLEAR_FLAG((__HANDLE__), IRDA_CLEAR_OREF)
533
534/** @brief Clear the IRDA IDLE pending flag.
535 * @param __HANDLE__ specifies the IRDA Handle.
536 * @retval None
537 */
538#define __HAL_IRDA_CLEAR_IDLEFLAG(__HANDLE__) __HAL_IRDA_CLEAR_FLAG((__HANDLE__), IRDA_CLEAR_IDLEF)
539
540/** @brief Check whether the specified IRDA flag is set or not.
541 * @param __HANDLE__ specifies the IRDA Handle.
542 * @param __FLAG__ specifies the flag to check.
543 * This parameter can be one of the following values:
544 * @arg @ref IRDA_FLAG_REACK Receive enable acknowledge flag
545 * @arg @ref IRDA_FLAG_TEACK Transmit enable acknowledge flag
546 * @arg @ref IRDA_FLAG_BUSY Busy flag
547 * @arg @ref IRDA_FLAG_ABRF Auto Baud rate detection flag
548 * @arg @ref IRDA_FLAG_ABRE Auto Baud rate detection error flag
549 * @arg @ref IRDA_FLAG_TXE Transmit data register empty flag
550 * @arg @ref IRDA_FLAG_TC Transmission Complete flag
551 * @arg @ref IRDA_FLAG_RXNE Receive data register not empty flag
552 * @arg @ref IRDA_FLAG_ORE OverRun Error flag
553 * @arg @ref IRDA_FLAG_NE Noise Error flag
554 * @arg @ref IRDA_FLAG_FE Framing Error flag
555 * @arg @ref IRDA_FLAG_PE Parity Error flag
556 * @retval The new state of __FLAG__ (TRUE or FALSE).
557 */
558#define __HAL_IRDA_GET_FLAG(__HANDLE__, __FLAG__) (((__HANDLE__)->Instance->ISR & (__FLAG__)) == (__FLAG__))
559
560
561/** @brief Enable the specified IRDA interrupt.
562 * @param __HANDLE__ specifies the IRDA Handle.
563 * @param __INTERRUPT__ specifies the IRDA interrupt source to enable.
564 * This parameter can be one of the following values:
565 * @arg @ref IRDA_IT_TXE Transmit Data Register empty interrupt
566 * @arg @ref IRDA_IT_TC Transmission complete interrupt
567 * @arg @ref IRDA_IT_RXNE Receive Data register not empty interrupt
568 * @arg @ref IRDA_IT_IDLE Idle line detection interrupt
569 * @arg @ref IRDA_IT_PE Parity Error interrupt
570 * @arg @ref IRDA_IT_ERR Error interrupt(Frame error, noise error, overrun error)
571 * @retval None
572 */
573#define __HAL_IRDA_ENABLE_IT(__HANDLE__, __INTERRUPT__) (((((__INTERRUPT__) & IRDA_CR_MASK) >> IRDA_CR_POS) == 1U)? ((__HANDLE__)->Instance->CR1 |= ((uint32_t)1U << ((__INTERRUPT__) & IRDA_IT_MASK))): \
574 ((((__INTERRUPT__) & IRDA_CR_MASK) >> IRDA_CR_POS) == 2U)? ((__HANDLE__)->Instance->CR2 |= ((uint32_t)1U << ((__INTERRUPT__) & IRDA_IT_MASK))): \
575 ((__HANDLE__)->Instance->CR3 |= ((uint32_t)1U << ((__INTERRUPT__) & IRDA_IT_MASK))))
576
577/** @brief Disable the specified IRDA interrupt.
578 * @param __HANDLE__ specifies the IRDA Handle.
579 * @param __INTERRUPT__ specifies the IRDA interrupt source to disable.
580 * This parameter can be one of the following values:
581 * @arg @ref IRDA_IT_TXE Transmit Data Register empty interrupt
582 * @arg @ref IRDA_IT_TC Transmission complete interrupt
583 * @arg @ref IRDA_IT_RXNE Receive Data register not empty interrupt
584 * @arg @ref IRDA_IT_IDLE Idle line detection interrupt
585 * @arg @ref IRDA_IT_PE Parity Error interrupt
586 * @arg @ref IRDA_IT_ERR Error interrupt(Frame error, noise error, overrun error)
587 * @retval None
588 */
589#define __HAL_IRDA_DISABLE_IT(__HANDLE__, __INTERRUPT__) (((((__INTERRUPT__) & IRDA_CR_MASK) >> IRDA_CR_POS) == 1U)? ((__HANDLE__)->Instance->CR1 &= ~ ((uint32_t)1U << ((__INTERRUPT__) & IRDA_IT_MASK))): \
590 ((((__INTERRUPT__) & IRDA_CR_MASK) >> IRDA_CR_POS) == 2U)? ((__HANDLE__)->Instance->CR2 &= ~ ((uint32_t)1U << ((__INTERRUPT__) & IRDA_IT_MASK))): \
591 ((__HANDLE__)->Instance->CR3 &= ~ ((uint32_t)1U << ((__INTERRUPT__) & IRDA_IT_MASK))))
592
593
594/** @brief Check whether the specified IRDA interrupt has occurred or not.
595 * @param __HANDLE__ specifies the IRDA Handle.
596 * @param __INTERRUPT__ specifies the IRDA interrupt source to check.
597 * This parameter can be one of the following values:
598 * @arg @ref IRDA_IT_TXE Transmit Data Register empty interrupt
599 * @arg @ref IRDA_IT_TC Transmission complete interrupt
600 * @arg @ref IRDA_IT_RXNE Receive Data register not empty interrupt
601 * @arg @ref IRDA_IT_IDLE Idle line detection interrupt
602 * @arg @ref IRDA_IT_ORE OverRun Error interrupt
603 * @arg @ref IRDA_IT_NE Noise Error interrupt
604 * @arg @ref IRDA_IT_FE Framing Error interrupt
605 * @arg @ref IRDA_IT_PE Parity Error interrupt
606 * @retval The new state of __IT__ (SET or RESET).
607 */
608#define __HAL_IRDA_GET_IT(__HANDLE__, __INTERRUPT__) ((((__HANDLE__)->Instance->ISR & (0x01U << (((__INTERRUPT__) & IRDA_ISR_MASK)>> IRDA_ISR_POS))) != 0U) ? SET : RESET)
609
610/** @brief Check whether the specified IRDA interrupt source is enabled or not.
611 * @param __HANDLE__ specifies the IRDA Handle.
612 * @param __INTERRUPT__ specifies the IRDA interrupt source to check.
613 * This parameter can be one of the following values:
614 * @arg @ref IRDA_IT_TXE Transmit Data Register empty interrupt
615 * @arg @ref IRDA_IT_TC Transmission complete interrupt
616 * @arg @ref IRDA_IT_RXNE Receive Data register not empty interrupt
617 * @arg @ref IRDA_IT_IDLE Idle line detection interrupt
618 * @arg @ref IRDA_IT_ERR Framing, overrun or noise error interrupt
619 * @arg @ref IRDA_IT_PE Parity Error interrupt
620 * @retval The new state of __IT__ (SET or RESET).
621 */
622#define __HAL_IRDA_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) ((((((((__INTERRUPT__) & IRDA_CR_MASK) >> IRDA_CR_POS) == 0x01U)? (__HANDLE__)->Instance->CR1 : \
623 (((((__INTERRUPT__) & IRDA_CR_MASK) >> IRDA_CR_POS) == 0x02U)? (__HANDLE__)->Instance->CR2 : \
624 (__HANDLE__)->Instance->CR3)) & ((uint32_t)0x01U << (((uint16_t)(__INTERRUPT__)) & IRDA_IT_MASK))) != 0U) ? SET : RESET)
625
626/** @brief Clear the specified IRDA ISR flag, in setting the proper ICR register flag.
627 * @param __HANDLE__ specifies the IRDA Handle.
628 * @param __IT_CLEAR__ specifies the interrupt clear register flag that needs to be set
629 * to clear the corresponding interrupt
630 * This parameter can be one of the following values:
631 * @arg @ref IRDA_CLEAR_PEF Parity Error Clear Flag
632 * @arg @ref IRDA_CLEAR_FEF Framing Error Clear Flag
633 * @arg @ref IRDA_CLEAR_NEF Noise detected Clear Flag
634 * @arg @ref IRDA_CLEAR_OREF OverRun Error Clear Flag
635 * @arg @ref IRDA_CLEAR_TCF Transmission Complete Clear Flag
636 * @retval None
637 */
638#define __HAL_IRDA_CLEAR_IT(__HANDLE__, __IT_CLEAR__) ((__HANDLE__)->Instance->ICR = (uint32_t)(__IT_CLEAR__))
639
640
641/** @brief Set a specific IRDA request flag.
642 * @param __HANDLE__ specifies the IRDA Handle.
643 * @param __REQ__ specifies the request flag to set
644 * This parameter can be one of the following values:
645 * @arg @ref IRDA_AUTOBAUD_REQUEST Auto-Baud Rate Request
646 * @arg @ref IRDA_RXDATA_FLUSH_REQUEST Receive Data flush Request
647 * @arg @ref IRDA_TXDATA_FLUSH_REQUEST Transmit data flush Request
648 * @retval None
649 */
650#define __HAL_IRDA_SEND_REQ(__HANDLE__, __REQ__) ((__HANDLE__)->Instance->RQR |= (uint16_t)(__REQ__))
651
652/** @brief Enable the IRDA one bit sample method.
653 * @param __HANDLE__ specifies the IRDA Handle.
654 * @retval None
655 */
656#define __HAL_IRDA_ONE_BIT_SAMPLE_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3|= USART_CR3_ONEBIT)
657
658/** @brief Disable the IRDA one bit sample method.
659 * @param __HANDLE__ specifies the IRDA Handle.
660 * @retval None
661 */
662#define __HAL_IRDA_ONE_BIT_SAMPLE_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR3 &= (uint32_t)~((uint32_t)USART_CR3_ONEBIT))
663
664/** @brief Enable UART/USART associated to IRDA Handle.
665 * @param __HANDLE__ specifies the IRDA Handle.
666 * @retval None
667 */
668#define __HAL_IRDA_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 |= USART_CR1_UE)
669
670/** @brief Disable UART/USART associated to IRDA Handle.
671 * @param __HANDLE__ specifies the IRDA Handle.
672 * @retval None
673 */
674#define __HAL_IRDA_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 &= ~USART_CR1_UE)
675
676/**
677 * @}
678 */
679
680/* Private macros --------------------------------------------------------*/
681/** @addtogroup IRDA_Private_Macros
682 * @{
683 */
684
685/** @brief Ensure that IRDA Baud rate is less or equal to maximum value.
686 * @param __BAUDRATE__ specifies the IRDA Baudrate set by the user.
687 * @retval True or False
688 */
689#define IS_IRDA_BAUDRATE(__BAUDRATE__) ((__BAUDRATE__) < 115201U)
690
691/** @brief Ensure that IRDA prescaler value is strictly larger than 0.
692 * @param __PRESCALER__ specifies the IRDA prescaler value set by the user.
693 * @retval True or False
694 */
695#define IS_IRDA_PRESCALER(__PRESCALER__) ((__PRESCALER__) > 0U)
696
697/** @brief Ensure that IRDA frame parity is valid.
698 * @param __PARITY__ IRDA frame parity.
699 * @retval SET (__PARITY__ is valid) or RESET (__PARITY__ is invalid)
700 */
701#define IS_IRDA_PARITY(__PARITY__) (((__PARITY__) == IRDA_PARITY_NONE) || \
702 ((__PARITY__) == IRDA_PARITY_EVEN) || \
703 ((__PARITY__) == IRDA_PARITY_ODD))
704
705/** @brief Ensure that IRDA communication mode is valid.
706 * @param __MODE__ IRDA communication mode.
707 * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid)
708 */
709#define IS_IRDA_TX_RX_MODE(__MODE__) ((((__MODE__) & (~((uint32_t)(IRDA_MODE_TX_RX)))) == 0x00U) && ((__MODE__) != 0x00U))
710
711/** @brief Ensure that IRDA power mode is valid.
712 * @param __MODE__ IRDA power mode.
713 * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid)
714 */
715#define IS_IRDA_POWERMODE(__MODE__) (((__MODE__) == IRDA_POWERMODE_LOWPOWER) || \
716 ((__MODE__) == IRDA_POWERMODE_NORMAL))
717
718/** @brief Ensure that IRDA clock Prescaler is valid.
719 * @param __CLOCKPRESCALER__ IRDA clock Prescaler value.
720 * @retval SET (__CLOCKPRESCALER__ is valid) or RESET (__CLOCKPRESCALER__ is invalid)
721 */
722#define IS_IRDA_CLOCKPRESCALER(__CLOCKPRESCALER__) (((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV1) || \
723 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV2) || \
724 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV4) || \
725 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV6) || \
726 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV8) || \
727 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV10) || \
728 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV12) || \
729 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV16) || \
730 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV32) || \
731 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV64) || \
732 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV128) || \
733 ((__CLOCKPRESCALER__) == IRDA_PRESCALER_DIV256))
734
735/** @brief Ensure that IRDA state is valid.
736 * @param __STATE__ IRDA state mode.
737 * @retval SET (__STATE__ is valid) or RESET (__STATE__ is invalid)
738 */
739#define IS_IRDA_STATE(__STATE__) (((__STATE__) == IRDA_STATE_DISABLE) || \
740 ((__STATE__) == IRDA_STATE_ENABLE))
741
742/** @brief Ensure that IRDA associated UART/USART mode is valid.
743 * @param __MODE__ IRDA associated UART/USART mode.
744 * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid)
745 */
746#define IS_IRDA_MODE(__MODE__) (((__MODE__) == IRDA_MODE_DISABLE) || \
747 ((__MODE__) == IRDA_MODE_ENABLE))
748
749/** @brief Ensure that IRDA sampling rate is valid.
750 * @param __ONEBIT__ IRDA sampling rate.
751 * @retval SET (__ONEBIT__ is valid) or RESET (__ONEBIT__ is invalid)
752 */
753#define IS_IRDA_ONE_BIT_SAMPLE(__ONEBIT__) (((__ONEBIT__) == IRDA_ONE_BIT_SAMPLE_DISABLE) || \
754 ((__ONEBIT__) == IRDA_ONE_BIT_SAMPLE_ENABLE))
755
756/** @brief Ensure that IRDA DMA TX mode is valid.
757 * @param __DMATX__ IRDA DMA TX mode.
758 * @retval SET (__DMATX__ is valid) or RESET (__DMATX__ is invalid)
759 */
760#define IS_IRDA_DMA_TX(__DMATX__) (((__DMATX__) == IRDA_DMA_TX_DISABLE) || \
761 ((__DMATX__) == IRDA_DMA_TX_ENABLE))
762
763/** @brief Ensure that IRDA DMA RX mode is valid.
764 * @param __DMARX__ IRDA DMA RX mode.
765 * @retval SET (__DMARX__ is valid) or RESET (__DMARX__ is invalid)
766 */
767#define IS_IRDA_DMA_RX(__DMARX__) (((__DMARX__) == IRDA_DMA_RX_DISABLE) || \
768 ((__DMARX__) == IRDA_DMA_RX_ENABLE))
769
770/** @brief Ensure that IRDA request is valid.
771 * @param __PARAM__ IRDA request.
772 * @retval SET (__PARAM__ is valid) or RESET (__PARAM__ is invalid)
773 */
774#define IS_IRDA_REQUEST_PARAMETER(__PARAM__) (((__PARAM__) == IRDA_AUTOBAUD_REQUEST) || \
775 ((__PARAM__) == IRDA_RXDATA_FLUSH_REQUEST) || \
776 ((__PARAM__) == IRDA_TXDATA_FLUSH_REQUEST))
777/**
778 * @}
779 */
780
781/* Include IRDA HAL Extended module */
782#include "stm32g0xx_hal_irda_ex.h"
783
784/* Exported functions --------------------------------------------------------*/
785/** @addtogroup IRDA_Exported_Functions IRDA Exported Functions
786 * @{
787 */
788
789/** @addtogroup IRDA_Exported_Functions_Group1 Initialization and de-initialization functions
790 * @{
791 */
792
793/* Initialization and de-initialization functions ****************************/
794HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda);
795HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda);
796void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda);
797void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda);
798
799#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
800/* Callbacks Register/UnRegister functions ***********************************/
801HAL_StatusTypeDef HAL_IRDA_RegisterCallback(IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID, pIRDA_CallbackTypeDef pCallback);
802HAL_StatusTypeDef HAL_IRDA_UnRegisterCallback(IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID);
803#endif /* USE_HAL_IRDA_REGISTER_CALLBACKS */
804
805/**
806 * @}
807 */
808
809/** @addtogroup IRDA_Exported_Functions_Group2 IO operation functions
810 * @{
811 */
812
813/* IO operation functions *****************************************************/
814HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout);
815HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size, uint32_t Timeout);
816HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size);
817HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size);
818HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size);
819HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef *hirda, uint8_t *pData, uint16_t Size);
820HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda);
821HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda);
822HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda);
823/* Transfer Abort functions */
824HAL_StatusTypeDef HAL_IRDA_Abort(IRDA_HandleTypeDef *hirda);
825HAL_StatusTypeDef HAL_IRDA_AbortTransmit(IRDA_HandleTypeDef *hirda);
826HAL_StatusTypeDef HAL_IRDA_AbortReceive(IRDA_HandleTypeDef *hirda);
827HAL_StatusTypeDef HAL_IRDA_Abort_IT(IRDA_HandleTypeDef *hirda);
828HAL_StatusTypeDef HAL_IRDA_AbortTransmit_IT(IRDA_HandleTypeDef *hirda);
829HAL_StatusTypeDef HAL_IRDA_AbortReceive_IT(IRDA_HandleTypeDef *hirda);
830
831void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda);
832void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda);
833void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda);
834void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda);
835void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda);
836void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda);
837void HAL_IRDA_AbortCpltCallback(IRDA_HandleTypeDef *hirda);
838void HAL_IRDA_AbortTransmitCpltCallback(IRDA_HandleTypeDef *hirda);
839void HAL_IRDA_AbortReceiveCpltCallback(IRDA_HandleTypeDef *hirda);
840
841/**
842 * @}
843 */
844
845/* Peripheral Control functions ************************************************/
846
847/** @addtogroup IRDA_Exported_Functions_Group4 Peripheral State and Error functions
848 * @{
849 */
850
851/* Peripheral State and Error functions ***************************************/
852HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda);
853uint32_t HAL_IRDA_GetError(IRDA_HandleTypeDef *hirda);
854
855/**
856 * @}
857 */
858
859/**
860 * @}
861 */
862
863/**
864 * @}
865 */
866
867/**
868 * @}
869 */
870
871#ifdef __cplusplus
872}
873#endif
874
875#endif /* STM32G0xx_HAL_IRDA_H */
876
877/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Note: See TracBrowser for help on using the repository browser.