#include "McuBspUart.h"

typedef struct {
    uint8_t Enable;
    uint8_t Mode;
    uint32_t BandRate;
    uint32_t DataBit;
    uint32_t StopBit;
    uint32_t CheckBit;
    uint8_t Txbusy;
    uint8_t Rxbusy;
} BSP_UART_OBJ;

static uint8_t gMcuBspUartRecvData0 = 0;
static uint8_t gMcuBspUartRecvData1 = 0;
static uint8_t gMcuBspUartRecvData2 = 0;
static uint8_t gMcuBspUartRecvData3 = 0;
static uint8_t gMcuBspUartRecvData4 = 0;
static uint8_t gMcuBspUartRecvData5 = 0;
static uint8_t gMcuBspUartRecvData6 = 0;
static uint8_t gMcuBspUartRecvData7 = 0;

static UART_RECV_CALLBACK gMcuBspUart0RecvCallback = NULL;
static UART_RECV_CALLBACK gMcuBspUart1RecvCallback = NULL;
static UART_RECV_CALLBACK gMcuBspUart2RecvCallback = NULL;
static UART_RECV_CALLBACK gMcuBspUart3RecvCallback = NULL;
static UART_RECV_CALLBACK gMcuBspUart4RecvCallback = NULL;
static UART_RECV_CALLBACK gMcuBspUart5RecvCallback = NULL;
static UART_RECV_CALLBACK gMcuBspUart6RecvCallback = NULL;
static UART_RECV_CALLBACK gMcuBspUart7RecvCallback = NULL;

static void McuBspUart0IntHandler(void);
static void McuBspUart1IntHandler(void);
static void McuBspUart2IntHandler(void);
static void McuBspUart3IntHandler(void);
static void McuBspUart4IntHandler(void);
static void McuBspUart5IntHandler(void);
static void McuBspUart6IntHandler(void);
static void McuBspUart7IntHandler(void);

static BSP_UART_OBJ gMcuBspUartObj[MCU_BSP_UART_ALL_NUM] = {{0, MCU_BSP_UART0_MODE, 0, 0, 0, 0, 0, 0},
                                                            {0, MCU_BSP_UART1_MODE, 0, 0, 0, 0, 0, 0},
                                                            {0, MCU_BSP_UART2_MODE, 0, 0, 0, 0, 0, 0},
                                                            {0, MCU_BSP_UART3_MODE, 0, 0, 0, 0, 0, 0},
                                                            {0, MCU_BSP_UART4_MODE, 0, 0, 0, 0, 0, 0},
                                                            {0, MCU_BSP_UART5_MODE, 0, 0, 0, 0, 0, 0},
                                                            {0, MCU_BSP_UART6_MODE, 0, 0, 0, 0, 0, 0},
                                                            {0, MCU_BSP_UART7_MODE, 0, 0, 0, 0, 0, 0}};

