超声波门禁系统

最新推荐文章于 2023-06-26 10:15:28 发布
最新推荐文章于 2023-06-26 10:15:28 发布
阅读量774 收藏 5
点赞数 3
分类专栏： 蓝桥杯单片机 蓝桥杯单片机 文章标签： 蓝桥杯 单片机 超声波 国赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28997735/article/details/90412295
版权

1.题目

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.代码

main.c

******************************************************************************
* 文件名：超声波门禁系统
* 描  述：
* 作  者：思索与猫
* 日  期:  19/5/21
* 备  注： 
*         
******************************************************************************
#include<stc15f2k60s2.h>
#include<sys.h>
uchar shi,fen,miao,hour;
bit mode,flag_keep;
sbit buzz = P0^6;
sbit relay = P0^4;

void relay_and_buzz();

void main()
{
		static uchar index;
		UltraWave_init();      //超声波初始化
		Timer0Init();
		CloseFucker();
		Read_PIN();            //读取eeprom内PIN
		set_time(06,59,00);
		while(1)
		{
				KeyDriver();
				ShowNumber();
				relay_and_buzz();      //蜂鸣器和继电器控制
			
				if(flag_time)          //读取时间
				{
						flag_time = 0;
						miao = Ds1302_Single_Byte_Read(0x81);
						Ds1302_Single_Byte_Write(0x00,0x00);
						fen = Ds1302_Single_Byte_Read(0x83);
						Ds1302_Single_Byte_Write(0x00,0x00);
						shi = Ds1302_Single_Byte_Read(0x85);
						Ds1302_Single_Byte_Write(0x00,0x00);
						hour = shi/16+shi%16;
						if(hour >= 7&&hour <= 22)
						{
								mode = 0;
						}
						else
						{
								mode = 1;
						}
				}
				
				if(flag_wave)      //读取超声波
				{
						flag_wave = 0;
						DealDistance();
						if(mode == 0&&distance <= 30)
						{
								flag_open = 1;
						}
				}		

				if(flag_keep == 1)    //保存PIN到eeprom内
				{
						if(flag_5ms)
						{
								switch(index)
								{
									case 0:write_eeprom(PINback[0],0x00);break;
									case 1:write_eeprom(PINback[1],0x01);break;
									case 2:write_eeprom(PINback[2],0x02);break;
									case 3:write_eeprom(PINback[3],0x03);break;
									case 4:write_eeprom(PINback[4],0x04);break;
									case 5:write_eeprom(PINback[5],0x05);break;
								}
								flag_5ms = 0;
								index++;
								if(index >= 6) 
								{
										index = 0;
										flag_keep = 0;
								}
						}
				}
		}
}

void relay_and_buzz()
{
		if(flag_open)
		{
				P2 = P2&0x1f|0xa0;
				relay = 1;buzz = 0;
				P2 &= 0x1f;
		}
		else if(flag_warn)
		{
				P2 = P2&0x1f|0xa0;
				relay = 0;buzz = 1;
				P2 &= 0x1f;
		}
		else if(flag_open == 0&&flag_warn == 0)
		{
				P2 = P2&0x1f|0xa0;
				relay = 0;buzz = 0;
				P2 &= 0x1f;
		}
}

sys.c

#include<sys.h>
bit flag_time = 1,flag_wave,flag_open,flag_5ms;

void Timer0Init()		//1ms@12.000MHz
{
		AUXR |= 0x80;		
		TMOD &= 0xF0;		
		TL0 = 0x20;		
		TH0 = 0xD1;		
		TF0 = 0;		
		TR0 = 1;	
		ET0 = 1;
		EA = 1;
}

