#include "uart_dev.h"
#include "FreeRTOS.h"

device_handle g_J0_handle;
device_handle g_J1_handle;
device_handle g_J2_handle;
device_handle g_J3_handle;
device_handle g_J4_handle;
device_handle g_J5_handle;
device_handle g_J6_handle;
device_handle g_J7_handle;
device_handle g_J8_handle;
device_handle g_J9_handle;
device_handle g_Mcu_handle;
device_handle g_Su806_handle;
device_handle g_Lora_handle;

static int32_t rs485BuffLen;
static int32_t loraBuffLen;
static int32_t mcuBuffLen;
static int32_t su806BuffLen;

static uint8_t *J0Buff;
static uint8_t *J1Buff;
static uint8_t *J2Buff;
static uint8_t *J3Buff;
static uint8_t *J4Buff;
static uint8_t *J5Buff;
static uint8_t *J6Buff;
static uint8_t *J7Buff;
static uint8_t *J8Buff;
static uint8_t *J9Buff;
static uint8_t *LoraBuff;
static uint8_t *McuBuff;
static uint8_t *Su806Buff;


/**
  * @brief  串口信息初始化，串口号及波特率.
  * @param  uart_index    对应的硬件串口号
  * @param  uart_baudrate 波特率
  */
uart_device_info uart_devices[]={
  [0] = {
      .init          = 0,
      .uart_index    = J01_485_INDEX,
      .uart_baudrate = 9600,
  },
  [1] = {
      .init          = 0,
      .uart_index    = J23_485_INDEX,
      .uart_baudrate = 9600,
  },
  [2] = {
      .init          = 0,
      .uart_index    = J45_485_INDEX,
      .uart_baudrate = 9600,
  },
  [3] = {
      .init          = 0,
      .uart_index    = J67_485_INDEX,
      .uart_baudrate = 9600,
  },
  [4] = {
      .init          = 0,
      .uart_index    = J8_485_INDEX,
      .uart_baudrate = 9600,
  },
  [5] = {
      .init          = 0,
      .uart_index    = J9_485_INDEX,
      .uart_baudrate = 9600,
  },
  [6] = {
      .init          = 0,
      .uart_index    = Lora_UART_INDEX,
      .uart_baudrate = 9600,
  },
  [7] = {
      .init          = 0,
      .uart_index    = Su806_UART_INDEX,
      .uart_baudrate = 115200,
  },
  [8] = {
      .init          = 0,
      .uart_index    = MCU_UART_INDEX,
      .uart_baudrate = 115200,
  },
};

static device_handle uart_dev_init(uartIndex_e uart_index, uint8_t *buff, int buff_size);
static void uart_init(uartIndex_e uart_index, uint32_t baud);

/**
  * @brief  初始化串口设备.
  * @param  uart_index 初始化串口号
  * @param  buff       串口循环buff地址
  * @param  buff_size  串口循环buff对应大小
  * @retval 串口句柄
  */
device_handle uart_dev_init(uartIndex_e uart_index, uint8_t *buff, int buff_size)
{
    int i = 0;
    for (; i < ELEMENT_OF(uart_devices); i++) {
        if (uart_devices[i].uart_index == uart_index) {
            if (!uart_devices[i].init) {
                InitRingQueue(&uart_devices[i].uart_ring_queue, buff, buff_size); 
                uart_init(uart_index, uart_devices[i].uart_baudrate);
                uart_devices[i].init = 1;
            }
            return (device_handle)(&uart_devices[i]);
        }
    }
    return 0;
}


/**
  * @brief  串口硬件初始化.
  * @param  uart_index 串口号
  * @param  baud 波特率
  * @retval None
  */
void uart_init(uartIndex_e uart_index, uint32_t baud)
{
    if (uart_index == J01_485_INDEX) {
        uart3Init(baud);
    }
    else if (uart_index == J23_485_INDEX) {
        uart4Init(baud);    
    }
    else if (uart_index == J45_485_INDEX) {
        uart5Init(baud);    
    }
    else if (uart_index == J67_485_INDEX) {
        uart6Init(baud);    
    }
    else if (uart_index == J8_485_INDEX) {
        uart8Init(baud);    
    }
    else if (uart_index == J9_485_INDEX) {
        uart7Init(baud);    
    }
    else if (uart_index == Lora_UART_INDEX) {
        uart7Init(baud);    
    }
    else if (uart_index == Su806_UART_INDEX) {
        uart8Init(baud);    
    }
    else if (uart_index == MCU_UART_INDEX) {
        uart2Init(baud);    
    }
}

