GD32 DMA串口通讯DEMO

GD32 USART0 DMA发送与接收不定长数据

GD32 USART0发送与接收不定长数据例程

GD32E230简介

GD32E230G是兆易创新于2018年11月1日正式推出的主频高达72MHz的超值型微控制器，是GD32 MCU家族基于Cortex-M23内核的首个产品系列。
ARM Cortex-M23是Cortex-M0和Cortex-M0+的继任者，基于最新的Armv8-M架构的嵌入式微处理器内核。
GD32E230系列超值型新品主频高达72MHz,配备了16KB到64KB的嵌入式闪存及4KB到8KB的SRAM，配合内置的硬件乘法器、除法器和加速单元，在最高主频下的工作性能可达55DMIPS。

GD32E230G-START是兆易创新官方提供的开发板，使用GD32E230G8U6作为主控器，评估板使用MINI USB接口提供5V电源，提供包括扩展引脚在内的即RESET,BOOT,USER KEY,LED,GD-LINK等外设资源。支持第三方集成仿真环境并可通过仿真工具在次班上调试软件，支持2线SWD接口。

GD32E230采用DMA进行串口通讯例程

1，配置滴答时钟
2，配置系统中断
3，配置串口usart0
4，配置串口usart0 tx的DMA通道ch1
5，配置串口usart0 rx的DMA通道ch2

发送不定长数据

1，失能DMA_CH1。
2，DMA_CH1配置内存地址以及发送长度。
3，使能DMA_CH1。
4，使能usart0的DMA发送
5，等待DMA发送完成

接收不定长数据

该功能需要与串口的空闲中断配合使用，当串口空闲中断发生时，检测接收的DMA通道中是否有接收到数据。
1，串口空闲中断
2，关闭DMA_CH2
3，清空DMA_CH2相关的flag
4，计算DMA_CH2中接收到的数据量
5，重新配置DMA_CH2

完整代码

usart.c

#include "gd32e23x.h"
#include "usart.h"
#include <stdio.h>
#include <string.h>

uint8_t rxbuffer[USART0_RX_SIZE];
uint8_t txbuffer[]="\n\rUSART DMA receive and transmit example, please input 10 bytes:\r\n";
uart_buf usart0;

void usart0_init(uint32_t baudrate)
{
    /* enable COM GPIO clock */
    rcu_periph_clock_enable(RCU_GPIOA);
    
     /* enable USART clock */
    rcu_periph_clock_enable(RCU_USART0);


    /* connect port to USARTx_Tx */
    gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_9);

    /* connect port to USARTx_Rx */
    gpio_af_set(GPIOA, GPIO_AF_1, GPIO_PIN_10);

    /* configure USART Tx as alternate function push-pull */
    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_9);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_9);

    /* configure USART Rx as alternate function push-pull */
    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_10);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_10);
    

    /* USART configure */
    usart_deinit(USART0);
    usart_baudrate_set(USART0, baudrate);
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
    
    //开启空闲中断
    usart_interrupt_enable(USART0,USART_INT_IDLE);
    
    usart_enable(USART0);
}

void usart0_dma_send(uint8_t* buffer, uint16_t len)
{
    dma_channel_disable(DMA_CH1);
    
    dma_memory_address_config(DMA_CH1, (uint32_t)buffer);
    dma_transfer_number_config(DMA_CH1, len);
    
    /* enable DMA channel1 */
    dma_channel_enable(DMA_CH1);
    /* USART DMA enable for transmission and reception */
    usart_dma_transmit_config(USART0, USART_DENT_ENABLE);
    /* wait DMA Channel transfer complete */
    while(RESET == dma_flag_get(DMA_CH1, DMA_FLAG_FTF));
}

void usart0_dma_txinit()
{
    dma_parameter_struct dma_init_struct;
    /* enable DMA clock */
    rcu_periph_clock_enable(RCU_DMA);
    
    /* deinitialize DMA channel1 */
    dma_deinit(DMA_CH1);
    dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    dma_init_struct.memory_addr = NULL;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = 0;
    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);
    
    /* configure DMA mode */
    dma_circulation_disable(DMA_CH1);
    dma_memory_to_memory_disable(DMA_CH1);
}