void T0_Time() interrupt 1
{
		static uint count_time = 0,count_wave = 0,count_open = 0,count_warn = 0;
		static uint count_5ms = 0;
		KeyScan();
		Display();
		
		if(++count_5ms >= 5)
		{
				count_5ms = 0;
				flag_5ms = 1;
		}
		
		if(++count_time >= 500)
		{
				count_time = 0;
				flag_time = 1;
		}
		
		if(++count_wave >= 800)
		{
				count_wave = 0;
				flag_wave = 1;
		}
		
		if(flag_open)    //开门5S
		{
				count_open++;
				if(count_open >= 5000)
				{
						count_open = 0;
						flag_open = 0;
				}
		}
		
		if(flag_warn)    //报警3S
		{
				count_warn++;
				if(count_warn >= 3000)
				{
						count_warn = 0;
						flag_warn = 0;
				}
		}
}

void CloseFucker()
{
		P2 = P2&0x1f|0xa0;
		P0 = 0xaf;
		P2 &= 0x1f;
}

void PIN_init()     //PIN初始化
{
		uchar i = 0;
		for(i=0; i<6; i++)
		{
				PIN[i] = 10;
		}
}

void Read_PIN()   //读取PIN
{
		PINback[0] = read_eeprom(0x00);
		PINback[1] = read_eeprom(0x01);
		PINback[2] = read_eeprom(0x02);
		PINback[3] = read_eeprom(0x03);
		PINback[4] = read_eeprom(0x04);
		PINback[5] = read_eeprom(0x05);
}

sys.h

#ifndef __SYS_H_
#define __SYS_H_

#include<stc15f2k60s2.h>
#include<ds1302.h>
#include<iic.h>

typedef unsigned char uchar;
typedef unsigned int uint;
	
void Timer0Init();
void CloseFucker();
void PIN_init();
void Read_PIN();

void Display();
void ShowNumber();

void KeyDriver();
void KeyAction(uchar key_value);
void KeyScan();

void UltraWave_init();
void SendWave();
void DealDistance();

extern uchar shi,fen,miao;
extern uchar view;
extern uint time,distance;
extern uchar PIN[];
extern uchar PINback[];
extern bit mode,flag_keep;
extern bit flag_time,flag_wave,flag_open,flag_warn,flag_5ms;
#endif

dispaly.c

#include<sys.h>

uchar code duan[] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x00,0x40};//10black,11-
uchar PIN[6] = {10,10,10,10,10,10};
uchar PINback[6] = {6,5,4,3,2,1};
uchar disbuf[8];

void Display()
{
		static uchar index = 0;
		P2 = P2&0x1f|0xe0;
		P0 = 0xff;
		P2 &= 0x1f;
	
		P2 = P2&0x1f|0xc0;
		P0 = 1<<index;
		P2 &= 0x1f;
	
		P2 = P2&0x1f|0xe0;
		P0 = ~duan[disbuf[index]];
		P2 &= 0x1f;
		
		index++;
		index &= 0x07;
}

void ShowNumber()
{
		if(mode == 0)
		{
	 		    disbuf[0] = shi/16;
			    disbuf[1] = shi%16;
			    disbuf[2] = 11;
//				disbuf[0] = distance/100;
//				disbuf[1] = distance/10%10;
//				disbuf[2] = distance%10;				
				disbuf[3] = fen/16;
				disbuf[4] = fen%16;
				disbuf[5] = 11;
				disbuf[6] = miao/16;
				disbuf[7] = miao%16;
		}
		else if(mode == 1)
		{
				if(view == 0)        //密码输入界面
				{
						disbuf[0] = 11;
						disbuf[1] = 11;
						disbuf[2] = PIN[0];
						disbuf[3] = PIN[1];
						disbuf[4] = PIN[2];
						disbuf[5] = PIN[3];
						disbuf[6] = PIN[4];
						disbuf[7] = PIN[5];
				}
				else if(view == 1)    //旧密码确认界面
				{
						disbuf[0] = 10;
						disbuf[1] = 11;
						disbuf[2] = PIN[0];
						disbuf[3] = PIN[1];
						disbuf[4] = PIN[2];
						disbuf[5] = PIN[3];
						disbuf[6] = PIN[4];
						disbuf[7] = PIN[5];
				}
				else if(view == 2)   //新密码输入界面
				{
						disbuf[0] = 11;
						disbuf[1] = 10;
						disbuf[2] = PIN[0];
						disbuf[3] = PIN[1];
						disbuf[4] = PIN[2];
						disbuf[5] = PIN[3];
						disbuf[6] = PIN[4];
						disbuf[7] = PIN[5];
				}
				
		}

}

