04.HC_SR04超声波测距

最新推荐文章于 2023-11-04 22:30:46 发布
最新推荐文章于 2023-11-04 22:30:46 发布
阅读量624 收藏 2
点赞数
文章标签： 单片机 stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lagligelang/article/details/119760891
版权

main函数

#include "stm32f10x.h" 
#include "./led/bsp_led.h"
#include "./systick/bsp_systick.h"
#include "./beep/bsp_beep.h"
#include "./key/bsp_key.h"
#include "./usart/bsp_usart.h"
#include "./HC_SR04/bsp_hcsr04.h"

//软件延时函数
void  Soft_Delay(unsigned int time)
{
	while(time--);
}

int main(void)
{
	int32_t d = 0;//距离
	LED_GPIO_Init();
	Beep_Init();
	KEY_GPIO_Init();
	USARTX_Config();
	HC_SR04_GPIO_Init();
	
	printf("HC_SR04测试模块\r\n");
	
	while(1)
	{
		d = HC_SR04_Config();
		if(d > 0)
		{
			if(d >= 20 && d<= 4000)//超声波模块测距范围：2cm~400cm
			{
				printf("超声波所测距离=%d mm\r\n",d);
				if(d > 450)//距离大于45mm，灯全灭、蜂鸣器也不叫
				{
					Red_Led_OFF;
					Green_Led_OFF;
					Blue_Led_OFF;
					Beep_OFF;
				}
				else if(350 <= d && d <= 450)//距离大于35mm小于45mm，亮绿灯，蜂鸣器不叫
				{
					Red_Led_OFF;
					Green_Led_ON;
					Blue_Led_OFF;
					Beep_OFF;					
				}
				else if(250 <= d && d <= 350)//距离大于25mm小于35mm，亮红灯，蜂鸣器不叫
				{
					Red_Led_ON;
					Green_Led_OFF;
					Blue_Led_OFF;
					Beep_OFF;					
				}				
				else if(150 <= d && d <= 250)//距离大于15mm小于25mm，亮红绿等，蜂鸣器不叫
				{
					Red_Led_ON;
					Green_Led_ON;
					Blue_Led_OFF;
					Beep_OFF;					
				}	
				else if(d <= 150)//距离小于15mm，亮红绿蓝等，蜂鸣器叫
				{
					Red_Led_ON;
					Green_Led_ON;
					Blue_Led_ON;
					Beep_ON;					
				}					
			}
		}
		Delay_ms(2000);//2s测一次
	}
	
}

LED

#include "./led/bsp_led.h"