/**
  * @brief  从串口设备循环buff读取一个数据.
  * @param  device 串口句柄
  * @retval 读取到的字符
  */
uint8_t uart_dev_in_char(device_handle device)
{
    uart_device_info *device_info = (uart_device_info *)device;
    char c = 0;

    if (uart_dev_char_present(device))
        OutRingQueue(&device_info->uart_ring_queue, (u_int8_t*)&c);
    return c;
}

/**
  * @brief  判断串口设备循环buff是否有数据.
  * @param  device 串口句柄
  * @retval 0 空   1有数据
  */
int uart_dev_char_present(device_handle device)
{
    uart_device_info *device_info = (uart_device_info *)device;

    if((!device) || (!device_info->init))
        return 0;

    return !RingQueueEmpty(&device_info->uart_ring_queue);
}

/**
  * @brief  主mcu初始化串口buff.
  * @param  rs485BufLen 485buff的长度
            loraBufLen  lora通信buff的长度
            mcuBufLen   mcu通信buff的长度
            su806BufLen su806通信buff的长度
  * @retval
  */
void HostMcu_uartBuf_Init(int32_t rs485BufLen, int32_t loraBufLen, int32_t mcuBufLen, int32_t su806BufLen)
{
    rs485BuffLen = rs485BufLen;
    loraBuffLen = loraBufLen;
    mcuBuffLen = mcuBufLen;
    su806BuffLen = su806BufLen;

    J0Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
    J2Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
    J4Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
    J6Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);

    McuBuff = (uint8_t *)pvPortMalloc(mcuBuffLen);

    Su806Buff = (uint8_t *)pvPortMalloc(su806BuffLen);

    LoraBuff = (uint8_t *)pvPortMalloc(loraBuffLen);
}

/**
  * @brief  从mcu初始化串口buff.
  * @param  rs485BufLen 485buff的长度
            mcuBufLen   mcu通信buff的长度
  * @retval
  */
void SlaveMcu_uartBuf_Init(int32_t rs485BufLen, int32_t mcuBufLen)
{
    rs485BuffLen = rs485BufLen;
    mcuBuffLen = mcuBufLen;

    J1Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
    J3Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
    J4Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
    J7Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
    J8Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
    J9Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);

    McuBuff = (uint8_t *)pvPortMalloc(mcuBuffLen);
}

void Init_J0_485(uint32_t baud)
{
    uart_devices[0].uart_baudrate = baud;
    g_J0_handle = uart_dev_init(J01_485_INDEX, J0Buff, rs485BuffLen);
}

void Init_J1_485(uint32_t baud)
{
    uart_devices[0].uart_baudrate = baud;
    g_J1_handle = uart_dev_init(J01_485_INDEX, J1Buff, rs485BuffLen);
}

void Init_J2_485(uint32_t baud)
{
    uart_devices[1].uart_baudrate = baud;
    g_J2_handle = uart_dev_init(J23_485_INDEX, J2Buff, rs485BuffLen);
}

void Init_J3_485(uint32_t baud)
{
    uart_devices[1].uart_baudrate = baud;
    g_J3_handle = uart_dev_init(J23_485_INDEX, J3Buff, rs485BuffLen);
}

void Init_J4_485(uint32_t baud)
{
    uart_devices[2].uart_baudrate = baud;
    g_J4_handle = uart_dev_init(J45_485_INDEX, J4Buff, rs485BuffLen);
}

void Init_J5_485(uint32_t baud)
{
    uart_devices[2].uart_baudrate = baud;
    g_J5_handle = uart_dev_init(J45_485_INDEX, J5Buff, rs485BuffLen);
}

void Init_J6_485(uint32_t baud)
{
    uart_devices[3].uart_baudrate = baud;
    g_J6_handle = uart_dev_init(J67_485_INDEX, J6Buff, rs485BuffLen);
}

void Init_J7_485(uint32_t baud)
{
    uart_devices[3].uart_baudrate = baud;
    g_J7_handle = uart_dev_init(J67_485_INDEX, J7Buff, rs485BuffLen);
}

void Init_J8_485(uint32_t baud)
{
    uart_devices[4].uart_baudrate = baud;
    g_J8_handle = uart_dev_init(J8_485_INDEX, J8Buff, rs485BuffLen);
}

void Init_J9_485(uint32_t baud)
{
    uart_devices[5].uart_baudrate = baud;
    g_J9_handle = uart_dev_init(J9_485_INDEX, J9Buff, rs485BuffLen);
}

