基于STM32的HC-SR04超声波测距（PWM蜂鸣器+滤波算法+数据上云-标准库实现）

菲菲QAQ

已于 2024-05-31 22:23:12 修改

阅读量1k

点赞数 15

文章标签： stm32 算法嵌入式硬件

于 2024-05-21 20:18:46 首次发布

本文链接：https://blog.csdn.net/weixin_68811361/article/details/139094478

版权

前言

本文介绍了基于STM32的HC-SR04超声波测距模块的应用和程序设计。通过控制STM32单片机与HC-SR04模块的交互，实现距离的测量与显示。提供了详细的电路连接和程序设计步骤，使读者能够快速开始使用和开发基于HC-SR04的超声波测距应用。

一、项目环境

硬件
stm32f013c8t6开发板
HC-SR04模块
蜂鸣器
ESP8266蓝牙模块
USB-TTL串口
杜邦线若干
软件
keil
野火多功能调试助手
云服务器平台
OneNet

二、HC-SR04超声波传感器原理

2.1 传感器概述：

HC-SR04超声波距离传感器的核心是两个超声波传感器。一个用作发射器，将电信号转换为40 KHz超声波脉冲。接收器监听发射的脉冲。如果接收到它们，它将产生一个输出脉冲，其宽度可用于确定脉冲传播的距离。就是如此简单！该传感器体积小，易于在任何机器人项目中使用，并提供2厘米至400厘米（约1英寸至13英尺）之间出色的非接触范围检测，精度为3mm。

在这里插入图片描述

2.2 传感器引脚

在这里插入图片描述

VCC 是HC-SR04超声波距离传感器的电源
Trig 引脚用于触发超声波脉冲
Echo 回声当接收到反射信号时，引脚产生一个脉冲。脉冲的长度与检测发射信号所需的时间成正比
GND 用于接地

2.3 传感器工作原理

当持续时间至少为10 µS（10微秒）的脉冲施加到触发引脚时，一切就开始了。响应于此，传感器以40 KHz发射八个脉冲的声音脉冲。这种8脉冲模式使设备的“超声特征”变得独一无二，从而使接收器能够将发射模式与环境超声噪声区分开。八个超声波脉冲通过空气传播，远离发射器。同时，回声引脚变为高电平，开始形成回声信号的开始。如果这些脉冲没有被反射回来，则回波信号将在38毫秒后超时并返回低电平。因此38 ms的脉冲表示在传感器范围内没有阻塞。
在这里插入图片描述如果这些脉冲被反射回去，则在收到信号后，Echo引脚就会变低。这会产生一个脉冲，其宽度在150 µS至25 mS之间变化，具体取决于接收信号所花费时间。

在这里插入图片描述

HC-SR04的时序图如下：
在这里插入图片描述

通过时序图我们可以知道，我们给HC-SR04发送长达 10us 的TTL脉冲，然后模块就会进行测距，测距的结果通过回响信号传达，回响的TTL电平信号时间即是超声波从HC-SR04模块发出，触碰到障碍物后返回到HC-SR04模块的时间总和。

TTL是逻辑电平标准，当电压达到2.4V-5V之间，那么为逻辑1（高电平），电压在0V~0.4V之间，那么为逻辑0（低电平）。所以我们可以直接通过GPIO口来输出以及输入时序所需的电平信号。

然后，将接收到的脉冲的宽度用于计算到反射物体的距离。这可以通过我们在初中学到的简单的距离-速度-时间方程来解决。

距离=速度x时间 ，当然温度，以及环境噪声等对实验结果都有影响，因此公式应在不同环境下进行修改

总所周知，声音的速度为340m/s，因此我们将回响电平的时间除340再除2之后得到的就是单位为米的测距结果。

2.4 整体测距原理及编写思路

在这里插入图片描述
编写思路：

以上时序图表明我们只需要提供一个10uS以上脉冲触发信号，该模块内部将发出8个40kHz周期电平并检测回波。一旦检测到有回波信号则输出回响信号。
回响信号的脉冲宽度与所测的距离成正比。此通过发射信号到收到的回响信号时间间隔可以计算得到距离。公式：uS/58=厘米或者uS/148=英寸；或是：距离=高电平时间*声速（340M/S）/2：建议测量周期为60ms以上，以防止发射信号对回响信号的影响。

结合说明书我们可以知道，我们仅需提供10us的高电平给Trig口即可。然后HC-SR04在测量完毕之后会将结果通过Echo回响回来。

所以我们只需要将Trig口拉高，等待10us（最好再延长一些，代码中用的是15us）后再拉低即可。

接着就只需要等待Echo将数据传输回来，通过时序图我们可以得知回响信号是拉高Echo口，再拉低，中间持续的时间就是测距的结果。

所以我们给Echo口配置一个中断事件，设置为上跳变下跳变都触发，另外再用一个变量记录Echo口到底是拉高还是拉低即可。