key.c

#include<sys.h>
#define  set 10
#define  reset 11 
#define  OK 14
#define  quit 15
sbit Key_Out_1 = P3^0;
sbit Key_Out_2 = P3^1;
sbit Key_Out_3 = P3^2;
sbit Key_Out_4 = P3^3;

sbit Key_In_1 = P4^4;
sbit Key_In_2 = P4^2;
sbit Key_In_3 = P3^5;
sbit Key_In_4 = P3^4;

uchar KeySta[4][4] = {1,1,1,1,
					  1,1,1,1,
					  1,1,1,1,
					  1,1,1,1};
uchar KeyCodeMap[4][4] = {0,1,2,3,
						  4,5,6,7,
						  8,9,set,reset,
						  12,13,OK,quit};
uchar Error = 0,view;										
bit flag_warn = 0;
void KeyDriver()
{
		static uchar KeyBack[4][4] = {1,1,1,1,
									  1,1,1,1,
									  1,1,1,1,
									  1,1,1,1};
		uchar i = 0,j = 0;
		
		for(i=0; i<4; i++)
		{
				for(j=0; j<4; j++)
				{
						if(KeySta[i][j] != KeyBack[i][j])
						{
								if(KeySta[i][j] == 0)
								{
										KeyAction(KeyCodeMap[i][j]);
								}
						}
						KeyBack[i][j] = KeySta[i][j];
				}
		}
}

void KeyAction(uchar key_value)
{
		 static uchar index = 0;
		 uchar i = 0;
		 if(mode == 1)
		 {
				if(key_value >= 0&&key_value <= 9)    //密码输入0~9
				{
						PIN[index] = key_value;
						index++;	
						if(index > 5) index = 0;
				}
				if(key_value == quit)                 //退出
				{
						view = 0;
						PIN_init();
						index = 0;
				}
				if(key_value == set)                //进入密码设置界面
				{
						view = 1;
				}
				if(key_value == reset)              //密码复位
				{
						PINback[0] = 6;
						PINback[1] = 5;
						PINback[2] = 4;
						PINback[3] = 3;
						PINback[4] = 2;
						PINback[5] = 1;
						flag_keep = 1;
				}
				if(view == 2)                       //新密码保存
				{
						if(key_value == OK)
						{
								for(i=0; i<6; i++)
								{
										PINback[i] = PIN[i];
								}
								flag_keep = 1;
								view = 0;
						}
				}			
				else if(key_value == OK)       //确认按键
				{
						for(i=0; i<6; i++)
						{
								if(PIN[i] != PINback[i])
								{
										flag_open = 0;
										Error++;
										if(Error>=3) 
										{
												Error = 0;       
												flag_warn = 1;     //错误3次报警
												if(view == 1)      //并退出
												{
														view = 0;
												}
										}
										break;
								}
								else
								{			
										if(view == 0)
										{
												flag_open = 1;     //开门
										}
										else if(view == 1)
										{
												view = 2;          //前往新密码输入界面
										}										
								}
						}
						PIN_init();     //初始化
						index = 0;
				}
		 }
}

