ISCS_CABINET_COLL_16/main/components/user_uart/user_uart.c

#include "user_uart.h"

#if (USER_USART1_ENABLE == 1)

static uint8_t usart1_rx_buffer[USER_UART_DATA_SIZE] = {0};
static uint16_t usart1_rx_size = 0;
static bool usart1_rx_stat = false;
static vUser_usart_data_upload_func vUsart1_data_upload = NULL;

#if (USER_USART1_DMA_TX_ENABLE == 1) || (USER_USART1_DMA_RX_ENABLE == 1)
static uint8_t usart1_tx_buffer[USER_UART_DATA_SIZE] = {0};
static uint16_t usart1_tx_size = 0;
static bool usart1_tx_stat = false;

/*******************************************************************************
  * @函数名称   prvUser_usart1_dma_init
  * @函数说明   DMA初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_usart1_dma_init(void)
{
    DMA_InitTypeDef DMA_InitStructure = {0};
    NVIC_InitTypeDef NVIC_InitStructure = {0};

    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

#if (USER_USART1_DMA_TX_ENABLE == 1)
    DMA_DeInit(DMA1_Channel4);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART1->DATAR);
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)usart1_tx_buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
    DMA_InitStructure.DMA_BufferSize = USER_UART_DATA_SIZE;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel4, &DMA_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    //DAM_IT_TC  传输完成中断屏蔽   DMA_IT_HT 传输过半中断屏蔽  DMA_IT_TE 传输错误中断屏蔽
    DMA_ITConfig(DMA1_Channel4, DMA_IT_TC | DMA_IT_TE, ENABLE);

    // DMA_Cmd(DMA1_Channel4, ENABLE); /* USART1 Tx */
    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
#endif

#if (USER_USART1_DMA_RX_ENABLE == 1)
    DMA_DeInit(DMA1_Channel5);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART1->DATAR);
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)usart1_rx_buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_BufferSize = USER_UART_DATA_SIZE;
    DMA_Init(DMA1_Channel5, &DMA_InitStructure);

#if (USER_USART1_RX_DMA_IRQ_ENABLE == 1)
    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel5_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    //DAM_IT_TC  传输完成中断屏蔽   DMA_IT_HT 传输过半中断屏蔽  DMA_IT_TE 传输错误中断屏蔽
    DMA_ITConfig(DMA1_Channel5, DMA_IT_TC, ENABLE);
#endif

    DMA_Cmd(DMA1_Channel5, ENABLE); /* USART1 Rx */
    USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
#endif
}
#endif

#if (USER_USART1_DMA_TX_ENABLE == 1) 
/*******************************************************************************
  * @函数名称   vUser_usart1_send
  * @函数说明   usart1发送函数
  * @输入参数  	data：数据
  *            size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
bool vUser_usart1_send(uint8_t *data, uint16_t size)
{
    if(size > USER_UART_DATA_SIZE)
    {
        return false;
    }

    if(usart1_tx_stat == false)
    {
        usart1_tx_stat = true;
        memcpy(usart1_tx_buffer, data, size);
        usart1_tx_size = size;
        DMA1_Channel4->CNTR = (uint32_t)usart1_tx_size;
        DMA_Cmd(DMA1_Channel4, ENABLE);  //开始DMA发送

        return true;
    }
    
    return false;
}

void DMA1_Channel4_IRQHandler(void)   __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   DMA1_Channel4_IRQHandler
  * @函数说明   DMA1 Channel4中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void DMA1_Channel4_IRQHandler()
{
    if(DMA_GetITStatus(DMA1_IT_TC4) == SET)
    {
        DMA_ClearITPendingBit(DMA1_IT_TC4);
        usart1_tx_stat = false;
    }
    else if(DMA_GetITStatus(DMA1_IT_TE4) == SET)
    {
        DMA_ClearITPendingBit(DMA1_IT_TE4);
        usart1_tx_stat = false;
    }
}
#else
/*******************************************************************************
  * @函数名称   vUser_usart1_send
  * @函数说明   usart1发送函数
  * @输入参数  	data：数据
  *            size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
bool vUser_usart1_send(uint8_t *data, uint16_t size)
{
    uint32_t timeout = 10000;
    for(int i = 0; i < size; i++)
    {
        while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
        {
            if(timeout > 0)
            {
                timeout--;
            }
            else{
                return false;
            }
        }
        USART_SendData(USART1, *data++);
    }

    return true;
}
#endif

#if (USER_USART1_DMA_RX_ENABLE == 1)
#if (USER_USART1_RX_DMA_IRQ_ENABLE == 1)
void DMA1_Channel5_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   DMA1_Channel5_IRQHandler
  * @函数说明   DMA1_Channel5中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void DMA1_Channel5_IRQHandler(void)
{
    if(DMA_GetITStatus(DMA1_IT_TC5))
    {
        // 清除中断标志
        DMA_ClearITPendingBit(DMA1_IT_TC5);
        
        // 获取接收到的数据长度
        usart1_rx_size = USER_UART_DATA_SIZE - DMA_GetCurrDataCounter(DMA1_Channel5);
        
        // 设置接收完成标志
        usart1_rx_stat = true;
        
        // 重新配置 DMA 接收
        USART_DMACmd(USART1, USART_DMAReq_Rx, DISABLE);
        DMA_Cmd(DMA1_Channel5, DISABLE);
        DMA_SetCurrDataCounter(DMA1_Channel5, USER_UART_DATA_SIZE);
        DMA_Cmd(DMA1_Channel5, ENABLE);
        USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
    }
}
#elif (USER_USART1_RX_IRQ_ENABLE == 1)
void USART1_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   USART1_IRQHandler
  * @函数说明   USART1接收中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void USART1_IRQHandler(void)
{
    if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)
    {
        USART1->DATAR;
        USART1->STATR;
        DMA_Cmd(DMA1_Channel5,DISABLE);
        uint16_t dma_len = DMA_GetCurrDataCounter(DMA1_Channel5);
        if(USER_UART_DATA_SIZE >= dma_len)
        {
            usart1_rx_size = USER_UART_DATA_SIZE - dma_len;
            usart1_rx_stat = true;
        }
        DMA1_Channel5->CNTR = USER_UART_DATA_SIZE;
        DMA_Cmd(DMA1_Channel5,ENABLE);
        USART_ClearITPendingBit(USART1, USART_IT_IDLE);
    }
}
#else
/*******************************************************************************
  * @函数名称   vUsart1_recieve_data
  * @函数说明   USART1接收等待
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUsart1_recieve_data(void)
{
    if(usart1_rx_stat == false)
    {
        while(DMA_GetFlagStatus(DMA1_FLAG_TC5) == RESET);
        // 获取接收到的数据长度
        usart1_rx_size = USER_UART_DATA_SIZE - DMA_GetCurrDataCounter(DMA1_Channel5);
        
        // 设置接收完成标志
        if(usart1_rx_size > 0)
        {
            usart1_rx_stat = true;
            USART_DMACmd(USART1, USART_DMAReq_Rx, DISABLE);
            DMA_Cmd(DMA1_Channel5, DISABLE);
            DMA_SetCurrDataCounter(DMA1_Channel5, USER_UART_DATA_SIZE);
            DMA_Cmd(DMA1_Channel5, ENABLE);
            USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
        }
    }
}
#endif
#else
#if (USER_USART1_RX_IRQ_ENABLE == 1)
void USART1_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   USART1_IRQHandler
  * @函数说明   USART1接收中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void USART1_IRQHandler(void)
{
    // IDLE 中断处理
    if(USART_GetITStatus(USART1, USART_IT_IDLE))
    {
        // 清除 IDLE 中断标志（通过读取 SR 和 DR 寄存器）
        uint32_t temp;
        temp = USART1->STATR;  // 读取状态寄存器
        temp = USART1->DATAR;  // 读取数据寄存器
        (void)temp;  // 防止编译器警告
        
        // 设置接收完成标志
        usart1_rx_stat = true;
        
        // 清除 USART IDLE 中断标志
        USART_ClearITPendingBit(USART1, USART_IT_IDLE);
    }
    
    // RXNE 中断处理（接收数据寄存器非空）
    if(USART_GetITStatus(USART1, USART_IT_RXNE))
    {
        if(usart1_rx_stat == false)
        {
            // 读取接收到的数据
            uint8_t data = USART_ReceiveData(USART1);
            
            // 存储数据到缓冲区
            if(usart1_rx_size < USER_UART_DATA_SIZE)
            {
                usart1_rx_buffer[usart1_rx_size++] = data;
            }
            else
            {
                // 缓冲区溢出处理
                usart1_rx_size = 0;  // 重置索引
            }
        }
        
        // 清除 RXNE 中断标志
        USART_ClearITPendingBit(USART1, USART_IT_RXNE);
    }
}
#else
static uint16_t usart1_rx_finish_size = USER_UART_DATA_SIZE;
/*******************************************************************************
  * @函数名称   vUsart1_recieve_data
  * @函数说明   USART1接收等待
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUsart1_recieve_data(void)
{
    if(usart1_rx_stat == false)
    {
        while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET)
        {
            /* waiting for receiving finish */
        }
        // 存储数据到缓冲区
        if(usart1_rx_size < usart1_rx_finish_size)
        {
            usart1_rx_buffer[usart1_rx_size++] = data;
        }
        else
        {
            // 设置接收完成标志
            usart1_rx_stat = true;
        }
    }
}

