一.实验一
实验目的
采用stm32F103和HC-SR04超声波模块， 使用标准库或HAL库+ 定时器中断，完成1或2路的超声波障碍物测距功能。
测试数据包含噪声，程序需要进行滤波处理；将测距数值通过串口上传到上位机串口助手
使用的硬件
STM32F103C8T6最小开发板
HC-SR04
ST-Link（其他烧录器也可以）
HC-SR04
通过时序图我们可以知道，我们给HC-SR04发送长达10us的TTL脉冲，然后模块就会进行测距，测距的结果通过回响信号传达，回响的TTL电平信号时间即是超声波从HC-SR04模块发出，触碰到障碍物后返回到HC-SR04模块的时间总和。
TTL是逻辑电平标准，当电压达到2.4V5V之间，那么为逻辑1（高电平），电压在0V0.4V之间，那么为逻辑0（低电平）。所以我们可以直接通过GPIO口来输出以及输入时序所需的电平信号。
总所周知，声音的速度为340m/s，因此我们将回响电平的时间除340再除2之后得到的就是单位为米的测距结果。
实现方法
我们仅需提供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。
配置HAL库
GPIO配置
NVIC配置
RCC配置
SYS配置
主要代码
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2024 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "tim.h"
#include "usart.h"
#include "gpio.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "SR04.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_TIM2_Init();
MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
SR04_GetData( );
HAL_Delay(1500);
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
实现效果
RS485与RS232（UART）
RS485和RS232（UART）是两种不同的串行通信标准，它们有以下不同之处：
电气特性：RS485是一种差分信号标准，使用两条线传输数据，一条用于正向传输，另一条用于反向传输。这使得RS485更适合长距离通信和抗干扰能力更强。而RS232（UART）则是单端信号标准，通常只适用于短距离通信。
信号电平：RS485使用不同的电平来表示逻辑1和逻辑0，通常为正负5V或正负12V，而RS232使用正负12V来表示逻辑1和逻辑0。
连接数量：RS485支持多点通信，可以连接多个设备，而RS232通常是一对一的连接方式。
通信速率：RS485通常支持更高的通信速率，可以达到几百kbps甚至更高，而RS232的通信速率通常较低，最高通常在几十kbps左右。
应用领域：由于其长距离通信和多点连接的特性，RS485常用于工业控制系统、远程监控以及建筑自动化等领域，而RS232通常用于连接个人电脑与外围设备，如串口打印机、调制解调器等。
Modbus协议是什么？
Modbus协议是一种用于串行通信的通信协议，常用于工业领域的自动化控制系统中。它定义了一组通信规则，允许不同设备之间进行数据交换。Modbus协议通常基于串行通信标准，如RS485和RS232，并且支持不同的传输模式，包括RTU（二进制编码）和ASCII（字符编码）。该协议包括一组功能码，用于读取和写入数据，以及进行其他控制操作。 Modbus协议简单、可靠，并且被广泛应用于工业自动化和监控系统中。
二.工程项目主演代码
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);
}
}
超声波模块
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;
}
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");
}
}
卡尔曼滤波和均值滤波
均值滤波：
//通过定时器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);//卡尔曼滤波设置
主函数模块
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");
}
}
726
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
