怎么判断单片机串口接收不定长数据这一包数据接收完成了呢

将以前做过的蓝牙和超声波结合就得到蓝牙无线超声波测距
通过hc05蓝牙模块使手机和stm32开发板能互相发送字符串——DMA&空闲中断
stm32f103之HC_SR04超声波测距
在正点原子MINI板上两个未使用到的引脚作为IO口，一个作为输入，接超声波的ECHO引脚，一个作为输出接超声波的TRIG引脚，选择了PA11和PA12，只在超声波头文件更改就行





”hc.sr04.h“代码：

#ifndef __HC_H
#define __HC_H         
#include "sys.h"


#define HCSR04_PORT     GPIOA
#define HCSR04_CLK      RCC_APB2Periph_GPIOA
#define HCSR04_TRIG     GPIO_Pin_11
#define HCSR04_ECHO     GPIO_Pin_12


#define TRIG_Send  PAout(11)
#define ECHO_Reci  PAin(12)




void HC_Init(void);
void OpenTimer_Hc(void);
void CloseTimer_Hc(void);
double GetEchoTimeMs_Hc(void);
void Trig_Hc(void);
double GetLength_Hc(void);
                                                     
#endif


超声波.c文件不变
”hc.sr04.c“代码：


#include "hc_sr04.h"
#include "timer.h"
#include "delay.h"
/*
用Trig和Echo引脚实现测距的流程：
1.通过Trig输出一段至少10us的高电平（脉冲），触发一次测距，超声波在传输的过程中Echo一直输出高电平。
2.在Trig脉冲输出后，立即检测Echo引脚的电平，测出Echo高电平持续的时间t，t就是超声波在所测距离一个来回所需时间。
*/
/*
#define HCSR04_PORT     GPIOA
#define HCSR04_CLK      RCC_APB2Periph_GPIOA
#define HCSR04_TRIG     GPIO_Pin_11
#define HCSR04_ECHO     GPIO_Pin_12


#define TRIG_Send  PAout(11)
#define ECHO_Reci  PAin(12)
*/


void HC_Init(void)
{
GPIO_InitTypeDef  GPIO_InitStructure;       
RCC_APB2PeriphClockCmd(HCSR04_CLK, ENABLE);         //使能时钟
        //触发引脚，推挽输出
GPIO_InitStructure.GPIO_Pin = HCSR04_TRIG;                 //端口配置
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;         //IO口速度为50MHz
GPIO_Init(HCSR04_PORT, &GPIO_InitStructure);                        //
GPIO_ResetBits(HCSR04_PORT,HCSR04_TRIG);                 //默认拉低
   //回应引脚，浮空输入
GPIO_InitStructure.GPIO_Pin = HCSR04_ECHO;                   //
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //
GPIO_Init(HCSR04_PORT, &GPIO_InitStructure);                                           //IO口速度为50MHz
GPIO_ResetBits(HCSR04_PORT,HCSR04_ECHO);                 //默认拉低
       
TIM3_Int_Init(1000-1,72-1);//1Mhz的计数频率，1us计数一次，计数到1000为1ms,产生一次溢出中断  
}

void OpenTimer_Hc(void)
{//每次开始的时候清空
        TIM_SetCounter(TIM3,0);//Counter值清零
        HcCountMs=0;//溢出次数清零
        TIM_Cmd(TIM3, ENABLE);  //使能TIM3外设       
}


void CloseTimer_Hc(void)
{
        TIM_Cmd(TIM3, DISABLE);  //使能TIM3外设       
}


