STM32F4串口：USART DMA方式任意长度数据通信

#ifndef __USART_H
#define __USART_H

#ifdef __cplusplus
extern "C" {
#endif

#include "stdio.h"
#include "stm32f4xx.h"


#define USART2_DMA_TX_BUF_SIZE        256
#define USART1_DMA_TX_BUF_SIZE        256
#define USART1_DMA_RX_BUF_SIZE        256

// 用户缓存容量定义最好不能小于USART1 RX缓存容量，
// 否则可能在一次接收大量数据时用户缓存溢出
#define USART_USER_Q_BUF_SIZE        ((USART1_DMA_RX_BUF_SIZE) << 1)



#define _DEBUG
#if defined(_DEBUG) || defined(DEBUG)
#define logx(...)                { usart2_printf(__VA_ARGS__); }
#else
#define logx(...)
#endif


uint16_t usart1_user_rx_buf_pop(uint8_t* data, uint16_t len);
uint8_t  usart1_user_rx_buf_is_full(void);
uint8_t  usart1_user_rx_buf_is_empty(void);
uint16_t usart1_user_rx_buf_get_avail(void);

void usart2_dma_init(void);
void usart1_dma_init(void);

void usart1_dma_tx(uint8_t* data, uint16_t size);
void usart2_dma_tx(uint8_t* data, uint16_t size);
int usart1_printf(const char *format, ...);
int usart2_printf(const char *format, ...);


#ifdef __cplusplus
}
#endif

#endif

#include <stdarg.h>
#include <string.h>
#include "delay.h"
#include "usart-dma.h"


// USART1 TX/RX 缓存定义
static __align(8) uint8_t usart1_dma_tx_buf[USART1_DMA_TX_BUF_SIZE];
static __align(8) uint8_t usart1_dma_rx_buf[USART1_DMA_RX_BUF_SIZE];
static volatile uint8_t flag_tx_usart1_dma_busy = 0;

// USART2 TX 缓存定义
static __align(8) uint8_t usart2_dma_tx_buf[USART2_DMA_TX_BUF_SIZE];
static volatile uint8_t flag_tx_usart2_dma_busy = 0;


// 用户缓存定义，USART1 RX数据中转到该缓存供用户读取
#define USER_Q_STATUS_AVAIL        0
#define USER_Q_STATUS_FULL        1
#define USER_Q_STATUS_EMPTY        2
typedef struct {
    uint8_t buff[USART_USER_Q_BUF_SIZE];
    volatile uint16_t head;
    volatile uint16_t tail;
    volatile uint8_t status;
} usart_user_q_t;

static usart_user_q_t usart1_user_q = {{0}, 0, 0, USER_Q_STATUS_EMPTY};



#if 1
#pragma import(__use_no_semihosting)
struct __FILE {
    int handle;
} __stdout;

void _sys_exit(int x) { x = x; }    // 定义_sys_exit()以避免使用半主机模式

int sendchar( char c )
{
    while ( (USART2->SR & 0x80) == 0 ); // 80 = TXE, 40 = TC
    USART2->DR = c;
    return 1;
}

/*int getkey(void)
{
    while ( (USART2->SR & 0x20) == 0 ); // 20 = RXNE
    return (USART2->DR);
}*/

int fputc( int ch, FILE *f )
{
    if ( (char)ch == '\n' ) sendchar('\r');
    return sendchar((char)ch);
}

// 由于USART2没有实现接收数据功能，故不重定义fgetc函数
//int fgetc( FILE *f ) { return getkey(); }

int ferror( FILE *f )
{
    // Your implementation of ferror
    return EOF;
}

void _ttywrch( int ch )
{
    if ( (char)ch == '\n' ) sendchar('\r');
    sendchar((char)ch);
}
#endif



//////////////////////////////////////////////////////////////////////////
////////////////////////////// USART1-DMA RX FIFO操作 /////////////////////