void usart0_dma_rxinit(void)
{
    dma_parameter_struct dma_init_struct;
    /* deinitialize DMA channel2 */
    dma_deinit(DMA_CH2);
    dma_init_struct.direction = DMA_PERIPHERAL_TO_MEMORY;
    dma_init_struct.memory_addr = (uint32_t)rxbuffer;
    dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct.number = USART0_RX_SIZE;
    dma_init_struct.periph_addr = USART0_RDATA_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_CH2, &dma_init_struct);
    
    dma_circulation_disable(DMA_CH2);
    dma_memory_to_memory_disable(DMA_CH2);

    /* enable DMA channel2 transfer complete interrupt */
    dma_interrupt_enable(DMA_CH2, DMA_INT_FTF);
    usart_dma_receive_config(USART0, USART_DENR_ENABLE);
    dma_channel_enable(DMA_CH2);
}

uint8_t usart0_dma_rxdata(void)
{
    dma_channel_disable(DMA_CH2);
    dma_flag_clear(DMA_CH2, DMA_FLAG_G);
    usart0.rx_index = USART0_RX_SIZE - dma_transfer_number_get(DMA_CH2);
    
    dma_transfer_number_config(DMA_CH2,USART0_RX_SIZE);
    dma_channel_enable(DMA_CH2);
    
    if( usart0.rx_index == 0 )
        return 0;
    else
        return 1;
}

gd23e23x_it.c

#include "gd32e23x_it.h"
#include "main.h"
#include "systick.h"
#include "usart.h"
extern uint8_t flag;
extern FlagStatus g_recv_complete;

/*!
    \brief      this function handles NMI exception
    \param[in]  none
    \param[out] none
    \retval     none
*/
void NMI_Handler(void)
{
}

/*!
    \brief      this function handles HardFault exception
    \param[in]  none
    \param[out] none
    \retval     none
*/
void HardFault_Handler(void)
{
    /* if Hard Fault exception occurs, go to infinite loop */
    while (1){
    }
}

/*!
    \brief      this function handles SVC exception
    \param[in]  none
    \param[out] none
    \retval     none
*/
void SVC_Handler(void)
{
}

/*!
    \brief      this function handles PendSV exception
    \param[in]  none
    \param[out] none
    \retval     none
*/
void PendSV_Handler(void)
{
}

/*!
    \brief      this function handles SysTick exception
    \param[in]  none
    \param[out] none
    \retval     none
*/
void SysTick_Handler(void)
{
//    led_spark();
    delay_decrement();
}

//1ms定时器
void TIMER0_BRK_UP_TRG_COM_IRQHandler(void)
{
    if( timer_flag_get(TIMER0, TIMER_INT_FLAG_UP) == SET )
    {
        timer_flag_clear(TIMER0,TIMER_INT_FLAG_UP);
    }
}

/*!
    \brief      this function handles DMA_Channel1_2_IRQHandler interrupt
    \param[in]  none
    \param[out] none
    \retval     none
*/
void DMA_Channel1_2_IRQHandler(void)
{
    //DMA接收缓存满，产生DMA中断
    if(RESET != dma_interrupt_flag_get(DMA_CH2, DMA_INT_FLAG_FTF)){
        dma_interrupt_flag_clear(DMA_CH2, DMA_INT_FLAG_G);
        g_recv_complete = SET;
    }
}


void USART0_IRQHandler()
{
    //利用串口的空闲中断，以及DMA的接收数据，判断串口是否接收完成
    if( SET == usart_interrupt_flag_get(USART0, USART_INT_FLAG_IDLE) )
    {
        usart_interrupt_flag_clear(USART0,USART_INT_FLAG_IDLE);
        if ( usart0_dma_rxdata() )
            g_recv_complete = SET;
    }
}