/*******************************************************************************
  * @函数名称   vUser_usart1_set_recieve_finish_size
  * @函数说明   设置USART1接收长度
  * @输入参数  	size：需接收的数据长度
  * @输出参数   无
  * @返回参数   设置是否成功
*******************************************************************************/
bool vUser_usart1_set_recieve_finish_size(uint16_t size)
{
    if(size > USER_UART_DATA_SIZE)
    {
        return false;
    }
    usart1_rx_finish_size = size;
    return true;
}
#endif
#endif

/*******************************************************************************
  * @函数名称   vUser_usart1_init
  * @函数说明   初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_usart1_init(user_uart_param_s *param)
{
    GPIO_InitTypeDef  GPIO_InitStructure = {0};
    USART_InitTypeDef USART_InitStructure = {0};

    USER_USART1_RCC_ENABLE;

#ifdef USER_USART1_REMAP_ENABLE
    USER_USART1_REMAP_ENABLE;
#endif

    GPIO_InitStructure.GPIO_Pin = USER_USART1_TX_PIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(USER_USART1_TX_GPIO, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Pin = USER_USART1_RX_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(USER_USART1_RX_GPIO, &GPIO_InitStructure);

    USART_InitStructure.USART_BaudRate = param->baudrate;
    USART_InitStructure.USART_WordLength = param->wordlength;
    USART_InitStructure.USART_StopBits = param->stopbit;
    USART_InitStructure.USART_Parity = param->parity;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;

    USART_Init(USART1, &USART_InitStructure);

#if (USER_USART1_RX_IRQ_ENABLE == 1)
    NVIC_InitTypeDef NVIC_InitStructure={0};

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);
#if (USER_USART1_DMA_RX_ENABLE == 0)
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
#endif
#endif

#if (USER_USART1_DMA_TX_ENABLE == 1) || (USER_USART1_DMA_RX_ENABLE == 1)
    prvUser_usart1_dma_init();
#endif

    USART_Cmd(USART1, ENABLE);
}

/*******************************************************************************
  * @函数名称   prvUser_usart1_pro
  * @函数说明   usart1接收上报任务
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_usart1_pro(void)
{
#if (USER_USART1_DMA_RX_ENABLE == 0) && ((USER_USART1_RX_DMA_IRQ_ENABLE == 1) && (USER_USART1_RX_IRQ_ENABLE == 0))
    vUsart1_recieve_data();
#endif
    if(usart1_rx_stat == true)
    {
        usart1_rx_stat = false;
        if(vUsart1_data_upload != NULL)
        {
            vUsart1_data_upload(usart1_rx_buffer, usart1_rx_size);
        }
        usart1_rx_size = 0;
        memset(usart1_rx_buffer, 0, USER_UART_DATA_SIZE);
    }
}

/*******************************************************************************
  * @函数名称   vUser_usart1_set_data_upload_func
  * @函数说明   设置usart1接收数据上报回调函数
  * @输入参数  	func：回调函数指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_usart1_set_data_upload_func(vUser_usart_data_upload_func func)
{
    vUsart1_data_upload = func;
}

#endif


/********************************************************************************************************************************************
*********************************************************************************************************************************************
以下为usart2
*********************************************************************************************************************************************
********************************************************************************************************************************************/

#if (USER_USART2_ENABLE == 1)
static uint8_t usart2_rx_buffer[USER_UART_DATA_SIZE] = {0};
static uint16_t usart2_rx_size = 0;
static bool usart2_rx_stat = false;
static vUser_usart_data_upload_func vUsart2_data_upload = NULL;