//LED_GPIO配置
void LED_GPIO_Init(void)
{
	GPIO_InitTypeDef 	GPIO_InitStructure={0};
	//开启时钟
	Led_RCC_CLK_ENABLE(Led_RCC_CLK_PERIPH,ENABLE);
	//作为普通的IO口，普通推挽输出即可
	//开漏输出，无法输出高电平，必须以来外围电路拉高IO口
	GPIO_InitStructure.GPIO_Pin =Red_Led_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
	GPIO_Init(Red_Led_GPIO_PORT,&GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin =Green_Led_GPIO_PIN;
	GPIO_Init(Green_Led_GPIO_PORT,&GPIO_InitStructure);


	GPIO_InitStructure.GPIO_Pin =Blue_Led_GPIO_PIN;
	GPIO_Init(Blue_Led_GPIO_PORT,&GPIO_InitStructure);	
	//首先先关闭所有LED
	Red_Led_OFF;
	Green_Led_OFF;
	Blue_Led_OFF;
}

#ifndef  __BSP_LED_H
#define  __BSP_LED_H
#include "stm32f10x.h"
#define    Led_RCC_CLK_ENABLE			RCC_APB2PeriphClockCmd
#define    Led_RCC_CLK_PERIPH			RCC_APB2Periph_GPIOB
//红灯宏定义
#define    Red_Led_RCC_CLK_ENABLE		RCC_APB2PeriphClockCmd
#define    Red_Led_RCC_CLK_PERIPH		RCC_APB2Periph_GPIOB
#define    Red_Led_GPIO_PORT			GPIOB
#define    Red_Led_GPIO_PIN				GPIO_Pin_5

#define    Red_Led_ON					GPIO_ResetBits(Red_Led_GPIO_PORT,Red_Led_GPIO_PIN)
#define    Red_Led_OFF					GPIO_SetBits(Red_Led_GPIO_PORT, Red_Led_GPIO_PIN)
#define    Red_Led_TOGGLE				{Red_Led_GPIO_PORT->ODR ^= Red_Led_GPIO_PIN;}
//绿灯宏定义
#define    Green_Led_RCC_CLK_ENABLE		RCC_APB2PeriphClockCmd
#define    Green_Led_RCC_CLK_PERIPH		RCC_APB2Periph_GPIOB
#define    Green_Led_GPIO_PORT			GPIOB
#define    Green_Led_GPIO_PIN			GPIO_Pin_0

#define    Green_Led_ON					GPIO_ResetBits(Green_Led_GPIO_PORT,Green_Led_GPIO_PIN)
#define    Green_Led_OFF				GPIO_SetBits(Green_Led_GPIO_PORT, Green_Led_GPIO_PIN)
#define    Green_Led_TOGGLE				{Green_Led_GPIO_PORT->ODR ^= Green_Led_GPIO_PIN;}
//蓝灯宏定义
#define    Blue_Led_RCC_CLK_ENABLE		RCC_APB2PeriphClockCmd
#define    Blue_Led_RCC_CLK_PERIPH		RCC_APB2Periph_GPIOB
#define    Blue_Led_GPIO_PORT			GPIOB
#define    Blue_Led_GPIO_PIN			GPIO_Pin_1

#define    Blue_Led_ON					GPIO_ResetBits(Blue_Led_GPIO_PORT,Blue_Led_GPIO_PIN)
#define    Blue_Led_OFF					GPIO_SetBits(Blue_Led_GPIO_PORT, Blue_Led_GPIO_PIN)
#define    Blue_Led_TOGGLE				{Blue_Led_GPIO_PORT->ODR ^= Blue_Led_GPIO_PIN;}

extern void LED_GPIO_Init(void);
#endif

SysTick

#include "./systick/bsp_systick.h"

//static __INLINE uint32_t SysTick_Config(uint32_t ticks)
//{ 
//  if (ticks > SysTick_LOAD_RELOAD_Msk)  return (1);            /* Reload value impossible */
//                                                               
//  SysTick->LOAD  = (ticks & SysTick_LOAD_RELOAD_Msk) - 1;      /* set reload register */
//  NVIC_SetPriority (SysTick_IRQn, (1<<__NVIC_PRIO_BITS) - 1);  /* set Priority for Cortex-M0 System Interrupts */
//  SysTick->VAL   = 0;                                          /* Load the SysTick Counter Value */
//  SysTick->CTRL  = SysTick_CTRL_CLKSOURCE_Msk | 
//                   SysTick_CTRL_TICKINT_Msk   | 
//                   SysTick_CTRL_ENABLE_Msk;                    /* Enable SysTick IRQ and SysTick Timer */
//  return (0);                                                  /* Function successful */
//}

//调用SysTick_Config时其中的形参是24位的自减滴答定时器---->>>>>最大值是：2^24-1 == 16777216-1 == 16777215
int32_t Delay_us(uint32_t us)
{
	uint32_t temp1 = 0;
	SysTick->CTRL = 0;//先关闭系统滴答定时器,然后再配置
	SysTick->VAL = 0;//清零
	SysTick->LOAD = ((us*72)-1);
	SysTick->CTRL = 0x05;//使能系统滴答定时器并且使用内部时钟72MHz
	//做一个检测信息
	while(1)
	{
		temp1 = SysTick->CTRL;
		//检测第16位的标志位：Counting位，如果计数值减到0，该为会变为1，读取它会自动变为零
		if(temp1 & 0x10000)
		{
			break;
		}
		//检测系统滴答定时器是否意外关闭
		if((temp1 & 0x01) == 0)
		{
			return -1;
		}		
	}
	SysTick->CTRL = 0;//关闭系统滴答定时器
	return 0;
}

int32_t Delay_ms(uint32_t ms)
{
	uint32_t temp2 = 0;	
	while(ms--)
	{
		SysTick->CTRL = 0;//先关闭系统滴答定时器,然后再配置
		SysTick->VAL = 0;//清零
		SysTick->LOAD = (72000-1);//1ms计数一次
		SysTick->CTRL = 0x05;//使能系统滴答定时器并且使用内部时钟72MHz
		//做一个检测信息
		while(1)
		{
			temp2 = SysTick->CTRL;
			//检测第16位的标志位：Counting位，如果计数值减到0，该为会变为1，读取它会自动变为零
			if(temp2 & 0x10000)
			{
				break;
			}
			//检测系统滴答定时器是否意外关闭
			if((temp2 & 0x01) == 0)
			{
				return -1;
			}		
		}
	}
	SysTick->CTRL = 0;//关闭系统滴答定时器
	return 0;
}

#ifndef  __BSP_SYSTICK_H
#define  __BSP_SYSTICK_H
#include "stm32f10x.h"
#include "core_cm3.h"

extern int32_t Delay_us(uint32_t us);
extern int32_t Delay_ms(uint32_t ms);
#endif

Beep

#include "./beep/bsp_beep.h"

//Beep_Init配置
void Beep_Init(void)
{
	GPIO_InitTypeDef 	GPIO_InitStructure={0};
	//开启时钟
	Beep_RCC_CLK_ENABLE(Beep_RCC_CLK_PERIPH,ENABLE);
	//作为普通的IO口，普通推挽输出即可
	//开漏输出，无法输出高电平，必须以来外围电路拉高IO口
	GPIO_InitStructure.GPIO_Pin =Beep_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
	GPIO_Init(Beep_GPIO_PORT,&GPIO_InitStructure);
	
	//首先先关闭所有Beep
	Beep_OFF;
}

#ifndef  __BSP_BEEP_H
#define  __BSP_BEEP_H
#include "stm32f10x.h"


//有源蜂鸣器宏定义
#define    Beep_RCC_CLK_ENABLE			RCC_APB2PeriphClockCmd
#define    Beep_RCC_CLK_PERIPH			RCC_APB2Periph_GPIOA
#define    Beep_GPIO_PORT				GPIOA
#define    Beep_GPIO_PIN				GPIO_Pin_8

#define    Beep_OFF					GPIO_ResetBits(Beep_GPIO_PORT,Beep_GPIO_PIN)
#define    Beep_ON					GPIO_SetBits(Beep_GPIO_PORT, Beep_GPIO_PIN)

extern void Beep_Init(void);
#endif

Key

#include "./key/bsp_key.h"
#include "./systick/bsp_systick.h"

//KEY_GPIO配置
void KEY_GPIO_Init(void)
{
	GPIO_InitTypeDef 	GPIO_InitStructure={0};
	//开启时钟
	Key1_RCC_CLK_ENABLE(Key1_RCC_CLK_PERIPH,ENABLE);	
	Key2_RCC_CLK_ENABLE(Key2_RCC_CLK_PERIPH,ENABLE);
	//作为普通的IO口，
	//根据原理图,没按下是低电平，按下是高电平.
	GPIO_InitStructure.GPIO_Pin = Key1_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(Key1_GPIO_PORT,&GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = Key2_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(Key2_GPIO_PORT,&GPIO_InitStructure);
}
//按键状态扫描函数
uint8_t Key_State_Scan(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
	if(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin) == Key_Down)//如果第一次读取的是高电平
	{
		Delay_ms(20);//消抖
		if(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin) == Key_Down)//如果第二次读取的是高电平,那就是真的高电平
		{
			while(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin) == Key_Down);//等按键松开再变化
			return Key_Down;
		}
		else
		{
			return Key_Up;
		}
	}
	else
	{
		return Key_Up;
	}
}
#ifndef  __BSP_KEY_H
#define  __BSP_KEY_H
#include "stm32f10x.h"

