#include "McuBspUart.h"

static UART_HandleTypeDef gUartHandle1;
static UART_HandleTypeDef gUartHandle2;
static UART_HandleTypeDef gUartHandle3;
static UART_HandleTypeDef gUartHandle4;
static UART_HandleTypeDef gUartHandle5;

static uint8_t gRecvData1;
static uint8_t gRecvData2;
static uint8_t gRecvData3;
static uint8_t gRecvData4;
static uint8_t gRecvData5;

static uint8_t gUart1UseFlag = 0;
static uint8_t gUart2UseFlag = 0;
static uint8_t gUart3UseFlag = 0;
static uint8_t gUart4UseFlag = 0;
static uint8_t gUart5UseFlag = 0;

static UART_SEND_CALLBACK gSendCallback1 = NULL;
static UART_RECV_CALLBACK gRecvCallback1 = NULL;
static UART_SEND_CALLBACK gSendCallback2 = NULL;
static UART_RECV_CALLBACK gRecvCallback2 = NULL;
static UART_SEND_CALLBACK gSendCallback3 = NULL;
static UART_RECV_CALLBACK gRecvCallback3 = NULL;
static UART_SEND_CALLBACK gSendCallback4 = NULL;
static UART_RECV_CALLBACK gRecvCallback4 = NULL;
static UART_SEND_CALLBACK gSendCallback5 = NULL;
static UART_RECV_CALLBACK gRecvCallback5 = NULL;

