/** * @brief DMA SMARTCARD transmit process complete callback. * @param hdma: Pointer to a DMA_HandleTypeDef structure that contains * the configuration information for the specified DMA module. * @retval None */ static void SMARTCARD_DMATransmitCplt(DMA_HandleTypeDef *hdma) { SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent; hsc->TxXferCount = 0; /* Disable the DMA transfer for transmit request by setting the DMAT bit in the SMARTCARD CR3 register */ CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAT); /* Wait for SMARTCARD TC Flag */ if(SMARTCARD_WaitOnFlagUntilTimeout(hsc, SMARTCARD_FLAG_TC, RESET, SMARTCARD_TIMEOUT_VALUE) != HAL_OK) { /* Timeout occurred */ hsc->State = HAL_SMARTCARD_STATE_TIMEOUT; HAL_SMARTCARD_ErrorCallback(hsc); } else { /* No Timeout */ /* Check if a non-blocking receive process is ongoing or not */ if(hsc->State == HAL_SMARTCARD_STATE_BUSY_TX_RX) { hsc->State = HAL_SMARTCARD_STATE_BUSY_RX; } else { hsc->State = HAL_SMARTCARD_STATE_READY; } HAL_SMARTCARD_TxCpltCallback(hsc); } }
/** * @brief This function handles SMARTCARD interrupt request. * @param hsc: pointer to a SMARTCARD_HandleTypeDef structure that contains * the configuration information for SMARTCARD module. * @retval None */ void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsc) { uint32_t tmp1 = 0, tmp2 = 0; tmp1 = hsc->Instance->SR; tmp2 = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_PE); /* SMARTCARD parity error interrupt occured --------------------------------*/ if(((tmp1 & SMARTCARD_FLAG_PE) != RESET) && (tmp2 != RESET)) { __HAL_SMARTCARD_CLEAR_PEFLAG(hsc); hsc->ErrorCode |= HAL_SMARTCARD_ERROR_PE; } tmp2 = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_ERR); /* SMARTCARD frame error interrupt occured ---------------------------------*/ if(((tmp1 & SMARTCARD_FLAG_FE) != RESET) && (tmp2 != RESET)) { __HAL_SMARTCARD_CLEAR_FEFLAG(hsc); hsc->ErrorCode |= HAL_SMARTCARD_ERROR_FE; } tmp2 = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_ERR); /* SMARTCARD noise error interrupt occured ---------------------------------*/ if(((tmp1 & SMARTCARD_FLAG_NE) != RESET) && (tmp2 != RESET)) { __HAL_SMARTCARD_CLEAR_NEFLAG(hsc); hsc->ErrorCode |= HAL_SMARTCARD_ERROR_NE; } tmp2 = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_ERR); /* SMARTCARD Over-Run interrupt occured ------------------------------------*/ if(((tmp1 & SMARTCARD_FLAG_ORE) != RESET) && (tmp2 != RESET)) { __HAL_SMARTCARD_CLEAR_OREFLAG(hsc); hsc->ErrorCode |= HAL_SMARTCARD_ERROR_ORE; } tmp2 = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_RXNE); /* SMARTCARD in mode Receiver ----------------------------------------------*/ if(((tmp1 & SMARTCARD_FLAG_RXNE) != RESET) && (tmp2 != RESET)) { SMARTCARD_Receive_IT(hsc); } tmp2 = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_TXE); /* SMARTCARD in mode Transmitter -------------------------------------------*/ if(((tmp1 & SMARTCARD_FLAG_TXE) != RESET) && (tmp2 != RESET)) { SMARTCARD_Transmit_IT(hsc); } /* Call the Error call Back in case of Errors */ if(hsc->ErrorCode != HAL_SMARTCARD_ERROR_NONE) { /* Set the SMARTCARD state ready to be able to start again the process */ hsc->State= HAL_SMARTCARD_STATE_READY; HAL_SMARTCARD_ErrorCallback(hsc); } }
/** * @brief DMA SMARTCARD communication abort callback, when call by HAL services on Error * (To be called at end of DMA Abort procedure following error occurrence). * @param hdma: DMA handle. * @retval None */ static void SMARTCARD_DMAAbortOnError(DMA_HandleTypeDef *hdma) { SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent; hsc->RxXferCount = 0U; hsc->TxXferCount = 0U; HAL_SMARTCARD_ErrorCallback(hsc); }
/** * @brief DMA SMARTCARD communication error callback * @param hdma: DMA handle * @retval None */ static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma) { SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent; hsc->RxXferCount = 0; hsc->TxXferCount = 0; hsc->State= HAL_SMARTCARD_STATE_READY; hsc->ErrorCode |= HAL_SMARTCARD_ERROR_DMA; HAL_SMARTCARD_ErrorCallback(hsc); }
/** * @brief DMA SMARTCARD communication error callback * @param hdma: DMA handle * @retval None */ static void SMARTCARD_DMAError(DMA_HandleTypeDef *hdma) { SMARTCARD_HandleTypeDef* hsc = ( SMARTCARD_HandleTypeDef* )((DMA_HandleTypeDef* )hdma)->Parent; hsc->RxXferCount = 0U; hsc->TxXferCount = 0U; hsc->ErrorCode = HAL_SMARTCARD_ERROR_DMA; /* Stop SMARTCARD DMA Tx request if ongoing */ if ( (hsc->gState == HAL_SMARTCARD_STATE_BUSY_TX) &&(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAT)) ) { SMARTCARD_EndTxTransfer(hsc); } /* Stop SMARTCARD DMA Rx request if ongoing */ if ( (hsc->RxState == HAL_SMARTCARD_STATE_BUSY_RX) &&(HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR)) ) { SMARTCARD_EndRxTransfer(hsc); } HAL_SMARTCARD_ErrorCallback(hsc); }
/** * @brief SMARTCARD interrupt requests handling. * @param hsc: SMARTCARD handle * @retval None */ void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsc) { /* SMARTCARD parity error interrupt occurred -------------------------------*/ if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_PE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_PE) != RESET)) { __HAL_SMARTCARD_CLEAR_IT(hsc, SMARTCARD_CLEAR_PEF); hsc->ErrorCode |= HAL_SMARTCARD_ERROR_PE; /* Set the SMARTCARD state ready to be able to start again the process */ hsc->State = HAL_SMARTCARD_STATE_READY; } /* SMARTCARD frame error interrupt occurred ---------------------------------*/ if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_FE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_ERR) != RESET)) { __HAL_SMARTCARD_CLEAR_IT(hsc, SMARTCARD_CLEAR_FEF); hsc->ErrorCode |= HAL_SMARTCARD_ERROR_FE; /* Set the SMARTCARD state ready to be able to start again the process */ hsc->State = HAL_SMARTCARD_STATE_READY; } /* SMARTCARD noise error interrupt occurred ---------------------------------*/ if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_NE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_ERR) != RESET)) { __HAL_SMARTCARD_CLEAR_IT(hsc, SMARTCARD_CLEAR_NEF); hsc->ErrorCode |= HAL_SMARTCARD_ERROR_NE; /* Set the SMARTCARD state ready to be able to start again the process */ hsc->State = HAL_SMARTCARD_STATE_READY; } /* SMARTCARD Over-Run interrupt occurred ------------------------------------*/ if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_ORE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_ERR) != RESET)) { __HAL_SMARTCARD_CLEAR_IT(hsc, SMARTCARD_CLEAR_OREF); hsc->ErrorCode |= HAL_SMARTCARD_ERROR_ORE; /* Set the SMARTCARD state ready to be able to start again the process */ hsc->State = HAL_SMARTCARD_STATE_READY; } /* SMARTCARD receiver timeout interrupt occurred ----------------------------*/ if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_RTO) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_RTO) != RESET)) { __HAL_SMARTCARD_CLEAR_IT(hsc, SMARTCARD_CLEAR_RTOF); hsc->ErrorCode |= HAL_SMARTCARD_ERROR_RTO; /* Set the SMARTCARD state ready to be able to start again the process */ hsc->State = HAL_SMARTCARD_STATE_READY; } /* Call SMARTCARD Error Call back function if need be ----------------------*/ if(hsc->ErrorCode != HAL_SMARTCARD_ERROR_NONE) { HAL_SMARTCARD_ErrorCallback(hsc); } /* SMARTCARD in mode Receiver ----------------------------------------------*/ if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_RXNE) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_RXNE) != RESET)) { SMARTCARD_Receive_IT(hsc); /* Clear RXNE interrupt flag */ __HAL_SMARTCARD_SEND_REQ(hsc, SMARTCARD_RXDATA_FLUSH_REQUEST); } /* SMARTCARD in mode Receiver, end of block interruption -------------------*/ if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_EOB) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_EOB) != RESET)) { hsc->State = HAL_SMARTCARD_STATE_READY; HAL_SMARTCARD_RxCpltCallback(hsc); /* Clear EOBF interrupt after HAL_SMARTCARD_RxCpltCallback() call for the End of Block information * to be available during HAL_SMARTCARD_RxCpltCallback() processing */ __HAL_SMARTCARD_CLEAR_IT(hsc, SMARTCARD_CLEAR_EOBF); } /* SMARTCARD in mode Transmitter -------------------------------------------*/ if((__HAL_SMARTCARD_GET_IT(hsc, SMARTCARD_IT_TC) != RESET) && (__HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_TC) != RESET)) { SMARTCARD_Transmit_IT(hsc); } }
/** * @brief SMARTCARD interrupt requests handling. * @param hsc: SMARTCARD handle * @retval None */ void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsc) { uint32_t isrflags = READ_REG(hsc->Instance->ISR); uint32_t cr1its = READ_REG(hsc->Instance->CR1); uint32_t cr3its = READ_REG(hsc->Instance->CR3); uint32_t dmarequest = 0x00U; uint32_t errorflags = 0x00U; /* If no error occurs */ errorflags = (isrflags & (uint32_t)(USART_ISR_PE | USART_ISR_FE | USART_ISR_ORE | USART_ISR_NE)); if(errorflags == RESET) { /* SMARTCARD in mode Receiver -------------------------------------------------*/ if(((isrflags & USART_ISR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET)) { SMARTCARD_Receive_IT(hsc); return; } } /* If some errors occur */ if((errorflags != RESET) && ((cr3its & (USART_CR3_EIE | USART_CR1_PEIE)) != RESET)) { /* SMARTCARD parity error interrupt occurred ---------------------------*/ if(((isrflags & SMARTCARD_FLAG_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET)) { hsc->ErrorCode |= HAL_SMARTCARD_ERROR_PE; } /* SMARTCARD frame error interrupt occurred ----------------------------*/ if(((isrflags & SMARTCARD_FLAG_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET)) { hsc->ErrorCode |= HAL_SMARTCARD_ERROR_FE; } /* SMARTCARD noise error interrupt occurred ----------------------------*/ if(((isrflags & SMARTCARD_FLAG_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET)) { hsc->ErrorCode |= HAL_SMARTCARD_ERROR_NE; } /* SMARTCARD Over-Run interrupt occurred -------------------------------*/ if(((isrflags & SMARTCARD_FLAG_ORE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET)) { hsc->ErrorCode |= HAL_SMARTCARD_ERROR_ORE; } /* Call the Error call Back in case of Errors */ if(hsc->ErrorCode != HAL_SMARTCARD_ERROR_NONE) { /* SMARTCARD in mode Receiver -----------------------------------------------*/ if(((isrflags & USART_ISR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET)) { SMARTCARD_Receive_IT(hsc); } /* If Overrun error occurs, or if any error occurs in DMA mode reception, consider error as blocking */ dmarequest = HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR); if(((hsc->ErrorCode & HAL_SMARTCARD_ERROR_ORE) != RESET) || dmarequest) { /* Blocking error : transfer is aborted Set the SMARTCARD state ready to be able to start again the process, Disable Rx Interrupts, and disable Rx DMA request, if ongoing */ SMARTCARD_EndRxTransfer(hsc); /* Disable the SMARTCARD DMA Rx request if enabled */ if (HAL_IS_BIT_SET(hsc->Instance->CR3, USART_CR3_DMAR)) { CLEAR_BIT(hsc->Instance->CR3, USART_CR3_DMAR); /* Abort the SMARTCARD DMA Rx channel */ if(hsc->hdmarx != NULL) { /* Set the SMARTCARD DMA Abort callback : will lead to call HAL_SMARTCARD_ErrorCallback() at end of DMA abort procedure */ hsc->hdmarx->XferAbortCallback = SMARTCARD_DMAAbortOnError; if(HAL_DMA_Abort_IT(hsc->hdmarx) != HAL_OK) { /* Call Directly XferAbortCallback function in case of error */ hsc->hdmarx->XferAbortCallback(hsc->hdmarx); } } else { /* Call user error callback */ HAL_SMARTCARD_ErrorCallback(hsc); } } else { /* Call user error callback */ HAL_SMARTCARD_ErrorCallback(hsc); } } else { /* Call user error callback */ HAL_SMARTCARD_ErrorCallback(hsc); hsc->ErrorCode = HAL_SMARTCARD_ERROR_NONE; } } return; } /* End if some error occurs */ /* SMARTCARD in mode Transmitter -------------------------------------------*/ if(((isrflags & SMARTCARD_FLAG_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET)) { SMARTCARD_Transmit_IT(hsc); return; } /* SMARTCARD in mode Transmitter (transmission end) ------------------------*/ if(((isrflags & SMARTCARD_FLAG_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET)) { /* Disable the SMARTCARD Transmit Complete Interrupt */ CLEAR_BIT(hsc->Instance->CR1, USART_CR1_TCIE); /* Disable the SMARTCARD Error Interrupt: (Frame error, noise error, overrun error) */ CLEAR_BIT(hsc->Instance->CR3, USART_CR3_EIE); /* Tx process is ended, restore hsmartcard->gState to Ready */ hsc->gState = HAL_SMARTCARD_STATE_READY; HAL_SMARTCARD_TxCpltCallback(hsc); return; } }
/** * @brief This function handles SMARTCARD interrupt request. * @param hsc: Pointer to a SMARTCARD_HandleTypeDef structure that contains * the configuration information for the specified SMARTCARD module. * @retval None */ void HAL_SMARTCARD_IRQHandler(SMARTCARD_HandleTypeDef *hsc) { uint32_t tmp_flag = 0, tmp_it_source = 0; tmp_flag = __HAL_SMARTCARD_GET_FLAG(hsc, SMARTCARD_FLAG_PE); tmp_it_source = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_PE); /* SMARTCARD parity error interrupt occurred -----------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { hsc->ErrorCode |= HAL_SMARTCARD_ERROR_PE; } tmp_flag = __HAL_SMARTCARD_GET_FLAG(hsc, SMARTCARD_FLAG_FE); tmp_it_source = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_ERR); /* SMARTCARD frame error interrupt occurred ------------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { hsc->ErrorCode |= HAL_SMARTCARD_ERROR_FE; } tmp_flag = __HAL_SMARTCARD_GET_FLAG(hsc, SMARTCARD_FLAG_NE); /* SMARTCARD noise error interrupt occurred ------------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { hsc->ErrorCode |= HAL_SMARTCARD_ERROR_NE; } tmp_flag = __HAL_SMARTCARD_GET_FLAG(hsc, SMARTCARD_FLAG_ORE); /* SMARTCARD Over-Run interrupt occurred ---------------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { hsc->ErrorCode |= HAL_SMARTCARD_ERROR_ORE; } tmp_flag = __HAL_SMARTCARD_GET_FLAG(hsc, SMARTCARD_FLAG_RXNE); tmp_it_source = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_RXNE); /* SMARTCARD in mode Receiver --------------------------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { SMARTCARD_Receive_IT(hsc); } tmp_flag = __HAL_SMARTCARD_GET_FLAG(hsc, SMARTCARD_FLAG_TXE); tmp_it_source = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_TXE); /* SMARTCARD in mode Transmitter -----------------------------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { SMARTCARD_Transmit_IT(hsc); } tmp_flag = __HAL_SMARTCARD_GET_FLAG(hsc, SMARTCARD_FLAG_TC); tmp_it_source = __HAL_SMARTCARD_GET_IT_SOURCE(hsc, SMARTCARD_IT_TC); /* SMARTCARD in mode Transmitter (transmission end) ------------------------*/ if((tmp_flag != RESET) && (tmp_it_source != RESET)) { SMARTCARD_EndTransmit_IT(hsc); } /* Call the Error call Back in case of Errors */ if(hsc->ErrorCode != HAL_SMARTCARD_ERROR_NONE) { /* Clear all the error flag at once */ __HAL_SMARTCARD_CLEAR_PEFLAG(hsc); /* Set the SMARTCARD state ready to be able to start again the process */ hsc->State= HAL_SMARTCARD_STATE_READY; HAL_SMARTCARD_ErrorCallback(hsc); } }