如果是拉高，那么我们需要记录下持续的时间，这时候我们需要用定时器计时，所以需要在一开始的时候就配置好定时器的初始化。唯一的问题就是该如何配置定时器的预分频器和自动重装器了。

根据说明书我们可以知道HC-SR04的精度为3mm，而测距的公式为 us/58-cm，稍加计算可知，如果我们需要测量3mm，那么得到的时间为17.4us，以此为一个刻度，那么定时器的频率应该为57471Hz。然而这样太麻烦了，而且也不好用，因此我们可以随意一些，我在代码中使用的是预分频器为72，自动重装器为100，那么得到的频率为72MHz/72/100=1000Hz，也就是一次定时器中断的时间为100us，而自动重装器里的每一个值就是1us，所以每次外部中断的下降沿触发之后只需要将定时器触发的次数*100再加上自动重装器里的值就可以得到回响信号的持续时间了，单位是us。

三、技术说明

3.1 TIM定时器介绍

TIM 在这里插入图片描述
对于简单的PWM的输出以及捕获都主要用到向上计数功能。计数值会按照设定的频率（根据预分频器寄存器的值得到设定频率）来计数（计数值存在计数器寄存器中），当计数值（计数器寄存器中的值）达到与自动装载寄存器中的值相等时，又从零计数，周而复始。

在这里插入图片描述

3.2 PWM脉冲调制介绍

PWM
根据配置PWM，使得一个周期内以固定占空比（duty，表示一个周期中高电平所占的比例）输出高电平与低电平。
在这里插入图片描述

根据stm32f103rbt6.pdf的第19页可以看到TIM3的通道1和通道2对应的引脚分别为PA6,PA7，TIM2的通道2和通道3对应的引脚为PA1,PA2。我们常用到以下四个引脚来配置PWM的输出和捕获。

3.3 TIM和PWM的初始化

这里以TIM2的通道2和3（TIM2_CH2、TIM2_CH3）为例，来配置PWM的输出的初始化

void PWM_INITOutput(u16 arr,u16 pre,u16 OC2pluse,u16 OC3pluse)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
	TIM_OCInitTypeDef TIM_OCInitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);
	
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_1|GPIO_Pin_2;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	
	TIM_TimeBaseInitStructure.TIM_Period=arr-1;//一个计数周期的整个计数值大小，是从0开始计数所以要减去1
	TIM_TimeBaseInitStructure.TIM_Prescaler=pre-1;//分频大小，分频后最终的计数频率为:(72M/pre)Hz;
	TIM_TimeBaseInitStructure.TIM_CounterMode=0x0;//记住
	TIM_TimeBaseInitStructure.TIM_ClockDivision=0x0;//记住
	TIM_TimeBaseInit(TIM2,&TIM_TimeBaseInitStructure);
	
	TIM_OCInitStructure.TIM_OCMode=TIM_OCMode_PWM2;//PWM2模式时配置极性为LOW（PWM1模式时配置极性为High）：这样配置，占空比的数值就是对应的pluse的值
	TIM_OCInitStructure.TIM_OCPolarity=TIM_OCPolarity_Low;//低电平有效
	TIM_OCInitStructure.TIM_OutputState=TIM_OutputState_Enable;//要用时就ENABLE（打开），不用该输出时就DISABLE（关闭）
	TIM_OCInitStructure.TIM_Pulse=OC2pluse;
	TIM_OC2Init(TIM2,&TIM_OCInitStructure);
	
	TIM_OCInitStructure.TIM_OCMode=TIM_OCMode_PWM2;
	TIM_OCInitStructure.TIM_OCPolarity=TIM_OCPolarity_Low;
	TIM_OCInitStructure.TIM_OutputState=TIM_OutputState_Enable;
	TIM_OCInitStructure.TIM_Pulse=OC3pluse;
	TIM_OC3Init(TIM2,&TIM_OCInitStructure);
	
	TIM_CtrlPWMOutputs(TIM2,ENABLE);
	TIM_Cmd(TIM2,ENABLE);
}

这个地方困扰了我很久，直到看到下面这篇博客

	TIM_OCInitStructure.TIM_OCMode=TIM_OCMode_PWM2;//PWM2模式时配置极性为LOW（PWM1模式时配置极性为High）：这样配置，占空比的数值就是对应的pluse的值
	TIM_OCInitStructure.TIM_OCPolarity=TIM_OCPolarity_Low;//低电平有效
	TIM_OCInitStructure.TIM_OutputState=TIM_OutputState_Enable;//要用时就ENABLE（打开），不用该输出时就DISABLE（关闭）
	TIM_OCInitStructure.TIM_Pulse=OC2pluse;
	TIM_OC2Init(TIM2,&TIM_OCInitStructure);