/*********************************************************************
* 内部函数：    读取USART1数据，
*            USART1及对应的DMA中断调用本函数，往用户缓存中填充数据。
* data:        源缓存，即分配给DMA2_Stream2的缓存
* len:        读取数据大小，按字节计，不应该超过data容量
* 返回值:    返回实际读取到的字节数据个数，如果为零，表示USART1内部缓存为空
**********************************************************************/
static uint16_t usart1_user_rx_buf_push( uint8_t* data, uint16_t len )
{
    uint16_t avail, avail0;
    uint16_t head = usart1_user_q.head;        // tail为push指针，head为pop指针
    uint16_t tail = usart1_user_q.tail;
    uint8_t* pqbuff = usart1_user_q.buff;

    // 首先检测缓存是否为满，满则直接返回
    if ( USER_Q_STATUS_FULL == usart1_user_q.status )
        return 0;

    if ( tail >= head )        // 可能需要分两段push
    {
        avail0 = USART_USER_Q_BUF_SIZE - tail;
        avail = avail0 + head;
        if ( len > avail ) len = avail;

        if ( len > avail0 ) {
            memcpy(pqbuff+tail, data, avail0);
            memcpy(pqbuff, data+avail0, len-avail0);
        }
        else
            memcpy(pqbuff+tail, data, len);
    }
    else    // 缓存部分可用
    {
        avail = head - tail;
        if ( len > avail ) len = avail;
        memcpy(pqbuff+tail, data, len);
    }

    // 最后更改状态及tail值
    usart1_user_q.status = (avail > len) ? USER_Q_STATUS_AVAIL : USER_Q_STATUS_FULL;
    usart1_user_q.tail = (tail+len) % USART_USER_Q_BUF_SIZE;
    return len;
}

/*********************************************************************
* 接口函数：    读取USART1数据
* data:        目的缓存
* len:        读取数据大小，按字节计，不应该超过data容量
* 返回值:    返回实际读取到的字节数据个数，如果为零，表示USART1内部缓存为空
**********************************************************************/
uint16_t usart1_user_rx_buf_pop( uint8_t* data, uint16_t len )
{
    uint16_t avail, avail0;
    uint16_t head = usart1_user_q.head;        // tail为push指针，head为pop指针
    uint16_t tail = usart1_user_q.tail;
    uint8_t* pqbuff = usart1_user_q.buff;

    // 首先检测缓存是否为空，空则直接返回
    if ( USER_Q_STATUS_EMPTY == usart1_user_q.status )
        return 0;

    if ( head >= tail )    // 可能需要分两段pop
    {
        avail0 = USART_USER_Q_BUF_SIZE - head;
        avail = avail0 + tail;
        if ( len > avail ) len = avail;

        if ( len > avail0 ) {
            memcpy(data, pqbuff+head, avail0);
            memcpy(data+avail0, pqbuff, tail);
        }
        else
            memcpy(data, pqbuff+head, len);
    }
    else {
        avail = tail - head;
        if ( len > avail ) len = avail;
        memcpy(data, pqbuff+head, len);
    }

    // 最后更改状态及head值
    usart1_user_q.status = (avail > len) ? USER_Q_STATUS_AVAIL : USER_Q_STATUS_EMPTY;
    usart1_user_q.head = (head+len) % USART_USER_Q_BUF_SIZE;
    return len;
}

/*********************************************************************
* USART1 RX缓存是否满。满返回非零，不满返回零。
**********************************************************************/
uint8_t usart1_user_rx_buf_is_full(void)
{
    if ( USER_Q_STATUS_FULL == usart1_user_q.status )
        return 1;
    return 0;
}

/*********************************************************************
* USART1 RX缓存是否空。空返回非零，不空返回零。
**********************************************************************/
uint8_t usart1_user_rx_buf_is_empty(void)
{
    if ( USER_Q_STATUS_EMPTY == usart1_user_q.status )
        return 1;
    return 0;
}

/*********************************************************************
* 获取USART1 RX缓存中可读取的数据字节个数
**********************************************************************/
uint16_t usart1_user_rx_buf_get_avail(void)
{
    uint8_t status = usart1_user_q.status;
    uint16_t head = usart1_user_q.head;        // tail为push指针，head为pop指针
    uint16_t avail, tail = usart1_user_q.tail;

    if ( USER_Q_STATUS_EMPTY == status ) return 0;
    if ( USER_Q_STATUS_FULL == status ) return (USART_USER_Q_BUF_SIZE);

    if ( head >= tail ) avail = USART_USER_Q_BUF_SIZE - head + tail;
    else avail = tail - head;
    return avail;
}






