//void WWDG_IRQHandler( void ) {} //void PVD_IRQHandler( void ) {} //void TAMP_STAMP_IRQHandler( void ) {} //void RTC_WKUP_IRQHandler( void ) {} //void FLASH_IRQHandler( void ) {} //void RCC_IRQHandler( void ) {} //void EXTI0_IRQHandler( void ) {} //void EXTI1_IRQHandler( void ) {} //void EXTI2_IRQHandler( void ) {} //void EXTI3_IRQHandler( void ) {} //void EXTI4_IRQHandler( void ) {} //void DMA1_Stream0_IRQHandler( void ) {} //void DMA1_Stream1_IRQHandler( void ) {} //void DMA1_Stream2_IRQHandler( void ) {} //void DMA1_Stream3_IRQHandler( void ) {} //void DMA1_Stream4_IRQHandler( void ) {} //void DMA1_Stream5_IRQHandler( void ) {} //void DMA1_Stream6_IRQHandler( void ) {} //void ADC_IRQHandler( void ) {} //void CAN1_TX_IRQHandler( void ) {} //void CAN1_RX0_IRQHandler( void ) {} //void CAN1_RX1_IRQHandler( void ) {} //void CAN1_SCE_IRQHandler( void ) {} //void EXTI9_5_IRQHandler( void ) {} //void TIM1_BRK_TIM9_IRQHandler( void ) {} //void TIM1_UP_TIM10_IRQHandler( void ) {} //void TIM1_TRG_COM_TIM11_IRQHandler( void ) {} //void TIM1_CC_IRQHandler( void ) {} //void TIM2_IRQHandler( void ) {} //void TIM3_IRQHandler( void ) {} //void TIM4_IRQHandler( void ) {} //void I2C1_EV_IRQHandler( void ) {} //void I2C1_ER_IRQHandler( void ) {} //void I2C2_EV_IRQHandler( void ) {} //void I2C2_ER_IRQHandler( void ) {} //void SPI1_IRQHandler( void ) {} //void SPI2_IRQHandler( void ) {} void USART1_IRQHandler( void ) { if(__HAL_UART_GET_IT_SOURCE(&Serial_HandleStruct, UART_IT_RXNE) != RESET) { Serial_evenCallBack(); } __HAL_UART_GET_IT_SOURCE(&Serial_HandleStruct, UART_IT_RXNE); }
static void uart_irq(UARTName uart_name) { int8_t id = get_uart_index(uart_name); if (id >= 0) { UART_HandleTypeDef * huart = &uart_handlers[id]; if (serial_irq_ids[id] != 0) { if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) { if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TXE) != RESET) { irq_handler(serial_irq_ids[id], TxIrq); } } if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) { if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) { irq_handler(serial_irq_ids[id], RxIrq); /* Flag has been cleared when reading the content */ } } if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) { if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) { volatile uint32_t tmpval __attribute__((unused)) = huart->Instance->DR; // Clear ORE flag } } } } }
void USART3_IRQHandler(void) { { if(__HAL_UART_GET_IT_SOURCE(&Private::get_uart_cube_handle<3>(), UART_IT_RXNE)) { if(Private::get_uart_rx_irq_handler<3>()) Private::get_uart_rx_irq_handler<3>()(); __HAL_UART_CLEAR_FLAG(&Private::get_uart_cube_handle<3>(), UART_IT_RXNE); } else if(__HAL_UART_GET_IT_SOURCE(&Private::get_uart_cube_handle<3>(), UART_IT_TC)) { if(Private::get_uart_tx_irq_handler<3>()) Private::get_uart_tx_irq_handler<3>()(); __HAL_UART_CLEAR_FLAG(&Private::get_uart_cube_handle<3>(), UART_IT_TC); } } }
/** * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25. */ void USART1_IRQHandler(void) { /* USER CODE BEGIN USART1_IRQn 0 */ if(__HAL_UART_GET_IT_SOURCE(&huart1, UART_IT_RXNE)!= RESET) { prvvUARTRxISR(); } if(__HAL_UART_GET_IT_SOURCE(&huart1, UART_IT_TXE)!= RESET) { prvvUARTTxReadyISR(); } /* USER CODE END USART1_IRQn 0 */ HAL_UART_IRQHandler(&huart1); /* USER CODE BEGIN USART1_IRQn 1 */ /* USER CODE END USART1_IRQn 1 */ }
//void TIM4_IRQHandler( void ) //void I2C1_EV_IRQHandler( void ) //void I2C1_ER_IRQHandler( void ) //void I2C2_EV_IRQHandler( void ) //void I2C2_ER_IRQHandler( void ) //void SPI1_IRQHandler( void ) //void SPI2_IRQHandler( void ) void USART1_IRQHandler( void ) { #if defined(KS_HW_UART_HAL_LIBRARY) HAL_UART_IRQHandler(hSerial.handle); #else if (__HAL_UART_GET_IT_SOURCE(hSerial.handle, UART_IT_TXE) != RESET) { __HAL_UART_GET_IT_SOURCE(hSerial.handle, UART_IT_TXE); HAL_UART_TxCpltCallback(hSerial.handle); } if (__HAL_UART_GET_IT_SOURCE(hSerial.handle, UART_IT_RXNE) != RESET) { __HAL_UART_GET_IT_SOURCE(hSerial.handle, UART_IT_RXNE); HAL_UART_RxCpltCallback(hSerial.handle); } #endif }
int uart_pgetc(int port) { if ((__HAL_UART_GET_IT(&handle, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_RXNE) != RESET)) { uint8_t c = (uint8_t)(handle.Instance->RDR & 0xff); return c; } return -1; }
void stm32_USART1_IRQ(void) { bool resched = false; arm_cm_irq_entry(); /* UART parity error interrupt occurred -------------------------------------*/ if ((__HAL_UART_GET_IT(&handle, UART_IT_PE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_PE) != RESET)) { __HAL_UART_CLEAR_PEFLAG(&handle); printf("UART PARITY ERROR\n"); } /* UART frame error interrupt occurred --------------------------------------*/ if ((__HAL_UART_GET_IT(&handle, UART_IT_FE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_ERR) != RESET)) { __HAL_UART_CLEAR_FEFLAG(&handle); printf("UART FRAME ERROR\n"); } /* UART noise error interrupt occurred --------------------------------------*/ if ((__HAL_UART_GET_IT(&handle, UART_IT_NE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_ERR) != RESET)) { __HAL_UART_CLEAR_NEFLAG(&handle); printf("UART NOISE ERROR\n"); } /* UART Over-Run interrupt occurred -----------------------------------------*/ if ((__HAL_UART_GET_IT(&handle, UART_IT_ORE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_ERR) != RESET)) { __HAL_UART_CLEAR_OREFLAG(&handle); printf("UART OVERRUN ERROR\n"); } /* UART in mode Receiver ---------------------------------------------------*/ if ((__HAL_UART_GET_IT(&handle, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_RXNE) != RESET)) { /* we got a character */ uint8_t c = (uint8_t)(handle.Instance->RDR & 0xff); if (cbuf_write_char(&uart1_rx_buf, c, false) != 1) { printf("WARNING: uart cbuf overrun!\n"); } resched = true; /* Clear RXNE interrupt flag */ __HAL_UART_SEND_REQ(&handle, UART_RXDATA_FLUSH_REQUEST); } /* UART in mode Transmitter ------------------------------------------------*/ if ((__HAL_UART_GET_IT(&handle, UART_IT_TXE) != RESET) &&(__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_TXE) != RESET)) { ; } /* UART in mode Transmitter (transmission end) -----------------------------*/ if ((__HAL_UART_GET_IT(&handle, UART_IT_TC) != RESET) &&(__HAL_UART_GET_IT_SOURCE(&handle, UART_IT_TC) != RESET)) { ; } arm_cm_irq_exit(resched); }
void UART_ProcessStatus(UART_HandleTypeDef* pUart) { /* UART parity error interrupt occurred ------------------------------------*/ if ((__HAL_UART_GET_IT(pUart, UART_IT_PE) != RESET) && (__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_PE) != RESET)) { __HAL_UART_CLEAR_IT(pUart, UART_CLEAR_PEF); pUart->ErrorCode |= HAL_UART_ERROR_PE; } /* UART frame error interrupt occurred --------------------------------------*/ if ((__HAL_UART_GET_IT(pUart, UART_IT_FE) != RESET) && (__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_ERR) != RESET)) { __HAL_UART_CLEAR_IT(pUart, UART_CLEAR_FEF); pUart->ErrorCode |= HAL_UART_ERROR_FE; } /* UART noise error interrupt occurred --------------------------------------*/ if ((__HAL_UART_GET_IT(pUart, UART_IT_NE) != RESET) && (__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_ERR) != RESET)) { __HAL_UART_CLEAR_IT(pUart, UART_CLEAR_NEF); pUart->ErrorCode |= HAL_UART_ERROR_NE; } /* UART Over-Run interrupt occurred -----------------------------------------*/ if ((__HAL_UART_GET_IT(pUart, UART_IT_ORE) != RESET) && (__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_ERR) != RESET)) { __HAL_UART_CLEAR_IT(pUart, UART_CLEAR_OREF); pUart->ErrorCode |= HAL_UART_ERROR_ORE; } /* Call UART Error Call back function if need be --------------------------*/ if (pUart->ErrorCode != HAL_UART_ERROR_NONE) { HAL_UART_ErrorCallback(pUart); } /* UART Wake Up interrupt occurred ------------------------------------------*/ if ((__HAL_UART_GET_IT(pUart, UART_IT_WUF) != RESET) && (__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_WUF) != RESET)) { __HAL_UART_CLEAR_IT(pUart, UART_CLEAR_WUF); HAL_UARTEx_WakeupCallback(pUart); } }
/** * @brief This function handles USART1 global interrupt. */ void USART1_IRQHandler(void) { uint8_t tmp1,tmp2; tmp1 = __HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE); tmp2 = __HAL_UART_GET_IT_SOURCE(&huart1, UART_IT_RXNE); if((tmp1 != RESET) && (tmp2 != RESET)) { RxBuffer[RxBufferHead] = UART_ReceiveData(&huart1); RxBufferHead = (RxBufferHead + 1) % RX_BUFFER_SIZE; } }
/** * @brief This function handles UART interrupt request. * @param huart: pointer to a UART_HandleTypeDef structure that contains * the configuration information for the specified UART module. * @retval None */ void vUARTIRQHandler(UART_HandleTypeDef *pxUARTHandle) { uint32_t tmp1 = 0, tmp2 = 0; tmp1 = __HAL_UART_GET_FLAG(pxUARTHandle, UART_FLAG_RXNE); tmp2 = __HAL_UART_GET_IT_SOURCE(pxUARTHandle, UART_IT_RXNE); /* UART in mode Receiver ---------------------------------------------------*/ if((tmp1 != RESET) && (tmp2 != RESET)) { vUARTReceive(pxUARTHandle); } }
/** * @brief This function handles UART interrupt request. * @param None * @retval None */ void USART1_IRQHandler(void) { /* Check if it's a RX interrupt */ uint32_t tmp_flag = 0, tmp_it_source = 0; tmp_flag = __HAL_UART_GET_FLAG(&UART_Handle, UART_FLAG_RXNE); tmp_it_source = __HAL_UART_GET_IT_SOURCE(&UART_Handle, UART_IT_RXNE); if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { UART1_DataReceivedHandler(); } /* Otherwise call the HAL IRQ handler */ else HAL_UART_IRQHandler(&UART_Handle); }
static void uart_irq(int id) { UART_HandleTypeDef * huart = &uart_handlers[id]; if (serial_irq_ids[id] != 0) { if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) { if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) { irq_handler(serial_irq_ids[id], TxIrq); __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC); } } if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) { if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) { irq_handler(serial_irq_ids[id], RxIrq); __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_RXNE); } } if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) { if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) { volatile uint32_t tmpval = huart->Instance->DR; // Clear ORE flag } } } }
/** * @brief This function handles USART2 global interrupt. */ void USART2_IRQHandler(void) { /* USER CODE BEGIN USART2_IRQn 0 */ #if 1 if(__HAL_UART_GET_FLAG(&huart2, UART_FLAG_IDLE) && __HAL_UART_GET_IT_SOURCE(&huart2, UART_IT_IDLE)) { __HAL_UART_CLEAR_IDLEFLAG(&huart2); ESP8266_RecvCallback(RECV_IDLE); } #else /* USER CODE END USART2_IRQn 0 */ HAL_UART_IRQHandler(&huart2); /* USER CODE BEGIN USART2_IRQn 1 */ #endif /* USER CODE END USART2_IRQn 1 */ }
void USART3_IRQHandler(void) { struct stm32_uart *uart; uart = &uart3; /* enter interrupt */ rt_interrupt_enter(); /* UART in mode Receiver ---------------------------------------------------*/ if ((__HAL_UART_GET_IT(&uart->UartHandle, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&uart->UartHandle, UART_IT_RXNE) != RESET)) { rt_hw_serial_isr(&serial3, RT_SERIAL_EVENT_RX_IND); /* Clear RXNE interrupt flag */ __HAL_UART_SEND_REQ(&uart->UartHandle, UART_RXDATA_FLUSH_REQUEST); } /* leave interrupt */ rt_interrupt_leave(); }
void USART2_IRQHandler(void) { struct drv_uart *uart; uart = &uart2; /* enter interrupt */ rt_interrupt_enter(); /* UART in mode Receiver -------------------------------------------------*/ if ((__HAL_UART_GET_FLAG(&uart->UartHandle, UART_FLAG_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&uart->UartHandle, UART_IT_RXNE) != RESET)) { rt_hw_serial_isr(&serial2, RT_SERIAL_EVENT_RX_IND); /* Clear RXNE interrupt flag */ __HAL_UART_CLEAR_FLAG(&uart->UartHandle, UART_FLAG_RXNE); } /* leave interrupt */ rt_interrupt_leave(); }
/** * @brief This function handles USART1 global interrupt. */ void USART1_IRQHandler(void) { /* USER CODE BEGIN USART1_IRQn 0 */ uint32_t tmp1, tmp2; tmp1 = __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE); tmp2 = __HAL_UART_GET_IT_SOURCE(&huart1, UART_IT_IDLE); if((tmp1 != RESET) && (tmp2 != RESET)) { __HAL_UART_DISABLE_IT(&huart1, UART_IT_IDLE); __HAL_UART_CLEAR_IDLEFLAG(&huart1); My_HAL_UART_IdleCallback(&huart1); } /* USER CODE END USART1_IRQn 0 */ HAL_UART_IRQHandler(&huart1); /* USER CODE BEGIN USART1_IRQn 1 */ /* USER CODE END USART1_IRQn 1 */ }
bool UART_GetCharacter(UART_HandleTypeDef* pUart, uint8_t* pChar) { UART_ProcessStatus(pUart); /* UART in mode Receiver ---------------------------------------------------*/ if((__HAL_UART_GET_IT(pUart, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(pUart, UART_IT_RXNE) != RESET)) { if((pUart->gState == HAL_UART_STATE_BUSY_RX) || (pUart->gState == HAL_UART_STATE_BUSY_TX_RX)) { *pChar = (uint8_t) (pUart->Instance->RDR & (uint8_t) pUart->Mask); return true; } else { return false; } } else { return false; } }
/** * @brief This function handles UART interrupt request. * @param huart: uart handle * @retval None */ void HAL_UART_IRQHandler(UART_HandleTypeDef *huart) { /* UART parity error interrupt occurred -------------------------------------*/ if((__HAL_UART_GET_IT(huart, UART_IT_PE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_PE) != RESET)) { __HAL_UART_CLEAR_IT(huart, UART_CLEAR_PEF); huart->ErrorCode |= HAL_UART_ERROR_PE; /* Set the UART state ready to be able to start again the process */ huart->State = HAL_UART_STATE_READY; } /* UART frame error interrupt occured --------------------------------------*/ if((__HAL_UART_GET_IT(huart, UART_IT_FE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET)) { __HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF); huart->ErrorCode |= HAL_UART_ERROR_FE; /* Set the UART state ready to be able to start again the process */ huart->State = HAL_UART_STATE_READY; } /* UART noise error interrupt occured --------------------------------------*/ if((__HAL_UART_GET_IT(huart, UART_IT_NE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET)) { __HAL_UART_CLEAR_IT(huart, UART_CLEAR_NEF); huart->ErrorCode |= HAL_UART_ERROR_NE; /* Set the UART state ready to be able to start again the process */ huart->State = HAL_UART_STATE_READY; } /* UART Over-Run interrupt occured -----------------------------------------*/ if((__HAL_UART_GET_IT(huart, UART_IT_ORE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET)) { __HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF); huart->ErrorCode |= HAL_UART_ERROR_ORE; /* Set the UART state ready to be able to start again the process */ huart->State = HAL_UART_STATE_READY; } /* Call UART Error Call back function if need be --------------------------*/ if(huart->ErrorCode != HAL_UART_ERROR_NONE) { HAL_UART_ErrorCallback(huart); } #if !defined(STM32F030x6) && !defined(STM32F030x8) /* UART wakeup from Stop mode interrupt occurred -------------------------------------*/ if((__HAL_UART_GET_IT(huart, UART_IT_WUF) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_WUF) != RESET)) { __HAL_UART_CLEAR_IT(huart, UART_CLEAR_WUF); /* Set the UART state ready to be able to start again the process */ huart->State = HAL_UART_STATE_READY; HAL_UART_WakeupCallback(huart); } #endif /* !defined(STM32F030x6) && !defined(STM32F030x8) */ /* UART in mode Receiver ---------------------------------------------------*/ if((__HAL_UART_GET_IT(huart, UART_IT_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET)) { UART_Receive_IT(huart); /* Clear RXNE interrupt flag */ __HAL_UART_SEND_REQ(huart, UART_RXDATA_FLUSH_REQUEST); } /* UART in mode Transmitter ------------------------------------------------*/ if((__HAL_UART_GET_IT(huart, UART_IT_TC) != RESET) &&(__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET)) { UART_Transmit_IT(huart); } }
/** * The asynchronous TX and RX handler. * * @param obj The serial object * @return Returns event flags if a TX/RX transfer termination condition was met or 0 otherwise */ int serial_irq_handler_asynch(serial_t *obj) { struct serial_s *obj_s = SERIAL_S(obj); UART_HandleTypeDef *huart = &uart_handlers[obj_s->index]; volatile int return_event = 0; uint8_t *buf = (uint8_t*)(obj->rx_buff.buffer); uint8_t i = 0; // TX PART: if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) { if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) { // Return event SERIAL_EVENT_TX_COMPLETE if requested if ((obj_s->events & SERIAL_EVENT_TX_COMPLETE ) != 0) { return_event |= (SERIAL_EVENT_TX_COMPLETE & obj_s->events); } } } // Handle error events if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) { if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) { return_event |= (SERIAL_EVENT_RX_PARITY_ERROR & obj_s->events); } } if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) { if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) { return_event |= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events); } } if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) { if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) { return_event |= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events); } } HAL_UART_IRQHandler(huart); // Abort if an error occurs if (return_event & SERIAL_EVENT_RX_PARITY_ERROR || return_event & SERIAL_EVENT_RX_FRAMING_ERROR || return_event & SERIAL_EVENT_RX_OVERRUN_ERROR) { return return_event; } //RX PART if (huart->RxXferSize != 0) { obj->rx_buff.pos = huart->RxXferSize - huart->RxXferCount; } if ((huart->RxXferCount == 0) && (obj->rx_buff.pos >= (obj->rx_buff.length - 1))) { return_event |= (SERIAL_EVENT_RX_COMPLETE & obj_s->events); } // Check if char_match is present if (obj_s->events & SERIAL_EVENT_RX_CHARACTER_MATCH) { if (buf != NULL) { for (i = 0; i < obj->rx_buff.pos; i++) { if (buf[i] == obj->char_match) { obj->rx_buff.pos = i; return_event |= (SERIAL_EVENT_RX_CHARACTER_MATCH & obj_s->events); serial_rx_abort_asynch(obj); break; } } } } return return_event; }
void CommUartIrqHandler(UART_HandleTypeDef *huart) { uint32_t tmp_flag = 0, tmp_it_source = 0; tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_PE); tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_PE); /* UART parity error interrupt occurred ------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { __HAL_UART_CLEAR_PEFLAG(huart); huart->ErrorCode |= HAL_UART_ERROR_PE; } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_FE); tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR); /* UART frame error interrupt occurred -------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { __HAL_UART_CLEAR_FEFLAG(huart); huart->ErrorCode |= HAL_UART_ERROR_FE; } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_NE); /* UART noise error interrupt occurred -------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { __HAL_UART_CLEAR_NEFLAG(huart); huart->ErrorCode |= HAL_UART_ERROR_NE; } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_ORE); /* UART Over-Run interrupt occurred ----------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { __HAL_UART_CLEAR_OREFLAG(huart); huart->ErrorCode |= HAL_UART_ERROR_ORE; } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE); tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE); /* UART in mode Receiver ---------------------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { CommUartRxIrqProcess(huart); } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_TXE); tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_TXE); /* UART in mode Transmitter ------------------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { CommUartTxIrqProcess(huart); } tmp_flag = __HAL_UART_GET_FLAG(huart, UART_FLAG_TC); tmp_it_source = __HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC); /* UART in mode Transmitter end --------------------------------------------*/ if ((tmp_flag != RESET) && (tmp_it_source != RESET)) { } if (huart->ErrorCode != HAL_UART_ERROR_NONE) { /* Set the UART state ready to be able to start again the process */ huart->State = HAL_UART_STATE_READY; HAL_UART_ErrorCallback(huart); } }
void UART_IRQProc(UART_CCB *uccb, UART_HandleTypeDef *UARTx) { uint32_t tmp1 = 0, tmp2 = 0; tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_PE); tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_PE); /* UART parity error interrupt occurred ------------------------------------*/ if((tmp1 != RESET) && (tmp2 != RESET)) { __HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_PE); UARTx->ErrorCode |= HAL_UART_ERROR_PE; } tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_FE); tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_ERR); /* UART frame error interrupt occurred -------------------------------------*/ if((tmp1 != RESET) && (tmp2 != RESET)) { __HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_FE); UARTx->ErrorCode |= HAL_UART_ERROR_FE; } tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_NE); tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_ERR); /* UART noise error interrupt occurred -------------------------------------*/ if((tmp1 != RESET) && (tmp2 != RESET)) { __HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_NE); UARTx->ErrorCode |= HAL_UART_ERROR_NE; } tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_ORE); tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_ERR); /* UART Over-Run interrupt occurred ----------------------------------------*/ if((tmp1 != RESET) && (tmp2 != RESET)) { __HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_ORE); UARTx->ErrorCode |= HAL_UART_ERROR_ORE; } tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_RXNE); tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_RXNE); /* UART in mode Receiver ---------------------------------------------------*/ if((tmp1 != RESET) && (tmp2 != RESET)) { //UART_Receive_IT(UARTx); *uccb->gpUartRxAddress++ = (uint8_t)(UARTx->Instance->DR & (uint8_t)0x00FF); if(uccb->gpUartRxAddress == uccb->gpUartRxEndAddress) { //回头 uccb->gpUartRxAddress = uccb->gpUartRxStartAddress; } if(uccb->gpUartRxReadAddress == uccb->gpUartRxAddress) { //可以考虑加错误统计 } __HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_RXNE); #if (LED_UART_EN > 0u) LED_UART_ON(); #endif } tmp1 = __HAL_UART_GET_FLAG(UARTx, UART_FLAG_TXE); tmp2 = __HAL_UART_GET_IT_SOURCE(UARTx, UART_IT_TXE); /* UART in mode Transmitter ------------------------------------------------*/ if((tmp1 != RESET) && (tmp2 != RESET)) { //UART_Transmit_IT(UARTx); if(uccb->gUartTxCnt > 0) { UARTx->Instance->DR = (uint8_t)(*uccb->gpUartTxAddress++ & (uint8_t)0x00FF); uccb->gUartTxCnt--; } else { __HAL_UART_DISABLE_IT(UARTx, UART_IT_TXE); } __HAL_UART_CLEAR_FLAG(UARTx, UART_FLAG_TXE); #if (LED_UART_EN > 0u) LED_UART_ON(); #endif } if(UARTx->ErrorCode != HAL_UART_ERROR_NONE) { /* Set the UART state ready to be able to start again the process */ UARTx->State = HAL_UART_STATE_READY; HAL_UART_ErrorCallback(UARTx); } }
/** * @brief This function handles USART3 global interrupt. */ void USART3_IRQHandler(void) { /* USER CODE BEGIN USART3_IRQn 0 */ uint32_t uart_status_flag; uint32_t uart_it_flag; static char *pBuffer = serial_buffer; unsigned char c; /* USER CODE END USART3_IRQn 0 */ HAL_UART_IRQHandler(&huart3); /* USER CODE BEGIN USART3_IRQn 1 */ // Get UART flags uart_status_flag = __HAL_UART_GET_FLAG(&huart3, UART_FLAG_RXNE); uart_it_flag = __HAL_UART_GET_IT_SOURCE(&huart3, UART_IT_RXNE); if ((uart_status_flag != RESET) && (uart_it_flag != RESET)) { // Clear interrupt flag __HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_RXNE); // Get the character received c = (uint16_t)(huart3.Instance->DR & (uint16_t)0x01FF); switch (c) { case CMDLINE_CR: // Carriage Return cmdline_ctxt.cmd_len = (pBuffer - serial_buffer) + 1; cmdline_ctxt.cmd_received = TRUE; *pBuffer = c; pBuffer = serial_buffer; return; case CMDLINE_LF: // Line Feed pBuffer = serial_buffer; break; case CMDLINE_BS: // Backspace if (pBuffer == serial_buffer) { HAL_UART_Transmit(&huart3, (unsigned char *)"\x07", 1, 100); } else { HAL_UART_Transmit(&huart3, (unsigned char *)"\x08\x7F", 2, 100); pBuffer--; } break; default: /* Echo received character */ HAL_UART_Transmit(&huart3, &c, 1, 100); *pBuffer = c; pBuffer++; break; } } /* USER CODE END USART3_IRQn 1 */ }