#define    Key_Down		1
#define    Key_Up		0
//Key1宏定义
#define    Key1_RCC_CLK_ENABLE			RCC_APB2PeriphClockCmd
#define    Key1_RCC_CLK_PERIPH			RCC_APB2Periph_GPIOA
#define    Key1_GPIO_PORT				GPIOA
#define    Key1_GPIO_PIN				GPIO_Pin_0

//Key2宏定义
#define    Key2_RCC_CLK_ENABLE			RCC_APB2PeriphClockCmd
#define    Key2_RCC_CLK_PERIPH			RCC_APB2Periph_GPIOC
#define    Key2_GPIO_PORT				GPIOC
#define    Key2_GPIO_PIN				GPIO_Pin_13

extern void KEY_GPIO_Init(void);
extern uint8_t Key_State_Scan(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);
#endif

USART

#include "./usart/bsp_usart.h"

//USART1配置
static void USARTX_GPIO_Init(void)
{
	GPIO_InitTypeDef 	GPIO_InitStructure = {0};
	//开启时钟
	USARTX_TX_RX_RCC_CLK_ENABLE(USARTX_TX_RX_RCC_CLK_PERIPH,ENABLE);	
	//Tx  复用推挽输出
	GPIO_InitStructure.GPIO_Pin = USARTX_TX_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(USARTX_TX_GPIO_PORT,&GPIO_InitStructure);
	//Rx  浮空输入
	GPIO_InitStructure.GPIO_Pin = USARTX_RX_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(USARTX_RX_GPIO_PORT,&GPIO_InitStructure);
}
static void USARSTX_NVIC_Init(void)
{
	NVIC_InitTypeDef		NVIC_InitStructure = {0};
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//配置中断分组为2
	NVIC_InitStructure.NVIC_IRQChannel = USARTX_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
}	
static void USARTX_Mode_Init(void)
{
	USART_InitTypeDef	USART_InitStructure = {0};
	//开启时钟
	USARTX_RCC_CLK_ENABLE(USARTX_RCC_CLK_PERIPH,ENABLE);	
	USART_InitStructure.USART_BaudRate = USARTX_Baudrate;//波特率：115200
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无需硬件流,如果需要硬件流，需要加上CTS、RTS位
	USART_InitStructure.USART_Mode = (USART_Mode_Tx|USART_Mode_Rx);//接收和发送模式
	USART_InitStructure.USART_Parity = USART_Parity_No;//没有奇偶检验位
	USART_InitStructure.USART_StopBits = USART_StopBits_1;//1位停止位.
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_Init(USARTX,&USART_InitStructure);

	USARSTX_NVIC_Init();
	//使能串口,并使能接收中断
	USART_ITConfig(USARTX,USART_IT_RXNE,ENABLE);
	//使能串口
	USART_Cmd(USARTX,ENABLE);
}
 
