如何使用超声波测距模块去读取源代码呢

　　超声波测距模块源代码
　　/*************************************
　　编写人：***
　　模块功能： 超声波测距
　　使用的资源：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