int McuBspUartInit(uint8_t UartId, uint32_t BandRate, uint32_t DataBit, uint32_t StopBit, uint32_t CheckBit)
{
    uint32_t ui32Status;
    if (UartId >= MCU_BSP_UART_ALL_NUM) {
        return -1;
    }
    if ((BandRate != MCU_BSP_UART_BANDRATE_4800) && (BandRate != MCU_BSP_UART_BANDRATE_9600) && (BandRate != MCU_BSP_UART_BANDRATE_14400) &&
        (BandRate != MCU_BSP_UART_BANDRATE_19200) && (BandRate != MCU_BSP_UART_BANDRATE_38400) && (BandRate != MCU_BSP_UART_BANDRATE_56000) &&
        (BandRate != MCU_BSP_UART_BANDRATE_57600) && (BandRate != MCU_BSP_UART_BANDRATE_115200)) {
        return -1;
    } else {
        gMcuBspUartObj[UartId].BandRate = BandRate;
    }
    switch (DataBit) {
        case MCU_BSP_UART_DATABIT_5:
            gMcuBspUartObj[UartId].DataBit = UART_CONFIG_WLEN_5;
            break;
        case MCU_BSP_UART_DATABIT_6:
            gMcuBspUartObj[UartId].DataBit = UART_CONFIG_WLEN_6;
            break;
        case MCU_BSP_UART_DATABIT_7:
            gMcuBspUartObj[UartId].DataBit = UART_CONFIG_WLEN_7;
            break;
        case MCU_BSP_UART_DATABIT_8:
            gMcuBspUartObj[UartId].DataBit = UART_CONFIG_WLEN_8;
            break;
        default:
            return -1;
    }
    switch (StopBit) {
        case MCU_BSP_UART_STOPBIT_ONE:
            gMcuBspUartObj[UartId].StopBit = UART_CONFIG_STOP_ONE;
            break;
        case MCU_BSP_UART_STOPBIT_TWO:
            gMcuBspUartObj[UartId].StopBit = UART_CONFIG_STOP_TWO;
            break;
        default:
            return -1;
    }
    switch (CheckBit) {
        case MCU_BSP_UART_CHECKBIT_NONE:
            gMcuBspUartObj[UartId].CheckBit = UART_CONFIG_PAR_NONE;
            break;
        case MCU_BSP_UART_CHECKBIT_EVEN:
            gMcuBspUartObj[UartId].CheckBit = UART_CONFIG_PAR_EVEN;
            break;
        case MCU_BSP_UART_CHECKBIT_ODD:
            gMcuBspUartObj[UartId].CheckBit = UART_CONFIG_PAR_ODD;
            break;
        default:
            return -1;
    }
    while ((gMcuBspUartObj[UartId].Txbusy == MCU_BSP_UART_BUSY) ||
           (gMcuBspUartObj[UartId].Rxbusy == MCU_BSP_UART_BUSY)) {
    }
    gMcuBspUartObj[UartId].Enable = MCU_BSP_UART_OFF;
    if (UartId == MCU_BSP_UART0) {
        SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
        SysCtlPeripheralEnable(MCU_BSP_UART0_RX_GPIO_CLK);
        SysCtlPeripheralEnable(MCU_BSP_UART0_TX_GPIO_CLK);
        GPIOPinConfigure(MCU_BSP_UART0_RX_GPIO_CONF);
        GPIOPinConfigure(MCU_BSP_UART0_TX_GPIO_CONF);
        GPIOPinTypeUART(MCU_BSP_UART0_RX_GPIO, MCU_BSP_UART0_RX_GPIO_PIN);
        GPIOPinTypeUART(MCU_BSP_UART0_TX_GPIO, MCU_BSP_UART0_TX_GPIO_PIN);
        UARTConfigSetExpClk(UART0_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            SysCtlPeripheralEnable(MCU_BSP_UART0_RS485_CTRL_GPIO_CLK);
            GPIODirModeSet(MCU_BSP_UART0_RS485_CTRL_GPIO, MCU_BSP_UART0_RS485_CTRL_GPIO_PIN, GPIO_DIR_MODE_OUT);
            GPIOPadConfigSet(MCU_BSP_UART0_RS485_CTRL_GPIO, MCU_BSP_UART0_RS485_CTRL_GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_WAKE_LOW);
            GPIOPinWrite(MCU_BSP_UART0_RS485_CTRL_GPIO, MCU_BSP_UART0_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART0_RS485_CTRL_GPIO_PIN);
        }
        BSP_IntVectSet((CPU_INT08U)BSP_INT_ID_UART0, (CPU_FNCT_VOID)McuBspUart0IntHandler);
        BSP_IntEn(BSP_INT_ID_UART0);
        IntEnable(INT_UART0);
        IntPrioritySet(INT_UART0, 3 << 5);
        UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
        ui32Status = UARTIntStatus(UART0_BASE, true);
        UARTIntClear(UART0_BASE, ui32Status);
        while(0 <= UARTCharGetNonBlocking(UART0_BASE));
    } else if (UartId == MCU_BSP_UART1) {
        SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
        SysCtlPeripheralEnable(MCU_BSP_UART1_RX_GPIO_CLK);
        SysCtlPeripheralEnable(MCU_BSP_UART1_TX_GPIO_CLK);
        GPIOPinConfigure(MCU_BSP_UART1_RX_GPIO_CONF);
        GPIOPinConfigure(MCU_BSP_UART1_TX_GPIO_CONF);
        GPIOPinTypeUART(MCU_BSP_UART1_RX_GPIO, MCU_BSP_UART1_RX_GPIO_PIN);
        GPIOPinTypeUART(MCU_BSP_UART1_TX_GPIO, MCU_BSP_UART1_TX_GPIO_PIN);
        UARTConfigSetExpClk(UART1_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
        SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
        GPIODirModeSet(GPIO_PORTK_BASE, GPIO_PIN_4, GPIO_DIR_MODE_OUT);
        GPIOPadConfigSet(GPIO_PORTK_BASE, GPIO_PIN_4, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            SysCtlPeripheralEnable(MCU_BSP_UART1_RS485_CTRL_GPIO_CLK);
            GPIOPinWrite(GPIO_PORTK_BASE, GPIO_PIN_4, GPIO_PIN_4);
            
            GPIODirModeSet(MCU_BSP_UART1_RS485_CTRL_GPIO, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN, GPIO_DIR_MODE_OUT);
            GPIOPadConfigSet(MCU_BSP_UART1_RS485_CTRL_GPIO, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
            GPIOPinWrite(MCU_BSP_UART1_RS485_CTRL_GPIO, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART1_RS485_CTRL_GPIO_PIN);
        } else {
            GPIOPinWrite(GPIO_PORTK_BASE, GPIO_PIN_4, ~GPIO_PIN_4);
        }
        BSP_IntVectSet((CPU_INT08U)BSP_INT_ID_UART1, (CPU_FNCT_VOID)McuBspUart1IntHandler);
        BSP_IntEn(BSP_INT_ID_UART1);
        IntEnable(INT_UART1);
        IntPrioritySet(INT_UART1, 3 << 5);
        UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT);
        ui32Status = UARTIntStatus(UART1_BASE, true);
        UARTIntClear(UART1_BASE, ui32Status);
        while(0 <= UARTCharGetNonBlocking(UART1_BASE));
    } else if (UartId == MCU_BSP_UART2) {
        SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2);
        SysCtlPeripheralEnable(MCU_BSP_UART2_RX_GPIO_CLK);
        SysCtlPeripheralEnable(MCU_BSP_UART2_TX_GPIO_CLK);
        GPIOPinConfigure(MCU_BSP_UART2_RX_GPIO_CONF);
        GPIOPinConfigure(MCU_BSP_UART2_TX_GPIO_CONF);
        GPIOPinTypeUART(MCU_BSP_UART2_RX_GPIO, MCU_BSP_UART2_RX_GPIO_PIN);
        GPIOPinTypeUART(MCU_BSP_UART2_TX_GPIO, MCU_BSP_UART2_TX_GPIO_PIN);
        UARTConfigSetExpClk(UART2_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            SysCtlPeripheralEnable(MCU_BSP_UART2_RS485_CTRL_GPIO_CLK);
            GPIODirModeSet(MCU_BSP_UART2_RS485_CTRL_GPIO, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN, GPIO_DIR_MODE_OUT);
            GPIOPadConfigSet(MCU_BSP_UART2_RS485_CTRL_GPIO, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
            GPIOPinWrite(MCU_BSP_UART2_RS485_CTRL_GPIO, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART2_RS485_CTRL_GPIO_PIN);
        }
        BSP_IntVectSet((CPU_INT08U)BSP_INT_ID_UART2, (CPU_FNCT_VOID)McuBspUart2IntHandler);
        BSP_IntEn(BSP_INT_ID_UART2);
        IntEnable(INT_UART2);
        IntPrioritySet(INT_UART2, 3 << 5);
        UARTIntEnable(UART2_BASE, UART_INT_RX | UART_INT_RT);
        ui32Status = UARTIntStatus(UART2_BASE, true);
        UARTIntClear(UART2_BASE, ui32Status);
        while(0 <= UARTCharGetNonBlocking(UART2_BASE));
    } else if (UartId == MCU_BSP_UART3) {
        SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3);
        SysCtlPeripheralEnable(MCU_BSP_UART3_RX_GPIO_CLK);
        SysCtlPeripheralEnable(MCU_BSP_UART3_TX_GPIO_CLK);
        GPIOPinConfigure(MCU_BSP_UART3_RX_GPIO_CONF);
        GPIOPinConfigure(MCU_BSP_UART3_TX_GPIO_CONF);
        GPIOPinTypeUART(MCU_BSP_UART3_RX_GPIO, MCU_BSP_UART3_RX_GPIO_PIN);
        GPIOPinTypeUART(MCU_BSP_UART3_TX_GPIO, MCU_BSP_UART3_TX_GPIO_PIN);
        UARTConfigSetExpClk(UART3_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            SysCtlPeripheralEnable(MCU_BSP_UART3_RS485_CTRL_GPIO_CLK);
            GPIODirModeSet(MCU_BSP_UART3_RS485_CTRL_GPIO, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN, GPIO_DIR_MODE_OUT);
            GPIOPadConfigSet(MCU_BSP_UART3_RS485_CTRL_GPIO, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_WAKE_LOW);
            GPIOPinWrite(MCU_BSP_UART3_RS485_CTRL_GPIO, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART3_RS485_CTRL_GPIO_PIN);
        }
        BSP_IntVectSet((CPU_INT08U)BSP_INT_ID_UART3, (CPU_FNCT_VOID)McuBspUart3IntHandler);
        BSP_IntEn(BSP_INT_ID_UART3);
        IntEnable(INT_UART3);
        IntPrioritySet(INT_UART3, 3 << 5);
        UARTIntEnable(UART3_BASE, UART_INT_RX | UART_INT_RT);
        ui32Status = UARTIntStatus(UART3_BASE, true);
        UARTIntClear(UART3_BASE, ui32Status);
        while(0 <= UARTCharGetNonBlocking(UART3_BASE));
    } else if (UartId == MCU_BSP_UART4) {
        SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4);
        SysCtlPeripheralEnable(MCU_BSP_UART4_RX_GPIO_CLK);
        SysCtlPeripheralEnable(MCU_BSP_UART4_TX_GPIO_CLK);
        GPIOPinConfigure(MCU_BSP_UART4_RX_GPIO_CONF);
        GPIOPinConfigure(MCU_BSP_UART4_TX_GPIO_CONF);
        GPIOPinTypeUART(MCU_BSP_UART4_RX_GPIO, MCU_BSP_UART4_RX_GPIO_PIN);
        GPIOPinTypeUART(MCU_BSP_UART4_TX_GPIO, MCU_BSP_UART4_TX_GPIO_PIN);
        UARTConfigSetExpClk(UART4_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            SysCtlPeripheralEnable(MCU_BSP_UART4_RS485_CTRL_GPIO_CLK);
            GPIODirModeSet(MCU_BSP_UART4_RS485_CTRL_GPIO, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN, GPIO_DIR_MODE_OUT);
            GPIOPadConfigSet(MCU_BSP_UART4_RS485_CTRL_GPIO, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_WAKE_LOW);
            GPIOPinWrite(MCU_BSP_UART4_RS485_CTRL_GPIO, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART4_RS485_CTRL_GPIO_PIN);
        }
        BSP_IntVectSet((CPU_INT08U)BSP_INT_ID_UART4, (CPU_FNCT_VOID)McuBspUart4IntHandler);
        BSP_IntEn(BSP_INT_ID_UART4);
        IntEnable(INT_UART4);
        IntPrioritySet(INT_UART4, 3 << 5);
        UARTIntEnable(UART4_BASE, UART_INT_RX | UART_INT_RT);
        ui32Status = UARTIntStatus(UART4_BASE, true);
        UARTIntClear(UART4_BASE, ui32Status);
        while(0 <= UARTCharGetNonBlocking(UART4_BASE));
    } else if (UartId == MCU_BSP_UART5) {
        SysCtlPeripheralEnable(SYSCTL_PERIPH_UART5);
        SysCtlPeripheralEnable(MCU_BSP_UART5_RX_GPIO_CLK);
        SysCtlPeripheralEnable(MCU_BSP_UART5_TX_GPIO_CLK);
        GPIOPinConfigure(MCU_BSP_UART5_RX_GPIO_CONF);
        GPIOPinConfigure(MCU_BSP_UART5_TX_GPIO_CONF);
        GPIOPinTypeUART(MCU_BSP_UART5_RX_GPIO, MCU_BSP_UART5_RX_GPIO_PIN);
        GPIOPinTypeUART(MCU_BSP_UART5_TX_GPIO, MCU_BSP_UART5_TX_GPIO_PIN);
        UARTConfigSetExpClk(UART5_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            SysCtlPeripheralEnable(MCU_BSP_UART5_RS485_CTRL_GPIO_CLK);
            GPIODirModeSet(MCU_BSP_UART5_RS485_CTRL_GPIO, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN, GPIO_DIR_MODE_OUT);
            GPIOPadConfigSet(MCU_BSP_UART5_RS485_CTRL_GPIO, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_WAKE_LOW);
            GPIOPinWrite(MCU_BSP_UART5_RS485_CTRL_GPIO, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART5_RS485_CTRL_GPIO_PIN);
        }
        BSP_IntVectSet((CPU_INT08U)BSP_INT_ID_UART5, (CPU_FNCT_VOID)McuBspUart5IntHandler);
        BSP_IntEn(BSP_INT_ID_UART5);
        IntEnable(INT_UART5);
        IntPrioritySet(INT_UART5, 3 << 5);
        UARTIntEnable(UART5_BASE, UART_INT_RX | UART_INT_RT);
        ui32Status = UARTIntStatus(UART5_BASE, true);
        UARTIntClear(UART5_BASE, ui32Status);
        while(0 <= UARTCharGetNonBlocking(UART5_BASE));
    } else if (UartId == MCU_BSP_UART6) {
        SysCtlPeripheralEnable(SYSCTL_PERIPH_UART6);
        SysCtlPeripheralEnable(MCU_BSP_UART6_RX_GPIO_CLK);
        SysCtlPeripheralEnable(MCU_BSP_UART6_TX_GPIO_CLK);
        GPIOPinConfigure(MCU_BSP_UART6_RX_GPIO_CONF);
        GPIOPinConfigure(MCU_BSP_UART6_TX_GPIO_CONF);
        GPIOPinTypeUART(MCU_BSP_UART6_RX_GPIO, MCU_BSP_UART6_RX_GPIO_PIN);
        GPIOPinTypeUART(MCU_BSP_UART6_TX_GPIO, MCU_BSP_UART6_TX_GPIO_PIN);
        UARTConfigSetExpClk(UART6_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            SysCtlPeripheralEnable(MCU_BSP_UART6_RS485_CTRL_GPIO_CLK);
            GPIODirModeSet(MCU_BSP_UART6_RS485_CTRL_GPIO, MCU_BSP_UART6_RS485_CTRL_GPIO_PIN, GPIO_DIR_MODE_OUT);
            GPIOPadConfigSet(MCU_BSP_UART6_RS485_CTRL_GPIO, MCU_BSP_UART6_RS485_CTRL_GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_WAKE_LOW);
            GPIOPinWrite(MCU_BSP_UART6_RS485_CTRL_GPIO, MCU_BSP_UART6_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART6_RS485_CTRL_GPIO_PIN);
        }
        BSP_IntVectSet((CPU_INT08U)BSP_INT_ID_UART6, (CPU_FNCT_VOID)McuBspUart6IntHandler);
        BSP_IntEn(BSP_INT_ID_UART6);
        IntEnable(INT_UART6);
        IntPrioritySet(INT_UART6, 3 << 5);
        UARTIntEnable(UART6_BASE, UART_INT_RX | UART_INT_RT);
        ui32Status = UARTIntStatus(UART6_BASE, true);
        UARTIntClear(UART6_BASE, ui32Status);
        while(0 <= UARTCharGetNonBlocking(UART6_BASE));
    } else if (UartId == MCU_BSP_UART7) {
        SysCtlPeripheralEnable(SYSCTL_PERIPH_UART7);
        SysCtlPeripheralEnable(MCU_BSP_UART7_RX_GPIO_CLK);
        SysCtlPeripheralEnable(MCU_BSP_UART7_TX_GPIO_CLK);
        GPIOPinConfigure(MCU_BSP_UART7_RX_GPIO_CONF);
        GPIOPinConfigure(MCU_BSP_UART7_TX_GPIO_CONF);
        GPIOPinTypeUART(MCU_BSP_UART7_RX_GPIO, MCU_BSP_UART7_RX_GPIO_PIN);
        GPIOPinTypeUART(MCU_BSP_UART7_TX_GPIO, MCU_BSP_UART7_TX_GPIO_PIN);
        UARTConfigSetExpClk(UART7_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            SysCtlPeripheralEnable(MCU_BSP_UART7_RS485_CTRL_GPIO_CLK);
            GPIODirModeSet(MCU_BSP_UART7_RS485_CTRL_GPIO, MCU_BSP_UART7_RS485_CTRL_GPIO_PIN, GPIO_DIR_MODE_OUT);
            GPIOPadConfigSet(MCU_BSP_UART7_RS485_CTRL_GPIO, MCU_BSP_UART7_RS485_CTRL_GPIO_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_WAKE_LOW);
            GPIOPinWrite(MCU_BSP_UART7_RS485_CTRL_GPIO, MCU_BSP_UART7_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART7_RS485_CTRL_GPIO_PIN);
        }
        BSP_IntVectSet((CPU_INT08U)BSP_INT_ID_UART7, (CPU_FNCT_VOID)McuBspUart7IntHandler);
        BSP_IntEn(BSP_INT_ID_UART7);
        IntEnable(INT_UART7);
        IntPrioritySet(INT_UART7, 3 << 5);
        UARTIntEnable(UART7_BASE, UART_INT_RX | UART_INT_RT);
        ui32Status = UARTIntStatus(UART7_BASE, true);
        UARTIntClear(UART7_BASE, ui32Status);
        while(0 <= UARTCharGetNonBlocking(UART7_BASE));
    }
    gMcuBspUartObj[UartId].Enable = MCU_BSP_UART_ON;
    return 0;
}