/* 串口初始化 */
int McuBspUartInit(uint8_t UartId, MCU_BSP_UART_CONF *conf, UART_SEND_CALLBACK SendCallback,
                       UART_RECV_CALLBACK RecvCallback)
{
    if (UartId == MCU_BSP_UART1_ID) {
        if (MCU_BSP_UART1_USE_FLAG == 0) {
            return -1;
        }
        if (gUart1UseFlag == 1) {
            return 0;
        }
        gUartHandle1.Instance = USART1;
        if (conf == NULL) {
            gUartHandle1.Init.BaudRate   = MCU_BSP_UART1_BAUDRATE;
            gUartHandle1.Init.WordLength = MCU_BSP_UART1_WORDLENGTH;
            gUartHandle1.Init.StopBits   = MCU_BSP_UART1_STOPBITS;
            gUartHandle1.Init.Parity     = MCU_BSP_UART1_PARITY;
            gUartHandle1.Init.Mode       = MCU_BSP_UART1_MODE;
        } else {
            gUartHandle1.Init.BaudRate   = conf->BaudRate;
            gUartHandle1.Init.WordLength = conf->WordLength;
            gUartHandle1.Init.StopBits   = conf->StopBits;
            gUartHandle1.Init.Parity     = conf->Parity;
            gUartHandle1.Init.Mode       = conf->Mode;
        }
        gUartHandle1.Init.HwFlowCtl  = MCU_BSP_UART1_HWFLOWCTL;
        if(HAL_UART_DeInit(&gUartHandle1) != HAL_OK) {
            return -1;
        }  
        if(HAL_UART_Init(&gUartHandle1) != HAL_OK) {
            return -1;
        }
        gSendCallback1 = SendCallback;
        gRecvCallback1 = RecvCallback;
        gUart1UseFlag = 1;
    } else if (UartId == MCU_BSP_UART2_ID) {
        if (MCU_BSP_UART2_USE_FLAG == 0) {
            return -1;
        }
        if (gUart2UseFlag == 1) {
            return 0;
        }
        gUartHandle2.Instance = USART2;
        if (conf == NULL) {
            gUartHandle2.Init.BaudRate   = MCU_BSP_UART2_BAUDRATE;
            gUartHandle2.Init.WordLength = MCU_BSP_UART2_WORDLENGTH;
            gUartHandle2.Init.StopBits   = MCU_BSP_UART2_STOPBITS;
            gUartHandle2.Init.Parity     = MCU_BSP_UART2_PARITY;
            gUartHandle2.Init.Mode       = MCU_BSP_UART2_MODE;
        } else {
            gUartHandle2.Init.BaudRate   = conf->BaudRate;
            gUartHandle2.Init.WordLength = conf->WordLength;
            gUartHandle2.Init.StopBits   = conf->StopBits;
            gUartHandle2.Init.Parity     = conf->Parity;
            gUartHandle2.Init.Mode       = conf->Mode;
        }
        gUartHandle2.Init.HwFlowCtl  = MCU_BSP_UART2_HWFLOWCTL;
        if(HAL_UART_DeInit(&gUartHandle2) != HAL_OK) {
            return -1;
        }  
        if(HAL_UART_Init(&gUartHandle2) != HAL_OK) {
            return -1;
        }
        gSendCallback2 = SendCallback;
        gRecvCallback2 = RecvCallback;
        gUart2UseFlag = 1;
    } else if (UartId == MCU_BSP_UART3_ID) {
        if (MCU_BSP_UART3_USE_FLAG == 0) {
            return -1;
        }
        if (gUart3UseFlag == 1) {
            return 0;
        }
        gUartHandle3.Instance = USART3;
        if (conf == NULL) {
            gUartHandle3.Init.BaudRate   = MCU_BSP_UART3_BAUDRATE;
            gUartHandle3.Init.WordLength = MCU_BSP_UART3_WORDLENGTH;
            gUartHandle3.Init.StopBits   = MCU_BSP_UART3_STOPBITS;
            gUartHandle3.Init.Parity     = MCU_BSP_UART3_PARITY;
            gUartHandle3.Init.Mode       = MCU_BSP_UART3_MODE;
        } else {
            gUartHandle3.Init.BaudRate   = conf->BaudRate;
            gUartHandle3.Init.WordLength = conf->WordLength;
            gUartHandle3.Init.StopBits   = conf->StopBits;
            gUartHandle3.Init.Parity     = conf->Parity;
            gUartHandle3.Init.Mode       = conf->Mode;
        }
        gUartHandle3.Init.HwFlowCtl  = MCU_BSP_UART3_HWFLOWCTL;
        if(HAL_UART_DeInit(&gUartHandle3) != HAL_OK) {
            return -1;
        }  
        if(HAL_UART_Init(&gUartHandle3) != HAL_OK) {
            return -1;
        }
        gSendCallback3 = SendCallback;
        gRecvCallback3 = RecvCallback;
        gUart3UseFlag = 1;
    } else if (UartId == MCU_BSP_UART4_ID) {
        if (MCU_BSP_UART4_USE_FLAG == 0) {
            return -1;
        }
        if (gUart4UseFlag == 1) {
            return 0;
        }
        gUartHandle4.Instance = UART4;
        if (conf == NULL) {
            gUartHandle4.Init.BaudRate   = MCU_BSP_UART4_BAUDRATE;
            gUartHandle4.Init.WordLength = MCU_BSP_UART4_WORDLENGTH;
            gUartHandle4.Init.StopBits   = MCU_BSP_UART4_STOPBITS;
            gUartHandle4.Init.Parity     = MCU_BSP_UART4_PARITY;
            gUartHandle4.Init.Mode       = MCU_BSP_UART4_MODE;
        } else {
            gUartHandle4.Init.BaudRate   = conf->BaudRate;
            gUartHandle4.Init.WordLength = conf->WordLength;
            gUartHandle4.Init.StopBits   = conf->StopBits;
            gUartHandle4.Init.Parity     = conf->Parity;
            gUartHandle4.Init.Mode       = conf->Mode;
        }
        gUartHandle4.Init.HwFlowCtl  = MCU_BSP_UART4_HWFLOWCTL;
        if(HAL_UART_DeInit(&gUartHandle4) != HAL_OK) {
            return -1;
        }  
        if(HAL_UART_Init(&gUartHandle4) != HAL_OK) {
            return -1;
        }
        gSendCallback4 = SendCallback;
        gRecvCallback4 = RecvCallback;
        gUart4UseFlag = 1;
    } else if (UartId == MCU_BSP_UART5_ID) {
        if (MCU_BSP_UART5_USE_FLAG == 0) {
            return -1;
        }
        if (gUart5UseFlag == 1) {
            return 0;
        }
        gUartHandle5.Instance = UART5;
        if (conf == NULL) {
            gUartHandle5.Init.BaudRate   = MCU_BSP_UART5_BAUDRATE;
            gUartHandle5.Init.WordLength = MCU_BSP_UART5_WORDLENGTH;
            gUartHandle5.Init.StopBits   = MCU_BSP_UART5_STOPBITS;
            gUartHandle5.Init.Parity     = MCU_BSP_UART5_PARITY;
            gUartHandle5.Init.Mode       = MCU_BSP_UART5_MODE;
        } else {
            gUartHandle5.Init.BaudRate   = conf->BaudRate;
            gUartHandle5.Init.WordLength = conf->WordLength;
            gUartHandle5.Init.StopBits   = conf->StopBits;
            gUartHandle5.Init.Parity     = conf->Parity;
            gUartHandle5.Init.Mode       = conf->Mode;
        }
        gUartHandle5.Init.HwFlowCtl  = MCU_BSP_UART5_HWFLOWCTL;
        if(HAL_UART_DeInit(&gUartHandle5) != HAL_OK) {
            return -1;
        }  
        if(HAL_UART_Init(&gUartHandle5) != HAL_OK) {
            return -1;
        }
        gSendCallback5 = SendCallback;
        gRecvCallback5 = RecvCallback;
        gUart5UseFlag = 1;
    } else {
        return -1;
    }
    return 0;
}

