void UART1_IRQHandler(void) { while ((itid = UART_GetPendingITID(UART0)) != UART_ITID_None) { if (itid == UART_ITID_RxLineStatus) { tmp = UART_GetLineStatus(UART); if (tmp & UART_BI) { /* BREAK */ } else if (tmp & (UART_OE | UART_PE | UART_FE)) { /* Overflow / Parity / Framing Error */ } UART_Recv(UART0); continue; } else if ((itid == UART_ITID_RxDataAvailable) || (itid == UART_ITID_CharacterTimeout)) { tmp = UART_Recv(UART); } else if (itid == UART_ITID_TxEmpty) { } else if (itid == UART_ITID_ModemStatus) { } else { /* UART_ITID_CharacterTimeOut */ } } }
/******************************************************************************* * Function Name : USART4_IRQHandler * Description : This function handles USART0 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void USART4_IRQHandler(void) { uint32_t intsrc; uint8_t lineStatus; OSIntEnter(); /****通知os进入中断*/ intsrc=UART_GetIntId(UART_4); if((intsrc&0x0f)==UART_IIR_INTID_RLS) /****接收线中断****/ { //2.1 检查线状态 lineStatus = UART_GetLineStatus(UART_4);//读取LSR时中断会被清除 prvvUARTRxISR(RS485_4); } /****接收数据或者超时中断****/ else if (((intsrc&0x0f) == UART_IIR_INTID_RDA) || ((intsrc&0x0f) == UART_IIR_INTID_CTI)) { prvvUARTRxISR(RS485_4); } /******发送中断*************/ else if((intsrc&0x0f) == UART_IIR_INTID_THRE) { prvvUARTTxReadyISR(RS485_4); } OSIntExit(); /*****通知os退出中断******/ }
/*********************************************************************//** * @brief UART1 interrupt handler sub-routine * @param[in] None * @return None **********************************************************************/ void UART1_IRQHandler(void) { // Call Standard UART 0 interrupt handler uint32_t intsrc, tmp, tmp1; /* Determine the interrupt source */ intsrc = UART_GetIntId(LPC_UART0); tmp = intsrc & UART_IIR_INTID_MASK; // Receive Line Status if (tmp == UART_IIR_INTID_RLS){ // Check line status tmp1 = UART_GetLineStatus(LPC_UART0); // Mask out the Receive Ready and Transmit Holding empty status tmp1 &= (UART_LSR_OE | UART_LSR_PE | UART_LSR_FE \ | UART_LSR_BI | UART_LSR_RXFE); // If any error exist if (tmp1) { UART_IntErr(tmp1); } } // Receive Data Available or Character time-out if ((tmp == UART_IIR_INTID_RDA) || (tmp == UART_IIR_INTID_CTI)){ UART_IntReceive(); } }
/** @brief Send a character via UART * * @param [in] uart The UART on which to send the character * @param [in] c The character to send * * @return None. * * Blocks until the UART is ready to accept the new character, then * writes it. */ void uart_putchar(UART_Type *uart, uint8_t c) { /* Wait for tx holding register to empty */ while ((UART_GetLineStatus(uart) & UART_LineStatus_TxEmpty) == 0); /* Send character */ UART_Send(uart, c); }
/*********************************************************************//** * @brief UART1 interrupt handler sub-routine * @param[in] None * @return None **********************************************************************/ void UART1_IRQHandler(void) { uint8_t modemsts; uint32_t intsrc, tmp, tmp1; /* Determine the interrupt source */ intsrc = UART_GetIntId((LPC_UART_TypeDef *)LPC_UART1); tmp = intsrc & UART_IIR_INTID_MASK; /* * In case of using UART1 with full modem, * interrupt ID = 0 that means modem status interrupt has been detected */ if (tmp == 0){ // Check Modem status modemsts = UART_FullModemGetStatus(LPC_UART1); #if (AUTO_RTS_CTS_USE == 0) // Check CTS status change flag if (modemsts & UART1_MODEM_STAT_DELTA_CTS) { // if CTS status is active, continue to send data if (modemsts & UART1_MODEM_STAT_CTS) { // Re-Enable Tx UART_TxCmd((LPC_UART_TypeDef *)LPC_UART1, ENABLE); } // Otherwise, Stop current transmission immediately else{ // Disable Tx UART_TxCmd((LPC_UART_TypeDef *)LPC_UART1, DISABLE); } } #endif } // Receive Line Status if (tmp == UART_IIR_INTID_RLS){ // Check line status tmp1 = UART_GetLineStatus((LPC_UART_TypeDef *)LPC_UART1); // Mask out the Receive Ready and Transmit Holding empty status tmp1 &= (UART_LSR_OE | UART_LSR_PE | UART_LSR_FE \ | UART_LSR_BI | UART_LSR_RXFE); // If any error exist if (tmp1) { UART1_IntErr(tmp1); } } // Receive Data Available or Character time-out if ((tmp == UART_IIR_INTID_RDA) || (tmp == UART_IIR_INTID_CTI)){ UART1_IntReceive(); } // Transmit Holding Empty if (tmp == UART_IIR_INTID_THRE){ UART1_IntTransmit(); } }
/*********************************************************************//** * @brief UART0 interrupt handler sub-routine * @param None * @return None **********************************************************************/ void UART0_IRQHandler(void) { // Call Standard UART 0 interrupt handler uint32_t intsrc, tmp, tmp1; /* Determine the interrupt source */ intsrc = UART_GetIntId(LPC_UART0); tmp = intsrc & UART_IIR_INTID_MASK; // Receive Line Status if (tmp == UART_IIR_INTID_RLS){ // Check line status tmp1 = UART_GetLineStatus(LPC_UART0); // Mask out the Receive Ready and Transmit Holding empty status tmp1 &= (UART_LSR_OE | UART_LSR_PE | UART_LSR_FE \ | UART_LSR_BI | UART_LSR_RXFE); // If any error exist if (tmp1) { while(tmp1){ ; //implement error handling here } } } intsrc &= (UART_IIR_ABEO_INT | UART_IIR_ABTO_INT); // Check if End of auto-baudrate interrupt or Auto baudrate time out if (intsrc){ // Clear interrupt pending if(intsrc & UART_IIR_ABEO_INT) UART_ABClearIntPending(LPC_UART0, UART_AUTOBAUD_INTSTAT_ABEO); if (intsrc & UART_IIR_ABTO_INT) UART_ABClearIntPending(LPC_UART0, UART_AUTOBAUD_INTSTAT_ABTO); if (Synchronous == RESET) { /* Interrupt caused by End of auto-baud */ if (intsrc & UART_AUTOBAUD_INTSTAT_ABEO){ // Disable AB interrupt UART_IntConfig(LPC_UART0, UART_INTCFG_ABEO, DISABLE); // Set Sync flag Synchronous = SET; } /* Auto-Baudrate Time-Out interrupt (not implemented) */ if (intsrc & UART_AUTOBAUD_INTSTAT_ABTO) { /* Just clear this bit - Add your code here */ UART_ABClearIntPending(LPC_UART0, UART_AUTOBAUD_INTSTAT_ABTO); } } } }
/** @brief Receive a character via UART * * @param [in] uart The UART on which to receive the character * * @return The received character * * Blocks until the UART has a character available to read. */ uint8_t uart_getchar(UART_Type *uart) { uint8_t c; /* Wait for a character to be ready */ while ((UART_GetLineStatus(uart) & UART_LineStatus_RxData) == 0); /* Receive it */ c = UART_Recv(uart); return c; }
/******************************************************************************* * Function Name : USART0_IRQHandler * Description : This function handles USART0 global interrupt request. * Input : None * Output : None * Return : None *******************************************************************************/ void USART0_IRQHandler(void) { // rt_interrupt_enter(); // //溢出错误 // if (USART_GetFlagStatus(USART2, USART_FLAG_ORE) == SET) // { // prvvUARTRxISR(); // } // //接收中断 // if (USART_GetITStatus(USART2, USART_IT_RXNE) == SET) // { // USART_ClearITPendingBit(USART2, USART_IT_RXNE); // prvvUARTRxISR(); // } // //发送中断 // if (USART_GetITStatus(USART2, USART_IT_TXE) == SET) // { // prvvUARTTxReadyISR(); // } // rt_interrupt_leave(); uint32_t intsrc; uint8_t lineStatus; OSIntEnter(); /****通知os进入中断*/ intsrc=UART_GetIntId(UART_0); if((intsrc&0x0f)==UART_IIR_INTID_RLS) /****接收线中断****/ { //2.1 检查线状态 lineStatus = UART_GetLineStatus(UART_0);//读取LSR时中断会被清除 prvvUARTRxISR(RS485_1); } /****接收数据或者超时中断****/ else if (((intsrc&0x0f) == UART_IIR_INTID_RDA) || ((intsrc&0x0f) == UART_IIR_INTID_CTI)) { prvvUARTRxISR(RS485_1); } /******发送中断*************/ else if((intsrc&0x0f) == UART_IIR_INTID_THRE) { prvvUARTTxReadyISR(RS485_1); } OSIntExit(); /*****通知os退出中断******/ }
/************************************************************* Function: void UART2_IRQHandler (void) Description: UART2中断函数,RS485接收中断 Calls: Called By: 无 Input: 无 Output: RS485Rx1.Len RS485Rx1.Idx RS485Rx1.Flag Return: 无 Others: 无 *************************************************************/ void UART2_IRQHandler ( void ) { uint32_t intsrc, tmp, tmp1; /* Determine the interrupt source */ intsrc = UART_GetIntId ( LPC_UART2 ); tmp = intsrc & UART_IIR_INTID_MASK; // Receive Line Status if ( tmp == UART_IIR_INTID_RLS ) { // Check line status tmp1 = UART_GetLineStatus ( LPC_UART2 ); // Mask out the Receive Ready and Transmit Holding empty status tmp1 &= ( UART_LSR_OE | UART_LSR_PE | UART_LSR_FE \ | UART_LSR_BI | UART_LSR_RXFE ); // If any error exist if ( tmp1 ) { RS4852_Err++; } } // Receive Data Available if ( ( tmp == UART_IIR_INTID_RDA ) ) { RS485Rx2.Len += UARTReceive ( LPC_UART2, &RS485Rx2.Buff[RS485Rx2.Idx], 0 ); RS485Rx2.Idx = RS485Rx2.Len ; FrameCntRS4852 = 0 ; } //Character time-out if ( tmp == UART_IIR_INTID_CTI ) { RS485Rx2.Len += UARTReceive ( LPC_UART2, &RS485Rx2.Buff[RS485Rx2.Idx], 0 ); RS485Rx2.Idx = RS485Rx2.Len ; RS485Rx2.Flag = 1 ; } }
/************************************************************* Function: void UART3_IRQHandler (void) Description: UART3中断函数,RS232接收中断 Calls: Called By: 无 Input: 无 Output: RS232Rx.Len RS232Rx.Idx RS232Rx.Flag Return: 无 Others: 无 *************************************************************/ void UART3_IRQHandler ( void ) { uint32_t intsrc, tmp, tmp1; /* Determine the interrupt source */ intsrc = UART_GetIntId ( RS232_UART ); tmp = intsrc & UART_IIR_INTID_MASK; // Receive Line Status if ( tmp == UART_IIR_INTID_RLS ) { // Check line status tmp1 = UART_GetLineStatus ( RS232_UART ); // Mask out the Receive Ready and Transmit Holding empty status tmp1 &= ( UART_LSR_OE | UART_LSR_PE | UART_LSR_FE \ | UART_LSR_BI | UART_LSR_RXFE ); // If any error exist if ( tmp1 ) { RS232_Err++;//UART_DeInit(RS232_UART);UartInit ( 0, 115200, UART_PARITY_NONE ); } } // Receive Data Available if ( ( tmp == UART_IIR_INTID_RDA ) ) { RS232Rx.Len += UARTReceive ( RS232_UART, &RS232Rx.Buff[RS232Rx.Idx], 0 ); RS232Rx.Idx = RS232Rx.Len ; FrameCntRS232 = 0 ; } //Character time-out if ( tmp == UART_IIR_INTID_CTI ) { RS232Rx.Len += UARTReceive ( RS232_UART, &RS232Rx.Buff[RS232Rx.Idx], 0 ); RS232Rx.Idx = RS232Rx.Len ; RS232Rx.Flag = 1 ; } }
void UART0_IRQHandler(void) { uint8_t tmpc; uint32_t tmp, tmp1; tmp = ((LPC_UART0->IIR) & UART_IIR_BITMASK) & UART_IIR_INTID_MASK; if (tmp == UART_IIR_INTID_RLS) // Receive Line Status { tmp1 = UART_GetLineStatus(UART_0);// Check line status tmp1 &= (UART_LSR_OE | UART_LSR_PE | UART_LSR_FE | UART_LSR_BI | UART_LSR_RXFE);// Mask out the Receive Ready and Transmit Holding empty status } if ((tmp == UART_IIR_INTID_RDA) || (tmp == UART_IIR_INTID_CTI)) // Receive Data Available or Character time-out { UART_Receive(UART_0, &tmpc, 1, NONE_BLOCKING); if(tmpc >= GUI_KEY_MENU && tmpc <= GUI_KEY_PGDOWN) { isKeyTrigged = 1; switch(tmpc) { case GUI_KEY_TRACE_ENABLE: break; case GUI_KEY_TRACE_DISABLE: break; default: GUI_StoreKeyMsg(tmpc, 1); break; } } else if(tmpc >= 0x80 && tmpc <(0x80+21)) { GUI_StoreKeyMsg(GUI_KEY_RELEASE, 1); } else { } } }
void UART0_IRQHandler(void) { struct lpc_uart *uart; uint32_t intsrc, tmp, tmp1; uart = &uart0; /* enter interrupt */ rt_interrupt_enter(); /* Determine the interrupt source */ intsrc = UART_GetIntId(uart->UART); tmp = intsrc & UART_IIR_INTID_MASK; // Receive Line Status if (tmp == UART_IIR_INTID_RLS) { // Check line status tmp1 = UART_GetLineStatus(uart->UART); // Mask out the Receive Ready and Transmit Holding empty status tmp1 &= (UART_LSR_OE | UART_LSR_PE | UART_LSR_FE \ | UART_LSR_BI | UART_LSR_RXFE); // If any error exist if (tmp1) { // } } // Receive Data Available or Character time-out if ((tmp == UART_IIR_INTID_RDA) || (tmp == UART_IIR_INTID_CTI)) { rt_hw_serial_isr(&serial0); } /* leave interrupt */ rt_interrupt_leave(); }
void Uart_X_Isr(int which_port) { uint32_t intsrc, tmp, tmp1; LPC_UART_TypeDef *UARTx; UARTx=(LPC_UART_TypeDef *)uartDrvDataArray[which_port].reg_base; /* Determine the interrupt source */ intsrc = UART_GetIntId(UARTx); tmp = intsrc & UART_IIR_INTID_MASK; // Receive Line Status if (tmp == UART_IIR_INTID_RLS){ // Check line status tmp1 = UART_GetLineStatus(UARTx); // Mask out the Receive Ready and Transmit Holding empty status tmp1 &= (UART_LSR_OE | UART_LSR_PE | UART_LSR_FE \ | UART_LSR_BI | UART_LSR_RXFE); // If any error exist if (tmp1) { UART_IntErr(tmp1); } } // Receive Data Available or Character time-out if ((tmp == UART_IIR_INTID_RDA) || (tmp == UART_IIR_INTID_CTI)){ UART_IntReceive(which_port); } // Transmit Holding Empty if (tmp == UART_IIR_INTID_THRE){ #if 0 UART_IntTransmit(); #else innerDeadNoOutput(); #endif } }
/* *@描述:串口中断 *@参数:void *@返回:无 */ void _UART_IRQHander(void) { uint32_t intsrc, tmp, tmp1; //OSIntEnter(); // Determine the interrupt source intsrc = UART_GetIntId((LPC_UART_TypeDef *)_LPC_UART); tmp = intsrc & UART_IIR_INTID_MASK; // Receive Line Status if (tmp == UART_IIR_INTID_RLS){ // Check line status tmp1 = UART_GetLineStatus((LPC_UART_TypeDef *)_LPC_UART); // Mask out the Receive Ready and Transmit Holding empty status tmp1 &= (UART_LSR_OE | UART_LSR_PE | UART_LSR_FE \ | UART_LSR_BI | UART_LSR_RXFE); // If any error exist if (tmp1) { UART_IntErr(tmp1); } } // Receive Data Available or Character time-out if ((tmp == UART_IIR_INTID_RDA) || (tmp == UART_IIR_INTID_CTI)){ UART_IntReceive(); //UART_Receive((LPC_UART_TypeDef *)_LPC_UART,&tmpchar,1,BLOCKING); } // Transmit Holding Empty if (tmp == UART_IIR_INTID_THRE){ //UART_IntTransmit(); } //OSIntExit(); }
/*---------------------------------------------------------------------------- Serial Device "LPC17xx" Send buffer *----------------------------------------------------------------------------*/ static int UartDev_BufTx (void *pData, int* pSize, unsigned int flags) { char *pChar; int bytesToWrite, bytesWritten; uint8_t tmpc; if (UARTInfo.State != _STATE_INITIALIZED_) { return (-1); /* Device not initialized */ } if ((pData == 0 ) && (*pSize > 0)) { return (-1); /* Parameter not valid */ } pChar = (char *)pData; bytesToWrite = *pSize; if (flags == UartDev_FLAG_BLOCKING) { /* Blocking transmission */ while (bytesToWrite-- > 0) { while (__BUF_FULL(BufTx)); /* Block until space is available */ __BUF_WR(BufTx, *pChar++); if (TxRestart) { /* If transmit interrupt is disabled, enable it */ // TxRestart = 0; if (UART_GetLineStatus(UARTInfo.pUart) & UART_LINESTAT_THRE){ if (!__BUF_EMPTY(BufTx)) { TxRestart = 0; tmpc = __BUF_RD(BufTx); UART_Send(UARTInfo.pUart, &tmpc, 1, BLOCKING); UART_IntConfig(UARTInfo.pUart, UART_INTCFG_THRE, ENABLE); /* enable TX interrupt */ } } // UART_IntConfig(UARTInfo.pUart, UART_INTCFG_THRE, ENABLE); /* enable TX interrupt */ } } } else { /* nonBlocking transmission */ bytesWritten = 0; while (bytesToWrite-- > 0) { if (!__BUF_FULL(BufTx)) { __BUF_WR(BufTx, *pChar++); /* just fill buffer */ bytesWritten++; } else { bytesToWrite = 0; } } *pSize = bytesWritten; /* return bytes written */ if (TxRestart) { /* If transmit interrupt is disabled, enable it */ // TxRestart = 0; if (UART_GetLineStatus(UARTInfo.pUart) & UART_LINESTAT_THRE){ if (!__BUF_EMPTY(BufTx)){ TxRestart = 0; tmpc = __BUF_RD(BufTx); UART_Send(UARTInfo.pUart, &tmpc, 1, BLOCKING); UART_IntConfig(UARTInfo.pUart, UART_INTCFG_THRE, ENABLE); /* enable TX interrupt */ } } // UART_IntConfig(UARTInfo.pUart, UART_INTCFG_THRE, ENABLE); /* enable TX interrupt */ } } return(0); /* success */ }
/** @brief Determine whether the given UART has a character in the rcv buffer * * @param [in] uart The UART to check * * @return 1 if the UART has at least 1 character available, 0 otherwise. */ int uart_available(UART_Type *uart) { return (UART_GetLineStatus(uart) & UART_LineStatus_RxData) ? 1:0; }
uint8 GetUart0Status(void) { return UART_GetLineStatus((LPC_UART_TypeDef *)LPC_UART0); }