精华内容
下载资源
问答
  • 基于stm32f103rct6的外部中断超声波测距,本测距方案稳定性高,不容易出现数据波动,测距范围在2-500cm左右,自带串口printf输出测试距离
  • 电子-超声波测距外部中断.zip,单片机/嵌入式STM32-F0/F1/F2
  • 电子-超声波测距外部中断需要进一步分析.zip,单片机/嵌入式STM32-F0/F1/F2
  • 使用STM32的定时器与外部中断配合实现超声波模块的测距功能。 这里总体说一说此程序比较理想的执行情况: (1)超声波被调用初始化函数,定时器被设定为可中断,并且定时器开始计数; (2)计数到溢出,触发定时器...
  • 基于STM32的超声波测距外部中断+定时器)

    千次阅读 多人点赞 2020-10-09 10:21:28
    基于STM32F103的超声波测距(定时器) 使用的硬件设备:stm32f103c8t6,0.96寸OLED,超声波模块HC-SR04 废话不多说,上程序就对了(亲测有效) 超声波模块ultrasound.h文件 #ifndef __ULTRASOUND_H #define __ULTRASOUND...

    基于STM32的超声波测距(外部中断+定时器)

    首先说明一下我使用的硬件:
    stm32f103c8t6最小系统、0.96寸OLED、超声波模块HC-SR04。

    再就是程序设计的一个思路:
    超声波模块的使用说明已经指出,给TRIG引脚一个不少于10微秒的高电平,模块自动发送8个40KHz的方波,接收到返回信号后引脚ECHO会输出高电平,其距离为ECHO引脚高电平时间*声速/2,每次测量间隔建议60ms以上。由此,我们可提取到需要使用到的三个芯片功能:1、定时器,2、外部中断,3、IO输出。

    下面是配置代码,进行一一介绍(不想看我哔哔的最下方有完整得超声波配置.c和.h +_+ ):
    1、外部中断和IO输出都是使用的GPIO所以使用一个配置函数
    1.1 GPIO宏定义参数:

    //超声波模块引脚配置
    #define ULTRASOUND_GPIO 						GPIOA
    #define ULTRASOUND_GPIO_CLK 				RCC_APB2Periph_GPIOA
    #define ULTRASOUND_TRIG 						GPIO_Pin_1
    #define ULTRASOUND_ECHO 						GPIO_Pin_0
    
    //超声波模块ECHO中断配置
    #define ULTRASOUND_GPIOSourceGPIO   GPIO_PortSourceGPIOA
    #define ULTRASOUND_PINSOURCE        GPIO_PinSource0
    #define ULTRASOUND_EXTI_LINE				EXTI_Line0
    #define ULTRASOUND_EXTI_IRQHandler  EXTI0_IRQHandler	//ECHO引脚中断服务函数
    

    1.2 GPIO端口配置函数Ultrasound_GPIO_Conf():
    这里要注意,中断的触发方式为上下边沿,用处在中断服务函数里面体现。

    static void Ultrasound_GPIO_Conf(void)//端口配置
    {
    	EXTI_InitTypeDef EXTI_InitStructure;
    	GPIO_InitTypeDef GPIO_InitStructure;
    	NVIC_InitTypeDef NVIC_InitStructure;
    	
    	RCC_APB2PeriphClockCmd(ULTRASOUND_GPIO_CLK | RCC_APB2Periph_AFIO,ENABLE);//打开GPIOA和端口复用时钟
    	
    	GPIO_EXTILineConfig(ULTRASOUND_GPIOSourceGPIO,ULTRASOUND_PINSOURCE);//配置中断线A-0
    	
    	GPIO_InitStructure.GPIO_Pin = ULTRASOUND_ECHO;//ECHO端口配置
    	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;//输入下拉
    	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    	GPIO_Init(ULTRASOUND_GPIO,&GPIO_InitStructure);
    	GPIO_ResetBits(ULTRASOUND_GPIO, ULTRASOUND_ECHO);//拉低ECHO
    	
    	GPIO_InitStructure.GPIO_Pin = ULTRASOUND_TRIG; //TRIG端口配置
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	//复用推挽输出
      GPIO_Init(ULTRASOUND_GPIO, &GPIO_InitStructure);//初始化GPIOA.9
    	
    	EXTI_InitStructure.EXTI_Line = ULTRASOUND_EXTI_LINE; //配置中断线A-0
    	EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    	EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;//上下边沿触发
    	EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    	EXTI_Init(&EXTI_InitStructure);
    
    	NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn; //配置中断A-0
    	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    	NVIC_Init(&NVIC_InitStructure);	
    }
    

    2、定时器配置(定时器在这里比较忙,它要进行返回信号高电平的计时,和测距间隔时间计时,所以要配置中断)
    2.1 定时器宏定义参数:

    //超声波模块定时器配置
    #define ULTRASOUND_TIM 							TIM2
    #define ULTRASOUND_TIM_CLK 					RCC_APB1Periph_TIM2
    #define ULTRASOUND_TIM_IRQ      		TIM2_IRQn
    #define ULTRASOUND_TIM_IRQHandler		TIM2_IRQHandler	//TIM2中断服务函数
    

    2.2 定时器配置函数Ultrasound_TIM_Conf():
    这里值得注意的是,在配置中断的时候必须要清除中断标志位,不然程序会死在NVIC_Init函数里面

    static void Ultrasound_TIM_Conf(void)//定时器配置
    {
    	uint16_t PrescalerValue;//分频系数
    	NVIC_InitTypeDef NVIC_InitStructure;
    	TIM_TimeBaseInitTypeDef TIM_TimeBaseStruct;
    
    	RCC_APB1PeriphClockCmd(ULTRASOUND_TIM_CLK,ENABLE);//打开ULTRASOUND_TIM时钟
    	
    	PrescalerValue = (uint16_t)((SystemCoreClock / 2)  / 1000000) - 1;//计算分频系数(设定为:每秒计数100万次,每计一次为1us)
    	TIM_TimeBaseStruct.TIM_Period = 0xFDE8;//重载寄存器的值,定时周期
    	TIM_TimeBaseStruct.TIM_Prescaler = PrescalerValue;//预分频
    	TIM_TimeBaseStruct.TIM_ClockDivision = TIM_CKD_DIV1;//时钟切割
    	TIM_TimeBaseStruct.TIM_CounterMode = TIM_CounterMode_Up;//向上计数
    	TIM_TimeBaseInit(ULTRASOUND_TIM,&TIM_TimeBaseStruct);//初始化ULTRASOUND_TIM
    	
    	TIM_ClearITPendingBit(ULTRASOUND_TIM,TIM_IT_Update);//清除中断标志位,配置时必须加上
    	TIM_ITConfig(ULTRASOUND_TIM, TIM_IT_Update, ENABLE);//事件更新中断配置
    	
    	NVIC_InitStructure.NVIC_IRQChannel = ULTRASOUND_TIM_IRQ; //配置ULTRASOUND_TIM中断
    	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    	NVIC_Init(&NVIC_InitStructure);	
    
    	TIM_Cmd(ULTRASOUND_TIM,ENABLE);	//开启计数器
    }
    

    3、超声波模块初始化函数(将上面写的两个函数调用一下下就好了)

    void Ultrasound_Init(void)//超声波模块初始化
    {
    	Ultrasound_GPIO_Conf();//超声波控制端口配置
    	Ultrasound_TIM_Conf();//超声波控制计数器配置
    }
    

    4、超声波启动函数
    这里比较尴尬,使用定时器和中断的目的就是尽量没有延时,但这里出现了12us的延时(若小伙伴有好的方法,敬请出招)

    void Ultrasound_start(void)//超声波模块启动
    {
    	GPIO_SetBits(ULTRASOUND_GPIO, ULTRASOUND_TRIG);//拉高TRIG
    	
    	ULTRASOUND_TIM->CNT = 0x0000;	//清空计数器计数寄存器值
    	ULTRASOUND_TIM->ARR = 0xffff; //重载值重新设定
    	TIM_Cmd(ULTRASOUND_TIM,ENABLE);	//开启计数器
    	while(ULTRASOUND_TIM->CNT != 12);//大于10us,此处等待12us,
    	
    	GPIO_ResetBits(ULTRASOUND_GPIO, ULTRASOUND_TRIG);//拉低TRIG
    }
    

    5、距离获取函数
    这里比较花里胡哨,因为进行了一下数据筛选。ULTRASOUND_DIS_INDEX是一个宏定义,它是我设定的获取多少次数据,进行一次数据筛选。

    float Ultrasound_GetDistance(void)//获取距离数据
    {
    	uint8_t i,j;//循环变量
    	float distance_temp;//排序的临时变量
    	for(i = 0;i < ULTRASOUND_DIS_INDEX - 1;i ++ )//降序排列,找出最大值和最小值
    	{
    		for(j = 0;j < ULTRASOUND_DIS_INDEX - 1;j ++)
    		{
    			if(ultrasound_data[j] < ultrasound_data[j + 1])
    			{
    				distance_temp = ultrasound_data[j + 1];
    				ultrasound_data[j + 1] = ultrasound_data[j];
    				ultrasound_data[j] = distance_temp;
    			}
    		}	
    	}
    				
    	distance_temp = 0;//清零
    		
    	for(i = 2; i < ULTRASOUND_DIS_INDEX - 2;i ++)//去掉两个最大值和两个最小值
    	{
    		distance_temp += ultrasound_data[i];//获取的距离值累加
    	}
    	
    	distance_temp /= (ULTRASOUND_DIS_INDEX - 4);//求平均值
    	return distance_temp;
    }
    

    5、定时器中断服务函数
    比较简单,调用一下超声波启动函数就好。

    void ULTRASOUND_TIM_IRQHandler(void)//超声波所用TIM中断服务函数
    {
    	if(TIM_GetITStatus(ULTRASOUND_TIM,TIM_IT_Update) == SET)//判断是否有事件更新
    	{
    		Ultrasound_start();//启动超声波模块
    	}
    	TIM_ClearITPendingBit(ULTRASOUND_TIM,TIM_IT_Update);//清除中断标志位
    }
    

    5、外部中断服务函数(敲黑板,比较绕请细品)
    这里总体说一说此程序比较理想的执行情况:

    (1)超声波被调用初始化函数,定时器被设定为可中断,并且定时器开始计数;

    (2)计数到溢出,触发定时器中断,它会调用超声波启动函数Ultrasound_start();

    (3)超声波启动后,有回波信号,将触发外部中断(上边沿),进入外部中断直接关掉定时器中断和定时器,判断确实有回波信号,进入到(检测到返回信号)代码段,清空定时器的CNT寄存器,重设重载值ARR寄存器,开启定时器。此时,定时器进行ECHO引脚得高电平持续时间检测;

    (4)再一次中断来临(下降沿),还是直接关掉定时器中断触发和定时器,这次进入(返回信号结束)代码段,首先判断定时器是不是计数的高电平时间。若是,就判断我的获取次数是否已满,满了就置位flag, 没有满,就将定时器CNT寄存器里面的值提出来参与距离公式运算得到当前所测距离。执行到最后继续开启定时器中断和定时器,并重新设定重载值。此时定时器进行间隔时间计数。所以,定时器计数到溢出中断后,又会去调用一次超声波启动函数Ultrasound_start();

    (5)外部中断函数则在此等待下一次工作来临;

    void ULTRASOUND_EXTI_IRQHandler(void)	//超声波ECHO引脚所用中断服务函数
    {
    	if(EXTI_GetITStatus(EXTI_Line0)!=0)	//判断是否真是触发中断
    	{	
    		TIM_ITConfig(ULTRASOUND_TIM, TIM_IT_Update, DISABLE);//关闭计数器中断
    		TIM_Cmd(ULTRASOUND_TIM,DISABLE);	//关闭计数器
    		if(GPIO_ReadInputDataBit(ULTRASOUND_GPIO, ULTRASOUND_ECHO) == 1)	//检测到返回信号
    		{
    			ULTRASOUND_TIM->CNT = 0x0000;	//清空计数器计数寄存器值
    			ULTRASOUND_TIM->ARR = 0xffff;//重载值重设为计数最大值
    			TIM_Cmd(ULTRASOUND_TIM,ENABLE);	//开启计数器
    		}
    		
    		if(GPIO_ReadInputDataBit(ULTRASOUND_GPIO, ULTRASOUND_ECHO) == 0 )	//返回信号结束
    		{
    			if(ULTRASOUND_TIM->ARR == 0xffff) //需要确定计数器当前是不是在计数返回信号时间
    			{
    				if(d_count == ULTRASOUND_DIS_INDEX) //判断获取数据的次数
    				{
    					d_count = 0;	//清空次数计数值
    					ultrasound_flag = 1;	//置位超声波标志位
    				}
    				else
    				{
    					ultrasound_flag = 0;	//清空超声波标志位
    					ultrasound_data[d_count] = (float)(ULTRASOUND_TIM->CNT*34000)/1000000/2;	//计算距离,单位cm。并将数据存入待处理数据数组
    					d_count++;	//次数计数值自增
    				}
    			}
    			ULTRASOUND_TIM->ARR = 0xFDE8;//重载值为计数64ms
    			TIM_ITConfig(ULTRASOUND_TIM, TIM_IT_Update, ENABLE);//开启计数器中断
    			TIM_Cmd(ULTRASOUND_TIM,ENABLE);	//开启计数器
    		}
    		EXTI_ClearITPendingBit(EXTI_Line0);	//清除LINE上的中断标志位
    	}
    }
    

    6、主函数

    #include "common.h"
    
    char display_buff[100] = {0};
    int main()
    {
    	SysTickInit();//系统定时器设置
    	NVIC_PriorityGroupConfig(0);//中断分组
    	OLED_Init();//0.96寸OLED初始化
    	Ultrasound_Init();//超声波模块初始化
    	
    	while(1)	
    	{		
    		if(ultrasound_flag == 1)
    		{
    			sprintf(display_buff,"distance: %-5.2fcm    ",Ultrasound_GetDistance());//将数据打印到显示缓冲区
    			OLED_Print(0,8,(uint8_t*)display_buff,TYPE6X8,TYPE6X8);//显示数据
    		}
    	} 
    }
    
    

    7、下面是超声波配置完整的.c和.h
    == ultrasound.c ==

    #ifndef __ULTRASOUND_H
    #define __ULTRASOUND_H
    
    #include "common.h"
    
    //超声波模块引脚配置
    #define ULTRASOUND_GPIO 						GPIOA
    #define ULTRASOUND_GPIO_CLK 				RCC_APB2Periph_GPIOA
    #define ULTRASOUND_TRIG 						GPIO_Pin_1
    #define ULTRASOUND_ECHO 						GPIO_Pin_0
    
    //超声波模块ECHO中断配置
    #define ULTRASOUND_GPIOSourceGPIO   GPIO_PortSourceGPIOA
    #define ULTRASOUND_PINSOURCE        GPIO_PinSource0
    #define ULTRASOUND_EXTI_LINE				EXTI_Line0
    #define ULTRASOUND_EXTI_IRQHandler  EXTI0_IRQHandler	//ECHO引脚中断服务函数
    
    //超声波模块定时器配置
    #define ULTRASOUND_TIM 							TIM2
    #define ULTRASOUND_TIM_CLK 					RCC_APB1Periph_TIM2
    #define ULTRASOUND_TIM_IRQ      		TIM2_IRQn
    #define ULTRASOUND_TIM_IRQHandler		TIM2_IRQHandler	//TIM2中断服务函数
    
    #define ULTRASOUND_DIS_INDEX 				10
    
    extern uint8_t ultrasound_flag;//获取完成标志位变量
    extern float ultrasound_data[ULTRASOUND_DIS_INDEX];//距离数据存储数组
    
    void Ultrasound_Init(void);//模块使用初始
    void Ultrasound_start(void);//启动一次
    float Ultrasound_GetDistance(void);//获取距离数据
    
    #endif
    
    
    

    == ultrasound.c ==

    #include "ultrasound.h"
    
    float ultrasound_data[ULTRASOUND_DIS_INDEX] = {0};//数据存储
    uint16_t d_count = 0;//获取数据次数计数变量
    uint8_t ultrasound_flag = 0;//获取完成标志位变量
    
    static void Ultrasound_GPIO_Conf(void)//端口配置
    {
    	EXTI_InitTypeDef EXTI_InitStructure;
    	GPIO_InitTypeDef GPIO_InitStructure;
    	NVIC_InitTypeDef NVIC_InitStructure;
    	
    	RCC_APB2PeriphClockCmd(ULTRASOUND_GPIO_CLK | RCC_APB2Periph_AFIO,ENABLE);//打开GPIOA和端口复用时钟
    	
    	GPIO_EXTILineConfig(ULTRASOUND_GPIOSourceGPIO,ULTRASOUND_PINSOURCE);//配置中断线A-0
    	
    	GPIO_InitStructure.GPIO_Pin = ULTRASOUND_ECHO;//ECHO端口配置
    	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;//输入下拉
    	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    	GPIO_Init(ULTRASOUND_GPIO,&GPIO_InitStructure);
    	GPIO_ResetBits(ULTRASOUND_GPIO, ULTRASOUND_ECHO);//拉低ECHO
    	
    	GPIO_InitStructure.GPIO_Pin = ULTRASOUND_TRIG; //TRIG端口配置
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;	//复用推挽输出
      GPIO_Init(ULTRASOUND_GPIO, &GPIO_InitStructure);//初始化GPIOA.9
    	
    	EXTI_InitStructure.EXTI_Line = ULTRASOUND_EXTI_LINE; //配置中断线A-0
    	EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    	EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;//上下边沿触发
    	EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    	EXTI_Init(&EXTI_InitStructure);
    
    	NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn; //配置中断A-0
    	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    	NVIC_Init(&NVIC_InitStructure);	
    }
    
    static void Ultrasound_TIM_Conf(void)//定时器配置
    {
    	uint16_t PrescalerValue;//分频系数
    	NVIC_InitTypeDef NVIC_InitStructure;
    	TIM_TimeBaseInitTypeDef TIM_TimeBaseStruct;
    
    	RCC_APB1PeriphClockCmd(ULTRASOUND_TIM_CLK,ENABLE);//打开ULTRASOUND_TIM时钟
    	
    	PrescalerValue = (uint16_t)((SystemCoreClock / 2)  / 1000000) - 1;//计算分频系数(设定为:每秒计数100万次,每计一次为1us)
    	TIM_TimeBaseStruct.TIM_Period = 0xFDE8;//重载寄存器的值,定时周期
    	TIM_TimeBaseStruct.TIM_Prescaler = PrescalerValue;//预分频
    	TIM_TimeBaseStruct.TIM_ClockDivision = TIM_CKD_DIV1;//时钟切割
    	TIM_TimeBaseStruct.TIM_CounterMode = TIM_CounterMode_Up;//向上计数
    	TIM_TimeBaseInit(ULTRASOUND_TIM,&TIM_TimeBaseStruct);//初始化ULTRASOUND_TIM
    	
    	TIM_ClearITPendingBit(ULTRASOUND_TIM,TIM_IT_Update);//清除中断标志位,配置时必须加上
    	TIM_ITConfig(ULTRASOUND_TIM, TIM_IT_Update, ENABLE);//事件更新中断配置
    	
    	NVIC_InitStructure.NVIC_IRQChannel = ULTRASOUND_TIM_IRQ; //配置ULTRASOUND_TIM中断
    	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    	NVIC_Init(&NVIC_InitStructure);	
    
    	TIM_Cmd(ULTRASOUND_TIM,ENABLE);	//开启计数器
    }
    
    void Ultrasound_Init(void)//超声波模块初始化
    {
    	Ultrasound_GPIO_Conf();//超声波控制端口配置
    	Ultrasound_TIM_Conf();//超声波控制计数器配置
    }
    
    void Ultrasound_start(void)//超声波模块启动
    {
    	GPIO_SetBits(ULTRASOUND_GPIO, ULTRASOUND_TRIG);//拉高TRIG
    	
    	ULTRASOUND_TIM->CNT = 0x0000;	//清空计数器计数寄存器值
    	ULTRASOUND_TIM->ARR = 0xffff; //重载值重新设定
    	TIM_Cmd(ULTRASOUND_TIM,ENABLE);	//开启计数器
    	while(ULTRASOUND_TIM->CNT != 12);//大于10us,此处等待12us,
    	
    	GPIO_ResetBits(ULTRASOUND_GPIO, ULTRASOUND_TRIG);//拉低TRIG
    }
    
    float Ultrasound_GetDistance(void)//获取距离数据
    {
    	uint8_t i,j;//循环变量
    	float distance_temp;//排序的临时变量
    	for(i = 0;i < ULTRASOUND_DIS_INDEX - 1;i ++ )//降序排列,找出最大值和最小值
    	{
    		for(j = 0;j < ULTRASOUND_DIS_INDEX - 1;j ++)
    		{
    			if(ultrasound_data[j] < ultrasound_data[j + 1])
    			{
    				distance_temp = ultrasound_data[j + 1];
    				ultrasound_data[j + 1] = ultrasound_data[j];
    				ultrasound_data[j] = distance_temp;
    			}
    		}	
    	}
    				
    	distance_temp = 0;//清零
    		
    	for(i = 2; i < ULTRASOUND_DIS_INDEX - 2;i ++)//去掉两个最大值和两个最小值
    	{
    		distance_temp += ultrasound_data[i];//获取的距离值累加
    	}
    	
    	distance_temp /= (ULTRASOUND_DIS_INDEX - 4);//求平均值
    	return distance_temp;
    }
    
    
    void ULTRASOUND_EXTI_IRQHandler(void)	//超声波ECHO引脚所用中断服务函数
    {
    	if(EXTI_GetITStatus(EXTI_Line0)!=0)	//判断是否真是触发中断
    	{
    		
    		TIM_ITConfig(ULTRASOUND_TIM, TIM_IT_Update, DISABLE);//关闭计数器中断
    		TIM_Cmd(ULTRASOUND_TIM,DISABLE);	//关闭计数器
    		if(GPIO_ReadInputDataBit(ULTRASOUND_GPIO, ULTRASOUND_ECHO) == 1)	//检测到返回信号
    		{
    			ULTRASOUND_TIM->CNT = 0x0000;	//清空计数器计数寄存器值
    			ULTRASOUND_TIM->ARR = 0xffff;//重载值重设为计数最大值
    			TIM_Cmd(ULTRASOUND_TIM,ENABLE);	//开启计数器
    		}
    		
    		if(GPIO_ReadInputDataBit(ULTRASOUND_GPIO, ULTRASOUND_ECHO) == 0 )	//返回信号结束
    		{
    			if(ULTRASOUND_TIM->ARR == 0xffff) //需要确定计数器当前是不是在计数返回信号时间
    			{
    				if(d_count == ULTRASOUND_DIS_INDEX) //判断获取数据的次数
    				{
    					d_count = 0;	//清空次数计数值
    					ultrasound_flag = 1;	//置位超声波标志位
    				}
    				else
    				{
    					ultrasound_flag = 0;	//清空超声波标志位
    					ultrasound_data[d_count] = (float)(ULTRASOUND_TIM->CNT*34000)/1000000/2;	//计算距离,单位cm。并将数据存入待处理数据数组
    					d_count++;	//次数计数值自增
    				}
    			}
    			ULTRASOUND_TIM->ARR = 0xFDE8;//重载值为计数64ms
    			TIM_ITConfig(ULTRASOUND_TIM, TIM_IT_Update, ENABLE);//开启计数器中断
    			TIM_Cmd(ULTRASOUND_TIM,ENABLE);	//开启计数器
    		}
    		EXTI_ClearITPendingBit(EXTI_Line0);	//清除LINE上的中断标志位
    	}
    }
    
    void ULTRASOUND_TIM_IRQHandler(void)//超声波所用TIM中断服务函数
    {
    	if(TIM_GetITStatus(ULTRASOUND_TIM,TIM_IT_Update) == SET)//判断是否有事件更新
    	{
    		Ultrasound_start();//启动超声波模块
    	}
    	TIM_ClearITPendingBit(ULTRASOUND_TIM,TIM_IT_Update);//清除中断标志位
    }
    
    

    8、实验结果
    在这里插入图片描述

    **若有不足之处还请各位指出。

    展开全文
  • 一路超声波测距串口1,串口2和串口3输出距离 外部中断四路超声波测距
  • stm32 使用中断方式实现超声波测距

    千次阅读 2019-11-23 16:35:43
    超声波测距模块源代码 /************************************* ...外部中断 EXTI_Line6; 使用方法:总是调用 Hcsr04GetLength(); 每调用一次就会启动一次测距; 取三次的平均值保存到 全局变量 ultr...

    超声波测距模块源代码

    /*************************************
    	编写人:***
    	模块功能:    超声波测距
    	使用的资源:HC-04超声波,定时器 TIM6,PB5,PB6;外部中断 EXTI_Line6;
    	使用方法:   3.3V供电,总是调用 Hcsr04GetLength(); 每调用一次就会启动一次测距;取三次的平均值保存到 全局变量 ultra_duration,在任何你想要知道距离的时候 读取 ultra_duration 就可以啦。
    *************************************/
    #include "delay.h"
    #define HCSR04_PORT     GPIOB
    #define HCSR04_CLK      RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO
    #define HCSR04_TRIG     GPIO_Pin_5
    #define HCSR04_ECHO     GPIO_Pin_6
    #define HCSR04_Exit_PORTSOURCE    GPIO_PortSourceGPIOB
    #define HCSR04_Exit_PINSOURCE    GPIO_PinSource6
    #define HCSR04_Exit_LINE         EXTI_Line6
    #define HCSR04_Exit_IRQ          EXTI9_5_IRQn  //中断源
    #define HCSR04_Exit_HANDLE       EXTI9_5_IRQHandler  //中断入口函数
    #define TRIG_Send  PBout(5) 
    #define ECHO_Reci  PBin(6)
    
    u8 msHcCount = 0;//ms计数
    static int ultra_state = 0;
    int ultra_time=0;
    float ultra_duration = 0;
    float ultra_cur_dis=0;
    float ultra_sum = 0;
    u32 GetEchoTimer(void);
    
    void Hcsr04Init()
    {  
    		// 定义初始化结构体
        TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;  //用于定时器设置
    		GPIO_InitTypeDef GPIO_InitStructure;  //GPIO
    		EXTI_InitTypeDef EXTI_InitStructure;  //外部中断
    		NVIC_InitTypeDef NVIC_InitStructure;  //嵌套中断向量管理器
    	  //开PB口和AFIO时钟
        RCC_APB2PeriphClockCmd(HCSR04_CLK, ENABLE);     
        //IO初始化 Trig
        GPIO_InitStructure.GPIO_Pin =HCSR04_TRIG;       //发送电平引脚
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出
        GPIO_Init(HCSR04_PORT, &GPIO_InitStructure);
        GPIO_ResetBits(HCSR04_PORT,HCSR04_TRIG);
        //IO初始化  Echo
        GPIO_InitStructure.GPIO_Pin =   HCSR04_ECHO;     //返回电平引脚
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
        GPIO_Init(HCSR04_PORT, &GPIO_InitStructure);
    	  // 设置 Echo为外部中断
    		GPIO_EXTILineConfig(HCSR04_Exit_PORTSOURCE, HCSR04_Exit_PINSOURCE);
    		EXTI_InitStructure.EXTI_Line = HCSR04_Exit_LINE;
    		EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    		EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;     //下降沿触发
    		EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    		EXTI_Init(&EXTI_InitStructure);
    		NVIC_InitStructure.NVIC_IRQChannel = HCSR04_Exit_IRQ;       //设置中断源
    		NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    		NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    		NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    		NVIC_Init(&NVIC_InitStructure);
      
         
        //定时器初始化 使用基本定时器TIM6
    		RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE);   //使能对应RCC时钟
    		//配置定时器基础结构体
    		//TIM_DeInit(TIM2);
    		TIM_TimeBaseStructure.TIM_Period = (1000-1); //设置在下一个更新事件装入活动的自动重装载寄存器周期的值         计数到1000为1ms
    		TIM_TimeBaseStructure.TIM_Prescaler =(72-1); //设置用来作为TIMx时钟频率除数的预分频值  1M的计数频率 1US计数
    		//TIM_TimeBaseStructure.TIM_ClockDivision=TIM_CKD_DIV1;//不分频
    		//TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
    		//TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;   //重复计数器
    		TIM_TimeBaseInit(TIM6, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx         
    		
    		TIM_ClearFlag(TIM6, TIM_FLAG_Update);   //清除计数器中断标志位,免得一打开中断立即产生中断
    		TIM_ITConfig(TIM6,TIM_IT_Update,ENABLE);    //打开定时器中断
    		// 定时器中断优先级配置
    		NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);           //设置中断分组为2
    		
    		NVIC_InitStructure.NVIC_IRQChannel = TIM6_IRQn;            //设置中断来源
    		NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  //抢占式中断优先级设置为1
    		NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;         //响应式中断优先级设置为1
    		NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;           //使能中断
    		NVIC_Init(&NVIC_InitStructure);
    		// 暂时关闭定时器
        TIM_Cmd(TIM6,DISABLE);     
    }
    
    
    
    //tips:static函数的作用域仅限于定义它的源文件内,所以不需要在头文件里声明
    static void OpenTimerForHc()        //打开定时器
    {
    			TIM_SetCounter(TIM6,0);//清除计数
    			msHcCount = 0;
    			TIM_Cmd(TIM6, ENABLE);  //使能TIMx外设
    }
     
    static void CloseTimerForHc()        //关闭定时器
    {
    			TIM_Cmd(TIM6, DISABLE);  //使能TIMx外设
    }
     
    //外部中断 Echo 处理
    void HCSR04_Exit_HANDLE(void)
    {
    		//读中断状态
    		if(EXTI_GetITStatus(HCSR04_Exit_LINE)) 
    		{
    				//清零中断 
    				EXTI_ClearITPendingBit(HCSR04_Exit_LINE);
    				//中断事务处理
    				if(ECHO_Reci == 0){
    					CloseTimerForHc();         //关闭定时器
    					ultra_time = GetEchoTimer();        //获取时间,分辨率为1US
    					ultra_cur_dis = ((float)ultra_time/58.0);  //cm
    					ultra_sum += ultra_cur_dis;
    					ultra_state++;
    				}
    		}  
    }
    
    //定时器6中断服务程序
    void TIM6_IRQHandler(void)   //TIM3中断
    {
    		if (TIM_GetITStatus(TIM6, TIM_IT_Update) != RESET)  //检查TIM3更新中断发生与否
    		{
    				TIM_ClearITPendingBit(TIM6, TIM_IT_Update  );  //清除TIMx更新中断标志 
    				msHcCount++;
    		}
    }
     
    
    //获取定时器时间
    u32 GetEchoTimer(void)
    {
    		u32 t = 0;
    		t = msHcCount*1000;//得到MS
    		t += TIM_GetCounter(TIM6);//得到US
    		TIM6->CNT = 0;  //将TIM2计数寄存器的计数值清零
    			delay_ms(50);
    		return t;
    }
     
    // 3次测距求平均
    void Hcsr04GetLength(void )
    {
    	// ultra_state为奇数,表示开始了测距; 偶数表示一次测距完成
    	if(ultra_state == 0 || ultra_state == 2 || ultra_state == 4){
    		TRIG_Send = 1;           // 发送口高电平输出
    		delay_us(20);
    		TRIG_Send = 0;
    		while(ECHO_Reci == 0);   // 等待接收口高电平输出
    		OpenTimerForHc();        // 打开定时器
    		ultra_state++;           // ultra_state为奇数,表示开始了测距
    		
    	}else if(ultra_state >= 6){
    		ultra_duration = ultra_sum/3.0; 
    		ultra_sum = 0;
    		ultra_state = 0;
    	}
    }
    
    

    主程序源代码

    #include "stm32f10x.h"
    extern float ultra_duration;
    void Hcsr04Init();
    void Hcsr04GetLength();
    int main(void)
    {
    	delay_init();	    	            //=====延时函数初始化	
    	Hcsr04Init();                   //=====超声波初始化
      while (1)
      {
    		Hcsr04GetLength();
      }
    }
    

    delay函数

    #include "delay.h"
    // 	 
    //如果需要使用OS,则包括下面的头文件即可.
    #if SYSTEM_SUPPORT_OS
    #include "includes.h"					//ucos 使用	  
    #endif
      /**************************************************************************
    作者:平衡小车之家
    我的淘宝小店:http://shop114407458.taobao.com/
    **************************************************************************/
    
    static u8  fac_us=0;							//us延时倍乘数			   
    static u16 fac_ms=0;							//ms延时倍乘数,在ucos下,代表每个节拍的ms数
    	
    	
    #if SYSTEM_SUPPORT_OS							//如果SYSTEM_SUPPORT_OS定义了,说明要支持OS了(不限于UCOS).
    //当delay_us/delay_ms需要支持OS的时候需要三个与OS相关的宏定义和函数来支持
    //首先是3个宏定义:
    //    delay_osrunning:用于表示OS当前是否正在运行,以决定是否可以使用相关函数
    //delay_ostickspersec:用于表示OS设定的时钟节拍,delay_init将根据这个参数来初始哈systick
    // delay_osintnesting:用于表示OS中断嵌套级别,因为中断里面不可以调度,delay_ms使用该参数来决定如何运行
    //然后是3个函数:
    //  delay_osschedlock:用于锁定OS任务调度,禁止调度
    //delay_osschedunlock:用于解锁OS任务调度,重新开启调度
    //    delay_ostimedly:用于OS延时,可以引起任务调度.
    
    //本例程仅作UCOSII和UCOSIII的支持,其他OS,请自行参考着移植
    //支持UCOSII
    #ifdef 	OS_CRITICAL_METHOD						//OS_CRITICAL_METHOD定义了,说明要支持UCOSII				
    #define delay_osrunning		OSRunning			//OS是否运行标记,0,不运行;1,在运行
    #define delay_ostickspersec	OS_TICKS_PER_SEC	//OS时钟节拍,即每秒调度次数
    #define delay_osintnesting 	OSIntNesting		//中断嵌套级别,即中断嵌套次数
    #endif
    
    //支持UCOSIII
    #ifdef 	CPU_CFG_CRITICAL_METHOD					//CPU_CFG_CRITICAL_METHOD定义了,说明要支持UCOSIII	
    #define delay_osrunning		OSRunning			//OS是否运行标记,0,不运行;1,在运行
    #define delay_ostickspersec	OSCfg_TickRate_Hz	//OS时钟节拍,即每秒调度次数
    #define delay_osintnesting 	OSIntNestingCtr		//中断嵌套级别,即中断嵌套次数
    #endif
    
    
    //us级延时时,关闭任务调度(防止打断us级延迟)
    void delay_osschedlock(void)
    {
    #ifdef CPU_CFG_CRITICAL_METHOD   				//使用UCOSIII
    	OS_ERR err; 
    	OSSchedLock(&err);							//UCOSIII的方式,禁止调度,防止打断us延时
    #else											//否则UCOSII
    	OSSchedLock();								//UCOSII的方式,禁止调度,防止打断us延时
    #endif
    }
    
    //us级延时时,恢复任务调度
    void delay_osschedunlock(void)
    {	
    #ifdef CPU_CFG_CRITICAL_METHOD   				//使用UCOSIII
    	OS_ERR err; 
    	OSSchedUnlock(&err);						//UCOSIII的方式,恢复调度
    #else											//否则UCOSII
    	OSSchedUnlock();							//UCOSII的方式,恢复调度
    #endif
    }
    
    //调用OS自带的延时函数延时
    //ticks:延时的节拍数
    void delay_ostimedly(u32 ticks)
    {
    #ifdef CPU_CFG_CRITICAL_METHOD
    	OS_ERR err; 
    	OSTimeDly(ticks,OS_OPT_TIME_PERIODIC,&err);	//UCOSIII延时采用周期模式
    #else
    	OSTimeDly(ticks);							//UCOSII延时
    #endif 
    }
     
    //systick中断服务函数,使用ucos时用到
    void SysTick_Handler(void)
    {	
    	if(delay_osrunning==1)						//OS开始跑了,才执行正常的调度处理
    	{
    		OSIntEnter();							//进入中断
    		OSTimeTick();       					//调用ucos的时钟服务程序               
    		OSIntExit();       	 					//触发任务切换软中断
    	}
    }
    #endif
    
    			   
    //初始化延迟函数
    //当使用OS的时候,此函数会初始化OS的时钟节拍
    //SYSTICK的时钟固定为HCLK时钟的1/8
    //SYSCLK:系统时钟
    void delay_init()
    {
    #if SYSTEM_SUPPORT_OS  							//如果需要支持OS.
    	u32 reload;
    #endif
    	SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);	//选择外部时钟  HCLK/8
    	fac_us=SystemCoreClock/8000000;				//为系统时钟的1/8  
    #if SYSTEM_SUPPORT_OS  							//如果需要支持OS.
    	reload=SystemCoreClock/8000000;				//每秒钟的计数次数 单位为M  
    	reload*=1000000/delay_ostickspersec;		//根据delay_ostickspersec设定溢出时间
    												//reload为24位寄存器,最大值:16777216,在72M下,约合1.86s左右	
    	fac_ms=1000/delay_ostickspersec;			//代表OS可以延时的最少单位	   
    
    	SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;   	//开启SYSTICK中断
    	SysTick->LOAD=reload; 						//每1/delay_ostickspersec秒中断一次	
    	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;   	//开启SYSTICK    
    
    #else
    	fac_ms=(u16)fac_us*1000;					//非OS下,代表每个ms需要的systick时钟数   
    #endif
    }								    
    
    #if SYSTEM_SUPPORT_OS  							//如果需要支持OS.
    //延时nus
    //nus为要延时的us数.		    								   
    void delay_us(u32 nus)
    {		
    	u32 ticks;
    	u32 told,tnow,tcnt=0;
    	u32 reload=SysTick->LOAD;					//LOAD的值	    	 
    	ticks=nus*fac_us; 							//需要的节拍数	  		 
    	tcnt=0;
    	delay_osschedlock();						//阻止OS调度,防止打断us延时
    	told=SysTick->VAL;        					//刚进入时的计数器值
    	while(1)
    	{
    		tnow=SysTick->VAL;	
    		if(tnow!=told)
    		{	    
    			if(tnow<told)tcnt+=told-tnow;		//这里注意一下SYSTICK是一个递减的计数器就可以了.
    			else tcnt+=reload-tnow+told;	    
    			told=tnow;
    			if(tcnt>=ticks)break;				//时间超过/等于要延迟的时间,则退出.
    		}  
    	};
    	delay_osschedunlock();						//恢复OS调度									    
    }
    //延时nms
    //nms:要延时的ms数
    void delay_ms(u16 nms)
    {	
    	if(delay_osrunning&&delay_osintnesting==0)	//如果OS已经在跑了,并且不是在中断里面(中断里面不能任务调度)	    
    	{		 
    		if(nms>=fac_ms)							//延时的时间大于OS的最少时间周期 
    		{ 
       			delay_ostimedly(nms/fac_ms);		//OS延时
    		}
    		nms%=fac_ms;							//OS已经无法提供这么小的延时了,采用普通方式延时    
    	}
    	delay_us((u32)(nms*1000));					//普通方式延时  
    }
    #else //不用OS时
    //延时nus
    //nus为要延时的us数.		    								   
    void delay_us(u32 nus)
    {		
    	u32 temp;	    	 
    	SysTick->LOAD=nus*fac_us; 					//时间加载	  		 
    	SysTick->VAL=0x00;        					//清空计数器
    	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;	//开始倒数	  
    	do
    	{
    		temp=SysTick->CTRL;
    	}while((temp&0x01)&&!(temp&(1<<16)));		//等待时间到达   
    	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;	//关闭计数器
    	SysTick->VAL =0X00;      					 //清空计数器	 
    }
    //延时nms
    //注意nms的范围
    //SysTick->LOAD为24位寄存器,所以,最大延时为:
    //nms<=0xffffff*8*1000/SYSCLK
    //SYSCLK单位为Hz,nms单位为ms
    //对72M条件下,nms<=1864 
    void delay_ms(u16 nms)
    {	 		  	  
    	u32 temp;		   
    	SysTick->LOAD=(u32)nms*fac_ms;				//时间加载(SysTick->LOAD为24bit)
    	SysTick->VAL =0x00;							//清空计数器
    	SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk ;	//开始倒数  
    	do
    	{
    		temp=SysTick->CTRL;
    	}while((temp&0x01)&&!(temp&(1<<16)));		//等待时间到达   
    	SysTick->CTRL&=~SysTick_CTRL_ENABLE_Msk;	//关闭计数器
    	SysTick->VAL =0X00;       					//清空计数器	  	    
    } 
    #endif 
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • #Arduino通过中断方式实现超声波测距 代码分享: #include <FlexiTimer2.h> int Ul_trigPin = 7, Ul_echoPin = 2; // 定义超声波的引脚 long Ul_duration; // 测到的距离 unsigned long Ul_starttime; ...

    最近做一个小车项目,为了实现高效准确的测距,我使用定时器和外部中断写了一个测距的模块,分享给大家参看,如果有不对的地方,请留言批评指正。
    代码分享:

    #include <FlexiTimer2.h>
    int Ul_trigPin = 7, Ul_echoPin = 2;     // 定义超声波的引脚
    long Ul_duration;                       // 测到的距离
    unsigned long Ul_starttime;             // 超声波测距的启动时间
    int Ul_startflag = 0;                  // 超声波测距的启动标志位
    /**
     * 定时器2的中断子程序,用于超声波延时20ms
     */
    void timer2()
    {
      FlexiTimer2::stop();
      digitalWrite(Ul_trigPin, LOW);
      Ul_starttime = micros();  
    }
    /**
     * 外部中断2的延时子程序,用于超声波回波接收,接Echo
     */
    void interrupt_0(){
      Ul_duration = (micros() - Ul_starttime-2240) / 59;   // 需要减去trig和echo变化之间的延迟2240us  time/2/1000 * 34cm/ms
      Ul_startflag = 0;
    }
    void setup()
    {
      Serial.begin(38400);   // 设定串口的波特率
      FlexiTimer2::set(20, 1.0/1000, timer2); // 初始化定时器2
      pinMode(Ul_trigPin, OUTPUT);
      pinMode(Ul_echoPin, INPUT);
      digitalWrite( Ul_trigPin , LOW );
      // 初始化外部中断0
      attachInterrupt(0, interrupt_0, FALLING);  //interrupt为你中断通道编号,function为中断函数,mode为中断触发模式
    }
    
    void loop()
    {
      if (Ul_startflag == 0){   //启动测距
        Ul_startflag = 1;
        digitalWrite(Ul_trigPin, LOW);
        delayMicroseconds(2);
        digitalWrite(Ul_trigPin, HIGH);
        FlexiTimer2::start();
        Serial.print("message");
        Serial.print(Ul_duration	);
        Serial.println();
      } 
    }
    

    执行此代码可以不断获取超声波测距的信息,并通过串口发送。
    更多关于Arduino的外部中断请查看

    展开全文
  • 51单片机超声波测距C程序(2010-01-26 14:09:10) 电子工程师电子资料大学校园超声波检测原理超声波测距的程序流程图程序如下://超声波模块程序#include #define uchar unsigned char#define uint unsigned int//void...

    51单片机超声波测距C程序

    43131454_1.gif(2010-01-26 14:09:10) 电子工程师电子资料大学校园

    43131454_2

    超声波检测原理

    43131454_3

    超声波测距的程序流程图

    43131454_4

    程序如下:

    //超声波模块程序

    #include

    #define uchar unsigned char

    #define uint unsigned int

    //

    void delay(uint z)

    {

    uint x,y;

    for(x=z;x>0;x--)

    for(y=110;y>0;y--);

    }

    //

    void delay_20us()

    {

    uchar a ;

    for(a=0;a<100;a++);

    }

    //***************************************************************

    //显示数据转换程序

    void display(uint temp)

    {

    uchar ge,shi,bai;

    bai=temp/100;

    shi=(temp%100)/10;

    ge=temp%10;

    wela=1;

    P0=0xf7;

    wela=0;

    dula=1;

    P0=table[bai];

    dula=0;

    delay(1);

    dula=1;

    P0=0x00; //关位码

    dula=0;

    wela=1;

    P0=0xef;

    wela=0;

    dula=1;

    P0=table[shi];

    dula=0;

    delay(1);

    dula=1;

    P0=0x00; //关位码

    dula=0;

    dula=1;

    P0=table[ge];

    dula=0;

    wela=1;

    P0=0xdf;

    wela=0;

    delay(1);

    dula=1;

    P0=0x00; //关位码

    dula=0;

    }

    //***************************************************************

    void main()

    {

    uint distance;

    test =0;

    Trig=0; //首先拉低脉冲输入引脚

    EA=1; //打开总中断0

    TMOD=0x10; //定时器1,16位工作方式

    while(1)

    {

    EA=0; //关总中断

    Trig=1; //超声波输入端

    delay_20us(); //延时20us

    Trig=0; //产生一个20us的脉冲

    while(Echo==0); //等待Echo回波引脚变高电平

    succeed_flag=0; //清测量成功标志

    EA=1;

    EX0=1; //打开外部中断0

    TH1=0; //定时器1清零

    TL1=0; //定时器1清零

    TF1=0; //计数溢出标志

    TR1=1; //启动定时器1

    delay(20); //等待测量的结果

    TR1=0; //关闭定时器1

    EX0=0; //关闭外部中断0

    if(succeed_flag==1)

    {

    time=timeH*256+timeL;

    distance=time*0.172; //毫米,便于数码管显示

    display(distance);

    }

    if(succeed_flag==0)

    {

    distance=0; //没有回波则清零

    test = !test; //测试灯变化

    }

    }

    }

    //***************************************************************

    //外部中断0,用做判断回波电平

    void exter() interrupt 0 // 外部中断0是0号

    {

    timeH =TH1; //取出定时器的值

    timeL =TL1; //取出定时器的值

    succeed_flag=1;//至成功测量的标志

    EX0=0; //关闭外部中断

    }

    //****************************************************************

    //定时器1中断,用做超声波测距计时

    void timer1() interrupt 3 //

    {

    TH1=0;

    TL1=0;

    }

    展开全文
  • 原标题:超声波测距51C程序//晶振=8M//MCU=STC10F04XE//P0.0-P0.6共阳数码管引脚//Trig = P1^0//Echo = P3^2#include //包括一个52标准内核的头文件#define uchar unsigned char //定义一下方便使用#define uint ...
  • 超声波测距

    2018-12-07 09:59:10
    STM32的三路超声波测距功能模块文件。使用时,只需要添加UltrasonicWave_Configuration和TIM2初始化函数。在每次测距前调用UltrasonicWave_StartMeasure发送信号。根据外部中断里测得距离值。
  • stm32超声波测距

    2016-11-30 11:07:01
    自己收集的超声波测距程序,包含了stm32的定时器测距、外部中断测距和输入捕获测距。
  • 下面的这款超声波测距C语言程序程序也挺简单的,用的定时器和外部中断,接收到回波的时候触发外部中断,在中断服务程序中进行处理,不用加注释应该能看懂吧,这款超声波测距C语言程序程序肯定还有很多不足,给初学者...
  • HC-SR04超声波测距C51程序

    热门讨论 2012-07-23 16:38:05
    HC-SR04超声波测距C51程序 HC-SR04超声波测距C51程序 51单片机程序。外部中断结束。 距离与时间成正比例
  • STM32嵌入式实现超声波测距三种方式实现 1.while循环检测; 2.外部中断检测; 3.定时器输入捕获检测。 分别有三个文件夹 单片机型号为:STM32F103系列,超声波型号为:HC-SR04
  • 摘要:VC/C++源码,界面编程,超声波 C超声波测距实验源代码,Tx=0; //首先拉低脉冲输入引脚,TMOD=0x11; //定时器0,定时器1,16位工作方式。TR0=1; //启动定时器0  IT0=0;//由高电平变低电平,触发外部中断  ET0...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 397
精华内容 158
关键字:

外部中断超声波测距