#if (USER_USART2_DMA_TX_ENABLE == 1) || (USER_USART2_DMA_RX_ENABLE == 1)
static uint8_t usart2_tx_buffer[USER_UART_DATA_SIZE] = {0};
static uint16_t usart2_tx_size = 0;
static bool usart2_tx_stat = false;

/*******************************************************************************
  * @函数名称   prvUser_usart2_dma_init
  * @函数说明   DMA初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_usart2_dma_init(void)
{
    DMA_InitTypeDef DMA_InitStructure = {0};
    NVIC_InitTypeDef NVIC_InitStructure = {0};

    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

#if (USER_USART2_DMA_TX_ENABLE == 1)
    DMA_DeInit(DMA1_Channel7);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART2->DATAR);
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)usart2_tx_buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
    DMA_InitStructure.DMA_BufferSize = USER_UART_DATA_SIZE;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel7, &DMA_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel7_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    //DAM_IT_TC  传输完成中断屏蔽   DMA_IT_HT 传输过半中断屏蔽  DMA_IT_TE 传输错误中断屏蔽
    DMA_ITConfig(DMA1_Channel7, DMA_IT_TC | DMA_IT_TE, ENABLE);

    // DMA_Cmd(DMA1_Channel7, ENABLE); /* USART1 Tx */
    USART_DMACmd(USART2, USART_DMAReq_Tx, ENABLE);
#endif

#if (USER_USART2_DMA_RX_ENABLE == 1)
    DMA_DeInit(DMA1_Channel6);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART2->DATAR);
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)usart2_rx_buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_BufferSize = USER_UART_DATA_SIZE;
    DMA_Init(DMA1_Channel6, &DMA_InitStructure);

#if (USER_USART2_RX_DMA_IRQ_ENABLE == 1)
    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel7_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    //DAM_IT_TC  传输完成中断屏蔽   DMA_IT_HT 传输过半中断屏蔽  DMA_IT_TE 传输错误中断屏蔽
    DMA_ITConfig(DMA1_Channel6, DMA_IT_TC, ENABLE);
#endif

    DMA_Cmd(DMA1_Channel6, ENABLE); /* USART1 Rx */
    USART_DMACmd(USART2, USART_DMAReq_Rx, ENABLE);
#endif
}
#endif

#if (USER_USART2_DMA_TX_ENABLE == 1) 
/*******************************************************************************
  * @函数名称   vUser_usart2_send
  * @函数说明   usart2发送函数
  * @输入参数  	data：数据
  *            size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
bool vUser_usart2_send(uint8_t *data, uint16_t size)
{
    if(size > USER_UART_DATA_SIZE)
    {
        return false;
    }

    if(usart2_tx_stat == false)
    {
        usart2_tx_stat = true;
        memcpy(usart2_tx_buffer, data, size);
        usart2_tx_size = size;
        DMA1_Channel7->CNTR = (uint32_t)usart2_tx_size;
        DMA_Cmd(DMA1_Channel7, ENABLE);  //开始DMA发送

        return true;
    }
    
    return false;
}

void DMA1_Channel7_IRQHandler(void)   __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   DMA1_Channel7_IRQHandler
  * @函数说明   DMA1 Channel7中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void DMA1_Channel7_IRQHandler()
{
    if(DMA_GetITStatus(DMA1_IT_TC7) == SET)
    {
        DMA_ClearITPendingBit(DMA1_IT_TC7);
        usart2_tx_stat = false;
    }
    else if(DMA_GetITStatus(DMA1_IT_TE7) == SET)
    {
        DMA_ClearITPendingBit(DMA1_IT_TE7);
        usart2_tx_stat = false;
    }
}
#else
/*******************************************************************************
  * @函数名称   vUser_usart2_send
  * @函数说明   usart2发送函数
  * @输入参数  	data：数据
  *            size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
bool vUser_usart2_send(uint8_t *data, uint16_t size)
{
    uint32_t timeout = 10000;
    for(int i = 0; i < size; i++)
    {
        while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET)
        {
            if(timeout > 0)
            {
                timeout--;
            }
            else{
                return false;
            }
        }
        USART_SendData(USART2, *data++);
    }

    return true;
}
#endif

#if (USER_USART2_DMA_RX_ENABLE == 1)
#if (USER_USART2_RX_DMA_IRQ_ENABLE == 1)
void DMA1_Channel6_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   DMA1_Channel6_IRQHandler
  * @函数说明   DMA1_Channel6中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void DMA1_Channel6_IRQHandler(void)
{
    if(DMA_GetITStatus(DMA1_IT_TC6))
    {
        // 清除中断标志
        DMA_ClearITPendingBit(DMA1_IT_TC6);
        
        // 获取接收到的数据长度
        usart2_rx_size = USER_UART_DATA_SIZE - DMA_GetCurrDataCounter(DMA1_Channel6);
        
        // 设置接收完成标志
        usart2_rx_stat = true;
        
        // 重新配置 DMA 接收
        USART_DMACmd(USART2, USART_DMAReq_Rx, DISABLE);
        DMA_Cmd(DMA1_Channel6, DISABLE);
        DMA_SetCurrDataCounter(DMA1_Channel6, USER_UART_DATA_SIZE);
        DMA_Cmd(DMA1_Channel6, ENABLE);
        USART_DMACmd(USART2, USART_DMAReq_Rx, ENABLE);
    }
}
#elif (USER_USART2_RX_IRQ_ENABLE == 1)
void USART2_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   USART2_IRQHandler
  * @函数说明   USART2接收中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void USART2_IRQHandler(void)
{
    if(USART_GetITStatus(USART2, USART_IT_IDLE) != RESET)
    {
        USART2->DATAR;
        USART2->STATR;
        DMA_Cmd(DMA1_Channel6,DISABLE);
        uint16_t dma_len = DMA_GetCurrDataCounter(DMA1_Channel6);
        if(USER_UART_DATA_SIZE >= dma_len)
        {
            usart2_rx_size = USER_UART_DATA_SIZE - dma_len;
            usart2_rx_stat = true;
        }
        DMA1_Channel6->CNTR = USER_UART_DATA_SIZE;
        DMA_Cmd(DMA1_Channel6,ENABLE);
        USART_ClearITPendingBit(USART2, USART_IT_IDLE);
    }
}
#else
/*******************************************************************************
  * @函数名称   vUsart2_recieve_data
  * @函数说明   USART2接收等待
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUsart2_recieve_data(void)
{
    if(usart2_rx_stat == false)
    {
        while(DMA_GetFlagStatus(DMA1_FLAG_TC6) == RESET);
        // 获取接收到的数据长度
        usart2_rx_size = USER_UART_DATA_SIZE - DMA_GetCurrDataCounter(DMA1_Channel6);
        
        // 设置接收完成标志
        if(usart2_rx_size > 0)
        {
            usart2_rx_stat = true;
            USART_DMACmd(USART2, USART_DMAReq_Rx, DISABLE);
            DMA_Cmd(DMA1_Channel6, DISABLE);
            DMA_SetCurrDataCounter(DMA1_Channel6, USER_UART_DATA_SIZE);
            DMA_Cmd(DMA1_Channel6, ENABLE);
            USART_DMACmd(USART2, USART_DMAReq_Rx, ENABLE);
        }
    }
}
#endif
#else
#if (USER_USART2_RX_IRQ_ENABLE == 1)
void USART2_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   USART2_IRQHandler
  * @函数说明   USART2接收中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void USART2_IRQHandler(void)
{
    // IDLE 中断处理
    if(USART_GetITStatus(USART2, USART_IT_IDLE))
    {
        // 清除 IDLE 中断标志（通过读取 SR 和 DR 寄存器）
        uint32_t temp;
        temp = USART2->STATR;  // 读取状态寄存器
        temp = USART2->DATAR;  // 读取数据寄存器
        (void)temp;  // 防止编译器警告
        
        // 设置接收完成标志
        usart2_rx_stat = true;
        
        // 清除 USART IDLE 中断标志
        USART_ClearITPendingBit(USART2, USART_IT_IDLE);
    }
    
    // RXNE 中断处理（接收数据寄存器非空）
    if(USART_GetITStatus(USART2, USART_IT_RXNE))
    {
        if(usart2_rx_stat == false)
        {
            // 读取接收到的数据
            uint8_t data = USART_ReceiveData(USART2);
            
            // 存储数据到缓冲区
            if(usart2_rx_size < USER_UART_DATA_SIZE)
            {
                usart2_rx_buffer[usart2_rx_size++] = data;
            }
            else
            {
                // 缓冲区溢出处理
                usart2_rx_size = 0;  // 重置索引
            }
        }
        
        // 清除 RXNE 中断标志
        USART_ClearITPendingBit(USART2, USART_IT_RXNE);
    }
}
#else
static uint16_t usart2_rx_finish_size = USER_UART_DATA_SIZE;
/*******************************************************************************
  * @函数名称   vUsart2_recieve_data
  * @函数说明   USART2接收等待
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUsart2_recieve_data(void)
{
    if(usart2_rx_stat == false)
    {
        while(USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET)
        {
            /* waiting for receiving finish */
        }
        // 存储数据到缓冲区
        if(usart2_rx_size < usart2_rx_finish_size)
        {
            usart2_rx_buffer[usart2_rx_size++] = data;
        }
        else
        {
            // 设置接收完成标志
            usart2_rx_stat = true;
        }
    }
}