void KeyScan()
{
		static uchar KeyBuf[4][4] = {0xff,0xff,0xff,0xff,
									 0xff,0xff,0xff,0xff,
									 0xff,0xff,0xff,0xff,
								     0xff,0xff,0xff,0xff};
		static uchar keyout = 0;
		uchar i = 0;
		
		switch(keyout)
		{
			case 0:Key_Out_1 = 0;Key_Out_4 = 1;break;
			case 1:Key_Out_2 = 0;Key_Out_1 = 1;break;
			case 2:Key_Out_3 = 0;Key_Out_2 = 1;break;
			case 3:Key_Out_4 = 0;Key_Out_3 = 1;break;
		}
		
		KeyBuf[keyout][0] = KeyBuf[keyout][0]<<1|Key_In_1;
		KeyBuf[keyout][1] = KeyBuf[keyout][1]<<1|Key_In_2;
		KeyBuf[keyout][2] = KeyBuf[keyout][2]<<1|Key_In_3;
		KeyBuf[keyout][3] = KeyBuf[keyout][3]<<1|Key_In_4;
		
		for(i=0; i<4; i++)
		{
				if(KeyBuf[keyout][i] == 0x00)
				{
						KeySta[keyout][i] = 0;
				}
				else if(KeyBuf[keyout][i] == 0xff)
				{
						KeySta[keyout][i] = 1;
				}
				else
				{
						;
				}
		}
		keyout++;
		keyout &= 0x03;
}

ultrawave.c

#include<sys.h>
#include<intrins.h>
sbit TX = P1^0;
sbit RX = P1^1;

#define somenop {_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();}

uint time;
uint distance;

void UltraWave_init()      //超声波初始化
{
		TMOD |= 0x10;
		TH1 = 0;
		TL1 = 0;
		TF1 = 0;
		TR1 = 0;
}

void SendWave()            //发送超声波
{
		uchar i = 0;
		for(i=0; i<8; i++)
		{
				TX = 1;
				somenop;somenop;somenop;somenop;somenop;
				somenop;somenop;somenop;somenop;somenop;
				TX = 0;
				somenop;somenop;somenop;somenop;somenop;
				somenop;somenop;somenop;somenop;somenop;
		}
}

void DealDistance()        //处理距离
{
		SendWave();
		TR1 = 1;
		while(RX == 1&&TF1 == 0);
		TR1 = 0;
		
		if(TF1 == 1&&RX == 1)
		{
				TF1 = 0;
				distance = 999;
		}
		else if(RX == 0&&TF1 == 0)
		{
				time = TH1*256+TL1;
				distance = (uint)time*0.017;
				TH1 = 0;
				TL1 = 0;
		}
}

ds1302.c

#include "ds1302.h"

void Write_Ds1302_Byte(unsigned char dat) 
{
	unsigned char i;
	SCK = 0;
	for (i=0;i<8;i++) 
	{ 
		if (dat & 0x01) 	
		{
			SDA_SET;		
		}
		else 
		{
			SDA_CLR;		
		}		 
		SCK_SET;
		SCK_CLR;		
		dat = dat >> 1; 
	} 
}

unsigned char Read_Ds1302_Byte(void) 
{
	unsigned char i, dat=0;	
	for (i=0;i<8;i++)
	{	
		dat = dat >> 1;
		if (SDA_R) 	  
		{
			dat |= 0x80;
		}
		else 
		{
			dat &= 0x7F;
		}
		SCK_SET;
		SCK_CLR;
	}
	return dat;
}

void Ds1302_Single_Byte_Write(unsigned char addr, unsigned char dat)
{ 

	RST_CLR;			
	SCK_CLR;			

	RST_SET;			
	addr = addr & 0xFE;	 
	Write_Ds1302_Byte(addr); 
	Write_Ds1302_Byte(dat);	
	RST_CLR;				
}

unsigned char Ds1302_Single_Byte_Read(unsigned char addr) 
{ 
	unsigned char temp;
	RST_CLR;			
	SCK_CLR;			

	RST_SET;	
	addr = addr | 0x01;	 
	Write_Ds1302_Byte(addr); 
	temp=Read_Ds1302_Byte();
	RST_CLR;	
	return temp;
}

void set_time(unsigned char shi,unsigned char fen,unsigned char miao)
{
		Ds1302_Single_Byte_Write(0x8e,0x00);
		Ds1302_Single_Byte_Write(0x80,miao/10*16+miao%10);
		Ds1302_Single_Byte_Write(0x82,fen/10*16+fen%10);
		Ds1302_Single_Byte_Write(0x84,shi/10*16+shi%10);
		Ds1302_Single_Byte_Write(0x8e,0x80);
}

