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