//////////////////////////////////////////////////////////////////////////
/////////////////// USART1 及 USART2 初始化 ///////////////////////////////
/*
* http://blog.csdn.net/jdh99/article/details/43307121
* http://jmarple.com/transmitting-data-over-usart-using-dma/    (需要翻墙)
*/

static void imp_usart2_dma_init()
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    DMA_InitTypeDef DMA_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);

    GPIO_PinAFConfig(GPIOA, GPIO_PinSource2, GPIO_AF_USART2);
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource3, GPIO_AF_USART2);

    GPIO_InitStructure.GPIO_Pin                = GPIO_Pin_2 | GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode            = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_Speed            = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_OType            = GPIO_OType_PP;
    GPIO_InitStructure.GPIO_PuPd            = GPIO_PuPd_UP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);


    //////////////////////////////////////////////////////////////////////////
    // USART2配置

    USART_InitStructure.USART_BaudRate        = 115200;
    USART_InitStructure.USART_WordLength    = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits        = USART_StopBits_1;
    USART_InitStructure.USART_Parity        = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode            = USART_Mode_Rx | USART_Mode_Tx;
    USART_Init(USART2, &USART_InitStructure);

    USART_Cmd(USART2, ENABLE);
    USART_ClearFlag(USART2, USART_FLAG_TC);


    //////////////////////////////////////////////////////////////////////////
    // DMA TX配置

    // DMA中断配置
    NVIC_InitStructure.NVIC_IRQChannel                        = DMA1_Stream6_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority    = 3;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority            = 3;
    NVIC_InitStructure.NVIC_IRQChannelCmd                    = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    // DMA通道配置
    DMA_DeInit(DMA1_Stream6);
    DMA_InitStructure.DMA_Channel                = DMA_Channel_4;
    DMA_InitStructure.DMA_PeripheralBaseAddr    = (uint32_t)(&USART2->DR);        // 外设地址
    DMA_InitStructure.DMA_Memory0BaseAddr        = (uint32_t)usart2_dma_tx_buf;    // 内存地址
    DMA_InitStructure.DMA_DIR                    = DMA_DIR_MemoryToPeripheral;    // DMA传输方向
    DMA_InitStructure.DMA_BufferSize            = USART2_DMA_TX_BUF_SIZE;        // 设置DMA在传输时缓冲区的长度
    DMA_InitStructure.DMA_PeripheralInc            = DMA_PeripheralInc_Disable;    // 设置DMA的外设递增模式，一个外设
    DMA_InitStructure.DMA_MemoryInc                = DMA_MemoryInc_Enable;            // 设置DMA的内存递增模式
    DMA_InitStructure.DMA_PeripheralDataSize    = DMA_PeripheralDataSize_Byte;    // 外设数据字长
    DMA_InitStructure.DMA_MemoryDataSize        = DMA_PeripheralDataSize_Byte;    // 内存数据字长
    DMA_InitStructure.DMA_Mode                    = DMA_Mode_Normal;                // 设置DMA的传输模式
    DMA_InitStructure.DMA_Priority                = DMA_Priority_High;            // 设置DMA的优先级别
    DMA_InitStructure.DMA_FIFOMode                = DMA_FIFOMode_Disable;            // 指定如果FIFO模式或直接模式将用于指定的流：不使能FIFO模式
    DMA_InitStructure.DMA_FIFOThreshold            = DMA_FIFOThreshold_HalfFull;    // 指定了FIFO阈值水平
    DMA_InitStructure.DMA_MemoryBurst            = DMA_MemoryBurst_Single;        // 指定的Burst转移配置内存传输
    DMA_InitStructure.DMA_PeripheralBurst        = DMA_PeripheralBurst_Single;    // 指定的Burst转移配置外围转移
    DMA_Init(DMA1_Stream6, &DMA_InitStructure);
    DMA_ITConfig(DMA1_Stream6, DMA_IT_TC, ENABLE);    // 使能传输完成中断

    USART_DMACmd(USART2, USART_DMAReq_Tx, ENABLE);    // 采用DMA方式发送
}