/*******************************************************************************
  * @函数名称   vUser_usart2_set_recieve_finish_size
  * @函数说明   设置USART2接收长度
  * @输入参数  	size：需接收的数据长度
  * @输出参数   无
  * @返回参数   设置是否成功
*******************************************************************************/
bool vUser_usart2_set_recieve_finish_size(uint16_t size)
{
    if(size > USER_UART_DATA_SIZE)
    {
        return false;
    }
    usart2_rx_finish_size = size;
    return true;
}
#endif
#endif

/*******************************************************************************
  * @函数名称   vUser_usart2_init
  * @函数说明   初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_usart2_init(user_uart_param_s *param)
{
    GPIO_InitTypeDef  GPIO_InitStructure = {0};
    USART_InitTypeDef USART_InitStructure = {0};

    USER_USART2_RCC_ENABLE;

#ifdef USER_USART2_REMAP_ENABLE
    USER_USART2_REMAP_ENABLE;
#endif

    GPIO_InitStructure.GPIO_Pin = USER_USART2_TX_PIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(USER_USART2_TX_GPIO, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Pin = USER_USART2_RX_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(USER_USART2_RX_GPIO, &GPIO_InitStructure);

    USART_InitStructure.USART_BaudRate = param->baudrate;
    USART_InitStructure.USART_WordLength = param->wordlength;
    USART_InitStructure.USART_StopBits = param->stopbit;
    USART_InitStructure.USART_Parity = param->parity;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;

    USART_Init(USART2, &USART_InitStructure);

#if (USER_USART2_RX_IRQ_ENABLE == 1)
    NVIC_InitTypeDef NVIC_InitStructure={0};

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);
#if (USER_USART2_DMA_RX_ENABLE == 0)
    USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
#endif
#endif

#if (USER_USART2_DMA_TX_ENABLE == 1) || (USER_USART2_DMA_RX_ENABLE == 1)
    prvUser_usart2_dma_init();
#endif

    USART_Cmd(USART2, ENABLE);
}

/*******************************************************************************
  * @函数名称   prvUser_usart2_pro
  * @函数说明   usart2接收上报任务
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_usart2_pro(void)
{
#if (USER_USART2_DMA_RX_ENABLE == 0) && ((USER_USART2_RX_DMA_IRQ_ENABLE == 1) && (USER_USART2_RX_IRQ_ENABLE == 0))
    vUsart2_recieve_data();
#endif
    if(usart2_rx_stat == true)
    {
        usart2_rx_stat = false;
        if(vUsart2_data_upload != NULL)
        {
            vUsart2_data_upload(usart2_rx_buffer, usart2_rx_size);
        }
        usart2_rx_size = 0;
        memset(usart2_rx_buffer, 0, USER_UART_DATA_SIZE);
    }
}

/*******************************************************************************
  * @函数名称   vUser_usart2_set_data_upload_func
  * @函数说明   设置usart2接收数据上报回调函数
  * @输入参数  	func：回调函数指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_usart2_set_data_upload_func(vUser_usart_data_upload_func func)
{
    vUsart2_data_upload = func;
}

#endif

#if defined(CH32V203C8) || defined(CH32V203RB)
/********************************************************************************************************************************************
*********************************************************************************************************************************************
以下为usart3
*********************************************************************************************************************************************
********************************************************************************************************************************************/

#if (USER_USART3_ENABLE == 1)
static uint8_t usart3_rx_buffer[USER_UART_DATA_SIZE] = {0};
static uint16_t usart3_rx_size = 0;
static bool usart3_rx_stat = false;
static vUser_usart_data_upload_func vUsart3_data_upload = NULL;

#if (USER_USART3_DMA_TX_ENABLE == 1) || (USER_USART3_DMA_RX_ENABLE == 1)
static uint8_t usart3_tx_buffer[USER_UART_DATA_SIZE] = {0};
static uint16_t usart3_tx_size = 0;
static bool usart3_tx_stat = false;

/*******************************************************************************
  * @函数名称   prvUser_usart3_dma_init
  * @函数说明   DMA初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_usart3_dma_init(void)
{
    DMA_InitTypeDef DMA_InitStructure = {0};
    NVIC_InitTypeDef NVIC_InitStructure = {0};

    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

#if (USER_USART3_DMA_TX_ENABLE == 1)
    DMA_DeInit(DMA1_Channel2);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART3->DATAR);
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)usart3_tx_buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
    DMA_InitStructure.DMA_BufferSize = USER_UART_DATA_SIZE;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel2, &DMA_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    //DAM_IT_TC  传输完成中断屏蔽   DMA_IT_HT 传输过半中断屏蔽  DMA_IT_TE 传输错误中断屏蔽
    DMA_ITConfig(DMA1_Channel2, DMA_IT_TC | DMA_IT_TE, ENABLE);

    // DMA_Cmd(DMA1_Channel6, ENABLE); /* USART1 Tx */
    USART_DMACmd(USART3, USART_DMAReq_Tx, ENABLE);
#endif

#if (USER_USART3_DMA_RX_ENABLE == 1)
    DMA_DeInit(DMA1_Channel3);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART3->DATAR);
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)usart3_rx_buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_BufferSize = USER_UART_DATA_SIZE;
    DMA_Init(DMA1_Channel3, &DMA_InitStructure);

#if (USER_USART3_RX_DMA_IRQ_ENABLE == 1)
    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel3_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    //DAM_IT_TC  传输完成中断屏蔽   DMA_IT_HT 传输过半中断屏蔽  DMA_IT_TE 传输错误中断屏蔽
    DMA_ITConfig(DMA1_Channel3, DMA_IT_TC, ENABLE);
#endif

    DMA_Cmd(DMA1_Channel3, ENABLE); /* USART1 Rx */
    USART_DMACmd(USART3, USART_DMAReq_Rx, ENABLE);
#endif
}
#endif

#if (USER_USART3_DMA_TX_ENABLE == 1) 
/*******************************************************************************
  * @函数名称   vUser_usart3_send
  * @函数说明   usart3发送函数
  * @输入参数  	data：数据
  *            size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
bool vUser_usart3_send(uint8_t *data, uint16_t size)
{
    if(size > USER_UART_DATA_SIZE)
    {
        return false;
    }

    if(usart3_tx_stat == false)
    {
        usart3_tx_stat = true;
        memcpy(usart3_tx_buffer, data, size);
        usart3_tx_size = size;
        DMA1_Channel2->CNTR = (uint32_t)usart3_tx_size;
        DMA_Cmd(DMA1_Channel2, ENABLE);  //开始DMA发送

        return true;
    }
    
    return false;
}

void DMA1_Channel2_IRQHandler(void)   __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   DMA1_Channel2_IRQHandler
  * @函数说明   DMA1 Channel2中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void DMA1_Channel2_IRQHandler()
{
    if(DMA_GetITStatus(DMA1_IT_TC2) == SET)
    {
        DMA_ClearITPendingBit(DMA1_IT_TC2);
        usart3_tx_stat = false;
    }
    else if(DMA_GetITStatus(DMA1_IT_TE2) == SET)
    {
        DMA_ClearITPendingBit(DMA1_IT_TE2);
        usart3_tx_stat = false;
    }
}
#else
/*******************************************************************************
  * @函数名称   vUser_usart3_send
  * @函数说明   usart3发送函数
  * @输入参数  	data：数据
  *            size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
bool vUser_usart3_send(uint8_t *data, uint16_t size)
{
    uint32_t timeout = 10000;
    for(int i = 0; i < size; i++)
    {
        while(USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET)
        {
            if(timeout > 0)
            {
                timeout--;
            }
            else{
                return false;
            }
        }
        USART_SendData(USART3, *data++);
    }

    return true;
}
#endif

#if (USER_USART3_DMA_RX_ENABLE == 1)
#if (USER_USART3_RX_DMA_IRQ_ENABLE == 1)
void DMA1_Channel3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   DMA1_Channel3_IRQHandler
  * @函数说明   DMA1_Channel3中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void DMA1_Channel3_IRQHandler(void)
{
    if(DMA_GetITStatus(DMA1_IT_TC3))
    {
        // 清除中断标志
        DMA_ClearITPendingBit(DMA1_IT_TC3);
        
        // 获取接收到的数据长度
        usart3_rx_size = USER_UART_DATA_SIZE - DMA_GetCurrDataCounter(DMA1_Channel3);
        
        // 设置接收完成标志
        usart3_rx_stat = true;
        
        // 重新配置 DMA 接收
        USART_DMACmd(USART3, USART_DMAReq_Rx, DISABLE);
        DMA_Cmd(DMA1_Channel3, DISABLE);
        DMA_SetCurrDataCounter(DMA1_Channel3, USER_UART_DATA_SIZE);
        DMA_Cmd(DMA1_Channel3, ENABLE);
        USART_DMACmd(USART3, USART_DMAReq_Rx, ENABLE);
    }
}
#elif (USER_USART3_RX_IRQ_ENABLE == 1)
void USART3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   USART3_IRQHandler
  * @函数说明   USART3接收中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void USART3_IRQHandler(void)
{
    if(USART_GetITStatus(USART3, USART_IT_IDLE) != RESET)
    {
        USART3->DATAR;
        USART3->STATR;
        DMA_Cmd(DMA1_Channel3,DISABLE);
        uint16_t dma_len = DMA_GetCurrDataCounter(DMA1_Channel3);
        if(USER_UART_DATA_SIZE >= dma_len)
        {
            usart3_rx_size = USER_UART_DATA_SIZE - dma_len;
            usart3_rx_stat = true;
        }
        DMA1_Channel3->CNTR = USER_UART_DATA_SIZE;
        DMA_Cmd(DMA1_Channel3,ENABLE);
        USART_ClearITPendingBit(USART3, USART_IT_IDLE);
    }
}
#else
/*******************************************************************************
  * @函数名称   vUsart3_recieve_data
  * @函数说明   USART3接收等待
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUsart3_recieve_data(void)
{
    if(usart3_rx_stat == false)
    {
        while(DMA_GetFlagStatus(DMA1_FLAG_TC3) == RESET);
        // 获取接收到的数据长度
        usart3_rx_size = USER_UART_DATA_SIZE - DMA_GetCurrDataCounter(DMA1_Channel3);
        
        // 设置接收完成标志
        if(usart3_rx_size > 0)
        {
            usart3_rx_stat = true;
            USART_DMACmd(USART3, USART_DMAReq_Rx, DISABLE);
            DMA_Cmd(DMA1_Channel3, DISABLE);
            DMA_SetCurrDataCounter(DMA1_Channel3, USER_UART_DATA_SIZE);
            DMA_Cmd(DMA1_Channel3, ENABLE);
            USART_DMACmd(USART3, USART_DMAReq_Rx, ENABLE);
        }
    }
}
#endif
#else
#if (USER_USART3_RX_IRQ_ENABLE == 1)
void USART3_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   USART3_IRQHandler
  * @函数说明   USART3接收中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void USART3_IRQHandler(void)
{
    // IDLE 中断处理
    if(USART_GetITStatus(USART3, USART_IT_IDLE))
    {
        // 清除 IDLE 中断标志（通过读取 SR 和 DR 寄存器）
        uint32_t temp;
        temp = USART3->STATR;  // 读取状态寄存器
        temp = USART3->DATAR;  // 读取数据寄存器
        (void)temp;  // 防止编译器警告
        
        // 设置接收完成标志
        usart3_rx_stat = true;
        
        // 清除 USART IDLE 中断标志
        USART_ClearITPendingBit(USART3, USART_IT_IDLE);
    }
    
    // RXNE 中断处理（接收数据寄存器非空）
    if(USART_GetITStatus(USART3, USART_IT_RXNE))
    {
        if(usart3_rx_stat == false)
        {
            // 读取接收到的数据
            uint8_t data = USART_ReceiveData(USART3);
            
            // 存储数据到缓冲区
            if(usart3_rx_size < USER_UART_DATA_SIZE)
            {
                usart3_rx_buffer[usart3_rx_size++] = data;
            }
            else
            {
                // 缓冲区溢出处理
                usart3_rx_size = 0;  // 重置索引
            }
        }
        
        // 清除 RXNE 中断标志
        USART_ClearITPendingBit(USART3, USART_IT_RXNE);
    }
}
#else
static uint16_t usart3_rx_finish_size = USER_UART_DATA_SIZE;
/*******************************************************************************
  * @函数名称   vUsart3_recieve_data
  * @函数说明   USART3接收等待
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUsart3_recieve_data(void)
{
    if(usart3_rx_stat == false)
    {
        while(USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == RESET)
        {
            /* waiting for receiving finish */
        }
        // 存储数据到缓冲区
        if(usart3_rx_size < usart3_rx_finish_size)
        {
            usart3_rx_buffer[usart3_rx_size++] = data;
        }
        else
        {
            // 设置接收完成标志
            usart3_rx_stat = true;
        }
    }
}

/*******************************************************************************
  * @函数名称   vUser_usart3_set_recieve_finish_size
  * @函数说明   设置USART3接收长度
  * @输入参数  	size：需接收的数据长度
  * @输出参数   无
  * @返回参数   设置是否成功
*******************************************************************************/
bool vUser_usart3_set_recieve_finish_size(uint16_t size)
{
    if(size > USER_UART_DATA_SIZE)
    {
        return false;
    }
    usart3_rx_finish_size = size;
    return true;
}
#endif
#endif

/*******************************************************************************
  * @函数名称   vUser_usart3_init
  * @函数说明   初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_usart3_init(user_uart_param_s *param)
{
    GPIO_InitTypeDef  GPIO_InitStructure = {0};
    USART_InitTypeDef USART_InitStructure = {0};

    USER_USART3_RCC_ENABLE;

#ifdef USER_USART3_REMAP_ENABLE
    USER_USART3_REMAP_ENABLE;
#endif

    GPIO_InitStructure.GPIO_Pin = USER_USART3_TX_PIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(USER_USART3_TX_GPIO, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Pin = USER_USART3_RX_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(USER_USART3_RX_GPIO, &GPIO_InitStructure);

    USART_InitStructure.USART_BaudRate = param->baudrate;
    USART_InitStructure.USART_WordLength = param->wordlength;
    USART_InitStructure.USART_StopBits = param->stopbit;
    USART_InitStructure.USART_Parity = param->parity;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;

    USART_Init(USART3, &USART_InitStructure);

#if (USER_USART3_RX_IRQ_ENABLE == 1)
    NVIC_InitTypeDef NVIC_InitStructure={0};

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    USART_ITConfig(USART3, USART_IT_IDLE, ENABLE);
#if (USER_USART3_DMA_RX_ENABLE == 0)
    USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
#endif
#endif

#if (USER_USART3_DMA_TX_ENABLE == 1) || (USER_USART3_DMA_RX_ENABLE == 1)
    prvUser_usart3_dma_init();
#endif

    USART_Cmd(USART3, ENABLE);
}

/*******************************************************************************
  * @函数名称   prvUser_usart3_pro
  * @函数说明   usart3接收上报任务
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_usart3_pro(void)
{
#if (USER_USART3_DMA_RX_ENABLE == 0) && ((USER_USART3_RX_DMA_IRQ_ENABLE == 1) && (USER_USART3_RX_IRQ_ENABLE == 0))
    vUsart3_recieve_data();
#endif
    if(usart3_rx_stat == true)
    {
        usart3_rx_stat = false;
        if(vUsart3_data_upload != NULL)
        {
            vUsart3_data_upload(usart3_rx_buffer, usart3_rx_size);
        }
        usart3_rx_size = 0;
        memset(usart3_rx_buffer, 0, USER_UART_DATA_SIZE);
    }
}

/*******************************************************************************
  * @函数名称   vUser_usart3_set_data_upload_func
  * @函数说明   设置usart3接收数据上报回调函数
  * @输入参数  	func：回调函数指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_usart3_set_data_upload_func(vUser_usart_data_upload_func func)
{
    vUsart3_data_upload = func;
}

#endif


/********************************************************************************************************************************************
*********************************************************************************************************************************************
以下为usart4
*********************************************************************************************************************************************
********************************************************************************************************************************************/

#if (USER_USART4_ENABLE == 1)
static uint8_t usart4_rx_buffer[USER_UART_DATA_SIZE] = {0};
static uint16_t usart4_rx_size = 0;
static bool usart4_rx_stat = false;
static vUser_usart_data_upload_func vUsart4_data_upload = NULL;

#if (USER_USART4_DMA_TX_ENABLE == 1) || (USER_USART4_DMA_RX_ENABLE == 1)
static uint8_t usart4_tx_buffer[USER_UART_DATA_SIZE] = {0};
static uint16_t usart4_tx_size = 0;
static bool usart4_tx_stat = false;

/*******************************************************************************
  * @函数名称   prvUser_usart4_dma_init
  * @函数说明   DMA初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_usart4_dma_init(void)
{
    DMA_InitTypeDef DMA_InitStructure = {0};
    NVIC_InitTypeDef NVIC_InitStructure = {0};

    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

#if (USER_USART4_DMA_TX_ENABLE == 1)
    DMA_DeInit(DMA1_Channel2);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&UART4->DATAR);
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)usart4_tx_buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
    DMA_InitStructure.DMA_BufferSize = USER_UART_DATA_SIZE;
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
    DMA_Init(DMA1_Channel1, &DMA_InitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    //DAM_IT_TC  传输完成中断屏蔽   DMA_IT_HT 传输过半中断屏蔽  DMA_IT_TE 传输错误中断屏蔽
    DMA_ITConfig(DMA1_Channel1, DMA_IT_TC | DMA_IT_TE, ENABLE);

    // DMA_Cmd(DMA1_Channel6, ENABLE); /* USART1 Tx */
    USART_DMACmd(UART4, USART_DMAReq_Tx, ENABLE);
#endif

#if (USER_USART4_DMA_RX_ENABLE == 1)
    DMA_DeInit(DMA1_Channel8);
    DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&UART4->DATAR);
    DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)usart4_rx_buffer;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_BufferSize = USER_UART_DATA_SIZE;
    DMA_Init(DMA1_Channel8, &DMA_InitStructure);

#if (USER_USART4_RX_DMA_IRQ_ENABLE == 1)
    NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel8_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    //DAM_IT_TC  传输完成中断屏蔽   DMA_IT_HT 传输过半中断屏蔽  DMA_IT_TE 传输错误中断屏蔽
    DMA_ITConfig(DMA1_Channel8, DMA_IT_TC, ENABLE);
#endif

    DMA_Cmd(DMA1_Channel8, ENABLE); /* USART1 Rx */
    USART_DMACmd(UART4, USART_DMAReq_Rx, ENABLE);
#endif
}
#endif

#if (USER_USART4_DMA_TX_ENABLE == 1) 
/*******************************************************************************
  * @函数名称   vUser_usart4_send
  * @函数说明   usart4发送函数
  * @输入参数  	data：数据
  *            size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
bool vUser_usart4_send(uint8_t *data, uint16_t size)
{
    if(size > USER_UART_DATA_SIZE)
    {
        return false;
    }

    if(usart4_tx_stat == false)
    {
        usart4_tx_stat = true;
        memcpy(usart4_tx_buffer, data, size);
        usart4_tx_size = size;
        DMA1_Channel1->CNTR = (uint32_t)usart4_tx_size;
        DMA_Cmd(DMA1_Channel1, ENABLE);  //开始DMA发送

        return true;
    }
    
    return false;
}

void DMA1_Channel1_IRQHandler(void)   __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   DMA1_Channel1_IRQHandler
  * @函数说明   DMA1 Channel1中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void DMA1_Channel1_IRQHandler()
{
    if(DMA_GetITStatus(DMA1_IT_TC1) == SET)
    {
        DMA_ClearITPendingBit(DMA1_IT_TC1);
        usart4_tx_stat = false;
    }
    else if(DMA_GetITStatus(DMA1_IT_TE1) == SET)
    {
        DMA_ClearITPendingBit(DMA1_IT_TE1);
        usart4_tx_stat = false;
    }
}
#else
/*******************************************************************************
  * @函数名称   vUser_usart4_send
  * @函数说明   usart4发送函数
  * @输入参数  	data：数据
  *            size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
bool vUser_usart4_send(uint8_t *data, uint16_t size)
{
    uint32_t timeout = 10000;
    for(int i = 0; i < size; i++)
    {
        while(USART_GetFlagStatus(UART4, USART_FLAG_TC) == RESET)
        {
            if(timeout > 0)
            {
                timeout--;
            }
            else{
                return false;
            }
        }
        USART_SendData(UART4, *data++);
    }

    return true;
}
#endif

#if (USER_USART4_DMA_RX_ENABLE == 1)
#if (USER_USART4_RX_DMA_IRQ_ENABLE == 1)
void DMA1_Channel8_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   DMA1_Channel8_IRQHandler
  * @函数说明   DMA1_Channel8中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void DMA1_Channel8_IRQHandler(void)
{
    if(DMA_GetITStatus(DMA1_IT_TC8))
    {
        // 清除中断标志
        DMA_ClearITPendingBit(DMA1_IT_TC8);
        
        // 获取接收到的数据长度
        usart4_rx_size = USER_UART_DATA_SIZE - DMA_GetCurrDataCounter(DMA1_Channel8);
        
        // 设置接收完成标志
        usart4_rx_stat = true;
        
        // 重新配置 DMA 接收
        USART_DMACmd(UART4, USART_DMAReq_Rx, DISABLE);
        DMA_Cmd(DMA1_Channel8, DISABLE);
        DMA_SetCurrDataCounter(DMA1_Channel8, USER_UART_DATA_SIZE);
        DMA_Cmd(DMA1_Channel8, ENABLE);
        USART_DMACmd(UART4, USART_DMAReq_Rx, ENABLE);
    }
}
#elif (USER_USART4_RX_IRQ_ENABLE == 1)
void UART4_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   UART4_IRQHandler
  * @函数说明   UART4接收中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void UART4_IRQHandler(void)
{
    if(USART_GetITStatus(UART4, USART_IT_IDLE) != RESET)
    {
        UART4->DATAR;
        UART4->STATR;
        DMA_Cmd(DMA1_Channel8,DISABLE);
        uint16_t dma_len = DMA_GetCurrDataCounter(DMA1_Channel8);
        if(USER_UART_DATA_SIZE >= dma_len)
        {
            usart4_rx_size = USER_UART_DATA_SIZE - dma_len;
            usart4_rx_stat = true;
        }
        DMA1_Channel8->CNTR = USER_UART_DATA_SIZE;
        DMA_Cmd(DMA1_Channel8,ENABLE);
        USART_ClearITPendingBit(UART4, USART_IT_IDLE);
    }
}
#else
/*******************************************************************************
  * @函数名称   vUsart4_recieve_data
  * @函数说明   USART4接收等待
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUsart4_recieve_data(void)
{
    if(usart4_rx_stat == false)
    {
        while(DMA_GetFlagStatus(DMA1_FLAG_TC8) == RESET);
        // 获取接收到的数据长度
        usart4_rx_size = USER_UART_DATA_SIZE - DMA_GetCurrDataCounter(DMA1_Channel8);
        
        // 设置接收完成标志
        if(usart4_rx_size > 0)
        {
            usart4_rx_stat = true;
            USART_DMACmd(UART4, USART_DMAReq_Rx, DISABLE);
            DMA_Cmd(DMA1_Channel8, DISABLE);
            DMA_SetCurrDataCounter(DMA1_Channel8, USER_UART_DATA_SIZE);
            DMA_Cmd(DMA1_Channel8, ENABLE);
            USART_DMACmd(UART4, USART_DMAReq_Rx, ENABLE);
        }
    }
}
#endif
#else
#if (USER_USART4_RX_IRQ_ENABLE == 1)
void UART4_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
/*******************************************************************************
  * @函数名称   UART4_IRQHandler
  * @函数说明   UART4接收中断函数
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void UART4_IRQHandler(void)
{
    // IDLE 中断处理
    if(USART_GetITStatus(UART4, USART_IT_IDLE))
    {
        // 清除 IDLE 中断标志（通过读取 SR 和 DR 寄存器）
        uint32_t temp;
        temp = UART4->STATR;  // 读取状态寄存器
        temp = UART4->DATAR;  // 读取数据寄存器
        (void)temp;  // 防止编译器警告
        
        // 设置接收完成标志
        usart4_rx_stat = true;
        
        // 清除 USART IDLE 中断标志
        USART_ClearITPendingBit(UART4, USART_IT_IDLE);
    }
    
    // RXNE 中断处理（接收数据寄存器非空）
    if(USART_GetITStatus(UART4, USART_IT_RXNE))
    {
        if(usart4_rx_stat == false)
        {
            // 读取接收到的数据
            uint8_t data = USART_ReceiveData(UART4);
            
            // 存储数据到缓冲区
            if(usart4_rx_size < USER_UART_DATA_SIZE)
            {
                usart4_rx_buffer[usart4_rx_size++] = data;
            }
            else
            {
                // 缓冲区溢出处理
                usart4_rx_size = 0;  // 重置索引
            }
        }
        
        // 清除 RXNE 中断标志
        USART_ClearITPendingBit(UART4, USART_IT_RXNE);
    }
}
#else
static uint16_t usart4_rx_finish_size = USER_UART_DATA_SIZE;
/*******************************************************************************
  * @函数名称   vUsart4_recieve_data
  * @函数说明   USART4接收等待
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUsart4_recieve_data(void)
{
    if(usart4_rx_stat == false)
    {
        while(USART_GetFlagStatus(UART4, USART_FLAG_RXNE) == RESET)
        {
            /* waiting for receiving finish */
        }
        // 存储数据到缓冲区
        if(usart4_rx_size < usart4_rx_finish_size)
        {
            usart4_rx_buffer[usart4_rx_size++] = data;
        }
        else
        {
            // 设置接收完成标志
            usart4_rx_stat = true;
        }
    }
}