TIM_OCInitStructure.TIM_OCMode=TIM_OCMode_PWM2;//PWM2模式时配置极性为LOW（PWM1模式时配置极性为High）：这样配置，占空比的数值就是对应的pluse的值
首先需要知道：TIM_OCInitStructure.TIM_Pulse=CCR1_Value;也就是说TIM_Pulse的值赋值到TIMx_CCR1。
PWM2模式是由CCMR1的OC1M和OC2M来决定的，因为我们选择的是是通道1，所以设置的是OC1M，再看相关介绍OC1M[2:0]：输出比较1模式(Output compare 1 enable)
110：PWM模式1－在向上计数时，一旦TIMx_CNT<TIMx_CCR1时通道1为 有效电平 ，否则为无效电平；在向下计数时，一旦TIMx_CNT>TIMx_CCR1时通道1为无效电平(OC1REF=0)，否则为有效电平(OC1REF=1)。
111：PWM模式2－在向上计数时，一旦TIMx_CNT<TIMx_CCR1时通道1为无效电平，否则为 有效电平；在向下计数时，一旦TIMx_CNT>TIMx_CCR1时通道1为有效电平，否则为无效电平。
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low; //输出极性:TIM输出比较极性低，所以这里我们设置的CC2P是1
CC1P：输入/捕获1输出极性(Capture/Compare 1 output polarity) 位1
CC1通道配置为输出：0：OC1高电平有效 1：OC1低电平有效
看了上面要是对输出电平又疑惑可以看这篇博客：STM32输出PWM时,PWM1和PWM2的区别 https://blog.csdn.net/kinsno/article/details/46763243

若arr=1000,pre=72,OC1pluse=400,OC2pluse=800.

在这里插入图片描述

3.4 卡尔曼滤波算法原理

（1）简单说明
卡尔曼滤波器 是一个“optimal recursive data processing algorithm（最优化自回归数据处理算法）”。对于解决很大部分的问题，它是最优、效率最高甚至是最有用的。

（2）基本公式

预测（Predict）
状态预测方程：
x̂ₖ⁻ = Fₖx̂ₖ₋₁ + Bₖuₖ

协方差预测方程：
Pₖ⁻ = FₖPₖ₋₁Fₖᵀ + Qₖ

其中，x̂ₖ⁻是先验（预测）状态估计，表示在时刻k时的状态预测值；Fₖ是状态转移矩阵，描述状态在时间上的演化；x̂ₖ₋₁是时刻k-1时的状态估计；Bₖ是控制输入矩阵，表示外部控制对系统状态的影响；uₖ是时刻k的控制输入；Qₖ是过程噪声协方差矩阵，表示系统模型中的不确定性。

Pₖ⁻是先验协方差矩阵，表示对状态预测的不确定性；Pₖ₋₁是时刻k-1时的协方差矩阵。

更新（Update）：
卡尔曼增益计算：
Kₖ = Pₖ⁻Hₖᵀ(HPₖ⁻Hₖᵀ + Rₖ)⁻¹

状态更新方程：
x̂ₖ = x̂ₖ⁻ + Kₖ(yₖ - Hₖx̂ₖ⁻)

协方差更新方程：
Pₖ = (I - KₖHₖ)Pₖ⁻

其中，Kₖ是卡尔曼增益，表示预测值和测量值之间的权衡；Hₖ是测量矩阵，描述测量值与状态之间的关系；yₖ是时刻k的测量值；Rₖ是测量噪声协方差矩阵，表示测量误差的不确定性。

x̂ₖ是最优的状态估计值，表示在时刻k时的状态估计；Pₖ是最优的协方差矩阵，表示对状态估计的不确定性。

通过递归地进行预测和更新步骤，卡尔曼滤波器能够实时地估计系统的状态，并通过不断地更新来适应系统的动态变化和测量噪声的影响。

（3）举例说明
这里先根据下面的例子对卡尔曼滤波的5条公式进行一步一步地探索。