static void imp_uart1_dma_init(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;        // 定义中断结构体
    GPIO_InitTypeDef GPIO_InitStructure;        // 定义IO初始化结构体
    USART_InitTypeDef USART_InitStructure;        // 定义串口结构体
    DMA_InitTypeDef DMA_InitStructure;            // 定义DMA结构体

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);    // 使能USART1时钟
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2, ENABLE);    // 启动DMA时钟


    //////////////////////////////////////////////////////////////////////////
    // 串口TX DMA 配置

    // DMA发送中断设置
    NVIC_InitStructure.NVIC_IRQChannel                        = DMA2_Stream7_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority    = 3;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority            = 3;
    NVIC_InitStructure.NVIC_IRQChannelCmd                    = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    // DMA通道配置
    DMA_DeInit(DMA2_Stream7);
    DMA_InitStructure.DMA_Channel                = DMA_Channel_4;
    DMA_InitStructure.DMA_PeripheralBaseAddr    = (uint32_t)(&USART1->DR);        // 外设地址
    DMA_InitStructure.DMA_Memory0BaseAddr        = (uint32_t)usart1_dma_tx_buf;    // 内存地址
    DMA_InitStructure.DMA_DIR                    = DMA_DIR_MemoryToPeripheral;    // DMA传输方向
    DMA_InitStructure.DMA_BufferSize            = USART1_DMA_TX_BUF_SIZE;        // 设置DMA在传输时缓冲区的长度
    DMA_InitStructure.DMA_PeripheralInc            = DMA_PeripheralInc_Disable;    // 设置DMA的外设递增模式，一个外设
    DMA_InitStructure.DMA_MemoryInc                = DMA_MemoryInc_Enable;            // 设置DMA的内存递增模式
    DMA_InitStructure.DMA_PeripheralDataSize    = DMA_PeripheralDataSize_Byte;    // 外设数据字长
    DMA_InitStructure.DMA_MemoryDataSize        = DMA_PeripheralDataSize_Byte;    // 内存数据字长
    DMA_InitStructure.DMA_Mode                    = DMA_Mode_Normal;                // 设置DMA的传输模式
    DMA_InitStructure.DMA_Priority                = DMA_Priority_High;            // 设置DMA的优先级别
    DMA_InitStructure.DMA_FIFOMode                = DMA_FIFOMode_Disable;            // 指定如果FIFO模式或直接模式将用于指定的流：不使能FIFO模式
    DMA_InitStructure.DMA_FIFOThreshold            = DMA_FIFOThreshold_HalfFull;    // 指定了FIFO阈值水平
    DMA_InitStructure.DMA_MemoryBurst            = DMA_MemoryBurst_Single;        // 指定的Burst转移配置内存传输
    DMA_InitStructure.DMA_PeripheralBurst        = DMA_PeripheralBurst_Single;    // 指定的Burst转移配置外围转移
    DMA_Init(DMA2_Stream7, &DMA_InitStructure);        // 配置DMA1的通道
    DMA_ITConfig(DMA2_Stream7, DMA_IT_TC, ENABLE);    // 使能传输完成中断


    //////////////////////////////////////////////////////////////////////////
    // 串口RX DMA 配置

    // DMA接收中断设置
    NVIC_InitStructure.NVIC_IRQChannel                        = DMA2_Stream2_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority    = 3;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority            = 3;
    NVIC_InitStructure.NVIC_IRQChannelCmd                    = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    // DMA通道配置
    DMA_DeInit(DMA2_Stream2);
    DMA_InitStructure.DMA_Channel                = DMA_Channel_4;
    DMA_InitStructure.DMA_PeripheralBaseAddr    = (uint32_t)(&USART1->DR);        // 外设地址
    DMA_InitStructure.DMA_Memory0BaseAddr        = (uint32_t)usart1_dma_rx_buf;    // 内存地址
    DMA_InitStructure.DMA_DIR                    = DMA_DIR_PeripheralToMemory;    // dma传输方向
    DMA_InitStructure.DMA_BufferSize            = USART1_DMA_RX_BUF_SIZE;        // 设置DMA在传输时缓冲区的长度
    DMA_InitStructure.DMA_PeripheralInc            = DMA_PeripheralInc_Disable;    // 设置DMA的外设递增模式，一个外设
    DMA_InitStructure.DMA_MemoryInc                = DMA_MemoryInc_Enable;            // 设置DMA的内存递增模式
    DMA_InitStructure.DMA_PeripheralDataSize    = DMA_PeripheralDataSize_Byte;    // 外设数据字长
    DMA_InitStructure.DMA_MemoryDataSize        = DMA_MemoryDataSize_Byte;        // 内存数据字长
    DMA_InitStructure.DMA_Mode                    = DMA_Mode_Normal;                // 设置DMA的传输模式
    DMA_InitStructure.DMA_Priority                = DMA_Priority_VeryHigh;        // 设置DMA的优先级别
    DMA_InitStructure.DMA_FIFOMode                = DMA_FIFOMode_Disable;            // 指定如果FIFO模式或直接模式将用于指定的流：不使能FIFO模式
    DMA_InitStructure.DMA_FIFOThreshold            = DMA_FIFOThreshold_Full;        // 指定了FIFO阈值水平，半满为DMA_FIFOThreshold_HalfFull
    DMA_InitStructure.DMA_MemoryBurst            = DMA_MemoryBurst_Single;        // 指定的Burst转移配置内存传输
    DMA_InitStructure.DMA_PeripheralBurst        = DMA_PeripheralBurst_Single;    // 指定的Burst转移配置外围转移
    DMA_Init(DMA2_Stream2, &DMA_InitStructure);        // 配置DMA1的通道
    DMA_ITConfig(DMA2_Stream2, DMA_IT_TC/*DMA_IT_HT*/, ENABLE);    // 使能传输完成中断
    DMA_Cmd(DMA2_Stream2, ENABLE);                    // 使能通道


    //////////////////////////////////////////////////////////////////////////
    // 初始化串口参数
    USART_InitStructure.USART_WordLength            = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits                = USART_StopBits_1;
    USART_InitStructure.USART_Parity                = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl    = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode                    = USART_Mode_Rx | USART_Mode_Tx;
    USART_InitStructure.USART_BaudRate                = 115200;
    USART_Init(USART1, &USART_InitStructure);        // 初始化串口

    // 配置中断
    NVIC_InitStructure.NVIC_IRQChannel                = USART1_IRQn;    // 通道设置为串口中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority= 3;        // 抢占优先级3
    NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 3;        // 子优先级3
    NVIC_InitStructure.NVIC_IRQChannelCmd            = ENABLE;        // 打开中断
    NVIC_Init(&NVIC_InitStructure);

    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);    // 采用DMA方式发送
    USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);    // 采用DMA方式接收

    // 中断配置
    USART_ITConfig(USART1, USART_IT_TC, DISABLE);
    USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
    USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
    USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);

    USART_Cmd(USART1, ENABLE);        // 启动串口


    //////////////////////////////////////////////////////////////////////////
    // GPIO复用

    // 串口1对应引脚复用映射
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_USART1);     // GPIOA9复用为USART1
    GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_USART1);     // GPIOA10复用为USART1

    // USART1端口配置
    GPIO_InitStructure.GPIO_Pin        = GPIO_Pin_9 | GPIO_Pin_10; // GPIOA9与GPIOA10
    GPIO_InitStructure.GPIO_Mode    = GPIO_Mode_AF;                // 复用功能
    GPIO_InitStructure.GPIO_Speed    = GPIO_Speed_50MHz;            // 速度50MHz
    GPIO_InitStructure.GPIO_OType    = GPIO_OType_PP;             // 推挽复用输出
    GPIO_InitStructure.GPIO_PuPd    = GPIO_PuPd_UP;             // 上拉
    GPIO_Init(GPIOA, &GPIO_InitStructure);                         // 初始化PA9，PA10
}





