串口通讯最主要的就是要不丢数据，不丢帧，基本设想就是建立一个大的串口缓冲区，串口接收到的数据使用循环队列的方式全部往这个缓冲区放，不过这种方式需要把串口缓冲区弄大一点，防止数据覆盖。在stm32中，利用DMA+空闲中断很容易做到这一点。只需要将DMA设置为循环模式，如下图：
也就是说，在循环模式下，当DMA传输了一个数据，DMA_CNDTRx传输数量寄存器相应减一，当DMA_CNDTRx传输数量寄存器减为0时，DMA_CNDTRx寄存器将恢复为相应的初始值，不用软件干预，那么，这不就是循环队列的方式吗？
于是，只需将DMA传输方式配置为循环模式，串口接收循环队列就此完成。串口初始化代码如下：
_USART1RXBUFF RxBuff; //定义串口接收缓冲区
/**
* @brief 配置嵌套向量中断控制器NVIC
* @param 无
* @retval 无
*/
static void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
/* 嵌套向量中断控制器组选择 */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
/* 配置USART为中断源 */
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
/* 抢断优先级*/
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
/* 子优先级 */
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
/* 使能中断 */
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
/* 初始化配置NVIC */
NVIC_Init(&NVIC_InitStructure);
}
/**
* @brief USART GPIO 配置,工作参数配置
* @param 无
* @retval 无
*/
void USART_Config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
// 打开串口GPIO的时钟
DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
// 打开串口外设的时钟
DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
// 将USART Tx的GPIO配置为推挽复用模式
GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
// 将USART Rx的GPIO配置为浮空输入模式
GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);
// 配置串口的工作参数
// 配置波特率
USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
// 配置 针数据字长
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(DEBUG_USARTx, &USART_InitStructure);
// 串口中断优先级配置
NVIC_Configuration();
// 使能串口接收中断
USART_ITConfig(DEBUG_USARTx, USART_IT_IDLE, ENABLE);
// 使能串口
USART_Cmd(DEBUG_USARTx, ENABLE);
}
/**
* @brief USARTx DMA 配置
* @param 无
* @retval 无
*/
void USARTx_DMA_Config(void)
{
DMA_InitTypeDef DMA_InitStructure;
// 开启DMA时钟
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
// // 设置DMA源地址：串口数据寄存器地址*/
// DMA_InitStructure.DMA_PeripheralBaseAddr = USART_DR_ADDRESS;
// // 内存地址(要传输的变量的指针)
// DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
// // 方向：从内存到外设
// DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
// // 传输大小
// DMA_InitStructure.DMA_BufferSize = SENDBUFF_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模式，一次或者循环模式
// DMA_InitStructure.DMA_Mode = DMA_Mode_Normal ;
// //DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
// // 优先级：中
// DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
// // 禁止内存到内存的传输
// DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
// // 配置DMA通道
// DMA_Init(USART_TX_DMA_CHANNEL, &DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = USART_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)RxBuff.rxarr; //串口接收基地址
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = RXBUFFSIZE; //接收缓冲区的大小
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_Circular ; //循环模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(USART1RX_DMA_CHANNEL, &DMA_InitStructure);
// 使能DMA
// DMA_Cmd (USART_TX_DMA_CHANNEL,ENABLE);
DMA_Cmd (USART1RX_DMA_CHANNEL,ENABLE);
USART_DMACmd(DEBUG_USARTx,USART_DMAReq_Rx,ENABLE);
}
初始化没什么好说的，定义了串口接收缓冲区，然后DMA配置为循环模式，接收缓冲区的结构体如下：
#define RXBUFFSIZE 100 //接收缓冲区的大小
/**串口接收缓冲区**/
typedef struct __USART1RXBUFF
{
uint16_t wp; //接收缓冲区写地址
uint16_t rp; //接收缓冲区的读地址
uint8_t rxarr[RXBUFFSIZE]; //接收缓冲区实体
}_USART1RXBUFF;
/**帧地址结构体**/
typedef struct __FRAMEADDR
{
uint16_t wpx; //本帧写地址的索引
uint16_t rpx; //本帧读地址的索引
}_FRAMEADDR;
#define FRADDRMAX 10 //最多能记录的帧
/**帧属性结构体**/
typedef struct __FRAMEATTRI
{
_FRAMEADDR fraddr[FRADDRMAX]; //每帧的地址
uint8_t currfra; //当前处理帧
uint8_t nextfra; //下一个帧
}_FRAMEATTRI;
总共有三个结构体，结构体详细介绍如下：
首先是第一个结构体，串口接收缓冲区结构体，串口接收缓冲区RxBuff的定义就是这个结构体属性。
#define RXBUFFSIZE 100 //接收缓冲区的大小
/**串口接收缓冲区**/
typedef struct __USART1RXBUFF
{
uint16_t wp; //接收缓冲区写地址
uint16_t rp; //接收缓冲区的读地址
uint8_t rxarr[RXBUFFSIZE]; //接收缓冲区实体
}_USART1RXBUFF;
其中 wp 记录接收缓冲区当前写到的地址， rp 记录接收缓冲区当前读到的地址，而 rxarr 则是接收缓冲区的主体，所有从串口接收到的数据都会放入这个数组中，大小为 RXBUFFSIZE 设置，这个值需要设置大一点，防止数据覆盖。图解如下：
刚开始时，rp、wp都指向0，之后来了第一帧数据之后如下：
之后帧1填充至串口缓冲区，rp记录帧1的起始地址，wp记录帧1的结束地址，这两个值的记录处理如下：
/*在串口空闲中断中调用*/
void USART1IDLE_IRQ(void)
{
uint16_t trnum=0;
USART1->SR;
USART1->DR;
//手册虽然说这个寄存器在DMA循环模式的时候，清0之后会自动恢复为最大接收缓冲区，但加入这一步以防万一
if(USART1RX_DMA_CHANNEL->CNDTR == 0)
{
trnum = RXBUFFSIZE;
}
else
{
trnum = USART1RX_DMA_CHANNEL->CNDTR&0xffff;
}
RxBuff.wp = RXBUFFSIZE-trnum; //指向接收缓冲区帧1的写地址末尾
}
知道了帧1在串口缓冲区的起始地址与结束地址，那么在主函数中就可以将数据从串口接收缓冲区取出来。等待帧1数据读取完之后，让RxBuff.rp=RxBuff.wp。如下：
/**
* @brief JustAFra获取一帧数据
* @param pbuff--获取一帧数据的数组，psize--获取的数目
* @retval rtflg--0代表没有获取数据，1代表获取到数据
*/
uint8_t JustAFra(uint8_t *pbuff,uint8_t *psize)
{
uint8_t rtflg=0;
if(RxBuff.rp != RxBuff.wp)
{
rtflg = 1;
printf("RxBuff.rp=%d,RxBuff.wp=%d\r\n",RxBuff.rp,RxBuff.wp);
if(RxBuff.rp<RxBuff.wp)
{
for(*psize=0;*psize<(RxBuff.wp-RxBuff.rp);(*psize)++)
{
pbuff[(*psize)] = RxBuff.rxarr[RxBuff.rp+(*psize)];
}
RxBuff.rp = RxBuff.wp;
}
else
{
for((*psize)=0;RxBuff.rp<RXBUFFSIZE;RxBuff.rp++)
{
pbuff[(*psize)] = RxBuff.rxarr[RxBuff.rp];
(*psize)++;
}
RxBuff.rp = 0;
while(RxBuff.rp<RxBuff.wp)
{
pbuff[(*psize)] = RxBuff.rxarr[RxBuff.rp];
(*psize)++;
RxBuff.rp++;
}
}
}
return rtflg;
}
但是，如果仅仅这样的话，设想一下，如果帧1处理的时间比较长，此时rp=wp（数据读取的时间很短，不考虑在读取的时候又接收到下一帧这种情况），这时候后面帧2、帧3、帧4来了，而你帧1还没有处理完，如此一来，rp还是指向帧1的末尾（即帧2的起始），但wp指向的却是帧4的末尾，等下一次帧处理的时候，帧2/帧3/帧4被当成一帧了。如下图：
这时候还使用上面那一种方式读取的话，帧2/3/4被当做一帧。
如何避免这种情况的发生？如果我们记录每一个到达帧的起始地址（rp）和结束地址（wp），再具备一个记录当前正在处理帧（currfra）与一个最新到达帧（nextfra），也就是说建立第二个帧属性的队列，在这个队列中记录了每个帧的属性。
这样的话，来了一个新的帧，即便我帧1还没有处理完，但是我可以记录帧2的属性（在串口接收缓冲区的起始地址rp与结束地址wp）、帧3、帧4；之后等帧1处理完之后，可以根据currfra的索引处理帧2、帧3、帧4，一直等待执行到currfra == nextfra，则说明所有的帧都处理完成，这种方法需要要求串口接收缓冲区足够大，不会使后面到达的帧破坏前面帧的数据。一般能同时存十个帧的大小就够用，自己估计下。
所以就使用到了后面的两个结构体：
/**帧地址结构体**/
typedef struct __FRAMEADDR
{
uint16_t wpx; //本帧写地址的索引
uint16_t rpx; //本帧读地址的索引
}_FRAMEADDR;
#define FRADDRMAX 10 //最多能记录的帧
/**帧属性结构体**/
typedef struct __FRAMEATTRI
{
_FRAMEADDR fraddr[FRADDRMAX]; //每帧的地址，队列主体
uint8_t currfra; //当前处理帧
uint8_t nextfra; //下一个帧
}_FRAMEATTRI;
定义帧属性队列：
_FRAMEATTRI g_Fra;
全新串口空闲中断调用函数修改如下：
/*在串口空闲中断中调用*/
void USART1IDLE_IRQ(void)
{
uint16_t trnum=0;
USART1->SR;
USART1->DR;
//手册虽然说这个寄存器在DMA循环模式的时候，清0之后会自动恢复为最大接收缓冲区，但加入这一步以防万一
if(USART1RX_DMA_CHANNEL->CNDTR == 0)
{
trnum = RXBUFFSIZE;
}
else
{
trnum = USART1RX_DMA_CHANNEL->CNDTR&0xffff;
}
RxBuff.wp = RXBUFFSIZE-trnum; //得到最新帧的结束地址
g_Fra.fraddr[g_Fra.nextfra].rpx = RxBuff.rp; //最新帧的起始地址
g_Fra.fraddr[g_Fra.nextfra].wpx = RxBuff.wp; //最新帧的结束地址
g_Fra.nextfra = (g_Fra.nextfra+1)%FRADDRMAX; //g_Fra.nextfra的值被限制再0,1....(FRADDRMAX-1)
RxBuff.rp = RxBuff.wp; //最新帧的起始与结束地址记录完，等待下一次记录
}
在空闲中断中，在帧属性队列主体中记录最新一帧的起始，结束地址；
获取一帧数据函数如下：
/**
* @brief GetAFra--获取一帧数据
* @param pbuff--获取一帧数据的数组，psize--获取的数目
* @retval rtflg--0代表没有获取数据，1代表获取到数据
*/
uint8_t GetAFra(uint8_t *pbuff,uint8_t *psize)
{
uint8_t rtflg=0; //返回值
uint16_t fralen=0; //帧长度
if(g_Fra.currfra != g_Fra.nextfra) //如果为真，说明有未处理的帧
{
// printf("RxBuff.rp=%d,RxBuff.wp=%d\r\n",RxBuff.rp,RxBuff.wp);
// printf("currfra=%d,nextfra=%d\r\n",g_Fra.currfra,g_Fra.nextfra);
/*根据每帧的帧属性(起始与结束地址)在串口接收缓冲区主体中获取一帧数据*/
if(g_Fra.fraddr[g_Fra.currfra].rpx<g_Fra.fraddr[g_Fra.currfra].wpx)
{
fralen = g_Fra.fraddr[g_Fra.currfra].wpx-g_Fra.fraddr[g_Fra.currfra].rpx;
for((*psize)=0;(*psize)<fralen;(*psize)++)
{
pbuff[(*psize)] = RxBuff.rxarr[g_Fra.fraddr[g_Fra.currfra].rpx+(*psize)];
}
g_Fra.fraddr[g_Fra.currfra].rpx=g_Fra.fraddr[g_Fra.currfra].wpx;
}
else
{
for((*psize)=0;g_Fra.fraddr[g_Fra.currfra].rpx<RXBUFFSIZE;g_Fra.fraddr[g_Fra.currfra].rpx++)
{
pbuff[(*psize)] = RxBuff.rxarr[g_Fra.fraddr[g_Fra.currfra].rpx];
(*psize)++;
}
g_Fra.fraddr[g_Fra.currfra].rpx = 0;
while(g_Fra.fraddr[g_Fra.currfra].rpx<g_Fra.fraddr[g_Fra.currfra].wpx)
{
pbuff[(*psize)] = RxBuff.rxarr[g_Fra.fraddr[g_Fra.currfra].rpx];
(*psize)++;
g_Fra.fraddr[g_Fra.currfra].rpx++;
}
}
g_Fra.currfra = (g_Fra.currfra+1)%FRADDRMAX;
// printf("currfra=%d,nextfra=%d\r\n",g_Fra.currfra,g_Fra.nextfra);
rtflg = 1;
}
return rtflg;
}
获取数据时有两种情况，一种是rp<wp，如下图所示
说明帧数据就在rp 与wp的地址中间，另外一种就是wp<rp,如下图所示：
数据需要分两段提取。
测试函数如下：
flg = GetAFra(arr,&getsize);
if(flg!=0)
{
if(test==8)
{
test = 0;
}
if(test == 0)
{
Delay(0x1ffffff);
}
test++;
printf("getsize=%d\r\n",getsize);
for(temp=0;temp<getsize;temp++)
{
printf("%d ",arr[temp]);
}
printf("\r\n");
getsize = 0;
}
就是将获取到的数据打印出来。
如图中所示：当我们获取了第一帧之后，因为加入了一个延时，模拟第一帧处理时间过长，这时候来了帧2,3,4,5，但我们能依次获取后面的4个帧。
大爷的，本来想上传工程赚几个积分，一直传不上，这就很烦。源码如下：
bsp_usart_dma.c
/*******************************************************
*设计：陈文德
*版本：V1.0
*******************************************************/
#include "bsp_usart_dma.h"
_USART1RXBUFF RxBuff; //定义串口接收缓冲区
_FRAMEATTRI g_Fra;
/**
* @brief 配置嵌套向量中断控制器NVIC
* @param 无
* @retval 无
*/
static void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
/* 嵌套向量中断控制器组选择 */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
/* 配置USART为中断源 */
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
/* 抢断优先级*/
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
/* 子优先级 */
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
/* 使能中断 */
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
/* 初始化配置NVIC */
NVIC_Init(&NVIC_InitStructure);
}
/**
* @brief USART GPIO 配置,工作参数配置
* @param 无
* @retval 无
*/
void USART_Config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
// 打开串口GPIO的时钟
DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
// 打开串口外设的时钟
DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
// 将USART Tx的GPIO配置为推挽复用模式
GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
// 将USART Rx的GPIO配置为浮空输入模式
GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);
// 配置串口的工作参数
// 配置波特率
USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
// 配置 针数据字长
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(DEBUG_USARTx, &USART_InitStructure);
// 串口中断优先级配置
NVIC_Configuration();
// 使能串口接收中断
USART_ITConfig(DEBUG_USARTx, USART_IT_IDLE, ENABLE);
// 使能串口
USART_Cmd(DEBUG_USARTx, ENABLE);
}
/**
* @brief USARTx DMA 配置
* @param 无
* @retval 无
*/
void USART1_DMA_Config(void)
{
DMA_InitTypeDef DMA_InitStructure;
// 开启DMA时钟
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
// // 设置DMA源地址：串口数据寄存器地址*/
// DMA_InitStructure.DMA_PeripheralBaseAddr = USART_DR_ADDRESS;
// // 内存地址(要传输的变量的指针)
// DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
// // 方向：从内存到外设
// DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
// // 传输大小
// DMA_InitStructure.DMA_BufferSize = SENDBUFF_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模式，一次或者循环模式
// DMA_InitStructure.DMA_Mode = DMA_Mode_Normal ;
// //DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
// // 优先级：中
// DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
// // 禁止内存到内存的传输
// DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
// // 配置DMA通道
// DMA_Init(USART_TX_DMA_CHANNEL, &DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = USART_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)RxBuff.rxarr; //串口接收基地址
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = RXBUFFSIZE; //接收缓冲区的大小
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_Circular ; //循环模式
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(USART1RX_DMA_CHANNEL, &DMA_InitStructure);
// 使能DMA
// DMA_Cmd (USART_TX_DMA_CHANNEL,ENABLE);
DMA_Cmd (USART1RX_DMA_CHANNEL,ENABLE);
USART_DMACmd(DEBUG_USARTx,USART_DMAReq_Rx,ENABLE);
}
void USART1Var_Init(void)
{
RxBuff.rp = 0;
RxBuff.wp = 0;
g_Fra.currfra = 0;
g_Fra.nextfra = 0;
}
void USART1_Init(void)
{
USART1Var_Init();
USART_Config();
USART1_DMA_Config();
}
/***************** 发送一个字节 **********************/
void Usart_SendByte( USART_TypeDef * pUSARTx, uint8_t ch)
{
/* 发送一个字节数据到USART */
USART_SendData(pUSARTx,ch);
/* 等待发送数据寄存器为空 */
while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
}
/****************** 发送8位的数组 ************************/
void Usart_SendArray( USART_TypeDef * pUSARTx, uint8_t *array, uint16_t num)
{
uint8_t i;
for(i=0; i<num; i++)
{
/* 发送一个字节数据到USART */
Usart_SendByte(pUSARTx,array[i]);
}
/* 等待发送完成 */
while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET);
}
/***************** 发送字符串 **********************/
void Usart_SendString( USART_TypeDef * pUSARTx, char *str)
{
unsigned int k=0;
do
{
Usart_SendByte( pUSARTx, *(str + k) );
k++;
} while(*(str + k)!='\0');
/* 等待发送完成 */
while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET)
{}
}
/***************** 发送一个16位数 **********************/
void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch)
{
uint8_t temp_h, temp_l;
/* 取出高八位 */
temp_h = (ch&0XFF00)>>8;
/* 取出低八位 */
temp_l = ch&0XFF;
/* 发送高八位 */
USART_SendData(pUSARTx,temp_h);
while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
/* 发送低八位 */
USART_SendData(pUSARTx,temp_l);
while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
}
///重定向c库函数printf到串口，重定向后可使用printf函数
int fputc(int ch, FILE *f)
{
/* 发送一个字节数据到串口 */
USART_SendData(DEBUG_USARTx, (uint8_t) ch);
/* 等待发送完毕 */
while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);
return (ch);
}
///重定向c库函数scanf到串口，重写向后可使用scanf、getchar等函数
int fgetc(FILE *f)
{
/* 等待串口输入数据 */
while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);
return (int)USART_ReceiveData(DEBUG_USARTx);
}
/**
* @brief USART1IDLE_IRQ--在空闲中断中调用
* @param 无
* @retval 无
*/
void USART1IDLE_IRQ(void)
{
uint16_t trnum=0;
USART1->SR;
USART1->DR;
//手册虽然说这个寄存器在DMA循环模式的时候，清0之后会自动恢复为最大接收缓冲区，但加入这一步以防万一
if(USART1RX_DMA_CHANNEL->CNDTR == 0)
{
trnum = RXBUFFSIZE;
}
else
{
trnum = USART1RX_DMA_CHANNEL->CNDTR&0xffff;
}
RxBuff.wp = RXBUFFSIZE-trnum; //得到最新帧的结束地址
g_Fra.fraddr[g_Fra.nextfra].rpx = RxBuff.rp; //最新帧的起始地址
g_Fra.fraddr[g_Fra.nextfra].wpx = RxBuff.wp; //最新帧的结束地址
g_Fra.nextfra = (g_Fra.nextfra+1)%FRADDRMAX; //g_Fra.nextfra的值被限制再0,1....(FRADDRMAX-1)
RxBuff.rp = RxBuff.wp; //最新帧的起始与结束地址记录完，等待下一次记录
}
/**
* @brief GetAFra--获取一帧数据
* @param pbuff--获取一帧数据的数组，psize--获取的数目
* @retval rtflg--0代表没有获取数据，1代表获取到数据
*/
uint8_t GetAFra(uint8_t *pbuff,uint8_t *psize)
{
uint8_t rtflg=0; //返回值
uint16_t fralen=0; //帧长度
if(g_Fra.currfra != g_Fra.nextfra) //如果为真，说明有未处理的帧
{
printf("RxBuff.rp=%d,RxBuff.wp=%d\r\n",RxBuff.rp,RxBuff.wp);
printf("currfra=%d,nextfra=%d\r\n",g_Fra.currfra,g_Fra.nextfra);
/*根据每帧的帧属性(起始与结束地址)在串口接收缓冲区主体中获取一帧数据*/
if(g_Fra.fraddr[g_Fra.currfra].rpx<g_Fra.fraddr[g_Fra.currfra].wpx)
{
fralen = g_Fra.fraddr[g_Fra.currfra].wpx-g_Fra.fraddr[g_Fra.currfra].rpx;
for((*psize)=0;(*psize)<fralen;(*psize)++)
{
pbuff[(*psize)] = RxBuff.rxarr[g_Fra.fraddr[g_Fra.currfra].rpx+(*psize)];
}
g_Fra.fraddr[g_Fra.currfra].rpx=g_Fra.fraddr[g_Fra.currfra].wpx;
}
else
{
for((*psize)=0;g_Fra.fraddr[g_Fra.currfra].rpx<RXBUFFSIZE;g_Fra.fraddr[g_Fra.currfra].rpx++)
{
pbuff[(*psize)] = RxBuff.rxarr[g_Fra.fraddr[g_Fra.currfra].rpx];
(*psize)++;
}
g_Fra.fraddr[g_Fra.currfra].rpx = 0;
while(g_Fra.fraddr[g_Fra.currfra].rpx<g_Fra.fraddr[g_Fra.currfra].wpx)
{
pbuff[(*psize)] = RxBuff.rxarr[g_Fra.fraddr[g_Fra.currfra].rpx];
(*psize)++;
g_Fra.fraddr[g_Fra.currfra].rpx++;
}
}
g_Fra.currfra = (g_Fra.currfra+1)%FRADDRMAX;
printf("currfra=%d,nextfra=%d\r\n",g_Fra.currfra,g_Fra.nextfra);
rtflg = 1;
}
return rtflg;
}
/**
* @brief JustAFra获取一帧数据
* @param pbuff--获取一帧数据的数组，psize--获取的数目
* @retval rtflg--0代表没有获取数据，1代表获取到数据
*/
uint8_t JustAFra(uint8_t *pbuff,uint8_t *psize)
{
uint8_t rtflg=0;
if(RxBuff.rp != RxBuff.wp)
{
rtflg = 1;
printf("RxBuff.rp=%d,RxBuff.wp=%d\r\n",RxBuff.rp,RxBuff.wp);
if(RxBuff.rp<RxBuff.wp)
{
for(*psize=0;*psize<(RxBuff.wp-RxBuff.rp);(*psize)++)
{
pbuff[(*psize)] = RxBuff.rxarr[RxBuff.rp+(*psize)];
}
RxBuff.rp = RxBuff.wp;
}
else
{
for((*psize)=0;RxBuff.rp<RXBUFFSIZE;RxBuff.rp++)
{
pbuff[(*psize)] = RxBuff.rxarr[RxBuff.rp];
(*psize)++;
}
RxBuff.rp = 0;
while(RxBuff.rp<RxBuff.wp)
{
pbuff[(*psize)] = RxBuff.rxarr[RxBuff.rp];
(*psize)++;
RxBuff.rp++;
}
}
}
return rtflg;
}
bsp_usart_dma.h：
/*******************************************************
*设计：陈文德
*版本：V1.0
*******************************************************/
#ifndef __USARTDMA_H
#define __USARTDMA_H
#include "stm32f10x.h"
#include <stdio.h>
// 串口工作参数宏定义
#define DEBUG_USARTx USART1
#define DEBUG_USART_CLK RCC_APB2Periph_USART1
#define DEBUG_USART_APBxClkCmd RCC_APB2PeriphClockCmd
#define DEBUG_USART_BAUDRATE 115200
// USART GPIO 引脚宏定义
#define DEBUG_USART_GPIO_CLK (RCC_APB2Periph_GPIOA)
#define DEBUG_USART_GPIO_APBxClkCmd RCC_APB2PeriphClockCmd
#define DEBUG_USART_TX_GPIO_PORT GPIOA
#define DEBUG_USART_TX_GPIO_PIN GPIO_Pin_9
#define DEBUG_USART_RX_GPIO_PORT GPIOA
#define DEBUG_USART_RX_GPIO_PIN GPIO_Pin_10
// 串口对应的DMA请求通道
#define USART_TX_DMA_CHANNEL DMA1_Channel4
#define USART1RX_DMA_CHANNEL DMA1_Channel5
// 外设寄存器地址
#define USART_DR_ADDRESS (USART1_BASE+0x04)
// 一次发送的数据量
#define SENDBUFF_SIZE 500
#define RXBUFFSIZE 50 //接收缓冲区的大小
/**串口接收缓冲区**/
typedef struct __USART1RXBUFF
{
uint16_t wp; //接收缓冲区写地址
uint16_t rp; //接收缓冲区的读地址
uint8_t rxarr[RXBUFFSIZE]; //接收缓冲区实体
}_USART1RXBUFF;
/**帧地址结构体**/
typedef struct __FRAMEADDR
{
uint16_t wpx; //本帧写地址的索引
uint16_t rpx; //本帧读地址的索引
}_FRAMEADDR;
#define FRADDRMAX 10 //最多能记录的帧
/**帧属性结构体**/
typedef struct __FRAMEATTRI
{
_FRAMEADDR fraddr[FRADDRMAX]; //每帧的地址，队列主体
uint8_t currfra; //当前处理帧
uint8_t nextfra; //下一个帧
}_FRAMEATTRI;
void USART1_Init(void);
void USART1IDLE_IRQ(void);
uint8_t GetAFra(uint8_t *pbuff,uint8_t *psize);
uint8_t JustAFra(uint8_t *pbuff,uint8_t *psize);
#endif /* __USARTDMA_H */
main.c
#include "stm32f10x.h"
#include "bsp_usart_dma.h"
static void Delay(__IO u32 nCount);
/**
* @brief 主函数
* @param 无
* @retval 无
*/
int main(void)
{
static uint8_t arr[10];
static uint8_t getsize=0;
static uint8_t test = 0;
uint16_t temp;
uint8_t flg;
/* 初始化USART */
USART1_Init();
while(1)
{
flg = GetAFra(arr,&getsize);
if(flg!=0)
{
if(test==8)
{
test = 0;
}
if(test == 0)
{
Delay(0x2ffffff);
}
test++;
printf("getsize=%d\r\n",getsize);
for(temp=0;temp<getsize;temp++)
{
printf("%d ",arr[temp]);
}
printf("\r\n");
getsize = 0;
}
}
}
static void Delay(__IO uint32_t nCount) //简单的延时函数
{
for(; nCount != 0; nCount--);
}