/* 串口发送函数 */
int McuBspUartSendData(uint8_t UartId, uint8_t *Data, uint32_t DataLen)
{
    uint32_t i = 0;
    CPU_SR_ALLOC();
    if (UartId >= MCU_BSP_UART_ALL_NUM) {
        return -1;
    }
    if (gMcuBspUartObj[UartId].Enable != MCU_BSP_UART_ON) {
        return -1;
    }
    while (gMcuBspUartObj[UartId].Txbusy == MCU_BSP_UART_BUSY) {
        
    }
    gMcuBspUartObj[UartId].Txbusy = MCU_BSP_UART_BUSY;
    OS_ENTER_CRITICAL();
    if (UartId == MCU_BSP_UART0) {
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART0_RS485_CTRL_GPIO, MCU_BSP_UART0_RS485_CTRL_GPIO_PIN, MCU_BSP_UART0_RS485_CTRL_GPIO_PIN);
        }
        for (; i < DataLen; i++) {
            UARTCharPut(UART0_BASE, Data[i]);
        }
        while (UARTBusy(UART0_BASE)) {
            
        }
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART0_RS485_CTRL_GPIO, MCU_BSP_UART0_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART0_RS485_CTRL_GPIO_PIN);
        }
    } else if (UartId == MCU_BSP_UART1) {
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART1_RS485_CTRL_GPIO, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN);
        }
        for (; i < DataLen; i++) {
            UARTCharPut(UART1_BASE, Data[i]);
        }
        while (UARTBusy(UART1_BASE)) {
            
        }
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART1_RS485_CTRL_GPIO, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART1_RS485_CTRL_GPIO_PIN);
        }
    } else if (UartId == MCU_BSP_UART2) {
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART2_RS485_CTRL_GPIO, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN);
        }
        for (; i < DataLen; i++) {
            UARTCharPut(UART2_BASE, Data[i]);
        }
        while (UARTBusy(UART2_BASE)) {
            
        }
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART2_RS485_CTRL_GPIO, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART2_RS485_CTRL_GPIO_PIN);
        }
    } else if (UartId == MCU_BSP_UART3) {
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART3_RS485_CTRL_GPIO, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN);
        }
        for (; i < DataLen; i++) {
            UARTCharPut(UART3_BASE, Data[i]);
        }
        while (UARTBusy(UART3_BASE)) {
            
        }
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART3_RS485_CTRL_GPIO, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART3_RS485_CTRL_GPIO_PIN);
        }
    } else if (UartId == MCU_BSP_UART4) {
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART4_RS485_CTRL_GPIO, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN);
        }
        for (; i < DataLen; i++) {
            UARTCharPut(UART4_BASE, Data[i]);
        }
        while (UARTBusy(UART4_BASE)) {
            
        }
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART4_RS485_CTRL_GPIO, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART4_RS485_CTRL_GPIO_PIN);
        }
    } else if (UartId == MCU_BSP_UART5) {
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART5_RS485_CTRL_GPIO, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN);
        }
        for (; i < DataLen; i++) {
            UARTCharPut(UART5_BASE, Data[i]);
        }
        while (UARTBusy(UART5_BASE)) {
            
        }
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART5_RS485_CTRL_GPIO, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART5_RS485_CTRL_GPIO_PIN);
        }
    } else if (UartId == MCU_BSP_UART6) {
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART6_RS485_CTRL_GPIO, MCU_BSP_UART6_RS485_CTRL_GPIO_PIN, MCU_BSP_UART6_RS485_CTRL_GPIO_PIN);
        }
        for (; i < DataLen; i++) {
            UARTCharPut(UART6_BASE, Data[i]);
        }
        while (UARTBusy(UART6_BASE)) {
            
        }
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART6_RS485_CTRL_GPIO, MCU_BSP_UART6_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART6_RS485_CTRL_GPIO_PIN);
        }
    } else if (UartId == MCU_BSP_UART7) {
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART7_RS485_CTRL_GPIO, MCU_BSP_UART7_RS485_CTRL_GPIO_PIN, MCU_BSP_UART7_RS485_CTRL_GPIO_PIN);
        }
        for (; i < DataLen; i++) {
            UARTCharPut(UART7_BASE, Data[i]);
        }
        while (UARTBusy(UART7_BASE)) {
            
        }
        if (gMcuBspUartObj[UartId].Mode == MCU_BSP_UART_RS485_TYPE) {
            GPIOPinWrite(MCU_BSP_UART7_RS485_CTRL_GPIO, MCU_BSP_UART7_RS485_CTRL_GPIO_PIN, ~MCU_BSP_UART7_RS485_CTRL_GPIO_PIN);
        }
    }
    OS_EXIT_CRITICAL();
    gMcuBspUartObj[UartId].Txbusy = MCU_BSP_UART_NOBUSY;
    return 0;
}