//////////////////////////////////////////////////////////////////////////
/////////////////////////// USART2 中断处理函数 ////////////////////////////

/*********************************************************************
* USART2 DMA 发送中断处理函数
**********************************************************************/
void DMA1_Stream6_IRQHandler(void)
{
    if ( DMA_GetITStatus(DMA1_Stream6, DMA_IT_TCIF6) ) {
        DMA_Cmd(DMA1_Stream6, DISABLE);    // 关闭DMA
        DMA_ClearITPendingBit(DMA1_Stream6, DMA_IT_TCIF6);    // Clear DMA Stream Transfer Complete interrupt pending bit
        flag_tx_usart2_dma_busy = 0;    // 发送完成
    }
}



//////////////////////////////////////////////////////////////////////////
////////////////////////// USART1 中断处理函数 /////////////////////////////


/*********************************************************************
* USART1 DMA 发送中断处理函数
**********************************************************************/
void DMA2_Stream7_IRQHandler(void)
{
    if ( DMA_GetITStatus(DMA2_Stream7, DMA_IT_TCIF7) ) {
        DMA_Cmd(DMA2_Stream7, DISABLE);                        // 关闭DMA
        DMA_ClearITPendingBit(DMA2_Stream7, DMA_IT_TCIF7);    // Clear DMA Stream Transfer Complete interrupt pending bit
        flag_tx_usart1_dma_busy = 0;                        // 发送完成
    }
}