void Init_Lora_Uart(uint32_t baud)
{
    uart_devices[6].uart_baudrate = baud;
    g_Lora_handle = uart_dev_init(Lora_UART_INDEX, LoraBuff, loraBuffLen);
}

void Init_Su806_Uart(uint32_t baud)
{
    uart_devices[7].uart_baudrate = baud;
    g_Su806_handle = uart_dev_init(Su806_UART_INDEX, Su806Buff, su806BuffLen);
}

void Init_Mcu_Uart(uint32_t baud)
{
    uart_devices[8].uart_baudrate = baud;
    g_Mcu_handle = uart_dev_init(MCU_UART_INDEX, McuBuff, mcuBuffLen);
}

/**
  * @brief  mcu初始化串口中断.
  * @retval
  */
void uartIT_Init(void)
{
    if (getMCU()) {
        setIDLE(J0_USART, ENABLE);
        setIDLE(J2_USART, ENABLE);
        setIDLE(J4_USART, ENABLE);
        setIDLE(J6_USART, ENABLE);
    }
    else {
        setIDLE(J1_USART, ENABLE);
        setIDLE(J3_USART, ENABLE);
        setIDLE(J5_USART, ENABLE);
        setIDLE(J7_USART, ENABLE);
        setIDLE(J8_USART, ENABLE);
        setIDLE(J9_USART, ENABLE);
    }
}