void USARTX_Config(void)
{
	USARTX_GPIO_Init();
	USARTX_Mode_Init();
}
/*****************  发送一个字节 **********************/
//形参1：哪个串口发送
//形参2：发送的数据是什么，因为我们规定8个数据位，所有定义uint8_t即可
void Usart_SendByte(USART_TypeDef * pUSARTx,uint8_t ch)
{
	USART_SendData(pUSARTx,ch);
	while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TXE) == RESET);
}
/****************** 发送8位的数组 ************************/
//形参1：哪个串口发送
//形参2：发送的数据是什么，因为我们规定8个数据位，所有定义uint8_t即可
//形参3：发送多少个数据
void Usart_SendArray(USART_TypeDef *pUSARTx,uint8_t *array,uint16_t num)
{
	uint8_t  i = 0;
	for(i=0 ; i<8 ;i++)
	{
		Usart_SendByte(pUSARTx,array[i]);			
	}
	while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC) == RESET);
}
/*****************  发送字符串 **********************/
void Usart_SendString( USART_TypeDef * pUSARTx, char *str)
{
	unsigned int k = 0;
	do
	{
		Usart_SendByte(pUSARTx,*(str+k));
		k++;
	}while(*(str+k) != '\0');
	while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC) == RESET);
}
/*****************  发送一个16位数 **********************/
void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch)
{
	uint8_t High_Temp = 0,Low_Temp = 0;
	High_Temp = ((ch&0xff00)>>8);
	Low_Temp = (ch&0xff);
	/* 发送高八位 */
	USART_SendData(pUSARTx,High_Temp);	
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
	/* 发送低八位 */
	USART_SendData(pUSARTx,Low_Temp);	
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
}
///重定向c库函数printf到串口，重定向后可使用printf函数
int fputc(int ch,FILE *f)
{
	USART_SendData(USARTX,(uint8_t)ch);
	while (USART_GetFlagStatus(USARTX, USART_FLAG_TXE) == RESET);
	return (ch);
}
///重定向c库函数scanf到串口，重写向后可使用scanf、getchar等函数
int fgetc(FILE *f)
{
	int Receive_Date = 0;
	while (USART_GetFlagStatus(USARTX, USART_FLAG_RXNE) == RESET);
	Receive_Date = (int)USART_ReceiveData(USARTX);	
	return (Receive_Date);
}