/*********************************************************************
* USART1 DMA 接收中断处理
* ！！！注意：DMA通道禁用->使能过程应该尽可能的快，
*        如需要添加调试用打印输出信息，
*        务必添加在使能DMA之后，且不能过多耗时！！！！
**********************************************************************/
void DMA2_Stream2_IRQHandler(void)
{
    uint16_t len = 0, lenuser = 0;

    if ( DMA_GetITStatus(DMA2_Stream2, DMA_IT_TCIF2/*DMA_IT_HTIF2*/) )
    {
        DMA_Cmd(DMA2_Stream2, DISABLE);
        /*DMA_ClearFlag(DMA2_Stream2, DMA_FLAG_TCIF2);
        DMA_ClearITPendingBit(DMA2_Stream2, DMA_IT_HTIF2);*/
        DMA_ClearITPendingBit(DMA2_Stream2, DMA_IT_TCIF2);

        len = USART1_DMA_RX_BUF_SIZE - DMA_GetCurrDataCounter(DMA2_Stream2);
        lenuser = usart1_user_rx_buf_push(usart1_dma_rx_buf, len);

        DMA_SetCurrDataCounter(DMA2_Stream2, USART1_DMA_RX_BUF_SIZE);    // 数据取出后，重新设置RX缓存大小
        DMA_Cmd(DMA2_Stream2, ENABLE);        // 打开DMA

        //log("usart1 rx dma:%d\n", len);
        if ( lenuser < len ) {
            logx("usart1 dma: overflow<%d, %d>\n", len, lenuser);
        }
    }
}

/*********************************************************************
* USART1 中断处理函数
* ！！！注意：DMA通道禁用->使能过程应该尽可能的快，
*        如需要添加调试用打印输出信息，
*        务必添加在使能DMA之后，且不能过多耗时！！！！
**********************************************************************/
void USART1_IRQHandler(void)
{
    uint16_t len = 0, lenuser = 0;

    if( USART_GetITStatus(USART1, USART_IT_IDLE) )
    {
        USART1->SR; USART1->DR; // 清USART_IT_IDLE标志
        USART_ClearITPendingBit(USART1, USART_IT_IDLE);
        //USART_ClearITPendingBit(USART1, USART_IT_TC);

        DMA_Cmd(DMA2_Stream2, DISABLE);                    // 关闭DMA
        DMA_ClearFlag(DMA2_Stream2, DMA_FLAG_TCIF2);    // 清除DMA满标志位
        DMA_ClearFlag(DMA2_Stream2, DMA_FLAG_HTIF2);    // 清除DMA半满标志位

        // 拷贝出rx缓存中的数据
        len = USART1_DMA_RX_BUF_SIZE - DMA_GetCurrDataCounter(DMA2_Stream2);
        if ( len > 0 ) lenuser = usart1_user_rx_buf_push(usart1_dma_rx_buf, len);

        DMA_SetCurrDataCounter(DMA2_Stream2, USART1_DMA_RX_BUF_SIZE);    // 设置传输数据长度
        DMA_Cmd(DMA2_Stream2, ENABLE);        // 打开DMA

        //log("usart1 idle:%d\n", len);
        if ( lenuser < len && len > 0 ) {
            logx("usart1 idle: overflow<%d, %d>\n", len, lenuser);
        }
    }
}




