精华内容
下载资源
问答
  • 超声波中断
    2019-11-13 00:10:15

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

    #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的外部中断请查看

    更多相关内容
  • 超声波模块中断

    2019-03-26 10:30:49
    简单来说就是单片机控制超声波发射模块发出一系列超声波,遇到障碍物反弹回来,被超声波接收模块接收到,然后计算这段时间(声音在空气中传播的速度为340m/s),通过计算,得出距离,这就是基本的思路。
  • 有信号返回,通过引脚 Echo 输出一高电平,高电平持续的时间就是 超声波从发射到返回的时间. 测试距离 = (高电平时间 * 声速(340M/S)) / 2; 时序图 我们可以借助通用定时器的 输入捕获 来测量 Echo 引脚高电平...

    开发板:秉火-霸道V1
    芯片:STM32F103ZET6
    定时器:TIM2
    通道: 3

    模块工作原理

    • 采用 IO 触发测距,给 Trig 引脚至少 10us 的高电平信号;
    • 模块自动发送 8 个 40khz 的方波,自动检测是否有信号返回;
    • 有信号返回,通过引脚 Echo 输出一高电平,高电平持续的时间就是 超声波从发射到返回的时间.
    • 测试距离 = (高电平时间 * 声速(340M/S)) / 2;

    时序图

    在这里插入图片描述

    我们可以借助通用定时器的 输入捕获 来测量 Echo 引脚高电平持续的时间

    HC_SR04.h

    #ifndef _BSP_HCSR04_H
    #define _BSP_HCSR04_H
    
    #include"stm32f10x.h"
    #include"stm32f10x_tim.h"
    
    //TIM2
    #define GENERAL_TIMx            TIM2
    #define GENERAL_TIMx_CLK_FUN    RCC_APB1PeriphClockCmd
    #define GENERAL_TIMx_CLK        RCC_APB1Periph_TIM2
    
    //Trig引脚定义---PA10
    #define HCSR04_GPIO_CLK_FUN  RCC_APB2PeriphClockCmd
    #define HCSR04_GPIO_CLK      RCC_APB2Periph_GPIOA
    #define HCSR04_GPIO_TRIG_PORT GPIOA
    #define HCSR04_GPIO_TRIG_PIN  GPIO_Pin_10
    
    #define HCSR04_TRIG_Hight   HCSR04_GPIO_TRIG_PORT->BSRR = HCSR04_GPIO_TRIG_PIN
    #define HCSR04_TRIG_Low     HCSR04_GPIO_TRIG_PORT->BRR = HCSR04_GPIO_TRIG_PIN
    
    //TIM引脚定义
    #define GENERAL_TIMx_CH3_CLK_FUN    RCC_APB2PeriphClockCmd
    #define GENERAL_TIMx_CH3_CLK        RCC_APB2Periph_GPIOA
    #define GENERAL_TIMx_CH3_PORT       GPIOA
    #define GENERAL_TIMx_CH3_PIN        GPIO_Pin_2
    #define GENERAL_TIMx_CHANNEL_x      TIM_Channel_3
    
    //TIM2中断
    #define GENERAL_TIMx_IRQn       TIM2_IRQn
    #define GENERAL_TIMx_IRQHandler TIM2_IRQHandler 
    
    
    typedef struct {
        uint8_t Capture_FinishFlag; // 捕获结束标志位
        uint8_t Capture_StartFlag;  // 捕获开始标志位
        uint16_t Capture_CcrValue;  // 捕获寄存器的值
        uint16_t Capture_Period;    // 自动重装载寄存器更新标志
    } TIM_ICUserValueTypeDef;
    
    extern TIM_ICUserValueTypeDef TIM_ICUserValueStruct;
    
    void TIM_Config(void);
    
    void HCSR04_GPIO_Config(void);
    void HCSR04_TRIG_Send(void);
    
    
    #endif /*_BSP_HCSR04_H*/
    

    HC_SR04.c

    /*
        Trig: PA2
        Echo: PA10
    */
    
    #include"bsp_HCSR04.h"
    #include "bsp_delay.h"
    
    TIM_ICUserValueTypeDef TIM_ICUserValueStruct = {0,0,0,0};
    
    //HCSR04初始化引脚
    void HCSR04_GPIO_Config(void)
    {
        //定义GPIO结构体变量
        GPIO_InitTypeDef GPIO_InitStruct;
        //打开时钟
        HCSR04_GPIO_CLK_FUN(HCSR04_GPIO_CLK,ENABLE);
    
        //Trig引脚
        GPIO_InitStruct.GPIO_Pin = HCSR04_GPIO_TRIG_PIN;
        GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
        GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(HCSR04_GPIO_TRIG_PORT,&GPIO_InitStruct);
    }
    
    void HCSR04_TRIG_Send(void)
    {
        HCSR04_TRIG_Hight;
        Delay_Us(15);
        HCSR04_TRIG_Low;
    }
    
    
    static void GENERAL_TIMx_GPIO_Config(void)
    {
        GPIO_InitTypeDef GPIO_InitStruct;
    
        GENERAL_TIMx_CH3_CLK_FUN(GENERAL_TIMx_CH3_CLK,ENABLE);
    
        GPIO_InitStruct.GPIO_Pin = GENERAL_TIMx_CH3_PIN;
        GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
        GPIO_Init(GENERAL_TIMx_CH3_PORT,&GPIO_InitStruct);
    }
    
    //中断初始化
    static void GENERAL_TIMx_NVIC_Config(void)
    {
        NVIC_InitTypeDef NVIC_InitStruct;
    
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    
        //设置中断通道
        NVIC_InitStruct.NVIC_IRQChannel = GENERAL_TIMx_IRQn;
        //设置子优先级
        NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
        //设置抢占优先级
        NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
        //中断通道使能
        NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
        NVIC_Init(&NVIC_InitStruct);
    }
    
    static void GENERAL_TIMx_Mode_Config(void)
    {
        TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;
        TIM_ICInitTypeDef TIM_ICInitStruct;
    
        GENERAL_TIMx_CLK_FUN(GENERAL_TIMx_CLK,ENABLE);
    
        //初始化时基
        TIM_TimeBaseInitStruct.TIM_Prescaler = (72-1);
        TIM_TimeBaseInitStruct.TIM_Period = 0xFFFF;
        TIM_TimeBaseInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
        TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;
        TIM_TimeBaseInitStruct.TIM_RepetitionCounter = 0;
        
        TIM_TimeBaseInit(GENERAL_TIMx,&TIM_TimeBaseInitStruct);
    
        //初始化 IC
        TIM_ICInitStruct.TIM_Channel = GENERAL_TIMx_CHANNEL_x;
        TIM_ICInitStruct.TIM_ICPolarity = TIM_ICPolarity_Rising;
        TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;
        TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;
        TIM_ICInitStruct.TIM_ICFilter = 0;
    
        TIM_ICInit(GENERAL_TIMx,&TIM_ICInitStruct);
    
        //清楚更新中断标志
        TIM_ClearFlag(GENERAL_TIMx,TIM_FLAG_Update | TIM_FLAG_CC3);
        //中断初始化
        TIM_ITConfig(GENERAL_TIMx,TIM_FLAG_Update | TIM_FLAG_CC3,ENABLE);
        //使能TIM
        TIM_Cmd(GENERAL_TIMx,ENABLE);
    }
    
    void TIM_Config(void)
    {
        GENERAL_TIMx_GPIO_Config();
        GENERAL_TIMx_NVIC_Config();
        GENERAL_TIMx_Mode_Config();
    }
    

    TIM2中断函数

    详细过程参考野火例徎 32-TIM—高级定时器

    //TIM2中断函数
    void GENERAL_TIMx_IRQHandler(void)
    {
      //判断是否超出Period   检测位为更新中断
      //若是更新,改变Capture_Period值
      if(TIM_GetITStatus(GENERAL_TIMx,TIM_IT_Update) != RESET)
      {
        TIM_ICUserValueStruct.Capture_Period++;
        //清除中断等待
        TIM_ClearITPendingBit(GENERAL_TIMx,TIM_IT_Update);
      }
      //捕获边沿
      if(TIM_GetITStatus(GENERAL_TIMx,TIM_IT_CC3) != RESET)
      {
        //表示第一次捕获  清除CCR
        if(TIM_ICUserValueStruct.Capture_StartFlag == 0)
        {
          
          TIM_SetCounter(GENERAL_TIMx,0);              //从0开始计数
         TIM_ICUserValueStruct.Capture_CcrValue = 0;  //捕获值为0 
         // 自动重装载寄存器更新标志清0
    			TIM_ICUserValueStruct.Capture_Period = 0;
          //改变捕获极性
          TIM_OC3PolarityConfig(GENERAL_TIMx,TIM_ICPolarity_Falling);
          TIM_ICUserValueStruct.Capture_StartFlag = 1;
        }
        //第二次捕获
        else
        {
          //得到CCR的值
          TIM_ICUserValueStruct.Capture_CcrValue = TIM_GetCapture3(GENERAL_TIMx);
          //改变捕获极性
          TIM_OC3PolarityConfig(GENERAL_TIMx,TIM_ICPolarity_Rising);
          //改变标志
          TIM_ICUserValueStruct.Capture_StartFlag = 0;
          TIM_ICUserValueStruct.Capture_FinishFlag = 1;
        }
        TIM_ClearITPendingBit (GENERAL_TIMx,TIM_IT_CC3);	
      }
    }
    

    在这里插入图片描述

    在这里插入图片描述

    delay函数

    #include "bsp_delay.h"
    
    void Delay_Us( __IO uint32_t us)
    {
        uint32_t i;
        SysTick_Config(SystemCoreClock/1000000);
        for (i=0; i<us; i++) 
        {
    
        // 当计数器的值减小到 0 的时候,CRTL 寄存器的位 16 会置 1
    
        while ( !((SysTick->CTRL)&(1<<16)) );
    
        }
    
        // 关闭 SysTick 定时器
    
        SysTick->CTRL &=~SysTick_CTRL_ENABLE_Msk;
    
    }
    

    main.c

    /*
    	按下 K1 启动测量
    */
    #include"bsp_HCSR04.h"
    #include"bsp_usart.h"
    #include"bsp_key.h"
    
    int main()
    {
    	uint32_t time;
    	
    	// TIM 计数器的驱动时钟
    	uint32_t TIM_PscCLK = 72000000 / (71+1);
    	float d = 0;
    
    	USART_Config();
    	HCSR04_GPIO_Config();
    	TIM_Config();
    	KEY_GPIO_Config();
    	
    	printf("\rHC_SR04实验\n");
    	
    	while (1)
    	{
    		if(Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN)== KEY_ON)
    			HCSR04_TRIG_Send();
    		if(TIM_ICUserValueStruct.Capture_FinishFlag == 1)
    		{
    			// 计算高电平时间的计数器的值
    			time = TIM_ICUserValueStruct.Capture_Period * (0xFFFF+1) + (TIM_ICUserValueStruct.Capture_CcrValue+1);
    
    			printf ( "\r\n测得高电平脉宽时间:%ld.%ld s\r\n",time/TIM_PscCLK,time%TIM_PscCLK );
    			d = (float)time * 170 / 10000;
    			printf("距离为:");
    			Print_Float(d);
    
    			TIM_ICUserValueStruct.Capture_FinishFlag = 0;			
    		}		
    	}
    }
    

    上述部分代码移植了野火的例程代码

    展开全文
  • 基于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、实验结果
    在这里插入图片描述

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

    展开全文
  • 使用STM32的定时器与外部中断配合实现超声波模块的测距功能。 这里总体说一说此程序比较理想的执行情况: (1)超声波被调用初始化函数,定时器被设定为可中断,并且定时器开始计数; (2)计数到溢出,触发定时器...
  • 基于stm32f103rct6的外部中断超声波测距,本测距方案稳定性高,不容易出现数据波动,测距范围在2-500cm左右,自带串口printf输出测试距离
  • stm32驱动HC-SR04超声波模块测距的中断例程,PA4->Trig,PA5->Echo 串口1打印测量距离。
  • 电子-超声波测距外部中断.zip,单片机/嵌入式STM32-F0/F1/F2
  • 电子-超声波测距外部中断需要进一步分析.zip,单片机/嵌入式STM32-F0/F1/F2
  • 基于STM32的扫雷小车4路超声波测距中断外部中断
  • 红外遥控循迹超声波避障跟随光电码盘计数测速五个中断智能小车 * 通过红外遥控,控制小车的方向,通过循迹前进,通过超声波跟随。通过光电码盘计数测速,把52的五个中断用上了。。。
  • 使用中断实现超声波传感器的测距,能够大大减少时间的占用!
  • 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 
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • MSP432中断初试

    千次阅读 2021-06-01 19:26:23
    MSP432中断初试 @目录 MSP430 单片机中断 再次领悟中部中断实验 一、MSP430 单片机中断 与所有单片机一样包括 中断请求,中断响应,中断处理,中断返回 下面展示一些 中断程序编写格式。 #pragma vector=中断向量...
  • 通过一个定时器 一个中断 理论上可接无限多个超声波 (需加门电路)
  • stm32资源整合系列
  • STM32 Cubemax(九) ——利用捕获中断实现超声波测距 文章目录STM32 Cubemax(九) ——利用捕获中断实现超声波测距前言一、超声波模块原理二、Cubmax配置三、代码实验结果总结 前言 因为要实现一下卡尔曼滤波,所以...
  • 摘自:stm32 超声波模块 原理 实现测距 +舵机使用 作者:点灯小哥 发布时间: 2021-03-10 19:37:16 网址:https://blog.csdn.net/weixin_46016743/article/details/114643703
  • MCU:获取超声波接口

    2022-04-18 09:12:12
    文章目录一、获取超声波数据接口二、使用方法 一、获取超声波数据接口 支持GPS模块列表: hc-sr04 Cubemx配置界面: 代码结构: sensor_hc_sr04.c sensor_hc_sr04.h main.c sensor_hc_sr04.c #include ...
  • STM32F103 4路超声波

    2020-11-14 23:39:39
    基于STM32F103的4路超声波程序,基于官方库函数版本,方便移植。移植简单,可以用来做4路超声波寻迹小车,也可以做避障小车。程序简单易懂,端口都进行了宏定义,直接修改使用。
  • 超声波发射器向某一方向发射超声波,在发射的同时开始计时,超声波在空气中传播,途中碰到障碍物就立即返回来,超声波接收器接收到反射就立即停止计时。一般情况下,超声波在空气中的传播速度为340m/ s,根据计时
  • 一路超声波测距串口1,串口2和串口3输出距离 外部中断四路超声波测距
  • 自己整理的三个模板,用keil写的tm4c123的外部中断和定时器,由于是整理 里面的注释有的与实际应用会不符,主要就是IO设置
  • STM32嵌入式实现超声波测距三种方式实现 1.while循环检测; 2.外部中断检测; 3.定时器输入捕获检测。 分别有三个文件夹 单片机型号为:STM32F103系列,超声波型号为:HC-SR04
  • 整个系统由单片机MSP430G5529控制,在单片机控制下,超声波发射装置发射脉冲信号与计数器开始计时...当超声波接收装置接收到由障碍物反射回来的回波信号时,单片机由外部比较电路中产生的高电平触发中断,停止计数。
  • 应用MSP430单片机,并口12864显示距离,可以应用多个超声波模块
  • 原理: 1.给控制端Trig一个至少持续10us的高电平信号 2.模块内部自动发送8个40kHZ的...4.鉴于我已经在别的模块用过外部中断,所以使用定时器的输入捕获引脚,进行抓取,当识别到上升沿时定时器开始计时,识别到下降...
  • 超声波测距的proteus

    2019-02-09 13:36:55
    基于51单片机的超声波测距仪,用proteus进行了仿真,挺有意思的,感兴趣的朋友可以下载玩一玩。
  • 超声波测距电路+汇编程序:用的是非门 + CX20106A方案。发射部分用非门驱动,我用的CX20106A是拆机件。用万用板搭好电路之后,在网上找到了一些参考汇编程序,我修改后可以通过串口发到PC显示超声波往返的时间。
  • 超声波测距

    2018-09-09 09:26:54
    超声波测距程序采用定时器中断的方式进行测距,代码简单易懂

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,976
精华内容 1,190
关键字:

超声波中断