double GetEchoTimeMs_Hc(void)
{
        double t=0;
        t=TIM_GetCounter(TIM3)/1000.0; //us换算成ms
        t+=HcCountMs;//直接用ms计算,算出总的时间,单位ms
        //delay_us(50);
        return t;
}
//通过Trig输出一段至少10us的高电平（脉冲），触发一次测距
void Trig_Hc(void)
{
        TRIG_Send=1;
        delay_us(15);//15us
        TRIG_Send=0;
}
double GetLength_Hc(void)
{
        double t=0;
        int i=0;
        double lengthTemp=0;
        double sum=0;       
        while(i!=5)//循环5次
        {
                Trig_Hc();//触发超声波模块测距
                while(ECHO_Reci!=1);//等待高电平（低电平就执行，高电平退出）
                OpenTimer_Hc();//此时进入高电平，开启定时器计数
                while(ECHO_Reci==1);//等待低电平（高电平就执行，低电平退出）
                CloseTimer_Hc();//关闭定时器，停止计数
                t=GetEchoTimeMs_Hc();//单位ms
                lengthTemp=(t/2.0)*344;//单位mm,344m/s=344*1000mm/1000ms=344mm/ms
                sum+=lengthTemp;                       
                i=i+1;
        }
        lengthTemp=sum/5.0;//单位mm
        return lengthTemp;       
}


超声波是用定时器3来计算高电平持续时间的，这个时间也就声波往返的总时间
定时器配置如下：
“timer.h”


#ifndef __TIMER_H
#define __TIMER_H
#include "sys.h"
extern u16 HcCountMs;


void TIM3_Int_Init(u16 arr,u16 psc);

#endif




“timer.c”


#include "timer.h"


u16 HcCountMs=0;
void TIM3_Int_Init(u16 arr,u16 psc)
{
  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
        NVIC_InitTypeDef NVIC_InitStructure;


        RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); //时钟使能


        TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值         计数到5000为500ms
        TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值  10Khz的计数频率  
        TIM_TimeBaseStructure.TIM_ClockDivision = 0; //设置时钟分割:TDTS = Tck_tim
        TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
        TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位

        TIM_ITConfig(TIM3, TIM_IT_Update,ENABLE);//使能更新中断，当溢出时产生中断
       
        NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  //TIM3中断
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  //先占优先级0级
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;  //从优先级3级
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
        NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器


        TIM_Cmd(TIM3, ENABLE);  //使能TIMx外设                                                 
}


void TIM3_IRQHandler(void)   //TIM3中断，一个节拍1us,共1000个节拍，即1ms中断一次
{
        if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET) //检查指定的TIM中断发生与否:溢出中断（更新中断）
                {
                        TIM_ClearITPendingBit(TIM3, TIM_IT_Update  );  //清除TIMx的中断待处理位:TIM 中断源
                        HcCountMs++;
                }
}


DMA作为数据的搬运工，搬运串口接收到的数据，和上文一样，代码不改

“dma.c”


#include "dma.h"
/*从串口1的DR把数据一个一个搬到指定位置，不确定具体有多少个数据需要
当一帧数据搬完后，产生空闲中断，再把搬了多少个数据确定：
USART_Rx_Plan_SIZE（要你搬多少个）-还剩多少个（中断之后还剩多少个）=（中断之前）已经搬了多少个
buff_length=USART_Rx_Plan_SIZE-DMA_GetCurrDataCounter(DMA1_Channel5);
*/


u8 US1_RXDate[buffer_size];
u8 USART_Rx_Plan_SIZE=Plan_SIZE;
void MYDMA_Init(void)
{
        DMA_InitTypeDef DMA_InitStruct;
        RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);        //使能DMA传输
        DMA_DeInit(DMA1_Channel5);
       
  DMA_InitStruct.DMA_PeripheralBaseAddr=(u32)&USART1->DR;
        DMA_InitStruct.DMA_PeripheralDataSize=DMA_PeripheralDataSize_Byte;
        DMA_InitStruct.DMA_MemoryBaseAddr=(u32)US1_RXDate;
        DMA_InitStruct.DMA_MemoryDataSize=DMA_MemoryDataSize_Byte;
        DMA_InitStruct.DMA_BufferSize=USART_Rx_Plan_SIZE;
        DMA_InitStruct.DMA_DIR=DMA_DIR_PeripheralSRC;//外设到内存
        DMA_InitStruct.DMA_M2M=DMA_M2M_Disable;
  DMA_InitStruct.DMA_Mode=DMA_Mode_Normal;
        DMA_InitStruct.DMA_MemoryInc=DMA_MemoryInc_Enable;
        DMA_InitStruct.DMA_PeripheralInc=DMA_PeripheralInc_Disable;
        DMA_InitStruct.DMA_Priority=DMA_Priority_High ;
        DMA_Init(DMA1_Channel5, &DMA_InitStruct);


        USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);//使能串口MDA
        DMA_Cmd(DMA1_Channel5, ENABLE);  //使能USART1 TX DMA1 所指示的通道
}