/* 串口反初始化 */
int McuBspUartDeInit(uint8_t UartId)
{
    if (UartId == MCU_BSP_UART1_ID) {
        if (MCU_BSP_UART1_USE_FLAG == 0) {
            return -1;
        }
        if (gUart1UseFlag == 0) {
            return 0;
        }
        if(HAL_UART_DeInit(&gUartHandle1) != HAL_OK) {
            return -1;
        }
        gUart1UseFlag = 0;
    } else if (UartId == MCU_BSP_UART2_ID) {
        if (MCU_BSP_UART2_USE_FLAG == 0) {
            return -1;
        }
        if (gUart2UseFlag == 0) {
            return 0;
        }
        if(HAL_UART_DeInit(&gUartHandle2) != HAL_OK) {
            return -1;
        }
        gUart2UseFlag = 0;
    } else if (UartId == MCU_BSP_UART3_ID) {
        if (MCU_BSP_UART3_USE_FLAG == 0) {
            return -1;
        }
        if (gUart3UseFlag == 0) {
            return 0;
        }
        if(HAL_UART_DeInit(&gUartHandle3) != HAL_OK) {
            return -1;
        }
        gUart3UseFlag = 0;
    } else if (UartId == MCU_BSP_UART4_ID) {
        if (MCU_BSP_UART4_USE_FLAG == 0) {
            return -1;
        }
        if (gUart4UseFlag == 0) {
            return 0;
        }
        if(HAL_UART_DeInit(&gUartHandle4) != HAL_OK) {
            return -1;
        }
        gUart4UseFlag = 0;
    } else if (UartId == MCU_BSP_UART5_ID) {
        if (MCU_BSP_UART5_USE_FLAG == 0) {
            return -1;
        }
        if (gUart5UseFlag == 0) {
            return 0;
        }
        if(HAL_UART_DeInit(&gUartHandle5) != HAL_OK) {
            return -1;
        }
        gUart5UseFlag = 0;
    } else {
        return -1;
    }
    return 0;
}