ds1302.h


#ifndef  __DS1302_H__
#define  __DS1302_H__

#include<stc15f2k60s2.h>
#include<intrins.h>

sbit SCK=P1^7;		
sbit SD=P2^3;		
sbit RST=P1^3;

#define RST_CLR	RST=0	
#define RST_SET	RST=1	

#define SDA_CLR	SD=0	
#define SDA_SET	SD=1	
#define SDA_R	SD	

#define SCK_CLR	SCK=0	
#define SCK_SET	SCK=1	

#define ds1302_sec_addr			0x80		
#define ds1302_min_addr			0x82		
#define ds1302_hr_addr			0x84		
#define ds1302_date_addr		0x86		
#define ds1302_month_addr		0x88		
#define ds1302_day_addr			0x8A		
#define ds1302_year_addr		0x8C		

#define ds1302_control_addr		0x8E		
#define ds1302_charger_addr		0x90 		
#define ds1302_clkburst_addr	0xBE		

extern void Write_Ds1302_Byte(unsigned char dat);
extern unsigned char Read_Ds1302_Byte(void);
extern void Ds1302_Single_Byte_Write(unsigned char addr, unsigned char dat);
extern unsigned char Ds1302_Single_Byte_Read(unsigned char addr);
extern void set_time(unsigned char shi,unsigned char fen,unsigned char miao);
#endif

iic.c

#include "iic.h"
void Delay5us()		//@12.000MHz
{
	unsigned char i;

	_nop_();
	_nop_();
	i = 12;
	while (--i);
}

void IIC_Start(void)
{
	SDA = 1;
	SCL = 1;
	somenop1;
	SDA = 0;
	somenop1;
	SCL = 0;	
}

void IIC_Stop(void)
{
	SDA = 0;
	SCL = 1;
	somenop1;
	SDA = 1;
}

void IIC_Ack(unsigned char ackbit)
{
	if(ackbit) 
	{	
		SDA = 0;
	}
	else 
	{
		SDA = 1;
	}
	somenop1;
	SCL = 1;
	somenop1;
	SCL = 0;
	SDA = 1; 
	somenop1;
}

bit IIC_WaitAck(void)
{
	SDA = 1;
	somenop1;
	SCL = 1;
	somenop1;
	if(SDA)    
	{   
		SCL = 0;
		IIC_Stop();
		return 0;
	}
	else  
	{ 
		SCL = 0;
		return 1;
	}
}

void IIC_SendByte(unsigned char byt)
{
	unsigned char i;
	for(i=0;i<8;i++)
	{   
		if(byt&0x80) 
		{	
			SDA = 1;
		}
		else 
		{
			SDA = 0;
		}
		somenop1;
		SCL = 1;
		byt <<= 1;
		somenop1;
		SCL = 0;
	}
}

unsigned char IIC_RecByte(void)
{
	unsigned char da;
	unsigned char i;
	
	for(i=0;i<8;i++)
	{   
		SCL = 1;
		somenop1;
		da <<= 1;
		if(SDA) 
		da |= 0x01;
		SCL = 0;
		somenop1;
	}
	return da;
}

void write_eeprom(unsigned char dat,unsigned char add)
{
		IIC_Start();
		IIC_SendByte(0xa0);
		IIC_WaitAck();
		IIC_SendByte(add);
		IIC_WaitAck();
		IIC_SendByte(dat);
		IIC_WaitAck();
		IIC_Stop(); 
}

unsigned char read_eeprom(unsigned char add)
{
		unsigned char dat;
	
		IIC_Start();
		IIC_SendByte(0xa0);
		IIC_WaitAck();
		IIC_SendByte(add);
		IIC_WaitAck();
	
		IIC_Start();
		IIC_SendByte(0xa1);
		IIC_WaitAck();
		dat = IIC_RecByte(); 
		IIC_WaitAck();
		IIC_Stop();

		return dat;	
}