/* 串口中断处理函数 */
void J0_Interrupt()
{
    if (getMCU()) {
        return;
    }

    /* 数据接收中断 */
    static uint8_t flag = 0;
    static uint8_t c;
    if (USART_GetITStatus(J0_USART, USART_IT_RXNE) != RESET) {
        if (flag == 0) {
            flag = 1;
            J0_485_IN_RXNE();
        }
        c = USART_ReceiveData(J0_USART); //接收数据
        uart_device_info *dev = (uart_device_info *)g_J0_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }
    
    /* 数据发送中断 */
    if (USART_GetITStatus(J0_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_J0_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(J0_USART, USART_IT_TXE, DISABLE);
            J0_485_IN_TXE();
            return;
        }
        USART_SendData(J0_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }

    /* 空闲中断 */
    if (USART_GetITStatus(J0_USART, USART_IT_IDLE) != RESET) {
        J0_USART->STATR;
        J0_USART->DATAR;
        J0_485_IN_IDLE();
    }
}

void J1_Interrupt()
{
    if (!getMCU()) {
        return;
    }

    /* 数据接收中断 */
    static uint8_t flag = 0;
    static uint8_t c;
    if (USART_GetITStatus(J1_USART, USART_IT_RXNE) != RESET) {
        if (flag == 0) {
            flag = 1;
            J1_485_IN_RXNE();
        }
        c = USART_ReceiveData(J1_USART); //接收数据
        uart_device_info *dev = (uart_device_info *)g_J1_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }
    
    /* 数据发送中断 */
    if (USART_GetITStatus(J1_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_J1_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(J1_USART, USART_IT_TXE, DISABLE);
            J1_485_IN_TXE();
            return;
        }
        USART_SendData(J1_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }

    /* 空闲中断 */
    if (USART_GetITStatus(J1_USART, USART_IT_IDLE) != RESET) {
        J1_USART->STATR;
        J1_USART->DATAR;
        J1_485_IN_IDLE();
    }
}

void J2_Interrupt()
{
    if (getMCU()) {
        return;
    }

    /* 数据接收中断 */
    static uint8_t flag = 0;
    static uint8_t c;
    if (USART_GetITStatus(J2_USART, USART_IT_RXNE) != RESET) {
        if (flag == 0) {
            flag = 1;
            J2_485_IN_RXNE();
        }
        c = USART_ReceiveData(J2_USART); //接收数据
        uart_device_info *dev = (uart_device_info *)g_J2_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }
    
    /* 数据发送中断 */
    if (USART_GetITStatus(J2_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_J2_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(J2_USART, USART_IT_TXE, DISABLE);
            J2_485_IN_TXE();
            return;
        }
        USART_SendData(J2_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }

    /* 空闲中断 */
    if (USART_GetITStatus(J2_USART, USART_IT_IDLE) != RESET) {
        J2_USART->STATR;
        J2_USART->DATAR;
        J2_485_IN_IDLE();
    }
}

void J3_Interrupt()
{
    if (!getMCU()) {
        return;
    }
    /* 数据接收中断 */
    static uint8_t flag = 0;
    static uint8_t c;
    if (USART_GetITStatus(J3_USART, USART_IT_RXNE) != RESET) {
        if (flag == 0) {
            flag = 1;
            J3_485_IN_RXNE();
        }
        c = USART_ReceiveData(J3_USART); //接收数据
        uart_device_info *dev = (uart_device_info *)g_J3_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }
    
    /* 数据发送中断 */
    if (USART_GetITStatus(J3_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_J3_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(J3_USART, USART_IT_TXE, DISABLE);
            J3_485_IN_TXE();
            return;
        }
        USART_SendData(J3_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }

    /* 空闲中断 */
    if (USART_GetITStatus(J3_USART, USART_IT_IDLE) != RESET) {
        J3_USART->STATR;
        J3_USART->DATAR;
        J3_485_IN_IDLE();
    }
}

void J4_Interrupt()
{
    if (getMCU()) {
        return;
    }
    /* 数据接收中断 */
    static uint8_t flag = 0;
    static uint8_t c;
    if (USART_GetITStatus(J4_USART, USART_IT_RXNE) != RESET) {
        if (flag == 0) {
            flag = 1;
            J4_485_IN_RXNE();
        }
        c = USART_ReceiveData(J4_USART); //接收数据
        uart_device_info *dev = (uart_device_info *)g_J4_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }
    
    /* 数据发送中断 */
    if (USART_GetITStatus(J4_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_J4_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(J4_USART, USART_IT_TXE, DISABLE);
            J4_485_IN_TXE();
            return;
        }
        USART_SendData(J4_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }

    /* 空闲中断 */
    if (USART_GetITStatus(J4_USART, USART_IT_IDLE) != RESET) {
        J4_USART->STATR;
        J4_USART->DATAR;
        J4_485_IN_IDLE();
    }

}

void J5_Interrupt()
{
    if (!getMCU()) {
        return;
    }

    /* 数据接收中断 */
    static uint8_t flag = 0;
    static uint8_t c;
    if (USART_GetITStatus(J5_USART, USART_IT_RXNE) != RESET) {
        if (flag == 0) {
            flag = 1;
            J5_485_IN_RXNE();
        }
        c = USART_ReceiveData(J5_USART); //接收数据
        uart_device_info *dev = (uart_device_info *)g_J5_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }
    
    /* 数据发送中断 */
    if (USART_GetITStatus(J5_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_J5_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(J5_USART, USART_IT_TXE, DISABLE);
            J5_485_IN_TXE();
            return;
        }
        USART_SendData(J5_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }

    /* 空闲中断 */
    if (USART_GetITStatus(J5_USART, USART_IT_IDLE) != RESET) {
        J5_USART->STATR;
        J5_USART->DATAR;
        J5_485_IN_IDLE();
    }

}

void J6_Interrupt()
{
    if (getMCU()) {
        return;
    }
    /* 数据接收中断 */
    static uint8_t flag = 0;
    static uint8_t c;
    if (USART_GetITStatus(J1_USART, USART_IT_RXNE) != RESET) {
        if (flag == 0) {
            flag = 1;
            J6_485_IN_RXNE();
        }
        c = USART_ReceiveData(J6_USART); //接收数据
        uart_device_info *dev = (uart_device_info *)g_J6_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }
    
    /* 数据发送中断 */
    if (USART_GetITStatus(J6_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_J6_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(J6_USART, USART_IT_TXE, DISABLE);
            J6_485_IN_TXE();
            return;
        }
        USART_SendData(J6_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }

    /* 空闲中断 */
    if (USART_GetITStatus(J6_USART, USART_IT_IDLE) != RESET) {
        J6_USART->STATR;
        J6_USART->DATAR;
        J6_485_IN_IDLE();
    }
}

void J7_Interrupt()
{
    if (!getMCU()) {
        return;
    }
    /* 数据接收中断 */
    static uint8_t flag = 0;
    static uint8_t c;
    if (USART_GetITStatus(J7_USART, USART_IT_RXNE) != RESET) {
        if (flag == 0) {
            flag = 1;
            J7_485_IN_RXNE();
        }
        c = USART_ReceiveData(J7_USART); //接收数据
        uart_device_info *dev = (uart_device_info *)g_J7_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }
    
    /* 数据发送中断 */
    if (USART_GetITStatus(J7_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_J7_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(J7_USART, USART_IT_TXE, DISABLE);
            J7_485_IN_TXE();
            return;
        }
        USART_SendData(J7_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }

    /* 空闲中断 */
    if (USART_GetITStatus(J7_USART, USART_IT_IDLE) != RESET) {
        J7_USART->STATR;
        J7_USART->DATAR;
        J7_485_IN_IDLE();
    }

}

void J8_Interrupt()
{
    if (!getMCU()) {
        return;
    }

    /* 数据接收中断 */
    static uint8_t flag = 0;
    static uint8_t c;
    if (USART_GetITStatus(J8_USART, USART_IT_RXNE) != RESET) {
        if (flag == 0) {
            flag = 1;
            J8_485_IN_RXNE();
        }
        c = USART_ReceiveData(J8_USART); //接收数据
        uart_device_info *dev = (uart_device_info *)g_J8_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }
    
    /* 数据发送中断 */
    if (USART_GetITStatus(J8_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_J8_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(J8_USART, USART_IT_TXE, DISABLE);
            J8_485_IN_TXE();
            return;
        }
        USART_SendData(J8_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }

    /* 空闲中断 */
    if (USART_GetITStatus(J8_USART, USART_IT_IDLE) != RESET) {
        J8_USART->STATR;
        J8_USART->DATAR;
        J8_485_IN_IDLE();
    }
}

void J9_Interrupt()
{
    if (!getMCU()) {
        return;
    }

    /* 数据接收中断 */
    static uint8_t flag = 0;
    static uint8_t c;
    if (USART_GetITStatus(J9_USART, USART_IT_RXNE) != RESET) {
        if (flag == 0) {
            flag = 1;
            J9_485_IN_RXNE();
        }
        c = USART_ReceiveData(J9_USART); //接收数据
        uart_device_info *dev = (uart_device_info *)g_J9_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }
    
    /* 数据发送中断 */
    if (USART_GetITStatus(J9_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_J9_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(J9_USART, USART_IT_TXE, DISABLE);
            J9_485_IN_TXE();
            return;
        }
        USART_SendData(J9_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }

    /* 空闲中断 */
    if (USART_GetITStatus(J9_USART, USART_IT_IDLE) != RESET) {
        J9_USART->STATR;
        J9_USART->DATAR;
        J9_485_IN_IDLE();
    }
}

void Mcu_Interrupt()
{
    /* 数据接收中断 */
    static uint8_t c;
    if (USART_GetITStatus(Mcu_USART, USART_IT_RXNE) != RESET) {
        c = USART_ReceiveData(Mcu_USART);                          //接收数据
        uart_device_info *dev = (uart_device_info *)g_Mcu_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }

    /* 数据发送中断 */
    if (USART_GetITStatus(Mcu_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_Mcu_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(Mcu_USART, USART_IT_TXE, DISABLE);
            if (getMCU()) {
                slaveMcu_uart_IN_TXE();            
            }
            else {
                hostMcu_uart_IN_TXE();
            }
            return;
        }
        USART_SendData(Mcu_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }
}

void Su806_Interrupt()
{
    if (getMCU()) {
        return;
    }

    /* 数据接收中断 */
    static uint8_t c;
    if (USART_GetITStatus(Su806_USART, USART_IT_RXNE) != RESET) {
        c = USART_ReceiveData(Su806_USART);                          //接收数据
        uart_device_info *dev = (uart_device_info *)g_Su806_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }

    /* 数据发送中断 */
    if (USART_GetITStatus(Su806_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_Su806_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(Su806_USART, USART_IT_TXE, DISABLE);
            Su806_uart_IN_TXE();
            return;
        }
        USART_SendData(Su806_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }
}

void Lora_Interrupt()
{
    if (getMCU()) {
        return;
    }

    /* 数据接收中断 */
    static uint8_t c;
    if (USART_GetITStatus(Lora_USART, USART_IT_RXNE) != RESET) {
        c = USART_ReceiveData(Lora_USART);                          //接收数据
        uart_device_info *dev = (uart_device_info *)g_Lora_handle;
        if(!RingQueueFull(&dev->uart_ring_queue))
            InRingQueue(&dev->uart_ring_queue, c);
    }

    /* 数据发送中断 */
    if (USART_GetITStatus(Lora_USART, USART_IT_TXE) != RESET) {
        uart_device_info *dev = (uart_device_info *)g_Lora_handle;
        if (dev->uart_send_data.count >= dev->uart_send_data.len) {
            USART_ITConfig(Lora_USART, USART_IT_TXE, DISABLE);
            Lora_uart_IN_TXE();
            return;
        }
        USART_SendData(Lora_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }
}