/* 串口发送 */
int McuBspUartSend(uint8_t UartId, uint8_t* tbuf, uint16_t tbuflen)
{
    if (UartId == MCU_BSP_UART1_ID) {
        if (MCU_BSP_UART1_USE_FLAG == 0) {
            return -1;
        }
        if (MCU_BSP_UART1_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_WritePin(MCU_BSP_UART1_RS485_CTRL_GPIO_PORT, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN, GPIO_PIN_SET);
        }
        /* 等待串口闲置 */
        while (gUartHandle1.gState != HAL_UART_STATE_READY) {
            
        }
        HAL_UART_Transmit_IT(&gUartHandle1, tbuf, tbuflen);
        /* 等待发送完成 */
        while (gUartHandle1.gState != HAL_UART_STATE_READY) {
            
        }
        if (MCU_BSP_UART1_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_WritePin(MCU_BSP_UART1_RS485_CTRL_GPIO_PORT, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
    } else if (UartId == MCU_BSP_UART2_ID) {
        if (MCU_BSP_UART2_USE_FLAG == 0) {
            return -1;
        }
        if (MCU_BSP_UART2_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_WritePin(MCU_BSP_UART2_RS485_CTRL_GPIO_PORT, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN, GPIO_PIN_SET);
        }
        /* 等待串口闲置 */
        while (gUartHandle2.gState != HAL_UART_STATE_READY) {
            
        }
        HAL_UART_Transmit_IT(&gUartHandle2, tbuf, tbuflen);
        /* 等待发送完成 */
        while (gUartHandle2.gState != HAL_UART_STATE_READY) {
            
        }
        if (MCU_BSP_UART2_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_WritePin(MCU_BSP_UART2_RS485_CTRL_GPIO_PORT, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
    } else if (UartId == MCU_BSP_UART3_ID) {
        if (MCU_BSP_UART3_USE_FLAG == 0) {
            return -1;
        }
        if (MCU_BSP_UART3_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_WritePin(MCU_BSP_UART3_RS485_CTRL_GPIO_PORT, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN, GPIO_PIN_SET);
        }
        /* 等待串口闲置 */
        while (gUartHandle3.gState != HAL_UART_STATE_READY) {
            
        }
        HAL_UART_Transmit_IT(&gUartHandle3, tbuf, tbuflen);
        /* 等待发送完成 */
        while (gUartHandle3.gState != HAL_UART_STATE_READY) {
            
        }
        if (MCU_BSP_UART3_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_WritePin(MCU_BSP_UART3_RS485_CTRL_GPIO_PORT, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
    } else if (UartId == MCU_BSP_UART4_ID) {
        if (MCU_BSP_UART4_USE_FLAG == 0) {
            return -1;
        }
        if (MCU_BSP_UART4_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_WritePin(MCU_BSP_UART4_RS485_CTRL_GPIO_PORT, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN, GPIO_PIN_SET);
        }
        /* 等待串口闲置 */
        while (gUartHandle4.gState != HAL_UART_STATE_READY) {
            
        }
        HAL_UART_Transmit_IT(&gUartHandle4, tbuf, tbuflen);
        /* 等待发送完成 */
        while (gUartHandle4.gState != HAL_UART_STATE_READY) {
            
        }
        if (MCU_BSP_UART4_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_WritePin(MCU_BSP_UART4_RS485_CTRL_GPIO_PORT, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
    } else if (UartId == MCU_BSP_UART5_ID) {
        if (MCU_BSP_UART5_USE_FLAG == 0) {
            return -1;
        }
        if (MCU_BSP_UART5_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_WritePin(MCU_BSP_UART5_RS485_CTRL_GPIO_PORT, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN, GPIO_PIN_SET);
        }
        /* 等待串口闲置 */
        while (gUartHandle5.gState != HAL_UART_STATE_READY) {
            
        }
        HAL_UART_Transmit_IT(&gUartHandle5, tbuf, tbuflen);
        /* 等待发送完成 */
        while (gUartHandle5.gState != HAL_UART_STATE_READY) {
            
        }
        if (MCU_BSP_UART5_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_WritePin(MCU_BSP_UART5_RS485_CTRL_GPIO_PORT, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
    } else {
        return -1;
    }
    return 0;
}

/* 串口开启接收 */
void McuBspUartStartRecv(uint8_t UartId)
{
    if (UartId == MCU_BSP_UART1_ID) {
        if (MCU_BSP_UART1_USE_FLAG == 0) {
            return;
        }
        HAL_UART_Receive_IT(&gUartHandle1, &gRecvData1, 1);
    } else if (UartId == MCU_BSP_UART2_ID) {
        if (MCU_BSP_UART2_USE_FLAG == 0) {
            return;
        }
        HAL_UART_Receive_IT(&gUartHandle2, &gRecvData2, 1);
    } else if (UartId == MCU_BSP_UART3_ID) {
        if (MCU_BSP_UART3_USE_FLAG == 0) {
            return;
        }
        HAL_UART_Receive_IT(&gUartHandle3, &gRecvData3, 1);
    } else if (UartId == MCU_BSP_UART4_ID) {
        if (MCU_BSP_UART4_USE_FLAG == 0) {
            return;
        }
        HAL_UART_Receive_IT(&gUartHandle4, &gRecvData4, 1);
    } else if (UartId == MCU_BSP_UART5_ID) {
        if (MCU_BSP_UART5_USE_FLAG == 0) {
            return;
        }
        HAL_UART_Receive_IT(&gUartHandle5, &gRecvData5, 1);
    }
}

/* uart sleep */
void McuBspUartSleep(void)
{
    GPIO_InitTypeDef  GPIO_InitStruct;
    if (MCU_BSP_UART1_USE_FLAG == 1) {
        if (gUart1UseFlag == 1) {
            __HAL_UART_DISABLE(&gUartHandle1);
            __HAL_RCC_USART1_CLK_DISABLE(); 
        }
        HAL_NVIC_DisableIRQ(MCU_BSP_UART1_IRQn);
        MCU_BSP_UART1_TX_GPIO_CLK();
        MCU_BSP_UART1_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART1_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
        GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(MCU_BSP_UART1_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART1_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
        GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(MCU_BSP_UART1_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART1_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART1_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART1_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_OD;
            GPIO_InitStruct.Pull      = GPIO_NOPULL;
            GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
            HAL_GPIO_Init(MCU_BSP_UART1_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
        }
    }
    if (MCU_BSP_UART2_USE_FLAG == 1) {
        if (gUart2UseFlag == 1) {
            __HAL_UART_DISABLE(&gUartHandle2);
            __HAL_RCC_USART2_CLK_DISABLE();  
        }
        HAL_NVIC_DisableIRQ(MCU_BSP_UART2_IRQn);
        MCU_BSP_UART2_TX_GPIO_CLK();
        MCU_BSP_UART2_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART2_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
        GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(MCU_BSP_UART2_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART2_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
        GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(MCU_BSP_UART2_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART2_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART2_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART2_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_OD;
            GPIO_InitStruct.Pull      = GPIO_NOPULL;
            GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
            HAL_GPIO_Init(MCU_BSP_UART2_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
        }
    }
    if (MCU_BSP_UART3_USE_FLAG == 1) {
        if (gUart3UseFlag == 1) {
            __HAL_UART_DISABLE(&gUartHandle3);
            __HAL_RCC_USART3_CLK_DISABLE();
        }
        HAL_NVIC_DisableIRQ(MCU_BSP_UART3_IRQn);
        MCU_BSP_UART3_TX_GPIO_CLK();
        MCU_BSP_UART3_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART3_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
        GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(MCU_BSP_UART3_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART3_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
        GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(MCU_BSP_UART3_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART3_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART3_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART3_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_OD;
            GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
            GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
            HAL_GPIO_Init(MCU_BSP_UART3_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
        }
    }
    if (MCU_BSP_UART4_USE_FLAG == 1) {
        if (gUart4UseFlag == 1) {
            __HAL_UART_DISABLE(&gUartHandle4);
            __HAL_RCC_UART4_CLK_DISABLE();
        }
        HAL_NVIC_DisableIRQ(MCU_BSP_UART4_IRQn);
        MCU_BSP_UART4_TX_GPIO_CLK();
        MCU_BSP_UART4_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART4_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
        GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(MCU_BSP_UART4_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART4_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
        GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(MCU_BSP_UART4_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART4_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART4_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART4_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_OD;
            GPIO_InitStruct.Pull      = GPIO_NOPULL;
            GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
            HAL_GPIO_Init(MCU_BSP_UART4_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
        }
    }
    if (MCU_BSP_UART5_USE_FLAG == 1) {
        if (gUart5UseFlag == 1) {
            __HAL_UART_DISABLE(&gUartHandle5);
            __HAL_RCC_UART5_CLK_DISABLE();
        }
        HAL_NVIC_DisableIRQ(MCU_BSP_UART5_IRQn);
        MCU_BSP_UART5_TX_GPIO_CLK();
        MCU_BSP_UART5_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART5_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
        GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(MCU_BSP_UART5_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART5_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
        GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
        HAL_GPIO_Init(MCU_BSP_UART5_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART5_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART5_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART5_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_OD;
            GPIO_InitStruct.Pull      = GPIO_NOPULL;
            GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
            HAL_GPIO_Init(MCU_BSP_UART5_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
        }
    }
}

/* uart wakeup */
void McuBspUart1WakeUp(void)
{
    GPIO_InitTypeDef  GPIO_InitStruct;
    if (gUart1UseFlag == 1) {
        MCU_BSP_UART1_CLK_ENABLE();
        MCU_BSP_UART1_TX_GPIO_CLK();
        MCU_BSP_UART1_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART1_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART1_TX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART1_TX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART1_TX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART1_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART1_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART1_RX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART1_RX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART1_RX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART1_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART1_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART1_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART1_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = MCU_BSP_UART1_RS485_CTRL_GPIO_MODE;
            GPIO_InitStruct.Pull      = MCU_BSP_UART1_RS485_CTRL_GPIO_PULL;
            GPIO_InitStruct.Speed     = MCU_BSP_UART1_RS485_CTRL_GPIO_SPEED;
            HAL_GPIO_Init(MCU_BSP_UART1_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
            // 默认为接收态
            HAL_GPIO_WritePin(MCU_BSP_UART1_RS485_CTRL_GPIO_PORT, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
        HAL_NVIC_EnableIRQ(MCU_BSP_UART1_IRQn);
        __HAL_UART_ENABLE(&gUartHandle1);
    }
}

/* uart wakeup */
void McuBspUart2WakeUp(void)
{
    GPIO_InitTypeDef  GPIO_InitStruct;
    if (gUart2UseFlag == 1) {
        MCU_BSP_UART2_CLK_ENABLE();
        MCU_BSP_UART2_TX_GPIO_CLK();
        MCU_BSP_UART2_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART2_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART2_TX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART2_TX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART2_TX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART2_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART2_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART2_RX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART2_RX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART2_RX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART2_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART2_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART2_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART2_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = MCU_BSP_UART2_RS485_CTRL_GPIO_MODE;
            GPIO_InitStruct.Pull      = MCU_BSP_UART2_RS485_CTRL_GPIO_PULL;
            GPIO_InitStruct.Speed     = MCU_BSP_UART2_RS485_CTRL_GPIO_SPEED;
            HAL_GPIO_Init(MCU_BSP_UART2_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
            // 默认为接收态
            HAL_GPIO_WritePin(MCU_BSP_UART2_RS485_CTRL_GPIO_PORT, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
        HAL_NVIC_EnableIRQ(MCU_BSP_UART2_IRQn);
        __HAL_UART_ENABLE(&gUartHandle2);
    }
}

/* uart wakeup */
void McuBspUart3WakeUp(void)
{
    GPIO_InitTypeDef  GPIO_InitStruct;
    if (gUart3UseFlag == 1) {
        MCU_BSP_UART3_CLK_ENABLE();
        MCU_BSP_UART3_TX_GPIO_CLK();
        MCU_BSP_UART3_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART3_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART3_TX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART3_TX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART3_TX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART3_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART3_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART3_RX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART3_RX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART3_RX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART3_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART3_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART3_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART3_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = MCU_BSP_UART3_RS485_CTRL_GPIO_MODE;
            GPIO_InitStruct.Pull      = MCU_BSP_UART3_RS485_CTRL_GPIO_PULL;
            GPIO_InitStruct.Speed     = MCU_BSP_UART3_RS485_CTRL_GPIO_SPEED;
            HAL_GPIO_Init(MCU_BSP_UART3_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
            // 默认为接收态
            HAL_GPIO_WritePin(MCU_BSP_UART3_RS485_CTRL_GPIO_PORT, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
        HAL_NVIC_EnableIRQ(MCU_BSP_UART3_IRQn);
        __HAL_UART_ENABLE(&gUartHandle3);
    }
}

/* uart wakeup */
void McuBspUart4WakeUp(void)
{
    GPIO_InitTypeDef  GPIO_InitStruct;
    if (gUart4UseFlag == 1) {
        MCU_BSP_UART4_CLK_ENABLE();
        MCU_BSP_UART4_TX_GPIO_CLK();
        MCU_BSP_UART4_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART4_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART4_TX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART4_TX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART4_TX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART4_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART4_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART4_RX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART4_RX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART4_RX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART4_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART4_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART4_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART4_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = MCU_BSP_UART4_RS485_CTRL_GPIO_MODE;
            GPIO_InitStruct.Pull      = MCU_BSP_UART4_RS485_CTRL_GPIO_PULL;
            GPIO_InitStruct.Speed     = MCU_BSP_UART4_RS485_CTRL_GPIO_SPEED;
            HAL_GPIO_Init(MCU_BSP_UART4_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
            // 默认为接收态
            HAL_GPIO_WritePin(MCU_BSP_UART4_RS485_CTRL_GPIO_PORT, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
        HAL_NVIC_EnableIRQ(MCU_BSP_UART4_IRQn);
        __HAL_UART_ENABLE(&gUartHandle4);
    }
}

/* uart wakeup */
void McuBspUart5WakeUp(void)
{
    GPIO_InitTypeDef  GPIO_InitStruct;
    if (gUart5UseFlag == 1) {
        MCU_BSP_UART5_CLK_ENABLE();
        MCU_BSP_UART5_TX_GPIO_CLK();
        MCU_BSP_UART5_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART5_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART5_TX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART5_TX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART5_TX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART5_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART5_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART5_RX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART5_RX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART5_RX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART5_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART5_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART5_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART5_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = MCU_BSP_UART5_RS485_CTRL_GPIO_MODE;
            GPIO_InitStruct.Pull      = MCU_BSP_UART5_RS485_CTRL_GPIO_PULL;
            GPIO_InitStruct.Speed     = MCU_BSP_UART5_RS485_CTRL_GPIO_SPEED;
            HAL_GPIO_Init(MCU_BSP_UART5_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
            // 默认为接收态
            HAL_GPIO_WritePin(MCU_BSP_UART5_RS485_CTRL_GPIO_PORT, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
        HAL_NVIC_EnableIRQ(MCU_BSP_UART5_IRQn);
        __HAL_UART_ENABLE(&gUartHandle5);
    }
}


/* 串口发送完成回调函数 */
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *UartHandle)
{
    if (UartHandle->Instance == USART1) {
        if (gSendCallback1 != NULL) {
            gSendCallback1();
        }
    } else if (UartHandle->Instance == USART2) {
        if (gSendCallback2 != NULL) {
            gSendCallback2();
        }
    } else if (UartHandle->Instance == USART3) {
        if (gSendCallback3 != NULL) {
            gSendCallback3();
        }
    } else if (UartHandle->Instance == UART4) {
        if (gSendCallback4 != NULL) {
            gSendCallback4();
        }
    } else if (UartHandle->Instance == UART5) {
        if (gSendCallback5 != NULL) {
            gSendCallback5();
        }
    }
}

/* 串口接收完成的回调函数 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
{
    if (UartHandle->Instance == USART1) {
        if (gRecvCallback1 != NULL) {
            gRecvCallback1(gRecvData1);
        }
        HAL_UART_Receive_IT(&gUartHandle1, &gRecvData1, 1);
    } else if (UartHandle->Instance == USART2) {
        if (gRecvCallback2 != NULL) {
            gRecvCallback2(gRecvData2);
        }
        HAL_UART_Receive_IT(&gUartHandle2, &gRecvData2, 1);
    } else if (UartHandle->Instance == USART3) {
        if (gRecvCallback3 != NULL) {
            gRecvCallback3(gRecvData3);
        }
        HAL_UART_Receive_IT(&gUartHandle3, &gRecvData3, 1);
    } else if (UartHandle->Instance == UART4) {
        if (gRecvCallback4 != NULL) {
            gRecvCallback4(gRecvData4);
        }
        HAL_UART_Receive_IT(&gUartHandle4, &gRecvData4, 1);
    } else if (UartHandle->Instance == UART5) {
        if (gRecvCallback5 != NULL) {
            gRecvCallback5(gRecvData5);
        }
        HAL_UART_Receive_IT(&gUartHandle5, &gRecvData5, 1);
    }
}

/* 串口的错误回调函数 */
void HAL_UART_ErrorCallback(UART_HandleTypeDef *UartHandle)
{
    
}

void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{  
    GPIO_InitTypeDef  GPIO_InitStruct;
    if (huart->Instance == USART1) {
        MCU_BSP_UART1_CLK_ENABLE();
        MCU_BSP_UART1_TX_GPIO_CLK();
        MCU_BSP_UART1_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART1_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART1_TX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART1_TX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART1_TX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART1_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART1_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART1_RX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART1_RX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART1_RX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART1_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART1_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART1_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART1_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = MCU_BSP_UART1_RS485_CTRL_GPIO_MODE;
            GPIO_InitStruct.Pull      = MCU_BSP_UART1_RS485_CTRL_GPIO_PULL;
            GPIO_InitStruct.Speed     = MCU_BSP_UART1_RS485_CTRL_GPIO_SPEED;
            HAL_GPIO_Init(MCU_BSP_UART1_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
            // 默认为接收态
            HAL_GPIO_WritePin(MCU_BSP_UART1_RS485_CTRL_GPIO_PORT, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
        HAL_NVIC_SetPriority(MCU_BSP_UART1_IRQn, 1, 0);
        HAL_NVIC_EnableIRQ(MCU_BSP_UART1_IRQn);
    } else if (huart->Instance == USART2) {
        MCU_BSP_UART2_CLK_ENABLE();
        MCU_BSP_UART2_TX_GPIO_CLK();
        MCU_BSP_UART2_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART2_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART2_TX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART2_TX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART2_TX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART2_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART2_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART2_RX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART2_RX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART2_RX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART2_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART2_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART2_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART2_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = MCU_BSP_UART2_RS485_CTRL_GPIO_MODE;
            GPIO_InitStruct.Pull      = MCU_BSP_UART2_RS485_CTRL_GPIO_PULL;
            GPIO_InitStruct.Speed     = MCU_BSP_UART2_RS485_CTRL_GPIO_SPEED;
            HAL_GPIO_Init(MCU_BSP_UART2_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
            // 默认为接收态
            HAL_GPIO_WritePin(MCU_BSP_UART2_RS485_CTRL_GPIO_PORT, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
        
        HAL_NVIC_SetPriority(MCU_BSP_UART2_IRQn, 5, 0);
        HAL_NVIC_EnableIRQ(MCU_BSP_UART2_IRQn);
    } else if (huart->Instance == USART3) {
        MCU_BSP_UART3_CLK_ENABLE();
        __HAL_AFIO_REMAP_USART3_ENABLE(); // 重定义口
        MCU_BSP_UART3_TX_GPIO_CLK();
        MCU_BSP_UART3_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART3_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART3_TX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART3_TX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART3_TX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART3_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART3_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART3_RX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART3_RX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART3_RX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART3_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART3_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART3_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART3_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = MCU_BSP_UART3_RS485_CTRL_GPIO_MODE;
            GPIO_InitStruct.Pull      = MCU_BSP_UART3_RS485_CTRL_GPIO_PULL;
            GPIO_InitStruct.Speed     = MCU_BSP_UART3_RS485_CTRL_GPIO_SPEED;
            HAL_GPIO_Init(MCU_BSP_UART3_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
            // 默认为接收态
            HAL_GPIO_WritePin(MCU_BSP_UART3_RS485_CTRL_GPIO_PORT, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
        HAL_NVIC_SetPriority(MCU_BSP_UART3_IRQn, 5, 0);
        HAL_NVIC_EnableIRQ(MCU_BSP_UART3_IRQn);
    } else if (huart->Instance == UART4) {
        MCU_BSP_UART4_CLK_ENABLE();
        MCU_BSP_UART4_TX_GPIO_CLK();
        MCU_BSP_UART4_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART4_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART4_TX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART4_TX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART4_TX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART4_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART4_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART4_RX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART4_RX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART4_RX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART4_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART4_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART4_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART4_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = MCU_BSP_UART4_RS485_CTRL_GPIO_MODE;
            GPIO_InitStruct.Pull      = MCU_BSP_UART4_RS485_CTRL_GPIO_PULL;
            GPIO_InitStruct.Speed     = MCU_BSP_UART4_RS485_CTRL_GPIO_SPEED;
            HAL_GPIO_Init(MCU_BSP_UART4_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
            // 默认为接收态
            HAL_GPIO_WritePin(MCU_BSP_UART4_RS485_CTRL_GPIO_PORT, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
        HAL_NVIC_SetPriority(MCU_BSP_UART4_IRQn, 1, 0);
        HAL_NVIC_EnableIRQ(MCU_BSP_UART4_IRQn);
    } else if (huart->Instance == UART5) {
        MCU_BSP_UART5_CLK_ENABLE();
        MCU_BSP_UART5_TX_GPIO_CLK();
        MCU_BSP_UART5_RX_GPIO_CLK();
        /* 初始化发送引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART5_TX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART5_TX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART5_TX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART5_TX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART5_TX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化接收引脚 */
        GPIO_InitStruct.Pin       = MCU_BSP_UART5_RX_GPIO_PIN;
        GPIO_InitStruct.Mode      = MCU_BSP_UART5_RX_GPIO_MODE;
        GPIO_InitStruct.Pull      = MCU_BSP_UART5_RX_GPIO_PULL;
        GPIO_InitStruct.Speed     = MCU_BSP_UART5_RX_GPIO_SPEED;
        HAL_GPIO_Init(MCU_BSP_UART5_RX_GPIO_PORT, &GPIO_InitStruct);
        /* 初始化485控制引脚 */
        if (MCU_BSP_UART5_TYPE == MCU_BSP_RS485_UART_TYPE) {
            MCU_BSP_UART5_RS485_CTRL_GPIO_CLK();
            GPIO_InitStruct.Pin       = MCU_BSP_UART5_RS485_CTRL_GPIO_PIN;
            GPIO_InitStruct.Mode      = MCU_BSP_UART5_RS485_CTRL_GPIO_MODE;
            GPIO_InitStruct.Pull      = MCU_BSP_UART5_RS485_CTRL_GPIO_PULL;
            GPIO_InitStruct.Speed     = MCU_BSP_UART5_RS485_CTRL_GPIO_SPEED;
            HAL_GPIO_Init(MCU_BSP_UART5_RS485_CTRL_GPIO_PORT, &GPIO_InitStruct);
            // 默认为接收态
            HAL_GPIO_WritePin(MCU_BSP_UART5_RS485_CTRL_GPIO_PORT, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN, GPIO_PIN_RESET);
        }
        HAL_NVIC_SetPriority(MCU_BSP_UART5_IRQn, 1, 0);
        HAL_NVIC_EnableIRQ(MCU_BSP_UART5_IRQn);
    }
}

void HAL_UART_MspDeInit(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART1) {
        MCU_BSP_UART1_FORCE_RESET();
        MCU_BSP_UART1_RELEASE_RESET();
        HAL_GPIO_DeInit(MCU_BSP_UART1_RX_GPIO_PORT, MCU_BSP_UART1_RX_GPIO_PIN);
        HAL_GPIO_DeInit(MCU_BSP_UART1_RX_GPIO_PORT, MCU_BSP_UART1_RX_GPIO_PIN);
        if (MCU_BSP_UART1_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_DeInit(MCU_BSP_UART1_RS485_CTRL_GPIO_PORT, MCU_BSP_UART1_RS485_CTRL_GPIO_PIN);
        }
        HAL_NVIC_DisableIRQ(MCU_BSP_UART1_IRQn);
    } else if (huart->Instance == USART2) {
        MCU_BSP_UART2_FORCE_RESET();
        MCU_BSP_UART2_RELEASE_RESET();
        HAL_GPIO_DeInit(MCU_BSP_UART2_TX_GPIO_PORT, MCU_BSP_UART2_TX_GPIO_PIN);
        HAL_GPIO_DeInit(MCU_BSP_UART2_RX_GPIO_PORT, MCU_BSP_UART2_RX_GPIO_PIN);
        if (MCU_BSP_UART2_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_DeInit(MCU_BSP_UART2_RS485_CTRL_GPIO_PORT, MCU_BSP_UART2_RS485_CTRL_GPIO_PIN);
        }
        HAL_NVIC_DisableIRQ(MCU_BSP_UART2_IRQn);
    } else if (huart->Instance == USART3) {
        MCU_BSP_UART3_FORCE_RESET();
        MCU_BSP_UART3_RELEASE_RESET();
        HAL_GPIO_DeInit(MCU_BSP_UART3_TX_GPIO_PORT, MCU_BSP_UART3_TX_GPIO_PIN);
        HAL_GPIO_DeInit(MCU_BSP_UART3_RX_GPIO_PORT, MCU_BSP_UART3_RX_GPIO_PIN);
        if (MCU_BSP_UART3_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_DeInit(MCU_BSP_UART3_RS485_CTRL_GPIO_PORT, MCU_BSP_UART3_RS485_CTRL_GPIO_PIN);
        }
        HAL_NVIC_DisableIRQ(MCU_BSP_UART3_IRQn);
    } else if (huart->Instance == UART4) {
        MCU_BSP_UART4_FORCE_RESET();
        MCU_BSP_UART4_RELEASE_RESET();
        HAL_GPIO_DeInit(MCU_BSP_UART4_TX_GPIO_PORT, MCU_BSP_UART4_TX_GPIO_PIN);
        HAL_GPIO_DeInit(MCU_BSP_UART4_RX_GPIO_PORT, MCU_BSP_UART4_RX_GPIO_PIN);
        if (MCU_BSP_UART4_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_DeInit(MCU_BSP_UART4_RS485_CTRL_GPIO_PORT, MCU_BSP_UART4_RS485_CTRL_GPIO_PIN);
        }
        HAL_NVIC_DisableIRQ(MCU_BSP_UART4_IRQn);
    } else if (huart->Instance == UART5) {
        MCU_BSP_UART5_FORCE_RESET();
        MCU_BSP_UART5_RELEASE_RESET();
        HAL_GPIO_DeInit(MCU_BSP_UART5_TX_GPIO_PORT, MCU_BSP_UART5_TX_GPIO_PIN);
        HAL_GPIO_DeInit(MCU_BSP_UART5_RX_GPIO_PORT, MCU_BSP_UART5_RX_GPIO_PIN);
        if (MCU_BSP_UART5_TYPE == MCU_BSP_RS485_UART_TYPE) {
            HAL_GPIO_DeInit(MCU_BSP_UART5_RS485_CTRL_GPIO_PORT, MCU_BSP_UART5_RS485_CTRL_GPIO_PIN);
        }
        HAL_NVIC_DisableIRQ(MCU_BSP_UART5_IRQn);
    }
}

/* 串口1中断 */
void USART1_IRQHandler(void)
{
    HAL_UART_IRQHandler(&gUartHandle1);
}

/* 串口2中断 */
void USART2_IRQHandler(void)
{
    HAL_UART_IRQHandler(&gUartHandle2);    
}

/* 串口3中断 */
void USART3_IRQHandler(void)
{
    HAL_UART_IRQHandler(&gUartHandle3);
}

/* 串口4中断 */
void UART4_IRQHandler(void)
{
    HAL_UART_IRQHandler(&gUartHandle4);
}

/* 串口5中断 */
void UART5_IRQHandler(void)
{
    HAL_UART_IRQHandler(&gUartHandle5);    
}