Context Navigation

stm32g0xx_hal_irda.h

Last change on this file was 6, checked in by f.jahn, 3 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>© 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
25	extern "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	*/
47	typedef 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	*/
118	typedef uint32_t HAL_IRDA_StateTypeDef;
119
120	/**
121	* @brief IRDA clock sources definition
122	*/
123	typedef 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)
136	typedef struct __IRDA_HandleTypeDef
137	#else
138	typedef 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	*/
203	typedef 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	*/
222	typedef 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 ****************************/
794	HAL_StatusTypeDef HAL_IRDA_Init(IRDA_HandleTypeDef *hirda);
795	HAL_StatusTypeDef HAL_IRDA_DeInit(IRDA_HandleTypeDef *hirda);
796	void HAL_IRDA_MspInit(IRDA_HandleTypeDef *hirda);
797	void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef *hirda);
798
799	#if (USE_HAL_IRDA_REGISTER_CALLBACKS == 1)
800	/* Callbacks Register/UnRegister functions ***********************************/
801	HAL_StatusTypeDef HAL_IRDA_RegisterCallback(IRDA_HandleTypeDef *hirda, HAL_IRDA_CallbackIDTypeDef CallbackID, pIRDA_CallbackTypeDef pCallback);
802	HAL_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 *****************************************************/
814	HAL_StatusTypeDef HAL_IRDA_Transmit(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size, uint32_t Timeout);
815	HAL_StatusTypeDef HAL_IRDA_Receive(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size, uint32_t Timeout);
816	HAL_StatusTypeDef HAL_IRDA_Transmit_IT(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size);
817	HAL_StatusTypeDef HAL_IRDA_Receive_IT(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size);
818	HAL_StatusTypeDef HAL_IRDA_Transmit_DMA(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size);
819	HAL_StatusTypeDef HAL_IRDA_Receive_DMA(IRDA_HandleTypeDef hirda, uint8_t pData, uint16_t Size);
820	HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda);
821	HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda);
822	HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda);
823	/* Transfer Abort functions */
824	HAL_StatusTypeDef HAL_IRDA_Abort(IRDA_HandleTypeDef *hirda);
825	HAL_StatusTypeDef HAL_IRDA_AbortTransmit(IRDA_HandleTypeDef *hirda);
826	HAL_StatusTypeDef HAL_IRDA_AbortReceive(IRDA_HandleTypeDef *hirda);
827	HAL_StatusTypeDef HAL_IRDA_Abort_IT(IRDA_HandleTypeDef *hirda);
828	HAL_StatusTypeDef HAL_IRDA_AbortTransmit_IT(IRDA_HandleTypeDef *hirda);
829	HAL_StatusTypeDef HAL_IRDA_AbortReceive_IT(IRDA_HandleTypeDef *hirda);
830
831	void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda);
832	void HAL_IRDA_TxCpltCallback(IRDA_HandleTypeDef *hirda);
833	void HAL_IRDA_RxCpltCallback(IRDA_HandleTypeDef *hirda);
834	void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda);
835	void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda);
836	void HAL_IRDA_ErrorCallback(IRDA_HandleTypeDef *hirda);
837	void HAL_IRDA_AbortCpltCallback(IRDA_HandleTypeDef *hirda);
838	void HAL_IRDA_AbortTransmitCpltCallback(IRDA_HandleTypeDef *hirda);
839	void 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 ***************************************/
852	HAL_IRDA_StateTypeDef HAL_IRDA_GetState(IRDA_HandleTypeDef *hirda);
853	uint32_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.

Context Navigation

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

Download in other formats: