GDResignationMaterials/485-breaker-sensor/util/dma_uart.c

#include "dma_uart.h"
#include "gd32e23x.h"
#include "string.h"
#include "systick.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>

// 串口发送buffer
uint8_t txbuffer0[COM0_DMA_SEND_LEN] = {0};
uint8_t txbuffer1[COM1_DMA_SEND_LEN] = {0};
// 串口接收buffer
uint8_t rxbuffer0[COM0_DMA_REC_LEN] = {0};
uint8_t rxbuffer1[COM1_DMA_REC_LEN] = {0};

uint16_t rx_len0 = 0;
uint16_t rx_len1 = 0;

uint8_t com0_recv_STA = 0;
uint8_t com0_recv_num;

uint8_t com1_recv_STA = 0;
uint8_t com1_recv_num;

COM_DATA_CB com0_data_cb = 0;
COM_DATA_CB com1_data_cb = 0;

void com0_set_cb(COM_DATA_CB cb)
{
    com0_data_cb = cb;
}

void com1_set_cb(COM_DATA_CB cb)
{
    com1_data_cb = cb;
}

uint8_t *com0_receive(uint32_t t, uint16_t *len)
{
    uint8_t m = t / UART_RECV_SUB_DELAY;
    uint8_t c = t % UART_RECV_SUB_DELAY;
    uint8_t i = 0;
    while (rx_len0 == 0 && i < m)
    {
        delay_ms(UART_RECV_SUB_DELAY, 0);
        i++;
    }
    if (rx_len0 == 0 && c > 0)
    {
        delay_ms(c, 0);
    }
    if (rx_len0 != 0)
    {

        *len = rx_len0;
        rx_len0 = 0;
        dma_transfer_number_config(DMA_CH2, ARRAYNUM(rxbuffer0));
        dma_channel_enable(DMA_CH2);
        return rxbuffer0;
    }
    return NULL;
}

uint8_t *com1_receive(uint32_t t, uint16_t *len)
{
    uint8_t m = t / UART_RECV_SUB_DELAY;
    uint8_t c = t % UART_RECV_SUB_DELAY;
    uint8_t i = 0;
    while (rx_len1 == 0 && i < m)
    {
        delay_ms(UART_RECV_SUB_DELAY, 0);
        i++;
    }
    if (rx_len1 == 0 && c > 0)
    {
        delay_ms(c, 0);
    }
    if (rx_len1 != 0)
    {

        *len = rx_len1;
        rx_len1 = 0;
        dma_transfer_number_config(DMA_CH4, ARRAYNUM(rxbuffer1));
        dma_channel_enable(DMA_CH4);
        return rxbuffer1;
    }
	*len = 0;
    return NULL;
}

/* 串口IO初始化 */
void com0_gpio_init(void)
{

    rcu_periph_clock_enable(COM0_GPIO_CLK);
    gpio_af_set(COM0_GPIO_PORT, COM0_AF, COM0_TX_PIN);
    gpio_af_set(COM0_GPIO_PORT, COM0_AF, COM0_RX_PIN);

    gpio_mode_set(COM0_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, COM0_TX_PIN);
    gpio_output_options_set(COM0_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, COM0_TX_PIN);

    gpio_mode_set(COM0_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, COM0_RX_PIN);
    gpio_output_options_set(COM0_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, COM0_RX_PIN);
}

/* 串口初始化 */
void com0_usart_init(void)
{
    /* enable USART clock */
    rcu_periph_clock_enable(RCU_USART0);

    /* USART configure */
    usart_deinit(USART0);
    usart_baudrate_set(USART0, COM0_BAUDRATE);
    usart_word_length_set(USART0, COM0_WORD_LEN);
    usart_stop_bit_set(USART0, COM0_STOP_BIT);
    usart_hardware_flow_coherence_config(USART0, COM0_CTRL);
    usart_parity_config(USART0, COM0_PM);
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);

    usart_enable(USART0);

    usart_flag_clear(USART0, USART_FLAG_TC);
    usart_interrupt_enable(USART0, USART_INT_IDLE); // 使用串口空闲中断

    if (COM0_USE_RTS)
    {
        com0_rts_init();
    }
}

void com0_nvic_config(void)
{
    nvic_irq_enable(DMA_Channel1_2_IRQn, 0);

    nvic_irq_enable(USART0_IRQn, 1);
}

/* 串口DMA初始化 */
void com0_dma_init(void)
{
    dma_parameter_struct dma_init_struct;
    /* enable DMA clock */
    rcu_periph_clock_enable(RCU_DMA);

    /* initilize the com */
    com0_gpio_init();
    com0_usart_init();
    com0_nvic_config();

    /* initialize DMA channel1 */
    dma_deinit(DMA_CH1);
    dma_struct_para_init(&dma_init_struct);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = (uint32_t)txbuffer0;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = ARRAYNUM(txbuffer0);
    dma_init_struct.periph_addr = USART0_TDATA_ADDRESS;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA_CH1, &dma_init_struct);

    /* initialize DMA channel2 */
    dma_deinit(DMA_CH2);
    dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.memory_addr = (uint32_t)rxbuffer0;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = ARRAYNUM(rxbuffer0);
    dma_init_struct.periph_addr = USART0_RDATA_ADDRESS;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA_CH2, &dma_init_struct);

    /* configure DMA mode */
    dma_circulation_disable(DMA_CH1);
    dma_memory_to_memory_disable(DMA_CH1);
    dma_circulation_disable(DMA_CH2);
    dma_memory_to_memory_disable(DMA_CH2);

    /* USART DMA enable for reception */
    usart_dma_receive_config(USART0, USART_DENR_ENABLE);

    /* enable DMA channel2 transfer complete interrupt */
    dma_interrupt_enable(DMA_CH2, DMA_INT_FTF);

    /* enable DMA channel2 */
    dma_channel_enable(DMA_CH2);

    /* USART DMA enable for transmission */
    usart_dma_transmit_config(USART0, USART_DENT_ENABLE);

    /* enable DMA channel1 transfer complete interrupt */
    dma_interrupt_enable(DMA_CH1, DMA_INT_FTF);

    /* enable DMA channel1 */
    dma_channel_enable(DMA_CH1);
}

// 串口DMA发送函数
void com0_dma_send_data(uint8_t *buffter, uint8_t length)
{

    uint8_t i; // txbuffer[128];
    dma_parameter_struct dma_init_struct;
    for (i = 0; i < length; i++)
    {
        txbuffer0[i] = buffter[i];
    }
    dma_channel_disable(DMA_CH1);
    dma_memory_address_config(DMA_CH1, (uint32_t)txbuffer0);

    dma_transfer_number_config(DMA_CH1, (uint32_t)length);

    dma_channel_enable(DMA_CH1);

    usart_dma_transmit_config(USART0, USART_DENT_ENABLE);
}

void DMA_Channel1_2_IRQHandler(void)
{
    if (RESET != dma_interrupt_flag_get(DMA_CH1, DMA_INT_FLAG_FTF))
    {
        // DMA串口发送触发中断
        dma_interrupt_flag_clear(DMA_CH1, DMA_INT_FLAG_G);
    }
    if (RESET != dma_interrupt_flag_get(DMA_CH2, DMA_INT_FLAG_FTF))
    {
        // DMA串口接收触发中断
        dma_channel_disable(DMA_CH2);
        dma_interrupt_flag_clear(DMA_CH2, DMA_INT_FLAG_G);
        dma_flag_clear(DMA_CH2, DMA_FLAG_G);
        com0_recv_num = COM0_DMA_REC_LEN; // 获取字节数
        com0_recv_STA = 1;                // 接收数据就绪

        // com0_data_transmit(rxbuffer0, COM0_DMA_REC_LEN);
        rx_len0 = COM0_DMA_REC_LEN;
        if (com0_data_cb != 0)
        {
            com0_data_cb(rxbuffer0, COM0_DMA_REC_LEN);

            dma_transfer_number_config(DMA_CH2, COM0_DMA_REC_LEN);
            dma_channel_enable(DMA_CH2);
        }
        else if (rx_len0 == 0)
        {
            dma_transfer_number_config(DMA_CH2, ARRAYNUM(rxbuffer0));
            dma_channel_enable(DMA_CH2);
        }
    }
}

