/** * @brief Wraps up transmission in non blocking mode. * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains * the configuration information for the specified IRDA module. * @retval HAL status */ static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda) { /* Disable the IRDA Transmit Complete Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TC); /* Check if a receive process is ongoing or not */ if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) { hirda->State = HAL_IRDA_STATE_BUSY_RX; } else { /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); /* Disable the IRDA Parity Error Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE); hirda->State = HAL_IRDA_STATE_READY; } HAL_IRDA_TxCpltCallback(hirda); return HAL_OK; }
/** * @brief Receive an amount of data in non blocking mode. * Function called under interruption only, once * interruptions have been enabled by HAL_IRDA_Receive_IT() * @param hirda: IRDA handle * @retval HAL status */ static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp; uint16_t uhMask = hirda->Mask; if ((hirda->State == HAL_IRDA_STATE_BUSY_RX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)) { /* Process Locked */ __HAL_LOCK(hirda); if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE)) { tmp = (uint16_t*) hirda->pRxBuffPtr ; *tmp = (uint16_t)(hirda->Instance->RDR & uhMask); hirda->pRxBuffPtr +=2; } else { *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask); } if(--hirda->RxXferCount == 0) { __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE); if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) { hirda->State = HAL_IRDA_STATE_BUSY_TX; } else { /* Disable the IRDA Parity Error Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE); /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); hirda->State = HAL_IRDA_STATE_READY; } /* Call the Process Unlocked before calling the Rx call back API to give the possibiity to start again the receiption under the Rx call back API */ __HAL_UNLOCK(hirda); HAL_IRDA_RxCpltCallback(hirda); return HAL_OK; } /* Process Unlocked */ __HAL_UNLOCK(hirda); return HAL_OK; } else { return HAL_BUSY; } }
/** * @brief Receive an amount of data in non blocking mode. * Function called under interruption only, once * interruptions have been enabled by HAL_IRDA_Transmit_IT() * @param hirda: IRDA handle * @retval HAL status */ static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp; if((hirda->State == HAL_IRDA_STATE_BUSY_TX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)) { __HAL_LOCK(hirda); if(hirda->TxXferCount == 0) { /* Disable the IRDA Transmit Complete Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TC); if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) { hirda->State = HAL_IRDA_STATE_BUSY_RX; } else { /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); hirda->State = HAL_IRDA_STATE_READY; } /* Call the Process Unlocked before calling the Tx call back API to give the possibiity to start again the Transmission under the Tx call back API */ __HAL_UNLOCK(hirda); HAL_IRDA_TxCpltCallback(hirda); return HAL_OK; } else { if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE)) { tmp = (uint16_t*) hirda->pTxBuffPtr; hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF); hirda->pTxBuffPtr += 2; } else { hirda->Instance->TDR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0xFF); } hirda->TxXferCount--; /* Process Unlocked */ __HAL_UNLOCK(hirda); return HAL_OK; } } else { return HAL_BUSY; } }
/** * @brief Receives an amount of data in non blocking mode. * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains * the configuration information for the specified IRDA module. * @retval HAL status */ static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp; /* Check that a Rx process is ongoing */ if(hirda->RxState == HAL_IRDA_STATE_BUSY_RX) { if(hirda->Init.WordLength == IRDA_WORDLENGTH_9B) { tmp = (uint16_t*) hirda->pRxBuffPtr; if(hirda->Init.Parity == IRDA_PARITY_NONE) { *tmp = (uint16_t)(hirda->Instance->DR & (uint16_t)0x01FFU); hirda->pRxBuffPtr += 2U; } else { *tmp = (uint16_t)(hirda->Instance->DR & (uint16_t)0x00FFU); hirda->pRxBuffPtr += 1U; } } else { if(hirda->Init.Parity == IRDA_PARITY_NONE) { *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->DR & (uint8_t)0x00FFU); } else { *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->DR & (uint8_t)0x007FU); } } if(--hirda->RxXferCount == 0U) { __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE); /* Disable the IRDA Parity Error Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE); /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); /* Rx process is completed, restore hirda->RxState to Ready */ hirda->RxState = HAL_IRDA_STATE_READY; HAL_IRDA_RxCpltCallback(hirda); return HAL_OK; } return HAL_OK; } else { return HAL_BUSY; } }
/** * @brief Receive an amount of data in non blocking mode. * Function called under interruption only, once * interruptions have been enabled by HAL_IRDA_Transmit_IT() * @param hirda: IRDA handle * @retval HAL status */ static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp; if((hirda->State == HAL_IRDA_STATE_BUSY_TX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)) { if(hirda->TxXferCount == 0) { /* Disable the IRDA Transmit Data Register Empty Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE); if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) { hirda->State = HAL_IRDA_STATE_BUSY_RX; } else { /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); hirda->State = HAL_IRDA_STATE_READY; } /* Wait on TC flag to be able to start a second transfer */ if(IRDA_WaitOnFlagUntilTimeout(hirda, IRDA_IT_TC, RESET, IRDA_TIMEOUT_VALUE) != HAL_OK) { return HAL_TIMEOUT; } HAL_IRDA_TxCpltCallback(hirda); return HAL_OK; } else { if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE)) { tmp = (uint16_t*) hirda->pTxBuffPtr; hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF); hirda->pTxBuffPtr += 2; } else { hirda->Instance->TDR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0xFF); } hirda->TxXferCount--; return HAL_OK; } } else { return HAL_BUSY; } }
/** * @brief Receive an amount of data in non blocking mode. * Function called under interruption only, once * interruptions have been enabled by HAL_IRDA_Receive_IT() * @param hirda: IRDA handle * @retval HAL status */ static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp; uint16_t uhMask = hirda->Mask; if ((hirda->State == HAL_IRDA_STATE_BUSY_RX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)) { if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE)) { tmp = (uint16_t*) hirda->pRxBuffPtr ; *tmp = (uint16_t)(hirda->Instance->RDR & uhMask); hirda->pRxBuffPtr +=2U; } else { *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask); } if(--hirda->RxXferCount == 0U) { while(HAL_IS_BIT_SET(hirda->Instance->ISR, IRDA_FLAG_RXNE)) { } __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE); /* Disable the IRDA Parity Error Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE); /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) { hirda->State = HAL_IRDA_STATE_BUSY_TX; } else { hirda->State = HAL_IRDA_STATE_READY; } HAL_IRDA_RxCpltCallback(hirda); return HAL_OK; } return HAL_OK; } else { return HAL_BUSY; } }
/** * @brief This function handles IRDA Communication Timeout. * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains * the configuration information for the specified IRDA module. * @param Flag: specifies the IRDA flag to check. * @param Status: The new Flag status (SET or RESET). * @param Timeout: Timeout duration * @retval HAL status */ static HAL_StatusTypeDef IRDA_WaitOnFlagUntilTimeout(IRDA_HandleTypeDef *hirda, uint32_t Flag, FlagStatus Status, uint32_t Timeout) { uint32_t tickstart = 0; /* Get tick */ tickstart = HAL_GetTick(); /* Wait until flag is set */ if(Status == RESET) { while(__HAL_IRDA_GET_FLAG(hirda, Flag) == RESET) { /* Check for the Timeout */ if(Timeout != HAL_MAX_DELAY) { if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout)) { /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE); __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE); __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE); __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); hirda->State= HAL_IRDA_STATE_READY; /* Process Unlocked */ __HAL_UNLOCK(hirda); return HAL_TIMEOUT; } } } } else { while(__HAL_IRDA_GET_FLAG(hirda, Flag) != RESET) { /* Check for the Timeout */ if(Timeout != HAL_MAX_DELAY) { if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout)) { /* Disable TXE, RXNE, PE and ERR (Frame error, noise error, overrun error) interrupts for the interrupt process */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE); __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE); __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE); __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); hirda->State= HAL_IRDA_STATE_READY; /* Process Unlocked */ __HAL_UNLOCK(hirda); return HAL_TIMEOUT; } } } } return HAL_OK; }
/** * @brief Wraps up transmission in non blocking mode. * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains * the configuration information for the specified IRDA module. * @retval HAL status */ static HAL_StatusTypeDef IRDA_EndTransmit_IT(IRDA_HandleTypeDef *hirda) { /* Disable the IRDA Transmit Complete Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TC); /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); /* Tx process is ended, restore hirda->gState to Ready */ hirda->gState = HAL_IRDA_STATE_READY; HAL_IRDA_TxCpltCallback(hirda); return HAL_OK; }
/** * @brief Receive an amount of data in non blocking mode. * Function called under interruption only, once * interruptions have been enabled by HAL_IRDA_Transmit_IT() * @param hirda: IRDA handle * @retval HAL status */ static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp; if((hirda->State == HAL_IRDA_STATE_BUSY_TX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)) { if(hirda->TxXferCount == 0) { /* Disable the IRDA Transmit Complete Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE); if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) { hirda->State = HAL_IRDA_STATE_BUSY_RX; } else { /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); hirda->State = HAL_IRDA_STATE_READY; } HAL_IRDA_TxCpltCallback(hirda); return HAL_OK; } else { if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE)) { tmp = (uint16_t*) hirda->pTxBuffPtr; hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF); hirda->pTxBuffPtr += 2; } else { hirda->Instance->TDR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0xFF); } hirda->TxXferCount--; return HAL_OK; } } else { return HAL_BUSY; } }
/** * @brief Receive an amount of data in non-blocking mode. * Function is called under interruption only, once * interruptions have been enabled by HAL_IRDA_Receive_IT(). * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains * the configuration information for the specified IRDA module. * @retval HAL status */ static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp; uint16_t uhMask = hirda->Mask; /* Check that a Rx process is ongoing */ if (hirda->RxState == HAL_IRDA_STATE_BUSY_RX) { if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE)) { tmp = (uint16_t*) hirda->pRxBuffPtr ; *tmp = (uint16_t)(hirda->Instance->RDR & uhMask); hirda->pRxBuffPtr +=2; } else { *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->RDR & (uint8_t)uhMask); } if(--hirda->RxXferCount == 0) { __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE); /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); /* Disable the IRDA Parity Error Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE); /* Rx process is completed, restore hirda->RxState to Ready */ hirda->RxState = HAL_IRDA_STATE_READY; HAL_IRDA_RxCpltCallback(hirda); return HAL_OK; } return HAL_OK; } else { /* Clear RXNE interrupt flag */ __HAL_IRDA_SEND_REQ(hirda, IRDA_RXDATA_FLUSH_REQUEST); return HAL_BUSY; } }
/** * @brief Send an amount of data in non-blocking mode. * Function called under interruption only, once * interruptions have been enabled by HAL_IRDA_Transmit_IT() * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains * the configuration information for the specified IRDA module. * @retval HAL status */ static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp = 0; uint32_t tmp_state = 0; tmp_state = hirda->State; if((tmp_state == HAL_IRDA_STATE_BUSY_TX) || (tmp_state == HAL_IRDA_STATE_BUSY_TX_RX)) { if(hirda->Init.WordLength == IRDA_WORDLENGTH_9B) { tmp = (uint16_t*) hirda->pTxBuffPtr; WRITE_REG(hirda->Instance->DR, (uint16_t)(*tmp & IRDA_DR_MASK_U16_9DATABITS)); if(hirda->Init.Parity == IRDA_PARITY_NONE) { hirda->pTxBuffPtr += 2; } else { hirda->pTxBuffPtr += 1; } } else { WRITE_REG(hirda->Instance->DR, (uint8_t)(*hirda->pTxBuffPtr++ & IRDA_DR_MASK_U8_8DATABITS)); } if(--hirda->TxXferCount == 0) { /* Disable the IRDA Transmit Data Register Empty Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE); /* Enable the IRDA Transmit Complete Interrupt */ __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC); } return HAL_OK; } else { return HAL_BUSY; } }
/** * @brief Send an amount of data in non blocking mode. * @param hirda: pointer to a IRDA_HandleTypeDef structure that contains * the configuration information for the specified IRDA module. * @retval HAL status */ static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp; /* Check that a Tx process is ongoing */ if(hirda->gState == HAL_IRDA_STATE_BUSY_TX) { if(hirda->Init.WordLength == IRDA_WORDLENGTH_9B) { tmp = (uint16_t*) hirda->pTxBuffPtr; hirda->Instance->DR = (uint16_t)(*tmp & (uint16_t)0x01FFU); if(hirda->Init.Parity == IRDA_PARITY_NONE) { hirda->pTxBuffPtr += 2U; } else { hirda->pTxBuffPtr += 1U; } } else { hirda->Instance->DR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0x00FFU); } if(--hirda->TxXferCount == 0U) { /* Disable the IRDA Transmit Data Register Empty Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE); /* Enable the IRDA Transmit Complete Interrupt */ __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC); } return HAL_OK; } else { return HAL_BUSY; } }
/** * @brief Receive an amount of data in non blocking mode. * Function called under interruption only, once * interruptions have been enabled by HAL_IRDA_Transmit_IT() * @param hirda: IRDA handle * @retval HAL status */ static HAL_StatusTypeDef IRDA_Transmit_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp; if((hirda->State == HAL_IRDA_STATE_BUSY_TX) || (hirda->State == HAL_IRDA_STATE_BUSY_TX_RX)) { if(hirda->TxXferCount == 0) { /* Disable the IRDA Transmit Data Register Empty Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE); /* Enable the IRDA Transmit Complete Interrupt */ __HAL_IRDA_ENABLE_IT(hirda, IRDA_IT_TC); return HAL_OK; } else { if ((hirda->Init.WordLength == IRDA_WORDLENGTH_9B) && (hirda->Init.Parity == IRDA_PARITY_NONE)) { tmp = (uint16_t*) hirda->pTxBuffPtr; hirda->Instance->TDR = (*tmp & (uint16_t)0x01FF); hirda->pTxBuffPtr += 2; } else { hirda->Instance->TDR = (uint8_t)(*hirda->pTxBuffPtr++ & (uint8_t)0xFF); } hirda->TxXferCount--; return HAL_OK; } } else { return HAL_BUSY; } }
/** * @brief This function handles IRDA interrupt request. * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains * the configuration information for the specified IRDA module. * @retval None */ void HAL_IRDA_IRQHandler(IRDA_HandleTypeDef *hirda) { uint32_t tmp_flag = 0, tmp_it_source = 0; tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_PE); tmp_it_source = __HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_PE); /* IRDA parity error interrupt occurred -----------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { hirda->ErrorCode |= HAL_IRDA_ERROR_PE; } tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_FE); tmp_it_source = __HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_ERR); /* IRDA frame error interrupt occurred ------------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { hirda->ErrorCode |= HAL_IRDA_ERROR_FE; } tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_NE); /* IRDA noise error interrupt occurred ------------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { hirda->ErrorCode |= HAL_IRDA_ERROR_NE; } tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_ORE); /* IRDA Over-Run interrupt occurred ---------------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { hirda->ErrorCode |= HAL_IRDA_ERROR_ORE; } /* Call the Error call Back in case of Errors */ if(hirda->ErrorCode != HAL_IRDA_ERROR_NONE) { /* Disable PE and ERR interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE); __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_TXE); /* Clear all the error flag at once */ __HAL_IRDA_CLEAR_PEFLAG(hirda); /* Set the IRDA state ready to be able to start again the process */ hirda->State = HAL_IRDA_STATE_READY; HAL_IRDA_ErrorCallback(hirda); } tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_RXNE); tmp_it_source = __HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_RXNE); /* IRDA in mode Receiver --------------------------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { IRDA_Receive_IT(hirda); } tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_TXE); tmp_it_source = __HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TXE); /* IRDA in mode Transmitter -----------------------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { IRDA_Transmit_IT(hirda); } tmp_flag = __HAL_IRDA_GET_FLAG(hirda, IRDA_FLAG_TC); tmp_it_source = __HAL_IRDA_GET_IT_SOURCE(hirda, IRDA_IT_TC); /* IRDA in mode Transmitter (transmission end) -----------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { IRDA_EndTransmit_IT(hirda); } }
/** * @brief Receive an amount of data in non-blocking mode. * @param hirda: Pointer to a IRDA_HandleTypeDef structure that contains * the configuration information for the specified IRDA module. * @retval HAL status */ static HAL_StatusTypeDef IRDA_Receive_IT(IRDA_HandleTypeDef *hirda) { uint16_t* tmp = 0; uint32_t tmp_state = 0; tmp_state = hirda->State; if((tmp_state == HAL_IRDA_STATE_BUSY_RX) || (tmp_state == HAL_IRDA_STATE_BUSY_TX_RX)) { if(hirda->Init.WordLength == IRDA_WORDLENGTH_9B) { tmp = (uint16_t*) hirda->pRxBuffPtr; if(hirda->Init.Parity == IRDA_PARITY_NONE) { *tmp = (uint16_t)(hirda->Instance->DR & IRDA_DR_MASK_U16_9DATABITS); hirda->pRxBuffPtr += 2; } else { *tmp = (uint16_t)(hirda->Instance->DR & IRDA_DR_MASK_U16_8DATABITS); hirda->pRxBuffPtr += 1; } } else { if(hirda->Init.Parity == IRDA_PARITY_NONE) { *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->DR & IRDA_DR_MASK_U8_8DATABITS); } else { *hirda->pRxBuffPtr++ = (uint8_t)(hirda->Instance->DR & IRDA_DR_MASK_U8_7DATABITS); } } if(--hirda->RxXferCount == 0) { __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_RXNE); if(hirda->State == HAL_IRDA_STATE_BUSY_TX_RX) { hirda->State = HAL_IRDA_STATE_BUSY_TX; } else { /* Disable the IRDA Parity Error Interrupt */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_PE); /* Disable the IRDA Error Interrupt: (Frame error, noise error, overrun error) */ __HAL_IRDA_DISABLE_IT(hirda, IRDA_IT_ERR); hirda->State = HAL_IRDA_STATE_READY; } HAL_IRDA_RxCpltCallback(hirda); return HAL_OK; } return HAL_OK; } else { return HAL_BUSY; } }