//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 */
}
