1 /**
2   ******************************************************************************
3   * @file    stm32wlxx_hal_irda_ex.h
4   * @author  MCD Application Team
5   * @brief   Header file of IRDA HAL Extended module.
6   ******************************************************************************
7   * @attention
8   *
9   * Copyright (c) 2020 STMicroelectronics.
10   * All rights reserved.
11   *
12   * This software is licensed under terms that can be found in the LICENSE file
13   * in the root directory of this software component.
14   * If no LICENSE file comes with this software, it is provided AS-IS.
15   *
16   ******************************************************************************
17   */
18 
19 /* Define to prevent recursive inclusion -------------------------------------*/
20 #ifndef STM32WLxx_HAL_IRDA_EX_H
21 #define STM32WLxx_HAL_IRDA_EX_H
22 
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26 
27 /* Includes ------------------------------------------------------------------*/
28 #include "stm32wlxx_hal_def.h"
29 
30 /** @addtogroup STM32WLxx_HAL_Driver
31   * @{
32   */
33 
34 /** @defgroup IRDAEx IRDAEx
35   * @brief IRDA Extended HAL module driver
36   * @{
37   */
38 
39 /* Exported types ------------------------------------------------------------*/
40 /* Exported constants --------------------------------------------------------*/
41 /** @defgroup IRDAEx_Extended_Exported_Constants IRDAEx Extended Exported Constants
42   * @{
43   */
44 
45 /** @defgroup IRDAEx_Word_Length IRDAEx Word Length
46   * @{
47   */
48 #define IRDA_WORDLENGTH_7B                  USART_CR1_M1   /*!< 7-bit long frame */
49 #define IRDA_WORDLENGTH_8B                  0x00000000U    /*!< 8-bit long frame */
50 #define IRDA_WORDLENGTH_9B                  USART_CR1_M0   /*!< 9-bit long frame */
51 /**
52   * @}
53   */
54 
55 /**
56   * @}
57   */
58 
59 /* Exported macros -----------------------------------------------------------*/
60 
61 /* Private macros ------------------------------------------------------------*/
62 
63 /** @defgroup IRDAEx_Private_Macros IRDAEx Private Macros
64   * @{
65   */
66 
67 /** @brief  Report the IRDA clock source.
68   * @param  __HANDLE__ specifies the IRDA Handle.
69   * @param  __CLOCKSOURCE__ output variable.
70   * @retval IRDA clocking source, written in __CLOCKSOURCE__.
71   */
72 #define IRDA_GETCLOCKSOURCE(__HANDLE__,__CLOCKSOURCE__)        \
73   do {                                                         \
74     if((__HANDLE__)->Instance == USART1)                       \
75     {                                                          \
76       switch(__HAL_RCC_GET_USART1_SOURCE())                    \
77       {                                                        \
78         case RCC_USART1CLKSOURCE_PCLK2:                        \
79           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK2;          \
80           break;                                               \
81         case RCC_USART1CLKSOURCE_HSI:                          \
82           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;            \
83           break;                                               \
84         case RCC_USART1CLKSOURCE_SYSCLK:                       \
85           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;         \
86           break;                                               \
87         case RCC_USART1CLKSOURCE_LSE:                          \
88           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;            \
89           break;                                               \
90         default:                                               \
91           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;      \
92           break;                                               \
93       }                                                        \
94     }                                                          \
95     else if((__HANDLE__)->Instance == USART2)                  \
96     {                                                          \
97       switch(__HAL_RCC_GET_USART2_SOURCE())                    \
98       {                                                        \
99         case RCC_USART2CLKSOURCE_PCLK1:                        \
100           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_PCLK1;          \
101           break;                                               \
102         case RCC_USART2CLKSOURCE_HSI:                          \
103           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_HSI;            \
104           break;                                               \
105         case RCC_USART2CLKSOURCE_SYSCLK:                       \
106           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_SYSCLK;         \
107           break;                                               \
108         case RCC_USART2CLKSOURCE_LSE:                          \
109           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_LSE;            \
110           break;                                               \
111         default:                                               \
112           (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;      \
113           break;                                               \
114       }                                                        \
115     }                                                          \
116     else                                                      \
117     {                                                         \
118       (__CLOCKSOURCE__) = IRDA_CLOCKSOURCE_UNDEFINED;         \
119     }                                                         \
120   } while(0U)
121 
122 /** @brief  Compute the mask to apply to retrieve the received data
123   *         according to the word length and to the parity bits activation.
124   * @param  __HANDLE__ specifies the IRDA Handle.
125   * @retval None, the mask to apply to the associated UART RDR register is stored in (__HANDLE__)->Mask field.
126   */
127 #define IRDA_MASK_COMPUTATION(__HANDLE__)                             \
128   do {                                                                \
129     if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_9B)          \
130     {                                                                 \
131       if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)              \
132       {                                                               \
133         (__HANDLE__)->Mask = 0x01FFU ;                                \
134       }                                                               \
135       else                                                            \
136       {                                                               \
137         (__HANDLE__)->Mask = 0x00FFU ;                                \
138       }                                                               \
139     }                                                                 \
140     else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_8B)     \
141     {                                                                 \
142       if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)              \
143       {                                                               \
144         (__HANDLE__)->Mask = 0x00FFU ;                                \
145       }                                                               \
146       else                                                            \
147       {                                                               \
148         (__HANDLE__)->Mask = 0x007FU ;                                \
149       }                                                               \
150     }                                                                 \
151     else if ((__HANDLE__)->Init.WordLength == IRDA_WORDLENGTH_7B)     \
152     {                                                                 \
153       if ((__HANDLE__)->Init.Parity == IRDA_PARITY_NONE)              \
154       {                                                               \
155         (__HANDLE__)->Mask = 0x007FU ;                                \
156       }                                                               \
157       else                                                            \
158       {                                                               \
159         (__HANDLE__)->Mask = 0x003FU ;                                \
160       }                                                               \
161     }                                                                 \
162     else                                                              \
163     {                                                                 \
164       (__HANDLE__)->Mask = 0x0000U;                                   \
165     }                                                                 \
166   } while(0U)
167 
168 /** @brief Ensure that IRDA frame length is valid.
169   * @param __LENGTH__ IRDA frame length.
170   * @retval SET (__LENGTH__ is valid) or RESET (__LENGTH__ is invalid)
171   */
172 #define IS_IRDA_WORD_LENGTH(__LENGTH__) (((__LENGTH__) == IRDA_WORDLENGTH_7B) || \
173                                          ((__LENGTH__) == IRDA_WORDLENGTH_8B) || \
174                                          ((__LENGTH__) == IRDA_WORDLENGTH_9B))
175 /**
176   * @}
177   */
178 
179 /* Exported functions --------------------------------------------------------*/
180 
181 /**
182   * @}
183   */
184 
185 /**
186   * @}
187   */
188 
189 #ifdef __cplusplus
190 }
191 #endif
192 
193 #endif /* STM32WLxx_HAL_IRDA_EX_H */
194 
195