iic.h

#ifndef _IIC_H
#define _IIC_H

#include "stc15f2k60s2.h"
#include "intrins.h"

#define somenop1 Delay5us() 
#define SlaveAddrW 0xA0
#define SlaveAddrR 0xA1

sbit SDA = P2^1;  
sbit SCL = P2^0; 

void IIC_Start(void); 
void IIC_Stop(void);  
void IIC_Ack(unsigned char ackbit); 
void IIC_SendByte(unsigned char byt); 
bit IIC_WaitAck(void);  
unsigned char IIC_RecByte(void); 
void Delay5us();
void write_eeprom(unsigned char dat,unsigned char add);
unsigned char read_eeprom(unsigned char add);
#endif
思索与猫
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
超声波接近门禁开关
12-01
利用超声波测距原理，实现可控制探测距离的自动门开关
超声波开门APP-android
08-28
超声波开门android APP,以前自己开发的，现在拿出来给大家分享，压箱底的货了。
Mind+超声波入侵检测
qq_45784065的博客
06-26 818
超声波测距仪 +——5v - ——GND echo——8 trig——7。超声波测距仪+红LED+蜂鸣器+电阻*1+公对公杜邦线*8+面包板+Uno板。蜂鸣器 +——3 - ——GND。测距规定为靠近10cm以内触发。Mind+超声波入侵检测。
超声波模块学习
eieieieiei的博客
12-12 1953
超声波模块学习第一阶段    1，了解了HC-SR04超声波模块的工作原理，由单片机提供一个30us左右的高电平，模块的Trig端会自动产生8个40KHZ的矩形脉冲波，Echo端接收到信号后后会产生高电平，用定时器记录所需时间，从而可以计算出距离。   2，如何用信号发生器，电源和示波器检测超声波模块的好坏。通过示波器观察Echo端产生的波的周期，计算出距离来与实际情况比较，来判断超声波模块的
蓝桥杯第三届决赛“门禁系统”
qq_46628267的博客
04-09 450
文章目录蓝桥杯第三届决赛“门禁系统”Author:LuisTime:2022-04-09Version:v1.0说明功能简介个人想法具体代码main.cds1302.cds1302.h 蓝桥杯第三届决赛“门禁系统” Author:Luis Time:2022-04-09 Version:v1.0 说明 ​ 蓝桥杯系列的代码都是本人亲手写和调试，可能有时会有点错误，请见谅。此外，代码仅供大家学习，祝福各位在蓝桥杯比赛中能获得比较满意的成绩。 ​ 忙着期中考试，今天就来“水”一下今天的博客。 ​ 从第五届的题目
基于Arduino的智能门禁系统模拟（智能舵机应用）
capodexi的博客
09-22 1万+
基于Arduino的智能门禁系统项目简介功能说明原理说明硬件结构图功能模块各元件介绍软件流程设计部分代码展示系统完整结构图拓展功能与设计 项目简介 在暑期课程设计的第二阶段，课程要求我们利用Arduino Nano开发板和大然科技的智能舵机外加任意外设以实现特定的使用功能。在仔细考虑之后，我最终选择了在此基础上外加三种外设实现工作在两种可选模式下的智能门禁仿真系统。 功能说明 本设计为以Arduino Nano开发板为核心驱动的智能门禁控制系统，主要功能有：根据上位机串口输入数据选择门禁系统工作模式; 外部
基于STM32的智能门禁系统
最新发布
05-14
【作品名称】：基于STM32的智能门禁系统 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： HARDW文件夹 存放了主要驱动...
基于RFID技术的门禁系统研究
08-13
基于RFID技术的门禁系统研究 在基于RFID技术的门禁系统中，射频识别技术作为核心技术，实现了人机操作、报警、实时监控等智能化功能。该系统结构是以射频识别技术为核心，将传统的门禁、报警等有机地结合在一起。...
基于51单片机的智能门禁系统.pdf
07-02
《基于51单片机的智能门禁系统》 智能门禁系统是现代科技与安全防护相结合的产物，尤其在住宅小区、办公楼宇等场所，它扮演着至关重要的角色。51单片机作为该系统的核心，负责处理各项任务，确保门禁系统的高效运行...
Arudino学习（一）读取超声波数值
yuyangyg的博客
09-10 2246
GPIO的arudino程序 unsigned int EchoPin = 2; // connect Pin 2(Arduino digital io) to Echo/RX at US-100 unsigned int TrigPin = 3; // connect Pin 3(Arduino digital io) to Trig/TX at US-
树莓派3B--超声波测距（HC-SR04）的使用
天道酬勤
01-04 1万+
  1.组件外观：   HC-SR04 模块可以测量 3cm - 4m 的距离，精确度可以达到 3mm。它包含了超声波发射器、接收器和控制电路三部分。   2.接线方式 一共两个电源引脚和两个控制引脚。 Vcc 和 Gnd 接 5v DC 电源，但不推荐用独立电源给它供电，应使用树莓派或单片机的 GPIO 口输出 5v 和 Gnd 给它供电。不然会影响这个模块的运行。 Trig 引...