int McuBspUartStartRecv(uint8_t UartId, UART_RECV_CALLBACK RecvCallback)
{
    if ((UartId >= MCU_BSP_UART_ALL_NUM) || (RecvCallback == NULL)) {
        return -1;
    }
    if (gMcuBspUartObj[UartId].Enable != MCU_BSP_UART_ON) {
        return -1;
    }
    while (gMcuBspUartObj[UartId].Rxbusy == MCU_BSP_UART_BUSY) {
    }
    gMcuBspUartObj[UartId].Rxbusy = MCU_BSP_UART_BUSY;
    switch (UartId) {
        case MCU_BSP_UART0:
            gMcuBspUart0RecvCallback = RecvCallback;
            break;
        case MCU_BSP_UART1:
            gMcuBspUart1RecvCallback = RecvCallback;
            break;
        case MCU_BSP_UART2:
            gMcuBspUart2RecvCallback = RecvCallback;
            break;
        case MCU_BSP_UART3:
            gMcuBspUart3RecvCallback = RecvCallback;
            break;
        case MCU_BSP_UART4:
            gMcuBspUart4RecvCallback = RecvCallback;
            break;
        case MCU_BSP_UART5:
            gMcuBspUart5RecvCallback = RecvCallback;
            break;
        case MCU_BSP_UART6:
            gMcuBspUart6RecvCallback = RecvCallback;
            break;
        case MCU_BSP_UART7:
            gMcuBspUart7RecvCallback = RecvCallback;
            break;
        default:
            return -1;
    }
    return 0;
}