“dma.h”


#ifndef __DMA_H
#define __DMA_H         
#include "sys.h"


#define buffer_size 20//申请20个字节的数组空间，当缓冲区
#define Plan_SIZE 50//计划最多搬50个字节
extern u8 US1_RXDate[buffer_size];
extern u8 USART_Rx_Plan_SIZE;


void MYDMA_Init(void);//初始化


#endif


"usart.h"不变


#ifndef __USART_H
#define __USART_H
#include "stdio.h"       
#include "sys.h"


#define EN_USART1_RX                         1                //使能（1）/禁止（0）串口1接收


extern u16 USART_RX_flag;
extern u8 size;
       


void uart_init(u32 bound);
#endif


"usart.c"不变


#include "sys.h"
#include "usart.h"       
#include "led.h"
#include "delay.h"
#include "dma.h"
/*


*/
#if SYSTEM_SUPPORT_OS
#include "includes.h"                                        //ucos 使用          
#endif


//加入以下代码,支持printf函数,而不需要选择use MicroLIB          
#if 1
#pragma import(__use_no_semihosting)            
//标准库需要的支持函数                 
struct __FILE
{
        int handle;


};


FILE __stdout;      
//定义_sys_exit()以避免使用半主机模式   
_sys_exit(int x)
{
        x = x;
}
//重定义fputc函数
int fputc(int ch, FILE *f)
{      
        while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
    USART1->DR = (u8) ch;      
        return ch;
}
#endif


#if EN_USART1_RX   //如果使能了接收        


u16 USART_RX_flag=0;
u8 size=0;


void uart_init(u32 bound)
{
  //GPIO端口设置
  GPIO_InitTypeDef GPIO_InitStructure;
        USART_InitTypeDef USART_InitStructure;
        NVIC_InitTypeDef NVIC_InitStructure;
         
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
  
        //USART1_TX   GPIOA.9
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
  GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
   
  //USART1_RX          GPIOA.10初始化
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  


  //Usart1 NVIC 配置
  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
        NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器
  
  //USART 初始化设置
        USART_InitStructure.USART_BaudRate = bound;//串口波特率
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
        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(USART1, &USART_InitStructure); //初始化串口1
       


        USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口空闲中断


  USART_Cmd(USART1, ENABLE);                    //使能串口1
}