#ifndef  __BSP_USART_H
#define  __BSP_USART_H
#include "stm32f10x.h"
#include <stdio.h>

//USART1 宏定义
#define    USARTX_RCC_CLK_ENABLE			RCC_APB2PeriphClockCmd
#define    USARTX_RCC_CLK_PERIPH			RCC_APB2Periph_USART1
#define    USARTX							USART1
#define    USARTX_Baudrate					115200
#define    USARTX_IRQn						USART1_IRQn
#define    USARTX_IRQHandler				USART1_IRQHandler

#define    USARTX_TX_RX_RCC_CLK_ENABLE		RCC_APB2PeriphClockCmd
#define    USARTX_TX_RX_RCC_CLK_PERIPH		RCC_APB2Periph_GPIOA
//USART1_TX宏定义
#define    USARTX_TX_RCC_CLK_ENABLE			RCC_APB2PeriphClockCmd
#define    USARTX_TX_RCC_CLK_PERIPH			RCC_APB2Periph_GPIOA
#define    USARTX_TX_GPIO_PORT				GPIOA
#define    USARTX_TX_GPIO_PIN				GPIO_Pin_9

//USART1_RX宏定义
#define    USARTX_RX_RCC_CLK_ENABLE			RCC_APB2PeriphClockCmd
#define    USARTX_RX_RCC_CLK_PERIPH			RCC_APB2Periph_GPIOA
#define    USARTX_RX_GPIO_PORT				GPIOA
#define    USARTX_RX_GPIO_PIN				GPIO_Pin_10


extern void USARTX_Config(void);
extern void Usart_SendByte(USART_TypeDef * pUSARTx,uint8_t ch);
extern void Usart_SendArray(USART_TypeDef *pUSARTx,uint8_t *array,uint16_t num);
extern void Usart_SendString( USART_TypeDef * pUSARTx, char *str);
extern void Usart_SendHalfWord( USART_TypeDef * pUSARTx, uint16_t ch);
extern int fputc(int ch,FILE *f);
extern int fgetc(FILE *f);
#endif

HC_SR04