void USART0_IRQHandler(void)
{
    if (RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_TC))
    {
        usart_interrupt_flag_clear(USART0, USART_INT_FLAG_TC);
    }

    if (RESET != usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE))
    {
        usart_interrupt_flag_clear(USART0, USART_INT_FLAG_IDLE);

        if (com0_recv_STA == 0)
        {
            dma_channel_disable(DMA_CH2);
            dma_interrupt_flag_clear(DMA_CH2, DMA_INT_FLAG_G);
            dma_flag_clear(DMA_CH2, DMA_FLAG_G);

            com0_recv_num = COM0_DMA_REC_LEN - (dma_transfer_number_get(DMA_CH2));
            // com0_data_transmit(rxbuffer0, com0_recv_num);
            rx_len0 = com0_recv_num;
            if (com0_data_cb != 0)
            {
                com0_data_cb(rxbuffer0, com0_recv_num);

                dma_transfer_number_config(DMA_CH2, ARRAYNUM(rxbuffer0));
                dma_channel_enable(DMA_CH2);
            }
            else if (rx_len0 == 0)
            {
                dma_transfer_number_config(DMA_CH2, ARRAYNUM(rxbuffer0));
                dma_channel_enable(DMA_CH2);
            }
        }
        else
        {
            dma_channel_disable(DMA_CH2);
            dma_interrupt_flag_clear(DMA_CH2, DMA_INT_FLAG_G);
            dma_flag_clear(DMA_CH2, DMA_FLAG_G);

            dma_transfer_number_config(DMA_CH2, ARRAYNUM(rxbuffer0));
            dma_channel_enable(DMA_CH2);
        }

        com0_recv_STA = 0;
    }
}

/* DMA方式printf */
void com0_dma_printf(const char *format, ...)
{
    uint32_t length;
    va_list args;

    va_start(args, format);
    length = vsnprintf((char *)txbuffer0, sizeof(txbuffer0), (char *)format, args);
    va_end(args);
    com0_dma_send_data(txbuffer0, length);
}

void com0_data_transmit(uint8_t arr[], uint32_t length)
{
    if (COM0_USE_RTS)
    {
        if (COM0_RTS_SEND_HIGH)
        {
            com0_rts_set();
        }
        else
        {
            com0_rts_reset();
        }
    }
    delay_ms(COM0_RTS_DELAY, 1);

    uint32_t i;
    for (i = 0; i < length; i++)
    {
        usart_data_transmit(USART0, arr[i]);
        while (usart_flag_get(USART0, USART_FLAG_TBE) == RESET)
            ;
    }
    delay_ms(COM0_RTS_DELAY, 1);
    if (COM0_USE_RTS)
    {
        if (COM0_RTS_SEND_HIGH)
        {
            com0_rts_reset();
        }
        else
        {
            com0_rts_set();
        }
    }
}

void com0_rts_init()
{
    // PA12-USART0_RTS引脚
    gpio_mode_set(GPIOA, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_12);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_12);
    if (COM0_RTS_SEND_HIGH)
    {
        gpio_bit_reset(GPIOA, GPIO_PIN_12);
    }
    else
    {
        gpio_bit_set(GPIOA, GPIO_PIN_12);
    }
}

void com0_rts_set()
{
    gpio_bit_set(GPIOA, GPIO_PIN_12);
}

void com0_rts_reset()
{
    gpio_bit_reset(GPIOA, GPIO_PIN_12);
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

/* 串口IO初始化 */
void com1_gpio_init(void)
{

    rcu_periph_clock_enable(COM1_GPIO_CLK);
    gpio_af_set(COM1_GPIO_PORT, COM1_AF, COM1_TX_PIN);
    gpio_af_set(COM1_GPIO_PORT, COM1_AF, COM1_RX_PIN);

    gpio_mode_set(COM1_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLUP, COM1_TX_PIN);
    gpio_output_options_set(COM1_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, COM1_TX_PIN);

    gpio_mode_set(COM1_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, COM1_RX_PIN);
    gpio_output_options_set(COM1_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, COM1_RX_PIN);
}

/* 串口初始化 */
void com1_usart_init(void)
{
    /* enable USART clock */
    rcu_periph_clock_enable(RCU_USART1);

    /* USART configure */
    usart_deinit(USART1);
    usart_baudrate_set(USART1, COM1_BAUDRATE);
    usart_word_length_set(USART1, COM1_WORD_LEN);
    usart_stop_bit_set(USART1, COM1_STOP_BIT);
    usart_parity_config(USART1, COM1_PM);
    usart_hardware_flow_coherence_config(USART1, COM1_CTRL);
    usart_receive_config(USART1, USART_RECEIVE_ENABLE);
    usart_transmit_config(USART1, USART_TRANSMIT_ENABLE);

    usart_enable(USART1);

    usart_flag_clear(USART1, USART_FLAG_TC);
    usart_interrupt_enable(USART1, USART_INT_IDLE); // 使用串口空闲中断

    if (COM1_USE_RTS)
    {
        // com1_rts_init();
    }
}

void com1_nvic_config(void)
{
    nvic_irq_enable(DMA_Channel3_4_IRQn, 0);

    nvic_irq_enable(USART1_IRQn, 1);
}

/* 串口DMA初始化 */
void com1_dma_init(void)
{
    dma_parameter_struct dma_init_struct;
    /* enable DMA clock */
    rcu_periph_clock_enable(RCU_DMA);

    /* initilize the com */
    com1_gpio_init();
    com1_usart_init();
    com1_nvic_config();

    /* initialize DMA channel1 */
    dma_deinit(DMA_CH3);
    dma_struct_para_init(&dma_init_struct);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = (uint32_t)txbuffer1;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = ARRAYNUM(txbuffer1);
    dma_init_struct.periph_addr = USART1_TDATA_ADDRESS;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA_CH3, &dma_init_struct);

    /* initialize DMA channel2 */
    dma_deinit(DMA_CH4);
    dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.memory_addr = (uint32_t)rxbuffer1;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = ARRAYNUM(rxbuffer1);
    dma_init_struct.periph_addr = USART1_RDATA_ADDRESS;
    dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct.memory_width = DMA_PERIPHERAL_WIDTH_8BIT;
    dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_init(DMA_CH4, &dma_init_struct);

    /* configure DMA mode */
    dma_circulation_disable(DMA_CH3);
    dma_memory_to_memory_disable(DMA_CH3);
    dma_circulation_disable(DMA_CH4);
    dma_memory_to_memory_disable(DMA_CH4);

    /* USART DMA enable for reception */
    usart_dma_receive_config(USART1, USART_DENR_ENABLE);

    /* enable DMA channel2 transfer complete interrupt */
    dma_interrupt_enable(DMA_CH4, DMA_INT_FTF);

    /* enable DMA channel2 */
    dma_channel_enable(DMA_CH4);

    /* USART DMA enable for transmission */
    usart_dma_transmit_config(USART1, USART_DENT_ENABLE);

    /* enable DMA channel1 transfer complete interrupt */
    dma_interrupt_enable(DMA_CH3, DMA_INT_FTF);

    /* enable DMA channel1 */
    dma_channel_enable(DMA_CH3);
}

// 串口DMA发送函数
void com1_dma_send_data(uint8_t *buffter, uint8_t length)
{

    uint8_t i; // txbuffer[128];
    dma_parameter_struct dma_init_struct;
    for (i = 0; i < length; i++)
    {
        txbuffer1[i] = buffter[i];
    }
    dma_channel_disable(DMA_CH3);
    dma_memory_address_config(DMA_CH3, (uint32_t)txbuffer1);

    dma_transfer_number_config(DMA_CH3, (uint32_t)length);

    dma_channel_enable(DMA_CH3);

    usart_dma_transmit_config(USART1, USART_DENT_ENABLE);
}

void DMA_Channel3_4_IRQHandler(void) // DMA串口发送接收中断
{
    if (RESET != dma_interrupt_flag_get(DMA_CH3, DMA_INT_FLAG_FTF))
    {
        // DMA串口发送触发中断
        dma_interrupt_flag_clear(DMA_CH3, DMA_INT_FLAG_G);
    }
    if (RESET != dma_interrupt_flag_get(DMA_CH4, DMA_INT_FLAG_FTF))
    {
        // DMA串口接收触发中断
        dma_channel_disable(DMA_CH4);
        dma_interrupt_flag_clear(DMA_CH4, DMA_INT_FLAG_G);
        dma_flag_clear(DMA_CH4, DMA_FLAG_G);
        com1_recv_num = COM1_DMA_REC_LEN; // 获取字节数
        com1_recv_STA = 1;                // 接收数据就绪

        // com1_data_transmit(rxbuffer1, COM1_DMA_REC_LEN);
        rx_len1 = COM1_DMA_REC_LEN;
        if (com1_data_cb != 0)
        {
            com1_data_cb(rxbuffer1, COM1_DMA_REC_LEN);
            dma_transfer_number_config(DMA_CH4, ARRAYNUM(rxbuffer1));
            dma_channel_enable(DMA_CH4);
        }
        else if (rx_len1 == 0)
        {
            dma_transfer_number_config(DMA_CH4, ARRAYNUM(rxbuffer1));
            dma_channel_enable(DMA_CH4);
        }
    }
}

void USART1_IRQHandler(void)
{
    if (RESET != usart_interrupt_flag_get(USART1, USART_INT_FLAG_TC))
    {
        usart_interrupt_flag_clear(USART1, USART_INT_FLAG_TC);
    }

    if (RESET != usart_interrupt_flag_get(USART1, USART_INT_FLAG_IDLE))
    {
        usart_interrupt_flag_clear(USART1, USART_INT_FLAG_IDLE);

        if (com1_recv_STA == 0)
        {
            dma_channel_disable(DMA_CH4);
            dma_interrupt_flag_clear(DMA_CH4, DMA_INT_FLAG_G);
            dma_flag_clear(DMA_CH4, DMA_FLAG_G);

            com1_recv_num = COM1_DMA_REC_LEN - (dma_transfer_number_get(DMA_CH4));

            // com1_data_transmit(rxbuffer1, com1_recv_num);
            rx_len1 = com1_recv_num;
            if (com1_data_cb != 0)
            {
                com1_data_cb(rxbuffer1, com1_recv_num);
                dma_transfer_number_config(DMA_CH4, ARRAYNUM(rxbuffer1));
                dma_channel_enable(DMA_CH4);
            }
            else if (rx_len1 == 0)
            {
                dma_transfer_number_config(DMA_CH4, ARRAYNUM(rxbuffer1));
                dma_channel_enable(DMA_CH4);
            }
        }
        else
        {
            dma_channel_disable(DMA_CH4);
            dma_interrupt_flag_clear(DMA_CH4, DMA_INT_FLAG_G);
            dma_flag_clear(DMA_CH4, DMA_FLAG_G);

            dma_transfer_number_config(DMA_CH4, ARRAYNUM(rxbuffer1));
            dma_channel_enable(DMA_CH4);
        }

        com1_recv_STA = 0;
    }
}

/* DMA方式printf */
void com1_dma_printf(const char *format, ...)
{
    uint32_t length;
    va_list args;

    va_start(args, format);
    length = vsnprintf((char *)txbuffer1, sizeof(txbuffer1), (char *)format, args);
    va_end(args);
    com1_dma_send_data(txbuffer1, length);
}

void com1_data_transmit(uint8_t arr[], uint32_t length)
{
    uint32_t i;
    for (i = 0; i < length; i++)
    {
        usart_data_transmit(USART1, arr[i]);
        while (usart_flag_get(USART1, USART_FLAG_TBE) == RESET)
            ;
    }
}