void USART1_IRQHandler(void)                        //串口1中断服务程序
{
        /* 接收的数据长度 */
  u8 buff_length;
        if(USART_GetITStatus(USART1,USART_IT_IDLE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
                {
                        //关闭DMA
                        DMA_Cmd(DMA1_Channel5, DISABLE);
                        buff_length=USART_Rx_Plan_SIZE-DMA_GetCurrDataCounter(DMA1_Channel5);
                        size=buff_length;//双缓冲区
                        DMA_SetCurrDataCounter(DMA1_Channel5,USART_Rx_Plan_SIZE);//DMA通道的DMA缓存的大小
                   DMA_Cmd(DMA1_Channel5, ENABLE);  //使能USART1 RX DMA1 所指示的通道
      //读操作，清空中断标志，USART_IT_IDLE
                  USART1->SR;
                        USART1->DR;
                  USART_RX_flag=1;//标记接收完成
                }
}


#endif       


主函数加了几句代码：


#include "led.h"
#include "delay.h"
#include "sys.h"
#include "usart.h"
#include "lcd.h"
#include "key.h"
#include "dma.h"
#include "hc_sr04.h"
#include "timer.h"


#include


/*
原理：利用串口的空闲中断和DMA搬运工
USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);//开启串口空闲中断


单片机串口接收不定长数据时，必须面对的一个问题为：怎么判断这一包数据接收完成了呢？
常见的方法主要有以下几种：
1.串口接收非空中断+在接收每个字节时启动一个定时器，在指定时间间隔内没有接收到新字节，认为数据接收完成；
2.在数据中加入帧头、帧尾，通过在程序中判断是否接收到帧尾来确定数据接收完毕或者像正点原子代码一样
，用回车换行0xod,oxoa来作为结尾
3.串口接收非空中断+串口空闲中断,每收到一个字节产生一次串口接收非空中断，
当所有字符（一帧数据）接收完毕，产生一次串口空闲中断，在中断函数标记一下，
然后主函数处理数据，记得将标记清除。
上面3种方法的缺点为，需要主程序来判断和处理，不停产生中断，打扰其他程序运行，对主程序造成不小压力。
4.串口空闲中断+DMA（DR运到内存）
本实验是第四种方式：最好的一种
空闲中断的工作原理为：
当STM32的串口接收完一包数据后，会产生一个空闲中断。这个中断在串口其他任何状态都不产生，
只会在接收完一包数据后才会产生，一包数据可以是1个字节或者多个字节。
因此，我们可以在这个空闲中断函数中，设置一个接收完成标志位。
那么，我们只需要在主程序中检测这个标志位就知道数据是否接收完成了。
实验原理：开启DMA搬运串口DR寄存器收到的字节，每次搬运一个字节Counter（（DMA_GetCurrDataCounter(DMA1_Channel5);）减一，
初始化时计划搬运字节为USART_Rx_Plan_SIZE，实际接收的数据并没计划的字节数大，所以实际接收的数据一般完，就产生串口空闲中断，
在串口中断函数中，将DMA搬运工停止搬运，得出实际搬运的字节数，传给主函数，再让DMA重新开始搬运，
主函数中根据实际长度，在数组后面插入字符串结束符‘’,得到一个完整的字符串。
USART_Rx_Plan_SIZE减去Counter就等于实际搬运的size。
*/
int main(void)
{
        u8 key=0;
        u8 num=0;
        u8 HC_Sr04_Data[12];       
        delay_init();                     //延时函数初始化       
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);// 设置中断优先级分组2         
        uart_init(115200);                 //串口初始化为115200
        LED_Init();                                  //初始化与LED连接的硬件接口
        LCD_Init();
        KEY_Init();
        MYDMA_Init();
        HC_Init();
  POINT_COLOR=RED;
        LCD_ShowString(0,170,200,24,24,"start HC!");                                              
        LCD_ShowString(100,290,200,24,24,"2021/1/14");          
  LED0=1;
  while(1)
        {        /*板子发送一帧数据给手机*/
                key=KEY_Scan(0);
                if(key)
                {
                        switch(key)
                        {
                                case KEY0_PRES :   num++; printf("%srn","KEY0"); break;
                                case KEY1_PRES :   num--;  printf("%srn","KEY1"); break;
                                case WKUP_PRES :   num=0; printf("%srn","WKUP");  break;
                        }
          }               
                sprintf((char*)HC_Sr04_Data,"Distance:%.2fmm",GetLength_Hc());//将数据以指定的字符串格式打印到数组
           LCD_Fill(120,220,230,220+24,WHITE);
                LCD_ShowString(0,200,230,24,24,"HC_Sr04_Data:");       
                LCD_ShowString(0,230,230,24,24,HC_Sr04_Data);        //显示超声波数据
                printf("%srn",HC_Sr04_Data);
                delay_ms(100);//每100ms采集5次


                if(USART_RX_flag==1)//接收到一帧数据
                {                                       
                        LCD_ShowString(30,100,200,24,24,"Receive Data:");               
                        LCD_Fill(30,130,239,170+24,WHITE);
                        LED0=!LED0;
                        US1_RXDate[size]='';        //插入字符串结束符       
                        LCD_ShowString(30,130,200,24,24,US1_RXDate);       
                        //切记清空标志和大小还有空间，准备下次接收
      USART_RX_flag=0;       
                        memset(US1_RXDate,0,buffer_size);//需要清空，再装新数据，否则新旧都在一起
                }


        }         
}