假设我们要研究的对象是一个房间的温度。根据你的经验判断，这个房间的温度是恒定的，也就是下一分钟的温度等于现在这一分钟的温度（假设我们用一分钟来做时间单位）。假设你对你的经验不是100%的相信，可能会有上下偏差几度。我们把这些偏差看成是高斯白噪声，也就是这些偏差跟前后时间是没有关系的而且符合高斯分配。另外，我们在房间里放一个温度计，但这个温度计也是不准确的，测量值会比实际值偏差。我们也把这些偏差看成是高斯白噪声。
好了，现在对于谋一分钟我们有两个关于该房间的温度值：你根据经验的预测值（系统的预测值）和温度计的值（测量值）。下面要用这两个值结合它们各自的噪声来估算出房间的实际温度值。
假如我们要估算k时刻的实际温度值。首先你要根据k-1时刻的温度值，来预测k kk时刻的温度。因为你相信温度是恒定的，所以你会得到k 时刻的温度预测值是跟k-1时刻一样的，假设是23度，同时该值的高斯噪声的偏差是5度（5是这样得到的：如果k -1时刻估算出的最优温度值的偏差是3，你对自己预测的不确定度是4，它们的平方相加再开方，就是5）。然后，你从温度计那里得到了k 时刻的温度值，假设是25度，同时该值的偏差是4度。
由于我们用于估算k 时刻的实际温度有两个温度值，分别是23度和25度。究竟实际温度是多少呢？相信自己还是相信温度计？究竟相信谁多一点，我们可以用它们的covariance来判断。Kg2=52/(52＋42)，所以Kg=0.78,我们可以估算出k时刻的实际温度值是：23 + 0.78 ∗ ( 25 − 23 ) = 24.56 度。可以看出，因为温度计的covariance比较小（比较相信温度计），所以估算出的最优温度值偏向温度计的值。现在我们可以得到k时刻的最优温度值了，下一步就是要进入k+1时刻，进行新的最优估算。到现在为止，好像还没看到什么自回归的东西出现。对了，在进入k+1时刻之前，我们还要算出k 时刻那个最优值（24.56度）的偏差。算法如下：((1一 Kg) * 52)0.5=2.35。这里的5 就是上面的k时刻你预测的那个23度温度值的偏差，得出的2.35就是进入k+1时刻以后k 时刻估算出的最优值的偏差（对应于上面的3）。
就是这样，卡尔曼滤波就不断地把covariance地柜，从而估算出最优的温度值。它运行的很快，而且它只保留了上一时刻的covariance。上面的K g ，就是卡尔曼增益。它可以随不同的时刻改变它自己的值。

三、工程项目

3.1 PWM驱动无源蜂鸣器模块

beep.c

//单片机头文件
#include "stm32f10x.h"

//硬件驱动
#include "beep.h"

#include "delay.h"

BEEP_INFO beepInfo = {0};


/*
************************************************************
*	函数名称：	Beep_Init
*
*	函数功能：	蜂鸣器初始化
*
*	入口参数：	无
*
*	返回参数：	无
*
*	说明：		
************************************************************
*/
void Beep_Init(void)//GPIOB12
{

	GPIO_InitTypeDef gpioInitStruct;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);		//打开GPIOB的时钟
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);	//禁止JTAG功能
	
	gpioInitStruct.GPIO_Mode = GPIO_Mode_Out_PP;				//设置为输出
	gpioInitStruct.GPIO_Pin = GPIO_Pin_12;						//将初始化的Pin脚
	gpioInitStruct.GPIO_Speed = GPIO_Speed_50MHz;				//可承载的最大频率
	
	GPIO_Init(GPIOB, &gpioInitStruct);							//初始化GPIO
	
	Beep_Set(BEEP_OFF);											//初始化完成后，关闭蜂鸣器

}

/*
************************************************************
*	函数名称：	Beep_Set
*
*	函数功能：	蜂鸣器控制
*
*	入口参数：	status：开关蜂鸣器
*
*	返回参数：	无
*
*	说明：		开-BEEP_ON		关-BEEP_OFF
************************************************************
*/
void Beep_Set(_Bool status)
{
	
	GPIO_WriteBit(GPIOB, GPIO_Pin_12, status == BEEP_ON ?  Bit_RESET: Bit_SET);		//如果status等于BEEP_ON，则返回Bit_SET，否则返回Bit_RESET
	
	beepInfo.Beep_Status = status;

}



//TIM4 PWM部分初始化
//PWM输出初始化
//arr：自动重装值
//psc：时钟预分频系数
void TIM2_PWM_Init(u16 arr,u16 psc)
{

	//开启TIM2时钟，TIM2是APB1总线的外设
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2,ENABLE);
	
	//选择时基单元的时钟为内部时钟
	TIM_InternalClockConfig(TIM2);
	
	
	//配置GPIO
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;//上拉输入
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	
	
	//配置时基单元
	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
	TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;//时钟分频
	TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up;//计数器模式，向上计数
	TIM_TimeBaseInitStructure.TIM_Period=arr;//周期，ARR自动重装器的值  100-1
	TIM_TimeBaseInitStructure.TIM_Prescaler=psc;//PSC预分频器的值  720-1
	TIM_TimeBaseInitStructure.TIM_RepetitionCounter=0;//重复计数器的值，高级计数器使用的 这里不需要
	TIM_TimeBaseInit(TIM2,&TIM_TimeBaseInitStructure);
	
	TIM_OCInitTypeDef TIM_OCInitStructure;
	TIM_OCStructInit(&TIM_OCInitStructure);//给结构体赋初始值
	TIM_OCInitStructure.TIM_OCMode=TIM_OCMode_PWM1;//设置输出比较的模式
	TIM_OCInitStructure.TIM_OCPolarity=TIM_OCPolarity_High;//设置输出比较的极性
	TIM_OCInitStructure.TIM_OutputState=TIM_OutputState_Enable;//设置输出使能
	TIM_OCInitStructure.TIM_Pulse=0;//设置CCR
	TIM_OC1Init(TIM2,&TIM_OCInitStructure);
	
	TIM_Cmd(TIM2,ENABLE);

}