#include "./HC_SR04/bsp_hcsr04.h"
#include "./systick/bsp_systick.h"
/************* 超声波模块,工作电压是：DC 5V **********/
//超声波模块有：触发信号接口，回响信号接口
//我们利用开发板的PB6接触发信号接口、PB7接回响信号接口（这个接口随便选）
//HC_SR04配置
void HC_SR04_GPIO_Init(void)
{
	GPIO_InitTypeDef 	GPIO_InitStructure={0};
	//开启时钟
	HC_SR04_RCC_CLK_ENABLE(HC_SR04_CLK_PERIPH,ENABLE);
	//作为普通的IO口，普通推挽输出即可
	GPIO_InitStructure.GPIO_Pin = HC_SR04_TRIG_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(HC_SR04_TRIG_GPIO_PORT,&GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = HC_SR04_ECHO_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(HC_SR04_ECHO_GPIO_PORT,&GPIO_InitStructure);
	//默认触发信号为低电平,拉低
	HC_SR04_TRIG_State_Low;
}
//HC_SR04的时序图配置
int32_t HC_SR04_Config(void)
{
	uint32_t time = 0;//延时次数
	int32_t Distance = 0;//距离
	//拉高触发信号,准备开始
	HC_SR04_TRIG_State_High;
	//10us
	Delay_us(20);
	HC_SR04_TRIG_State_Low;
	//如果此时一直检测不到高电平，我们还是做个超时处理比较好
	while(HC_SR04_ECHO_ReadState == HC_SR04_ECHO_LOW)
	{
		time++;
		Delay_us(1);
		if(time >= 1000000)
		{
			return -1;
		}
	}
	//此时，模块内部会自动 循环发出8个4KHz的脉冲.
	//为了检测发送完毕，我们只需要检测输出回响信号是否为高电平
	//检测回响信号是否为高电平
	time = 0;
	while(HC_SR04_ECHO_ReadState == HC_SR04_ECHO_HIGH)
	{
		//距离 = 高电平时间*声速(340m/s)/2
		//340m=340000mm --->>> 1s=10^6us
		//而HC_SR04模块测距的误差是3mm，也就是如果我测到距离是9.7~10.3，系统均认为是10
		//那3mm距离，需要多久时间tus？
		//则有公式:340 000mm    对应于 10^6 us
		//		   3mm					tus
		// ---》》》 t = 10^6 * 3 / 340 000 ≈ 8.8us = 9us
		//意味着，如果我延时9us,就代表距离是3mm，那我们看有几个9us，就可以知道距离了
		time++;
		Delay_us(9);
		//如果一直高电平，那也有问题
		if(time >= 1000000)
		{
			return -2;
		}
	}
	time = time/2;//因为time属于发出信号到收到信号的总时间，距离的时间是总的一半
	Distance = time*3;//时间us乘以距离3mm
	return (Distance);
}

#ifndef  __BSP_HCSR04_H
#define  __BSP_HCSR04_H
#include "stm32f10x.h"
#define    HC_SR04_RCC_CLK_ENABLE		RCC_APB2PeriphClockCmd
#define    HC_SR04_CLK_PERIPH			RCC_APB2Periph_GPIOB
//触发控制信号TRIG宏定义
#define    HC_SR04_TRIG_RCC_CLK_ENABLE		RCC_APB2PeriphClockCmd
#define    HC_SR04_TRIG_RCC_CLK_PERIPH		RCC_APB2Periph_GPIOB
#define    HC_SR04_TRIG_GPIO_PORT			GPIOB
#define    HC_SR04_TRIG_GPIO_PIN			GPIO_Pin_6

#define    HC_SR04_TRIG_State_Low			GPIO_ResetBits(HC_SR04_TRIG_GPIO_PORT,HC_SR04_TRIG_GPIO_PIN)
#define    HC_SR04_TRIG_State_High			GPIO_SetBits(HC_SR04_TRIG_GPIO_PORT,HC_SR04_TRIG_GPIO_PIN)
		
//回响信号ECHO宏定义
#define    HC_SR04_ECHO_RCC_CLK_ENABLE		RCC_APB2PeriphClockCmd
#define    HC_SR04_ECHO_RCC_CLK_PERIPH		RCC_APB2Periph_GPIOB
#define    HC_SR04_ECHO_GPIO_PORT			GPIOB
#define    HC_SR04_ECHO_GPIO_PIN			GPIO_Pin_7

#define    HC_SR04_ECHO_ReadState			GPIO_ReadInputDataBit(HC_SR04_ECHO_GPIO_PORT,HC_SR04_ECHO_GPIO_PIN)

#define    HC_SR04_ECHO_HIGH		1
#define    HC_SR04_ECHO_LOW			0

extern void HC_SR04_GPIO_Init(void);
extern int32_t HC_SR04_Config(void);
#endif
一场终散的不醒梦
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HC_SR04超声波测距模块测试.zip
01-31
HC_SR04超声波测距模块是一款广泛应用在各种距离检测项目中的电子元件，尤其适合初学者和专业开发者。这款模块通过发送和接收超声波脉冲来计算与目标之间的距离，具有低成本、简单易用的特点。在STM32微控制器上进行...
超声波模块hc-sr04
04-02
可以调为TTL接口，URM05大功率超声波传感器测试距离能到10米，算是目前来说测试距离比较远的一款了，另外还有比较常用的国外的几款SRF系列的超声波模块，目前的超声波模块精度能到1cm。本文主要详解HC-SR04模块吉他的工作原理，首先介绍的是HC-SR04模块的优势及应用领域，其次阐述了超声波测距模块工作原理及电路图，最后介绍了电气参数、超声波时序图、操作以及程序，具体的跟随小编来了解一下。
STM32F103+HC04超声波测距详解（附代码）
qq_29716885的博客
10-22 6674
914无人机创新实验室开课了。 第二节课讲解使用STM32F103ZET6和HC-SR04超声波来完成测距功能。 一、超声波简介 根据HC_SR04超声波使用手册，该模块可提供2cm-400cm非接触式测距功能，测距精度可达3mm，包括超声波发送器、接收器和基本控制电路。经实测，HC_SR04可测量2.5cm-500cm的距离，测距精度达2.6mm，在测距准确条件下，最大测量角度在30°-32...
9. STM32——HC_SR04超声波测距
黄色的拉拉的博客
09-25 2万+
STM32——HC_SR04超声波测距HC_SR04实物图基本参数工作原理时序图超声波测距步骤1. 使能GPIO时钟、定时器时钟2. 配置GPIO引脚3.配置TIM定时器时钟4. 配置NVIC优先级5. 开启TIM4定时器6. 关闭TIM4定时器7. TIM4定时器中断服务函数8. 获取Echo时间9. 获取距离整合代码HC_SR04.cHC_SR04.husart.cusart.hmain.c测距完成 HC_SR04 实物图 基本参数 工作原理 时序图 超声波测距步骤 1. 使能GPIO时钟、
使用HC-SR04实现超声波测距
mjmmm的博客
05-30 829
超声波测距模块是用来测量距离的一种产品，通过发送和接受超声波，利用时间差和声音传播速度，计算出到前方障碍物的距离。波发出去的那一瞬，开启定时器，波回来的那一瞬，停止定时器，计算经过了多少时间，即。，即可使该模块开始循环发送8个40Khz的脉冲方波。3. 怎么知道接收了返回波？2. 怎么知道开始发了？1. 怎么让他发送波？
基于STM32的高精度超声波模块HC-SR04测距
李田所的博客
10-04 3466
准备材料 超声波模块 HC−SR04HC-SR04HC−SR04 STM32F103RCT6(Mini板) 超声波模块原理分析 引脚 功能 VCC 接5V GND 接开发板GND Trig 接外部PWM信号输入 Echo 输出整形过的方波信号 性能指标 精度：3mm3mm3mm 测距范围：2cm2cm2cm至4m4m4m 原理 给TrigTrigTrig引脚输入一个10us10us10us以上的高电平信号，此时模块会发出超声波，并从EchoEchoEcho引脚输出5V5
HC-SR04测距
firemakers的博客
02-24 1382
HC-SR04测距原理 控制端(Trig) 发送一个大于10us的高电平信号 等待数据接收端(Echo) 变成高电平，计时器开始计时 当数据接收端(Echo) 变成低电平后，计时器结束计时 通过公式s = v * t 计算出距离 s —— 距离，即声音走过的路径 v —— 声音在空气中的传播速度(340m/s) t —— 计时器所计的时间 注意：该模块中声音从发出到接收是所测距离...
HC-SR04.zip_HC-SR04_Hc-sr04 verilog_SR04_hc sr04 verilog_超声波测距
07-14
超声波测距技术是一种广泛应用于机器人导航、自动化设备、智能家居等领域的距离测量方法，而HC-SR04是一款常见的超声波传感器模块。本文将深入探讨如何利用Verilog语言来设计并实现一个基于HC-SR04的超声波测距系统...
chaoshengbo.zip_HC-SR04 stc_STC 超声波_STC 超声波测距_超声波传感器
09-23
在电子工程领域，超声波测距是一种广泛应用的技术，它基于声波的传播特性来测量物体与传感器之间的距离。在本项目中，我们探讨的是一个使用STC单片机控制的HC-SR04超声波传感器实现的测距系统。下面我们将详细解析这...
chaoshengbo.zip_超声波测距_超声波测距 单片机
09-21
- `超声波测距.c` 或 `.cpp`：这是实现超声波测距算法的主程序，包含了上述步骤的代码实现。 - `MSP430F149.h`：头文件，包含了MSP430F149微控制器的相关定义和函数声明。 - `config.h` 或 `setup.h`：配置文件，...
csb.rar_超声波 avr_超声波测距 avr
09-20
它会发送一个触发脉冲启动超声波传感器（如HC-SR04或GP2Y0A21YK），然后进入接收模式等待回波。当接收到回波时，单片机会计算时间差并转化为距离。为了实现厘米级别的精度，可能需要高分辨率的定时器和精细的信号...
HC-SR04超声波测距模块资料
11-04
单片机测距摸快，可以用来测距，这是一个传感器模块，
HC-SR04超声波模块使用记录
ApexYuan
09-12 3530
文章目录HC-SR04超声波模块使用记录轮询测量方式一、模块使用中的问题二、应对方法三、注意分时测量利用输入捕获测量利用输入捕获测量 HC-SR04超声波模块使用记录 具体使用方法见HC-SR04使用手册，本文重点记录该模块使用中的一些问题，和相应的解决方式。 轮询测量方式 以下描述都是针对用中断方式触发，延时等待Echo高电平，如果超出最大距离，跳出等待循环结束的处理方式。 下面示波器的显示： ...
STM32进阶之HC-SR04超声波测距
最新发布
dev_joker的博客
11-04 623
HC-SR04的一端发出超声波，接触到反射物后反射，被另一个端口接收到，所以只要知道发射和接收的时间差，就可以根据声波传播的速率算出HC-SR04和反射物直接的距离。2.在Trig脉冲输出后，立即检测Echo引脚的电平，测出Echo高电平持续的时间t，t就是超声波在所测距离一个来回所需时间。//设置左右方向，0xA1正常 0xA0左右反置。//设置上下方向，0xC8正常 0xC0上下反置。//设置显示时钟分频比/振荡器频率。//设置COM引脚硬件配置。//设置整个显示打开/关闭。//设置正常/倒转显示。
超声波测距模块（HC-SR04模块）特点及使用介绍
热门推荐
qq_51712037的博客
08-23 3万+
超声波测距模块（HC-SR04模块）特点及使用介绍前言一、超声波测距模块（HC-SR04模块）外观二、原理图三、相关参数讲解1.参数2.测量范围3.计算公式4.优点5.产品特性（根据官方参考资料）四、适用场所范围总结 前言 本文着重介绍超声波测距模块（HC-SR04模块）此模块(一个控制口发一个10US以上的高电平，就可以在接收口等待高电平输出)的原理、功能及使用方法 一、超声波测距模块（HC-SR04模块）外观 二、原理图 如下图所示，超声波测距模块（HC-SR04模块）原理图如下 三、相关参数讲解
【mcuclub】超声波测距模块HC-SR04
weixin_61121477的博客
11-08 1万+
HC-SR04
STM32F407 USART1控制RGB彩灯实验
xj666668的博客
03-20 3799
STM32F407–USART1 控制 RGB 彩灯实验 编程的大部分函数都是在 c 文件里写的，头文件是一个声明 c 文件里函数的地方。 USART1 控制 RGB 彩灯实验的 c 文件里主要包括两个函数 void Debug_USARTx_Config(void) 、 void Usart_SendByte( USART_TypeDef * pUSARTx, uint8_t ch) 函数名字...
单片机超声波测距
田野麦子
06-16 1万+
项目简介： 用HC-SR04超声波模块测量距离,并用单片机(STC89C52RC)接收信号，计算距离，并在LCD1602上实时显示当前距离。 C语言代码如下： /*----------------------- FileName: Ultrasonic.h Function: 头文件 Author: Zhang Kaizhou Date: 2019-6-16 18:26:16 ----------...
RaspberryPi 4B 使用超声波传感器 HC-SR04 进行距离检测
洪伟的专栏
06-20 1624
由于超声波指向性强，能量消耗缓慢，在介质中传播的距离较远，因而超声波经常用于距离的测量，如测距仪和物位测量仪等都可以通过超声波来实现。利用超声波检测往往比较迅速、方便、计算简单、易于做到实时控制，并且在测量精度方面能达到工业实用的要求，因此在移动机器人研制上也得到了广泛的应用。 一、超声波测距原理 超声波测距原理是在超声波发射装置发出超声波，它的根据是接收器接到超声波时的时间差，与雷达测距原理相似。超声波发射器向某一方向发射超声波，在发射时刻的同时开始计时，超声波在空气中传播，途中碰到障碍物就立即返回来，超
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值