//////////////////////////////////////////////////////////////////////////
//////////////////////////// 接口函数 /////////////////////////////////////


void usart1_dma_init(void)
{
    usart1_user_q.head = 0;
    usart1_user_q.tail = 0;
    usart1_user_q.status = USER_Q_STATUS_EMPTY;

    flag_tx_usart1_dma_busy = 0;
    imp_uart1_dma_init();
}

void usart2_dma_init(void)
{
    flag_tx_usart2_dma_busy = 0;
    imp_usart2_dma_init();
}

/*********************************************************************
* 接口函数: USART1发送数据
* 参数:    data: 发送数据存放地址
*          size: 发送数据字节数
* 说明: size值不能超过USART1_DMA_TX_LEN，否则剩余数据不会被发送。
**********************************************************************/
void usart1_dma_tx( uint8_t* data, uint16_t size )
{
    while ( flag_tx_usart1_dma_busy );        // 等待空闲
    flag_tx_usart1_dma_busy = 1;

    if ( size > USART1_DMA_TX_BUF_SIZE ) size = USART1_DMA_TX_BUF_SIZE;
    memcpy(usart1_dma_tx_buf, data, size);        // 复制数据
    DMA_SetCurrDataCounter(DMA2_Stream7, size);    // 设置传输数据长度
    DMA_Cmd(DMA2_Stream7, ENABLE);                // 打开DMA,开始发送
}

/*********************************************************************
* 接口函数: USART2发送数据
* 参数:    data: 发送数据存放地址
*          size: 发送数据字节数
* 说明: size值不能超过USART2_DMA_TX_LEN，否则剩余数据不会被发送。
**********************************************************************/
void usart2_dma_tx( uint8_t* data, uint16_t size )
{
    while ( flag_tx_usart2_dma_busy );        // 等待空闲
    flag_tx_usart2_dma_busy = 1;

    if ( size > USART2_DMA_TX_BUF_SIZE ) size = USART2_DMA_TX_BUF_SIZE;
    memcpy(usart2_dma_tx_buf, data, size);        // 复制数据
    DMA_SetCurrDataCounter(DMA1_Stream6, size);    // 设置传输数据长度
    DMA_Cmd(DMA1_Stream6, ENABLE);                // 打开DMA,开始发送
}

/*********************************************************************
* 接口函数: 格式化数据输出到USART1
* 说明: 格式化缓存容量USART1_DMA_TX_LEN，即USART1发送缓存容量。
**********************************************************************/
int usart1_printf( const char* format, ...)
{
    int rv;
    va_list arg;

    while ( flag_tx_usart1_dma_busy );        // 等待空闲
    flag_tx_usart1_dma_busy = 1;

    va_start(arg, format);
    rv = vsnprintf((char*)usart1_dma_tx_buf, USART1_DMA_TX_BUF_SIZE, format, arg);
    va_end(arg);

    DMA_SetCurrDataCounter(DMA2_Stream7, rv);    // 设置传输数据长度
    DMA_Cmd(DMA2_Stream7, ENABLE);                // 打开DMA,开始发送
    return rv;
}

/*********************************************************************
* 接口函数: 格式化数据输出到USART2
* 说明: 格式化缓存容量USART2_DMA_TX_LEN，即USART2发送缓存容量。
**********************************************************************/
int usart2_printf( const char* format, ...)
{
    int rv;
    va_list arg;

    while ( flag_tx_usart2_dma_busy );        // 等待空闲
    flag_tx_usart2_dma_busy = 1;

    va_start(arg, format);
    rv = vsnprintf((char*)usart2_dma_tx_buf, USART2_DMA_TX_BUF_SIZE, format, arg);
    va_end(arg);

    DMA_SetCurrDataCounter(DMA1_Stream6, rv);    // 设置传输数据长度
    DMA_Cmd(DMA1_Stream6, ENABLE);                // 打开DMA,开始发送
    return rv;
}