void PWM_SetCompare1(uint16_t Compare)
{
	TIM_SetCompare1(TIM2,Compare);//设置CCR的值
}


void alarm_data_Exception()
{
	//4000hz=72M/(72*250)=4k
	TIM2_PWM_Init(249,71);//4000hz的声音 比较尖锐
	for(int i=0;i<3;i++)
	{
		PWM_SetCompare1(125);
		delay_ms(100);
		PWM_SetCompare1(0);
		delay_ms(100);
	}
}


void alarm_data_NOTException()
{
	//1000hz=72M/（72*1000）=1K
	TIM2_PWM_Init(999,71);//1KHz 声音比较低

	PWM_SetCompare1(500);
	delay_ms(100);
	PWM_SetCompare1(0);//不发生占空比设为0
	delay_ms(100);
}

void alarm_init_finish()
{
	//   72M/（72*500）=2k
	TIM2_PWM_Init(499,71);
	
	for(int i=0;i<2;i++)
	{
		PWM_SetCompare1(250);
		delay_ms(100);
		PWM_SetCompare1(0);
		delay_ms(100);
	}
	
	
}

3.2 超声波模块

hc.c

#include "hc.h"
#include "delay.h"
#include "sys.h"
#include "usart.h"	
#include "led.h"
#include "key.h"

//超声波硬件接口定义
#define HCSR04_PORT     GPIOB
#define HCSR04_CLK      RCC_APB2Periph_GPIOB
#define HCSR04_TRIG     GPIO_Pin_11
#define HCSR04_ECHO     GPIO_Pin_10

u16 msHcCount = 0;
//定时器4设置
void hcsr04_NVIC()
{
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
			
	NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;             
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;         
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;       
	NVIC_Init(&NVIC_InitStructure);
}

//IO口初始化 及其他初始化
void Hcsr04Init()
{  
    TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(HCSR04_CLK, ENABLE);
   
    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);
     
    GPIO_InitStructure.GPIO_Pin =   HCSR04_ECHO;     
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(HCSR04_PORT, &GPIO_InitStructure);  
    GPIO_ResetBits(HCSR04_PORT,HCSR04_ECHO);    
     
          
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);   
    
	
	//定时频率 = CK_CNT/(ARR+1) = CK_PSC/(PSC+1)/(ARR+1)
	//  队72MHz进行72分频，得到的就是106次方的计数频率，在这个计数频率下记1000个数，就是1ms
    TIM_DeInit(TIM2);
    TIM_TimeBaseStructure.TIM_Period = (1000-1); //周期，arr自动重装器的值，定时器的周期是1000
    TIM_TimeBaseStructure.TIM_Prescaler =(72-1); //PSC,分频器的值72 
    TIM_TimeBaseStructure.TIM_ClockDivision=TIM_CKD_DIV1;//指定时钟分频，不分频
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//计数器模式  
    TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);          
        
    TIM_ClearFlag(TIM4, TIM_FLAG_Update);  
    TIM_ITConfig(TIM4,TIM_IT_Update,ENABLE);    
    hcsr04_NVIC();
    TIM_Cmd(TIM4,DISABLE);     
}


//打开定时器4
static void OpenTimerForHc()  
{
   TIM_SetCounter(TIM4,0);
   msHcCount = 0;
   TIM_Cmd(TIM4, ENABLE); 
}

//关闭定时器4
static void CloseTimerForHc()    
{
   TIM_Cmd(TIM4, DISABLE); 
}

//定时器4终中断
void TIM4_IRQHandler(void)  
{
   if (TIM_GetITStatus(TIM4, TIM_IT_Update) != RESET)  
   {
       TIM_ClearITPendingBit(TIM4, TIM_IT_Update  ); 
       msHcCount++;
   }
}
 

//获取定时器4计数器值
u32 GetEchoTimer(void)
{
   u32 t = 0;
   t = msHcCount*1000;
   t += TIM_GetCounter(TIM4);
   TIM4->CNT = 0;  
   delay_ms(50);
   return t;
}
 
//通过定时器4计数器值推算距离
float Hcsr04GetLength(void )
{
   u32 t = 0;// 定义一个无符号32位整数变量t，用于存储定时器的计数
   int i = 0;// 定义一个整型变量i，用作循环计数器
   float lengthTemp = 0;// 定义一个浮点型变量lengthTemp，用于存储每次测量的距离
   float sum = 0;// 定义一个浮点型变量sum，用于累加测量的距离
   while(i!=5) // 循环5次进行距离测量
   {
      TRIG_Send = 1;      // 发送一个触发信号，通常是一个短的高电平脉冲
      delay_us(20);// 延迟20微秒，确保传感器准备好发送超声波
      TRIG_Send = 0;// 结束触发信号
	   
      while(ECHO_Reci == 0);      // 等待ECHO_Reci变为低电平，即超声波发送完毕
	   
      OpenTimerForHc();  //打开定时器4，准备测量超声波的飞行时间
	   
	  //计数周期是1ms
      i = i + 1;// 增加循环计数器
	   
	   
      while(ECHO_Reci == 1);// 等待ECHO_Reci变为高电平，即接收到超声波回声
	   
      CloseTimerForHc();   //关闭定时器4     
	   
      t = GetEchoTimer();    // 读取定时器4的计数值    
	   
      lengthTemp = ((float)t/58.0);//cm
	   //lengthTemp = ((float)t/17.0);//cm
	   
	   
      sum = lengthTemp + sum ;
        
    }
   
	 // 计算平均距离
    lengthTemp = sum/5.0;
	
    return lengthTemp;
	
}