20元制作NodeMCU+超声波模块+Python开门检测神器
dyingstraw的博客
11-28 1153
目录 前言 效果图 硬软件条件： 单片机程序 服务器端代码 结束 前言 最近出来实习，一个人住出租屋每天晚上回来总感觉屋子里面有人来过，因此像制作一个开门预警通知的小工具。 效果图 原理也很简单：单片机检测与门的距离，距离小于设定值且持续一段时间（2s），发邮件给我预警。 硬软件条件 1.NodeMCU+超声波 2.云端服务...
蓝桥杯单片机第三届国赛：门禁系统
FILWY_M
04-05 1631
本次使用到的模块大概有：超声波测距、EEPROM读和写、时钟DS1302、矩阵键盘、数码管显示 这一届国赛感觉不是特别难，但是还是有几点需要注意： 1.不要把超声波程序写在中断里面。如果把超声波程序写在中断里面的话，可能就不会及时的检测到溢出标志，在我开始验证代码的时候出现的现象是最后一个数码管闪烁，然后把超声波写在主函数里面就解决了问题。 2.程序里面经常调...
基于树莓派的人脸识别门禁系统
热门推荐
蓝色鲜橙多的博客
05-05 4万+
这是近期以来完成的第二个项目，第一个项目是基于STM32的智能窗帘控制系统（语音控制、温湿度控制、蓝牙APP控制、光敏控制）第一个项目也会在后续进行一个赘述。 1. 前期准备: 某宝准备一块相对性能好的树莓派，我自己用的是树莓派3B+。 购置一个配套电源 购置一个SD卡，因为你需要安装系统、配置环境。这里特别强调配置环境是一个让人特别头大的事情。如果你想无压力的话你可以购买64G，如果性价...
DS18B20读取温度（带小数）
记得提醒我去学习
03-08 1万+
由于DS18B20对时间精度要求很高，所以在写读取温度之前一定要改时序 1. 单总线延时函数 //单总线延时函数 void Delay_OneWire(unsigned int t) { t*=12; //t改成t*12 while(t--); } 2. 读取温度（整数） unsigned char read_temperature1() { unsigned c...
DA转换
记得提醒我去学习
03-28 8955
转换代码： 注意： 这里的temp还不是DA输出电压 DA输出电压公式：volt = temp*5/255(volt为输出电压，temp为DA转换值) void SetDAC(unsigned char temp) { IIC_Start(); IIC_SendByte(0x90); IIC_WaitAck(); IIC_SendByte(0x40); IIC_WaitAck(...
arduion门禁系统
06-08
门禁系统通常涉及以下几个方面的内容：传感器、控制器、执行器和用户界面。 对于传感器，可以选择使用人体红外传感器或超声波传感器来检测人员进出。 对于控制器，可以使用Arduino等微控制器来进行控制和处理信息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值