int McuBspUartEndRecv(uint8_t UartId)
{
    if (UartId >= MCU_BSP_UART_ALL_NUM) {
        return -1;
    }
    if (gMcuBspUartObj[UartId].Enable != MCU_BSP_UART_ON) {
        return -1;
    }
    switch (UartId) {
        case MCU_BSP_UART0:
            gMcuBspUart0RecvCallback = NULL;
            break;
        case MCU_BSP_UART1:
            gMcuBspUart1RecvCallback = NULL;
            break;
        case MCU_BSP_UART2:
            gMcuBspUart2RecvCallback = NULL;
            break;
        case MCU_BSP_UART3:
            gMcuBspUart3RecvCallback = NULL;
            break;
        case MCU_BSP_UART4:
            gMcuBspUart4RecvCallback = NULL;
            break;
        case MCU_BSP_UART5:
            gMcuBspUart5RecvCallback = NULL;
            break;
        case MCU_BSP_UART6:
            gMcuBspUart6RecvCallback = NULL;
            break;
        case MCU_BSP_UART7:
            gMcuBspUart7RecvCallback = NULL;
            break;
        default:
            return -1;
    }
    gMcuBspUartObj[UartId].Rxbusy = MCU_BSP_UART_NOBUSY;
    return 0;
}

/* 修改配置文件 */
int McuBspUartModifyConf(uint8_t UartId, uint32_t BandRate, uint32_t DataBit, uint32_t StopBit, uint32_t CheckBit)
{
    if (UartId >= MCU_BSP_UART_ALL_NUM) {
        return -1;
    }
    if ((BandRate != MCU_BSP_UART_BANDRATE_4800) && (BandRate != MCU_BSP_UART_BANDRATE_9600) && (BandRate != MCU_BSP_UART_BANDRATE_14400) &&
        (BandRate != MCU_BSP_UART_BANDRATE_19200) && (BandRate != MCU_BSP_UART_BANDRATE_38400) && (BandRate != MCU_BSP_UART_BANDRATE_56000) &&
        (BandRate != MCU_BSP_UART_BANDRATE_57600) && (BandRate != MCU_BSP_UART_BANDRATE_115200)) {
        return -1;
    } else {
        gMcuBspUartObj[UartId].BandRate = BandRate;
    }
    switch (DataBit) {
        case MCU_BSP_UART_DATABIT_5:
            gMcuBspUartObj[UartId].DataBit = UART_CONFIG_WLEN_5;
            break;
        case MCU_BSP_UART_DATABIT_6:
            gMcuBspUartObj[UartId].DataBit = UART_CONFIG_WLEN_6;
            break;
        case MCU_BSP_UART_DATABIT_7:
            gMcuBspUartObj[UartId].DataBit = UART_CONFIG_WLEN_7;
            break;
        case MCU_BSP_UART_DATABIT_8:
            gMcuBspUartObj[UartId].DataBit = UART_CONFIG_WLEN_8;
            break;
        default:
            return -1;
    }
    switch (StopBit) {
        case MCU_BSP_UART_STOPBIT_ONE:
            gMcuBspUartObj[UartId].StopBit = UART_CONFIG_STOP_ONE;
            break;
        case MCU_BSP_UART_STOPBIT_TWO:
            gMcuBspUartObj[UartId].StopBit = UART_CONFIG_STOP_ONE;
            break;
        default:
            return -1;
    }
    switch (CheckBit) {
        case MCU_BSP_UART_CHECKBIT_NONE:
            gMcuBspUartObj[UartId].CheckBit = UART_CONFIG_PAR_NONE;
            break;
        case MCU_BSP_UART_CHECKBIT_EVEN:
            gMcuBspUartObj[UartId].CheckBit = UART_CONFIG_PAR_EVEN;
            break;
        case MCU_BSP_UART_CHECKBIT_ODD:
            gMcuBspUartObj[UartId].CheckBit = UART_CONFIG_PAR_ODD;
            break;
        default:
            return -1;
    }
    while ((gMcuBspUartObj[UartId].Rxbusy == 1) || (gMcuBspUartObj[UartId].Txbusy == 1)) {
        
    }
    gMcuBspUartObj[UartId].Enable = MCU_BSP_UART_OFF;
    if (UartId == MCU_BSP_UART0) {
        UARTConfigSetExpClk(UART0_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
    } else if (UartId == MCU_BSP_UART1) {
        UARTConfigSetExpClk(UART1_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
    } else if (UartId == MCU_BSP_UART2) {
        UARTConfigSetExpClk(UART2_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
    } else if (UartId == MCU_BSP_UART3) {
        UARTConfigSetExpClk(UART3_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
    } else if (UartId == MCU_BSP_UART4) {
        UARTConfigSetExpClk(UART4_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
    } else if (UartId == MCU_BSP_UART5) {
        UARTConfigSetExpClk(UART5_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
    } else if (UartId == MCU_BSP_UART6) {
        UARTConfigSetExpClk(UART6_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
    } else if (UartId == MCU_BSP_UART7) {
        UARTConfigSetExpClk(UART7_BASE, SysFreqGet(), gMcuBspUartObj[UartId].BandRate,
                            ((gMcuBspUartObj[UartId].DataBit) | (gMcuBspUartObj[UartId].StopBit) |
                            (gMcuBspUartObj[UartId].CheckBit)));
    }
    gMcuBspUartObj[UartId].Enable = MCU_BSP_UART_ON;
    return 0;
}

static void McuBspUart0IntHandler(void)
{
    uint32_t ui32Status;
    CPU_SR_ALLOC();
    OSIntEnter(); //通知系统进入OS中断
    OS_ENTER_CRITICAL();
    ui32Status = UARTIntStatus(UART0_BASE, true);
    UARTIntClear(UART0_BASE, ui32Status);
    while (UARTCharsAvail(UART0_BASE)) {
        gMcuBspUartRecvData0 = (uint8_t)UARTCharGetNonBlocking(UART0_BASE);
        if ((gMcuBspUartObj[MCU_BSP_UART0].Rxbusy == 1) && (gMcuBspUart0RecvCallback != NULL)) {
            gMcuBspUart0RecvCallback(gMcuBspUartRecvData0);
        }
    }
    OS_EXIT_CRITICAL();
    OSIntExit();
}

static void McuBspUart1IntHandler(void)
{
    uint32_t ui32Status;
    CPU_SR_ALLOC();
    OSIntEnter(); //通知系统进入OS中断
    OS_ENTER_CRITICAL();
    ui32Status = UARTIntStatus(UART1_BASE, true);
    UARTIntClear(UART1_BASE, ui32Status);
    while (UARTCharsAvail(UART1_BASE)) {
        gMcuBspUartRecvData1 = (uint8_t)UARTCharGetNonBlocking(UART1_BASE);
        if ((gMcuBspUartObj[MCU_BSP_UART1].Rxbusy == 1) && (gMcuBspUart1RecvCallback != NULL)) {
            gMcuBspUart1RecvCallback(gMcuBspUartRecvData1);
        }
    }
    OS_EXIT_CRITICAL();
    OSIntExit();
}

static void McuBspUart2IntHandler(void)
{
    uint32_t ui32Status;
    CPU_SR_ALLOC();
    OSIntEnter(); //通知系统进入OS中断
    OS_ENTER_CRITICAL();
    ui32Status = UARTIntStatus(UART2_BASE, true);
    UARTIntClear(UART2_BASE, ui32Status);
    while (UARTCharsAvail(UART2_BASE)) {
        gMcuBspUartRecvData2 = (uint8_t)UARTCharGetNonBlocking(UART2_BASE);
        if ((gMcuBspUartObj[MCU_BSP_UART2].Rxbusy == 1) && (gMcuBspUart2RecvCallback != NULL)) {
            gMcuBspUart2RecvCallback(gMcuBspUartRecvData2);
        }
    }
    OS_EXIT_CRITICAL();
    OSIntExit();
}

static void McuBspUart3IntHandler(void)
{
    uint32_t ui32Status;
    CPU_SR_ALLOC();
    OSIntEnter(); //通知系统进入OS中断
    OS_ENTER_CRITICAL();
    ui32Status = UARTIntStatus(UART3_BASE, true);
    UARTIntClear(UART3_BASE, ui32Status);
    while (UARTCharsAvail(UART3_BASE)) {
        gMcuBspUartRecvData3 = (uint8_t)UARTCharGetNonBlocking(UART3_BASE);
        if ((gMcuBspUartObj[MCU_BSP_UART3].Rxbusy == 1) && (gMcuBspUart3RecvCallback != NULL)) {
            gMcuBspUart3RecvCallback(gMcuBspUartRecvData3);
        }
    }
    OS_EXIT_CRITICAL();
    OSIntExit();
}

static void McuBspUart4IntHandler(void)
{
    uint32_t ui32Status;
    CPU_SR_ALLOC();
    OSIntEnter(); //通知系统进入OS中断
    OS_ENTER_CRITICAL();
    ui32Status = UARTIntStatus(UART4_BASE, true);
    UARTIntClear(UART4_BASE, ui32Status);
    while (UARTCharsAvail(UART4_BASE)) {
        gMcuBspUartRecvData4 = (uint8_t)UARTCharGetNonBlocking(UART4_BASE);
        if ((gMcuBspUartObj[MCU_BSP_UART4].Rxbusy == 1) && (gMcuBspUart4RecvCallback != NULL)) {
            gMcuBspUart4RecvCallback(gMcuBspUartRecvData4);
        }
    }
    OS_EXIT_CRITICAL();
    OSIntExit();
}

static void McuBspUart5IntHandler(void)
{
    uint32_t ui32Status;
    CPU_SR_ALLOC();
    OSIntEnter(); //通知系统进入OS中断
    OS_ENTER_CRITICAL();
    ui32Status = UARTIntStatus(UART5_BASE, true);
    UARTIntClear(UART5_BASE, ui32Status);
    while (UARTCharsAvail(UART5_BASE)) {
        gMcuBspUartRecvData5 = (uint8_t)UARTCharGetNonBlocking(UART5_BASE);
        if ((gMcuBspUartObj[MCU_BSP_UART5].Rxbusy == 1) && (gMcuBspUart5RecvCallback != NULL)) {
            gMcuBspUart5RecvCallback(gMcuBspUartRecvData5);
        }
    }
    OS_EXIT_CRITICAL();
    OSIntExit();
}

static void McuBspUart6IntHandler(void)
{
    uint32_t ui32Status;
    CPU_SR_ALLOC();
    OSIntEnter(); //通知系统进入OS中断
    OS_ENTER_CRITICAL();
    ui32Status = UARTIntStatus(UART6_BASE, true);
    UARTIntClear(UART6_BASE, ui32Status);
    while (UARTCharsAvail(UART6_BASE)) {
        gMcuBspUartRecvData6 = (uint8_t)UARTCharGetNonBlocking(UART6_BASE);
        if ((gMcuBspUartObj[MCU_BSP_UART6].Rxbusy == 1) && (gMcuBspUart6RecvCallback != NULL)) {
            gMcuBspUart6RecvCallback(gMcuBspUartRecvData6);
        }
    }
    OS_EXIT_CRITICAL();
    OSIntExit();
}

static void McuBspUart7IntHandler(void)
{
    uint32_t ui32Status;
    CPU_SR_ALLOC();
    OSIntEnter(); //通知系统进入OS中断
    OS_ENTER_CRITICAL();
    ui32Status = UARTIntStatus(UART7_BASE, true);
    UARTIntClear(UART7_BASE, ui32Status);
    while (UARTCharsAvail(UART7_BASE)) {
        gMcuBspUartRecvData7 = (uint8_t)UARTCharGetNonBlocking(UART7_BASE);
        if ((gMcuBspUartObj[MCU_BSP_UART7].Rxbusy == 1) && (gMcuBspUart7RecvCallback != NULL)) {
            gMcuBspUart7RecvCallback(gMcuBspUartRecvData7);
        }
    }
    OS_EXIT_CRITICAL();
    OSIntExit();
}