3.3 ESP8266模块

初始化代码:


//==========================================================
//	函数名称：	ESP8266_Init
//
//	函数功能：	初始化ESP8266
//
//	入口参数：	无
//
//	返回参数：	无
//
//	说明：		
//==========================================================
void ESP8266_Init(void)
{
	
	GPIO_InitTypeDef GPIO_Initure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);

	//ESP8266复位引脚
	GPIO_Initure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_Initure.GPIO_Pin = GPIO_Pin_14;					//GPIOC14-复位
	GPIO_Initure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOC, &GPIO_Initure);
	
	GPIO_WriteBit(GPIOC, GPIO_Pin_14, Bit_RESET);
	delay_ms(250);
	GPIO_WriteBit(GPIOC, GPIO_Pin_14, Bit_SET);
	delay_ms(500);
	
	ESP8266_Clear();
	
	UsartPrintf(USART_DEBUG, "0. AT\r\n");
	while(ESP8266_SendCmd("AT\r\n", "OK"))
		delay_ms(500);
	
	UsartPrintf(USART_DEBUG, "1. RST\r\n");
	ESP8266_SendCmd("AT+RST\r\n", "");
	  delay_ms(500);	
	
	ESP8266_SendCmd("AT+CIPCLOSE\r\n", "");
		delay_ms(500);	
	
	UsartPrintf(USART_DEBUG, "2. CWMODE\r\n");
	while(ESP8266_SendCmd("AT+CWMODE=1\r\n", "OK"))
		delay_ms(500);
	
	UsartPrintf(USART_DEBUG, "3. AT+CWDHCP\r\n");
	while(ESP8266_SendCmd("AT+CWDHCP=1,1\r\n", "OK"))
		delay_ms(500);
	
	//连接wifi
	UsartPrintf(USART_DEBUG, "4. CWJAP\r\n");
	while(ESP8266_SendCmd(ESP8266_WIFI_INFO, "GOT IP"))
		delay_ms(500);
	
	//连接设备
	UsartPrintf(USART_DEBUG, "5. CIPSTART\r\n");
	while(ESP8266_SendCmd(ESP8266_ONENET_INFO, "CONNECT"))
		delay_ms(500);
	
	UsartPrintf(USART_DEBUG, "6. ESP8266 Init OK\r\n");

}

将测得的距离数据转化成JSON格式：


//==========================================================
//	函数名称：	OneNet_FillBuf
//
//	函数功能：	数据封装函数，此函数将我们想上传的数据进行包装整合到一个数组中
//
//	入口参数：	buf：发送的数据
//
//	返回参数：	数据流长度
//
//	说明：		
//==========================================================

//main模块的
extern float distance;//声明变量存放温湿度数据
unsigned char OneNet_FillBuf(char *buf)
{
	char  text[32];
	float length;
	
	memset(text,0,sizeof(text));//初始化为0
	
	strcpy(buf,",;");//buf=
	
	//获取超声波传感器检测到的距离
	//length = Hcsr04GetLength();
	length = distance ;
	
	memset(text,0,sizeof(text));
	
	//sprintf(text,"Tempreture,%f;",length);//将长度值格式化为一个字符串，并将字符串保存到text变量中。
	sprintf(text,"Distance,%f;",length);//将长度值格式化为一个字符串，并将字符串保存到text变量中。

	
	strcat(buf,text);//将字符串 text 连接到字符串 buf 的末尾。
	
	
	return strlen(buf);//返回长度
}

上传数据到云平台：



//==========================================================
//	函数名称：	OneNet_SendData
//
//	函数功能：	上传数据到平台
//
//	入口参数：	type：发送数据的格式
//
//	返回参数：	无
//
//	说明：		
//==========================================================
void OneNet_SendData(void)
{
	MQTT_PACKET_STRUCTURE mqttPacket={NULL,0,0,0};//协议包
	char buf[128];
	
	short body_len=0,i=0;
	
	//UsartPrintf(USART_DEBUG,"Tips: OneNet_SendData-MQTT\r\n");
	
	memset(buf,0,sizeof(buf));//清空数组内容，初始化为0
	
	body_len=OneNet_FillBuf(buf);//获取当前需要发送的数据流的总长度
	
	if(body_len)
	{
		if(MQTT_PacketSaveData(DEVID,body_len,NULL,5,&mqttPacket)==0)//封包
		{
			for(;i<body_len;i++)
				mqttPacket._data[mqttPacket._len++]=buf[i];//
			
			ESP8266_SendData(mqttPacket._data,mqttPacket._len);//上传数据到平台
			//UsartPrintf(USART_DEBUG,"Send %d Bytes\r\n",mqttPacket._len);
			
			MQTT_DeleteBuffer(&mqttPacket);//删除包
		}
		else
			UsartPrintf(USART_DEBUG,"WARN:EDP_NewBuffer Failed\r\n");
	}
}