/*******************************************************************************
  * @函数名称   vUser_usart4_set_recieve_finish_size
  * @函数说明   设置USART4接收长度
  * @输入参数  	size：需接收的数据长度
  * @输出参数   无
  * @返回参数   设置是否成功
*******************************************************************************/
bool vUser_usart4_set_recieve_finish_size(uint16_t size)
{
    if(size > USER_UART_DATA_SIZE)
    {
        return false;
    }
    usart4_rx_finish_size = size;
    return true;
}
#endif
#endif

/*******************************************************************************
  * @函数名称   vUser_usart4_init
  * @函数说明   初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_usart4_init(user_uart_param_s *param)
{
    GPIO_InitTypeDef  GPIO_InitStructure = {0};
    USART_InitTypeDef USART_InitStructure = {0};

    USER_USART4_RCC_ENABLE;

#ifdef USER_USART4_REMAP_ENABLE
    USER_USART4_REMAP_ENABLE;
#endif

    GPIO_InitStructure.GPIO_Pin = USER_USART4_TX_PIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init(USER_USART4_TX_GPIO, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Pin = USER_USART4_RX_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(USER_USART4_RX_GPIO, &GPIO_InitStructure);

    USART_InitStructure.USART_BaudRate = param->baudrate;
    USART_InitStructure.USART_WordLength = param->wordlength;
    USART_InitStructure.USART_StopBits = param->stopbit;
    USART_InitStructure.USART_Parity = param->parity;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;

    USART_Init(UART4, &USART_InitStructure);

#if (USER_USART4_RX_IRQ_ENABLE == 1)
    NVIC_InitTypeDef NVIC_InitStructure={0};

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    USART_ITConfig(UART4, USART_IT_IDLE, ENABLE);
#if (USER_USART4_DMA_RX_ENABLE == 0)
    USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);
#endif
#endif

#if (USER_USART4_DMA_TX_ENABLE == 1) || (USER_USART4_DMA_RX_ENABLE == 1)
    prvUser_usart4_dma_init();
#endif

    USART_Cmd(UART4, ENABLE);
}

/*******************************************************************************
  * @函数名称   prvUser_usart4_pro
  * @函数说明   usart4接收上报任务
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_usart4_pro(void)
{
#if (USER_USART4_DMA_RX_ENABLE == 0) && ((USER_USART4_RX_DMA_IRQ_ENABLE == 1) && (USER_USART4_RX_IRQ_ENABLE == 0))
    vUsart4_recieve_data();
#endif
    if(usart4_rx_stat == true)
    {
        usart4_rx_stat = false;
        if(vUsart4_data_upload != NULL)
        {
            vUsart4_data_upload(usart4_rx_buffer, usart4_rx_size);
        }
        usart4_rx_size = 0;
        memset(usart4_rx_buffer, 0, USER_UART_DATA_SIZE);
    }
}

/*******************************************************************************
  * @函数名称   vUser_usart4_set_data_upload_func
  * @函数说明   设置usart4接收数据上报回调函数
  * @输入参数  	func：回调函数指针
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_usart4_set_data_upload_func(vUser_usart_data_upload_func func)
{
    vUsart4_data_upload = func;
}

#endif

#endif

/*******************************************************************************
  * @函数名称   vUser_usart_pro
  * @函数说明   usart接收上报任务
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_usart_pro(void)
{
#if (USER_USART1_ENABLE == 1)
    prvUser_usart1_pro();
#endif

#if (USER_USART2_ENABLE == 1)
    prvUser_usart2_pro();
#endif

#if defined(CH32V203C8) || defined(CH32V203RB)
#if (USER_USART3_ENABLE == 1)
    prvUser_usart3_pro();
#endif

#if (USER_USART4_ENABLE == 1)
    prvUser_usart4_pro();
#endif
#endif
}