基于STM32的HC-SR04超声波测距（PWM蜂鸣器+滤波算法+数据上云-标准库实现）
基于STM32的HC-SR04超声波测距（滤波算法+数据上云）
文章目录
前言
本文介绍了基于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是1CC1P：输入/捕获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就会比较影响传感器的灵敏度
参考文献
【STM32F103】HC-SR04超声波测距模块详解（附工程文件）
开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！
更多推荐
17
0- 0
已为社区贡献18条内容
所有评论(0)