3.5 卡尔曼滤波和均值滤波

均值滤波：


//通过定时器4计数器值推算距离
float Hcsr04GetLength(void )
{
   u32 t = 0;// 定义一个无符号32位整数变量t，用于存储定时器的计数
   int i = 0;// 定义一个整型变量i，用作循环计数器
   float lengthTemp = 0;// 定义一个浮点型变量lengthTemp，用于存储每次测量的距离
   float sum = 0;// 定义一个浮点型变量sum，用于累加测量的距离
   while(i!=5) // 循环5次进行距离测量
   {
      TRIG_Send = 1;      // 发送一个触发信号，通常是一个短的高电平脉冲
      delay_us(20);// 延迟20微秒，确保传感器准备好发送超声波
      TRIG_Send = 0;// 结束触发信号
	   
      while(ECHO_Reci == 0);      // 等待ECHO_Reci变为低电平，即超声波发送完毕
	   
      OpenTimerForHc();  //打开定时器4，准备测量超声波的飞行时间
	   
	  //计数周期是1ms
      i = i + 1;// 增加循环计数器
	   
	   
      while(ECHO_Reci == 1);// 等待ECHO_Reci变为高电平，即接收到超声波回声
	   
      CloseTimerForHc();   //关闭定时器4     
	   
      t = GetEchoTimer();    // 读取定时器4的计数值    
	   
      lengthTemp = ((float)t/58.0);//cm
	   //lengthTemp = ((float)t/17.0);//cm
	   
	   
      sum = lengthTemp + sum ;
        
    }
   
	 // 计算平均距离
    lengthTemp = sum/5.0;
	
    return lengthTemp;
	
}

卡尔曼滤波：


// 卡尔曼滤波变量设置
float P=1;   // 初始估计误差协方差，表示对初始估计不确定性的度量
float P_;   // 下一次预测误差协方差，即公式中的p'
float X=0;    // 初始状态估计，通常是位置或者速度等
float X_;   // 下一次状态预测，即公式中的X'
float K=0;  // 卡尔曼增益，用于权衡预测值和观测值
float Q=0.01;// 过程噪声协方差，表示状态转移过程中的不确定性
// R大，更相信预测，那么传感器反应就会迟钝，反之亦然
float R=0.2;// 观测噪声协方差，这里0.5算有点大，R的值需要根据实际情况调整


// 卡尔曼滤波函数
float KLM(float Z)
{
  X_=X+0;       // 预测当前状态，这里没有变化，因为是简单的示例
  P_=P+Q;       // 更新预测误差协方差，考虑过程噪声
  K=P_/(P_+R);   // 计算卡尔曼增益，权衡预测值和观测值
  X=X_+K*(Z-X_); // 更新状态估计，根据观测值调整预测
  P=P_-K*P_;     // 更新估计误差协方差
  return X;      // 返回更新后的状态估计
}

distance = KLM(distance);//卡尔曼滤波设置

3.4 主函数模块

main.c

#include "delay.h"
#include "sys.h"
#include "usart.h"	 
#include "led.h"	
#include "key.h"	
#include "hc.h"	
#include "beep.h"
#include "onenet.h"
#include "mqttkit.h"
#include "esp8266.h"

//存放超声波模块测到的距离
float distance;




// 卡尔曼滤波变量设置
float P=1;   // 初始估计误差协方差，表示对初始估计不确定性的度量
float P_;   // 下一次预测误差协方差，即公式中的p'
float X=0;    // 初始状态估计，通常是位置或者速度等
float X_;   // 下一次状态预测，即公式中的X'
float K=0;  // 卡尔曼增益，用于权衡预测值和观测值
float Q=0.01;// 过程噪声协方差，表示状态转移过程中的不确定性
// R大，更相信预测，那么传感器反应就会迟钝，反之亦然
float R=0.2;// 观测噪声协方差，这里0.5算有点大，R的值需要根据实际情况调整


// 卡尔曼滤波函数
float KLM(float Z)
{
  X_=X+0;       // 预测当前状态，这里没有变化，因为是简单的示例
  P_=P+Q;       // 更新预测误差协方差，考虑过程噪声
  K=P_/(P_+R);   // 计算卡尔曼增益，权衡预测值和观测值
  X=X_+K*(Z-X_); // 更新状态估计，根据观测值调整预测
  P=P_-K*P_;     // 更新估计误差协方差
  return X;      // 返回更新后的状态估计
}

void judge(){

}




//测试主函数
int main(void)
 {	 
	 
	//char PUB_BUF[256];//上传数据的buf 
	float length;
	const char *topics[] = {"mysmart/sub"};
	unsigned short timeCount = 0;	//发送间隔变量
	unsigned char *dataPtr = NULL;
	
	delay_init();//延时函数初始化	 
	
	//Beep_Init();	 //有源蜂鸣器需要初始化，无源蜂鸣器不需要初始化，只需要使用PWM波即可
	
	NVIC_Configuration();//设置NVIC中断分组2:2位抢占优先级，2位响应优先级
	
	Usart1_Init(115200);	 //串口1初始化为115200
	Usart2_Init(115200);//串口2初始化为115200
	
	Hcsr04Init();//超声波模块初始化
	
	
//	while(1){
//		distance  = Hcsr04GetLength();	
//		//distance = KLM(distance);//卡尔曼滤波设置
//			
//		UsartPrintf(USART_DEBUG,"超声波测距模块测量的距离为：%f cm\r\n",distance);
//		
//		if(distance <10){
//			alarm_data_Exception();//4k
//		}else if(distance >=10 && distance<20){
//			alarm_init_finish();//2k
//		}else if(distance >=20 && distance<40){
//			alarm_data_NOTException();//1k
//		}
//			
//		
//		delay_ms(500);
//		
//	}
	
	
	
	UsartPrintf(USART1,"串口测试\r\n");      
	UsartPrintf(USART1,"超声波初始化成功!\n");
	
	ESP8266_Init();//初始化ESP8266
	UsartPrintf(USART1,"ESP8266初始化成功!\n");

	UsartPrintf(USART1,"正在尝试连接设备.......\n");
	while(OneNet_DevLink())//接入OneNET
		delay_ms(500);
	
//	Beep_Set(BEEP_ON);//蜂鸣器鸣叫表示OneNet接入成功
//	delay_ms(500);
//	Beep_Set(BEEP_OFF);
	alarm_init_finish();//蜂鸣器鸣叫表示初始化成功
	
    OneNet_Subscribe(topics, 1);
	
   while(1) 
	 {	 
	 
//		if(timeCount%40==0)//1000毫秒/完成一次25ms=40 一秒执行一次（有一点点误差）		 
//		{  length = Hcsr04GetLength();
//			UsartPrintf(USART1,"距离为:%.3fcm\n",length);    
//		}	

		if(++timeCount >= 50)//发送间隔5s，也就是5s上传一次数据，5000/25=200
		{
//			UsartPrintf(USART_DEBUG, "OneNet_Publish\r\n");
			UsartPrintf(USART_DEBUG, "OneNet_SendData\r\n");
			
			OneNet_SendData();//发送数据给onenet
			
			distance  = Hcsr04GetLength();
			
			distance = KLM(distance);//卡尔曼滤波设置
			
			//PWM驱动蜂鸣器
			if(distance <10){
				alarm_data_Exception();//4k
			}else if(distance >=10 && distance<20){
				alarm_init_finish();//2k
			}else if(distance >=20 && distance<40){
				alarm_data_NOTException();//1k
			}
			
			
			UsartPrintf(USART_DEBUG,"超声波测距模块测量的距离为：%f cm\r\n",distance);
			
			UsartPrintf(USART_DEBUG, "OneNet_SendData_End\r\n");
			

			//sprintf(PUB_BUF,"{\"length \":%1.f cm}",length);
//			OneNet_Publish("pcTopic",PUB_BUF);
			timeCount = 0;
			ESP8266_Clear();
		}
		
		dataPtr = ESP8266_GetIPD(3);//获取平台返回的数据，完成需要15个毫秒，三次循环，一次5个毫秒
		if(dataPtr != NULL)//如果返回数据不为空
			OneNet_RevPro(dataPtr);//平台返回数据监测
		delay_ms(10); 
		
		//UsartPrintf(USART_DEBUG, "\r\n");
		 
	 
	}
}

四、效果演示：

4.1 数据上云

云平台展示实时数据
在这里插入图片描述

测量的距离数据历史记录：
在这里插入图片描述

4.2 串口助手

在这里插入图片描述

4.3 整体接线图

在这里插入图片描述

4.4 整体演示视频：

视频演示效果：

基于STM32的HC-SR04超声波测距（滤波算法+数据上云）

五、源码获取方法

基于STM32的HC-SR04超声波测距（PWM蜂鸣器+滤波算法+数据上云-标准库实现）

总结

本文介绍了基于STM32的HC-SR04超声波测距模块的应用和程序设计。通过电路连接和程序设计的步骤，对于超声波模块有了一定的认识和掌握，也能做到触类旁通，除了用stm32来实现外，用fpga的来实现超声波测距也有了一定的思路，虽然代码编写还是有很大不同。然后也理解到了卡尔曼滤波算法的原理及应用，代码编写是那个R值超过0.5就会比较影响传感器的灵敏度