基于51单片机的电子密码锁设计

做个俗人挺好，狮子不留恋过往

已于 2023-09-04 17:37:57 修改

阅读量953

点赞数 7

分类专栏：单片机文章标签： 51单片机嵌入式硬件单片机

于 2023-09-04 15:29:21 首次发布

本文链接：https://blog.csdn.net/m0_74071712/article/details/132670429

版权

单片机专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本设计采用STC89C52单片机为主控芯片，通过软件程序组成电子密码锁系统，能够实现：

(1) 密码输入错误，蜂鸣器报警，累计三次，系统锁死。

(2) 密码为6-10位，可以随意更改。

(3) 采用矩阵按键输入和红外输入两种。

(4) 通过LCD1602液晶显示。

(5) 有开锁指示灯及蜂鸣器警示音。

(6) 具有模糊识别功能

代码部分：

main.c

#include <reg52.h>
#include <intrins.h>
#include <stdio.h>


#define PSW_MAX_LEN    16    //用宏定义出密码最大长度（最大不超过16）
#define PSW_SAVE_ADDR  0x30  //用宏定义出密码在EEPROM中的保存地址

sbit Buzzer = P1^6;//用于控制蜂鸣器的状态
sbit ADDR0 = P1^0;
sbit ADDR1 = P1^1;
sbit ADDR2 = P1^2;
sbit ADDR3 = P1^3;
sbit ENLED = P1^4;
sbit LED2 = P0^0;
sbit LED3 = P0^1;
sbit LED4 = P0^2;
sbit LED5 = P0^3;
sbit LED6 = P0^4;
sbit LED7 = P0^5;
sbit LED8 = P0^6;
sbit LED9 = P0^7;  

unsigned char status;  //系统状态字：0-输入密码，1-设置密码，2-设置密码确认，
                       //3-密码设置失败，4-输入的密码正确，5-输入的密码错误
unsigned char PswCnt;  //当前输入密码位数的计数器
unsigned char pdata PswSet[PSW_MAX_LEN];   //已设定的密码数据
unsigned char pdata PswBuf1[PSW_MAX_LEN];  //密码输入缓冲区1
unsigned char pdata PswBuf2[PSW_MAX_LEN];  //密码输入缓冲区2
unsigned char pdata Pswret[PSW_MAX_LEN]={'1','2','2','2'};//设置密码被初始化密码为"1222"

unsigned char T0RH = 0;  //T0重载值的高字节
unsigned char T0RL = 0;  //T0重载值的低字节

int a=1;

int isPswretUsed = 0; // 初始值为未使用过

extern void KeyScan();
extern void KeyDriver();
extern void InitLcd1602();
extern void LcdClearScreen();
extern void LcdShowStr(unsigned char x, unsigned char y, unsigned char *str);
extern void E2Read(unsigned char *buf, unsigned char addr, unsigned char len);
extern void E2Write(unsigned char *buf, unsigned char addr, unsigned char len);
unsigned char fuzzy_recognition(char *arr1, char *arr2, unsigned char len2);//模糊识别函数

void FillMemory(unsigned char *dest, unsigned char byt, unsigned char len);//用于将指定长度的内存块填充为指定的字节值
void ConfigTimer0(unsigned int ms);
bit  ReadPassword();
bit CmpMemory(unsigned char *ptr1, unsigned char *ptr2, unsigned char len);
void Alarm(unsigned char n);
extern bit irflag;//判断是否有红外信号接收到
extern unsigned char ircode[4];//红外代码接收缓冲区
extern void InitInfrared();
extern void fDriver();

unsigned char retKey(unsigned char ircode)//定义了一个函数 retKey()，用于根据传入的参数 ircode 返回对应的按键字符
{
	char a;
	switch (ircode)
	{
		case 0x16:
			a='0';
		break;
		case 0x0C:
			a='1';
		break;
		case 0x18:
			a='2';
		break;
		case 0x5E:
			a='3';
		break;
		case 0x08:
			a='4';
		break;
		case 0x1C:
			a='5';
		break;
		case 0x5A:
			a='6';
		break;
		case 0x42:
			a='7';
		break;
		case 0x52:
			a='8';
		break;
		case 0x4A:
			a='9';
		break;
		case 0x43://播放右
			a=0x0D;
		break;
		case 0x40://播放左
			a=0x1B;
		break;
		case 0X45://开机键
		  a=0x26;//向上键
	default :
		break;
	}
	return a;
}
void Delay100ms()		//@11.0592MHz
{
	unsigned char i, j;

	i = 180;
	j = 73;
	do
	{
		while (--j);
	} while (--i);
}
void Delay1000ms()		//@11.0592MHz
{
	unsigned char i, j, k;
	i = 8;
	j = 1;
	k = 243;
	do
	{
		do
		{
			while (--k);
		} while (--j);
	} while (--i);
}
void Delay300ms()		//@11.0592MHz
{
	unsigned char i, j, k;
	_nop_();
	i = 3;
	j = 26;
	k = 223;
	do
	{
		do
		{
			while (--k);
		} while (--j);
	} while (--i);
}
/*控制led函数*/
void LedOpen()
{
	unsigned char n;
	ADDR0 = 0;
	ADDR1 = 1;
	ADDR2 = 1;
	ADDR3 = 1;
	ENLED = 0;
	LED2 = 1;
	LED3 = 1;
	LED4 = 1;
	LED5 = 1;
	LED6 = 1;
	LED7 = 1;
	LED8 = 1;
	LED9 = 1;
	for(n=0;n<5;n++)
	{
		LED2 = ~LED2;// 点亮LED灯
		LED3 = ~LED3;
		LED4 = ~LED4;
		LED5 = ~LED5;
		LED6 = ~LED6;
		LED7 = ~LED7;
		LED8 = ~LED8;
		LED9 = ~LED9;
		Delay300ms();
	}
}
void main()
{
    Buzzer=1;  //初始化蜂鸣器
	  TMOD = 1;  //配置T0工作在模式1，但先不启动
    EA = 1;       //使能全局中断
    ConfigTimer0(1);  //配置T0定时1ms
    InitLcd1602();    //初始化液晶
		InitInfrared();
    if (ReadPassword())  //读取密码并判断是否有效
    {
        LcdShowStr(0, 0, "Enter Password");  //有效时提示输入密码
        status = 0;
    }
    else
    {
        LcdShowStr(0, 0, "Set Password");  //无效时提示设置密码			
        status = 1;
    }
    FillMemory(PswBuf1, '\0', PSW_MAX_LEN);
    FillMemory(PswBuf2, '\0', PSW_MAX_LEN);
    PswCnt = 0;
    while (1)
    {
			KeyDriver();
			if(irflag)//是否有红外信号接收到
			{
				irflag=0;
        fDriver();
			}
    }
}
/* 将一段内存数据拷贝到另一处，dest-目的地址，src-源地址，len-数据长度 */
void CopyMemory(unsigned char *dest, unsigned char *src, unsigned char len)
{
    while (len--)
    {
        *dest++ = *src++;
    }
}
/* 用一个指定字节填充一段内存，dest-目的地址，byt-填充用字节，len-数据长度 */
void FillMemory(unsigned char *dest, unsigned char byt, unsigned char len)
{
    while (len--)
    {
        *dest++ = byt;
    }
}
/* 内存比较函数，比较两个指针所指向的内存数据是否相同，
   ptr1-待比较指针1，ptr2-待比较指针2，len-待比较长度
   返回值-两段内存数据完全相同时返回1，不同返回0 */
bit CmpMemory(unsigned char *ptr1, unsigned char *ptr2, unsigned char len)
{
    while (len--)
    {
        if (*ptr1++ != *ptr2++)  //遇到不相等数据时即刻返回0
        {
            return 0;
        }
    }
    return 1;  //比较完全部长度数据都相等则返回1
}
/* 将一段数据按字节累加，返回获得的累加和，dat-数据指针，len-数据长度 */
unsigned char GetChkSum(unsigned char *dat, unsigned char len)
{
    unsigned char sum = 0;
    while (len--)
    {
        sum += *dat++;
    }
    return sum;
}
/* 从EEPROM中读取保存的密码数据，并对密码进行“累加和”校验，返回值-校验通过返回1，否则返回0 */
bit ReadPassword()
{
    unsigned char sum;
    unsigned char buf[PSW_MAX_LEN+1];

    E2Read(buf, PSW_SAVE_ADDR, PSW_MAX_LEN+1);  //读取密码数据和校验字节
    sum = GetChkSum(buf, PSW_MAX_LEN); //计算密码数据的累加和
    if (buf[PSW_MAX_LEN] == ~sum)      //校验通过，即密码有效时，拷贝密码
    {
        CopyMemory(PswSet, buf, PSW_MAX_LEN);
        return 1;
    }
    else  //密码数据无效时，缓冲区默认成全0
    {
        FillMemory(PswSet, '\0', PSW_MAX_LEN);
        return 0;
    }
}
/* 将当前的密码数据保存到EEPROM中，同时添加校验字节 */
void SavePassword()
{
    unsigned char buf[PSW_MAX_LEN+1];
  
    CopyMemory(buf, PswSet, PSW_MAX_LEN);  //复制密码数据到缓冲区中
    buf[PSW_MAX_LEN] = ~GetChkSum(buf, PSW_MAX_LEN);  //填充最后的累加和校验字节
    E2Write(buf, PSW_SAVE_ADDR, PSW_MAX_LEN+1);  //将密码数据保存到EEPROM中
}
/* 在液晶上显示与当前输入密码位数相同的*，以指示当前输入的密码位数 */
void ShowPswCnt()
{
    unsigned char buf[PSW_MAX_LEN+1];
    
    FillMemory(buf, '*', PswCnt);
    FillMemory(buf+PswCnt, '\0', sizeof(buf)-PswCnt);
    LcdShowStr(0, 1, buf);
}
/* 数字键动作函数，keycode-数字按键的ASCII值 */
void KeyNumAction(unsigned char keycode)
{
    switch (status)
    {
        case 0: //输入密码状态时，将输入字符填充到PswBuf1
            if (PswCnt < PSW_MAX_LEN)
            {
                PswBuf1[PswCnt] = keycode;
                PswCnt++;
                ShowPswCnt();
            }
            break;
        case 1: //设置密码状态时，将输入字符填充到PswBuf1
            if (PswCnt < PSW_MAX_LEN)
            {
                PswBuf1[PswCnt] = keycode;
                PswCnt++;
                ShowPswCnt();
            }
            break;
        case 2: //设置密码确认状态时，将输入字符填充到PswBuf2
            if (PswCnt < PSW_MAX_LEN)
            {
                PswBuf2[PswCnt] = keycode;
                PswCnt++;
                ShowPswCnt();
            }
            break;
            default: //其它状态不予响应
            break;
    }
}
/*向上键动作函数*/
void KetUPAction()
{	
	  LcdClearScreen();
    LcdShowStr(0, 0, "Set Password");
    FillMemory(PswBuf1, '\0', PSW_MAX_LEN);
    FillMemory(PswBuf2, '\0', PSW_MAX_LEN);
    PswCnt = 0;
    status = 1;
}
/* 回车键动作函数 */
void KeyEnterAction()
{
	  char buf[10];//创建一个字符数组 buf
    switch (status)
    {
        case 0: //检查输入的密码是否正确
           LcdClearScreen();
				if(fuzzy_recognition(PswSet, PswBuf1, PSW_MAX_LEN))
            {   //正确时显示解锁的提示
                LcdShowStr(0, 0, "Password Correct");
                LcdShowStr(0, 1, "system unlock");
								LedOpen();  //控制led亮灭
                status = 5;  //进入解锁状态
						   	ENLED = 1;
            }
            else if (!isPswretUsed&&CmpMemory(Pswret,PswBuf1,PSW_MAX_LEN))
				           {
					           LcdShowStr(0, 0, "Password Correct");
					           LcdShowStr(0, 1, "system unlock");
					           LedOpen();  //控制led亮灭
					           ENLED = 1;
					           status = 5;  //进入解锁状态
					           // 将Pswret设置为NULL
                     Pswret[PSW_MAX_LEN] = -1; 
										 isPswretUsed = 1; // 设置标志变量为已使用
									 }
            else
            {   //错误时显示已锁定的提示
                if(a<3)//错误次数
								{
									LcdShowStr(0, 0, "Password Wrong");
                  sprintf(buf, "%d", a);//使用 sprintf 将错误次数 a 格式化为字符串
                  LcdShowStr(0, 1, buf);
								  Alarm(4);
									status = 5;
									a++;
									}
								else{
									while(1)
									{
										Alarm(5);
										LcdShowStr(0, 0, "Password Wrong");
							      LcdShowStr(0, 1, "system locked");
									}
								}
            }
            break;
        case 1: //进入密码设置的确认步骤，即再输入一次密码
            LcdClearScreen();
            LcdShowStr(0, 0, "Confirm Password");
            PswCnt = 0;
            status = 2;
            break;
        case 2: //检查两次输入的密码是否一致
            LcdClearScreen();
            if (CmpMemory(PswBuf1, PswBuf2, PSW_MAX_LEN))
            {   //一致时保存设置的密码
                LcdShowStr(0, 0, "Enter Password");
                CopyMemory(PswSet, PswBuf1, PSW_MAX_LEN);
                SavePassword();
                FillMemory(PswBuf1, '\0', PSW_MAX_LEN);
                PswCnt = 0;
                status = 0;  //进入密码输入状态
            }
            else
            {   //不一致时提示密码设置失败
                LcdShowStr(0, 0, "Confirm Password");
							  Alarm(5);
                LcdShowStr(0, 1, "Failed");
                status = 3;  //进入密码设置失败状态
            }
            break;
        case 3: //重新提示设置密码，进入密码设置状态
            LcdClearScreen();
            LcdShowStr(0, 0, "Set Password");
            FillMemory(PswBuf1, '\0', PSW_MAX_LEN);
            FillMemory(PswBuf2, '\0', PSW_MAX_LEN);
            PswCnt = 0;
            status = 1;
            break;
        case 4: //重新设置即修改密码
            LcdClearScreen();
            LcdShowStr(0, 0, "Set Password");
            FillMemory(PswBuf1, '\0', PSW_MAX_LEN);
            FillMemory(PswBuf2, '\0', PSW_MAX_LEN);
            PswCnt = 0;
            status = 1;
            break;
        case 5: //重新输入密码
            LcdClearScreen();
            LcdShowStr(0, 0, "Enter Password");
            FillMemory(PswBuf1, '\0', PSW_MAX_LEN);
            PswCnt = 0;
            status = 0;
            break;		
        default: //不予响应
            break;
    }
}
/*模糊识别*/
unsigned char fuzzy_recognition(char *arr1, char *arr2, unsigned char len2)
{
    unsigned char pos1 = 0; // 当前匹配到的位置
    unsigned char pos2 = 0; // 下一个需要匹配的位置
    unsigned char i, len1 = 0;
    for (i = 0; i < 10; i++)
    {
        if (arr1[i] != '\0')
        {
            ++len1;
        }
    }
    for (i = 0; i < len2; i++)
    { // 如果当前的字符匹配上了，就继续匹配后面的字符是否相等
        if (arr1[pos1] == arr2[i])
        {
            pos2 = pos1 + 1;
            while ((pos2 < len1) && (i < len2) && (arr1[pos2] == arr2[i + 1]))
            {
                i++;	// 匹配成功，arr2的下标往后移动一位
                pos2++;	// 匹配成功，pos2的下标往后移动一位
            }
            if (pos2 == len1)
            {
                return 1; // 找到了
            }
        }
        else
        {
            pos1 = 0;	// 从头开始匹配
        }
    }
    return 0; // 没有找到
}
/* Esc键动作函数 */
void KeyEscAction()
{
    switch (status)
    {
        case 0: //输入密码状态时，清空当前输入以重新开始
            LcdClearScreen();
            LcdShowStr(0, 0, "Enter Password");
            FillMemory(PswBuf1, '\0', PSW_MAX_LEN);
            PswCnt = 0;
            break;
        case 1: //设置密码状态时，清空当前输入以重新开始
            LcdClearScreen();
            LcdShowStr(0, 0, "Set Password");
            FillMemory(PswBuf1, '\0', PSW_MAX_LEN);
            PswCnt = 0;
            break;
        case 2: //设置密码确认状态时，清空输入并返回密码设置状态
            LcdClearScreen();
            LcdShowStr(0, 0, "Set Password");
            FillMemory(PswBuf1, '\0', PSW_MAX_LEN);
            FillMemory(PswBuf2, '\0', PSW_MAX_LEN);
            PswCnt = 0;
            status = 1;
            break;
        default: //其它状态不予响应
            break;
    }
}
/* 按键动作函数，根据键码执行相应的操作，keycode-按键键码 */
void KeyAction(unsigned char keycode)
{
    if  ((keycode>='0') && (keycode<='9'))  //输入字符
    {
        KeyNumAction(keycode);
    }
    else if (keycode == 0x0D)  //回车键
    {
        KeyEnterAction();
    }
    else if (keycode == 0x1B)  //Esc键
    {
        KeyEscAction();
    }
		else if (keycode == 0x26)  //向上键
		{
			  KetUPAction();
		}
}
/* 配置并启动T0，ms-T0定时时间 */
void ConfigTimer0(unsigned int ms)
{
    unsigned long tmp;  //临时变量
    tmp = 11059200 / 12;      //定时器计数频率
    tmp = (tmp * ms) / 1000;  //计算所需的计数值
    tmp = 65536 - tmp;        //计算定时器重载值
    tmp = tmp + 28;           //补偿中断响应延时造成的误差
    T0RH = (unsigned char)(tmp>>8);  //定时器重载值拆分为高低字节
    T0RL = (unsigned char)tmp;
    TMOD &= 0xF0;   //清零T0的控制位
    TMOD |= 0x01;   //配置T0为模式1
    TH0 = T0RH;     //加载T0重载值
    TL0 = T0RL;
    ET0 = 1;        //使能T0中断
    TR0 = 1;        //启动T0
}
/*控制蜂鸣器*/
void Alarm(unsigned char n)
{
	unsigned char i,j,k;
	for(k=0;k<n;k++)
	{
		for(j=0;j<100;j++)
		{
			Buzzer = ~Buzzer;
			for(i=0;i<100;i++);
		}
		Delay100ms();
	}
}
/* T0中断服务函数，执行按键扫描 */
void InterruptTimer0() interrupt 1
{
    TH0 = T0RH;  //重新加载重载值
    TL0 = T0RL;
    KeyScan();   //按键扫描
	
}

keyboard.c

#include <reg52.h>

sbit KEY_IN_1  = P2^4;
sbit KEY_IN_2  = P2^5;
sbit KEY_IN_3  = P2^6;
sbit KEY_IN_4  = P2^7;
sbit KEY_OUT_1 = P2^3;
sbit KEY_OUT_2 = P2^2;
sbit KEY_OUT_3 = P2^1;
sbit KEY_OUT_4 = P2^0;

unsigned char code KeyCodeMap[4][4] = { //矩阵按键编号到标准键盘键码的映射表
    { '1',  '2',  '3', 0x26 }, //数字键1、数字键2、数字键3、向上键
    { '4',  '5',  '6', 0x25 }, //数字键4、数字键5、数字键6、向左键
    { '7',  '8',  '9', 0x28 }, //数字键7、数字键8、数字键9、向下键
    { '0', 0x1B, 0x0D, 0x27 }  //数字键0、ESC键、  回车键、 向右键
};
unsigned char pdata KeySta[4][4] = {  //全部矩阵按键的当前状态
    {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}
};

extern void KeyAction(unsigned char keycode);

/* 按键驱动函数，检测按键动作，调度相应动作函数，需在主循环中调用 */
void KeyDriver()
{
    unsigned char i, j;
    static unsigned char pdata backup[4][4] = {  //按键值备份，保存前一次的值
        {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1},  {1, 1, 1, 1}
    };
    
    for (i=0; i<4; i++)  //循环检测4*4的矩阵按键
    {
        for (j=0; j<4; j++)
        {
            if (backup[i][j] != KeySta[i][j])    //检测按键动作
            {
                if (backup[i][j] != 0)           //按键按下时执行动作
                {
                    KeyAction(KeyCodeMap[i][j]); //调用按键动作函数
                }
                backup[i][j] = KeySta[i][j];     //刷新前一次的备份值
            }
        }
    }
}
/* 按键扫描函数，需在定时中断中调用，推荐调用间隔1ms */
void KeyScan()
{
    unsigned char i;
    static unsigned char keyout = 0;   //矩阵按键扫描输出索引
    static unsigned char keybuf[4][4] = {  //矩阵按键扫描缓冲区
        {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF},
        {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF}
    };

    //将一行的4个按键值移入缓冲区
    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++)  //每行4个按键，所以循环4次
    {
        if ((keybuf[keyout][i] & 0x0F) == 0x00)
        {   //连续4次扫描值为0，即4*4ms内都是按下状态时，可认为按键已稳定的按下
            KeySta[keyout][i] = 0;
        }
        else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
        {   //连续4次扫描值为1，即4*4ms内都是弹起状态时，可认为按键已稳定的弹起
            KeySta[keyout][i] = 1;
        }
    }
    //执行下一次的扫描输出
    keyout++;         //输出索引递增
    keyout &= 0x03;   //索引值加到4即归零
    switch (keyout)   //根据索引，释放当前输出引脚，拉低下次的输出引脚
    {
        case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
        case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
        case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
        case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
        default: break;
    }
}

hongwai.h

#include <reg52.h>

sbit IR_INPUT = P3^3;  //红外接收引脚
bit irflag = 0;  //红外接收标志，收到一帧正确数据后置1
unsigned char ircode[4];  //红外代码接收缓冲区
extern unsigned char retKey(unsigned char ircode);//返回红外代码对应的按键值
extern void KeyAction(unsigned char keycode);//执行按键动作

/* 红外驱动函数,初始化红外接收功能 */
void fDriver()
{
    KeyAction(retKey(ircode[2]));
}

void InitInfrared()//初始化红外接收功能，配置计数器T1、中断INT1等
{
    IR_INPUT = 1;  //确保红外接收引脚被释放
    TMOD &= 0x0F;  //清零T1的控制位
    TMOD |= 0x10;  //配置T1为模式1
    TR1 = 0;       //停止T1计数
    ET1 = 0;       //禁止T1中断
    IT1 = 1;       //设置INT1为负边沿触发
    EX1 = 1;       //使能INT1中断
}
/* 获取当前高电平的持续时间 */
unsigned int GetHighTime()
{
    TH1 = 0;  //清零T1计数初值
    TL1 = 0;
    TR1 = 1;  //启动T1计数
    while (IR_INPUT)  //红外输入引脚为1时循环检测等待，变为0时则结束本循环
    {
        if (TH1 >= 0x40)
        {            //当T1计数值大于0x4000，即高电平持续时间超过约18ms时，
            break;   //强制退出循环，是为了避免信号异常时，程序假死在这里。
        }
    }
    TR1 = 0;  //停止T1计数

    return (TH1*256 + TL1);  //T1计数值合成为16bit整型数，并返回该数
}
/* 获取当前低电平的持续时间 */
unsigned int GetLowTime()
{
    TH1 = 0;  //清零T1计数初值
    TL1 = 0;
    TR1 = 1;  //启动T1计数
    while (!IR_INPUT)  //红外输入引脚为0时循环检测等待，变为1时则结束本循环
    {
        if (TH1 >= 0x40)
        {            //当T1计数值大于0x4000，即低电平持续时间超过约18ms时，
            break;   //强制退出循环，是为了避免信号异常时，程序假死在这里。
        }
    }
    TR1 = 0;  //停止T1计数

    return (TH1*256 + TL1);  //T1计数值合成为16bit整型数，并返回该数
}
/* INT1中断服务函数，执行红外接收及解码 */
void EXINT1_ISR() interrupt 2
{
    unsigned char i, j;
    unsigned char byt;
    unsigned int time;
    
    //接收并判定引导码的9ms低电平
    time = GetLowTime();
    if ((time<7833) || (time>8755))  //时间判定范围为8.5～9.5ms，
    {                                //超过此范围则说明为误码，直接退出
        IE1 = 0;   //退出前清零INT1中断标志
        return;
    }
    //接收并判定引导码的4.5ms高电平
    time = GetHighTime();
    if ((time<3686) || (time>4608))  //时间判定范围为4.0～5.0ms，
    {                                //超过此范围则说明为误码，直接退出
        IE1 = 0;
        return;
    }
    //接收并判定后续的4字节数据
    for (i=0; i<4; i++)  //循环接收4个字节
    {
        for (j=0; j<8; j++)  //循环接收判定每字节的8个bit
        {
            //接收判定每bit的560us低电平
            time = GetLowTime();
            if ((time<313) || (time>718)) //时间判定范围为340～780us，
            {                             //超过此范围则说明为误码，直接退出
                IE1 = 0;
                return;
            }
            //接收每bit高电平时间，判定该bit的值
            time = GetHighTime();
            if ((time>313) && (time<718)) //时间判定范围为340～780us，
            {                             //在此范围内说明该bit值为0
                byt >>= 1;   //因低位在先，所以数据右移，高位为0
            }
            else if ((time>1345) && (time<1751)) //时间判定范围为1460～1900us，
            {                                    //在此范围内说明该bit值为1
                byt >>= 1;   //因低位在先，所以数据右移，
                byt |= 0x80; //高位置1
            }
            else  //不在上述范围内则说明为误码，直接退出
            {
                IE1 = 0;
                return;
            }
        }
        ircode[i] = byt;  //接收完一个字节后保存到缓冲区
    }
    irflag = 1;  //接收完毕后设置标志
    IE1 = 0;     //退出前清零INT1中断标志
}

lcd1602.h

#include <reg52.h>

#define LCD1602_DB  P0
sbit LCD1602_RS = P1^0;
sbit LCD1602_RW = P1^1;
sbit LCD1602_E  = P1^5;


/* 等待液晶准备好 */
void LcdWaitReady()
{
    unsigned char sta;
    LCD1602_DB = 0xFF;
    LCD1602_RS = 0;
    LCD1602_RW = 1;
    do {
        LCD1602_E = 1;
        sta = LCD1602_DB; //读取状态字
        LCD1602_E = 0;
    } while (sta & 0x80); //bit7等于1表示液晶正忙，重复检测直到其等于0为止
}

/* 向LCD1602液晶写入一字节命令，cmd-待写入命令值 */
void LcdWriteCmd(unsigned char cmd)
{
    LcdWaitReady();
    LCD1602_RS = 0;
    LCD1602_RW = 0;
    LCD1602_DB = cmd;
    LCD1602_E  = 1;
    LCD1602_E  = 0;
}

/* 向LCD1602液晶写入一字节数据，dat-待写入数据值 */
void LcdWriteDat(unsigned char dat)
{
    LcdWaitReady();
    LCD1602_RS = 1;
    LCD1602_RW = 0;
    LCD1602_DB = dat;
    LCD1602_E  = 1;
    LCD1602_E  = 0;
}

/* 设置显示RAM起始地址，亦即光标位置，(x,y)-对应屏幕上的字符坐标 */
void LcdSetCursor(unsigned char x, unsigned char y)
{
    unsigned char addr;
    
    if (y == 0)  //由输入的屏幕坐标计算显示RAM的地址
        addr = 0x00 + x;  //第一行字符地址从0x00起始
    else
        addr = 0x40 + x;  //第二行字符地址从0x40起始
    LcdWriteCmd(addr | 0x80);  //设置RAM地址
}

/* 在液晶上显示字符串，(x,y)-对应屏幕上的起始坐标，str-字符串指针 */
void LcdShowStr(unsigned char x, unsigned char y, unsigned char *str)
{
    LcdSetCursor(x, y);   //设置起始地址
    while (*str != '\0')  //连续写入字符串数据，直到检测到结束符
    {
        LcdWriteDat(*str++);
    }
}

/* 清屏 */
void LcdClearScreen()
{
    LcdWriteCmd(0x01);
}

/* 初始化1602液晶 */
void InitLcd1602()
{
    LcdWriteCmd(0x38);  //16*2显示，5*7点阵，8位数据接口
    LcdWriteCmd(0x0C);  //显示器开，光标关闭
    LcdWriteCmd(0x06);  //文字不动，地址自动+1
    LcdWriteCmd(0x01);  //清屏
}

I2C.c

#include <reg52.h>
#include <intrins.h>

#define I2CDelay()  {_nop_();_nop_();_nop_();_nop_();}
sbit I2C_SCL = P3^7;
sbit I2C_SDA = P3^6;

/* 产生总线起始信号 */
void I2CStart()
{
    I2C_SDA = 1; //首先确保SDA、SCL都是高电平
    I2C_SCL = 1;
    I2CDelay();
    I2C_SDA = 0; //先拉低SDA
    I2CDelay();
    I2C_SCL = 0; //再拉低SCL
}
/* 产生总线停止信号 */
void I2CStop()
{
    I2C_SCL = 0; //首先确保SDA、SCL都是低电平
    I2C_SDA = 0;
    I2CDelay();
    I2C_SCL = 1; //先拉高SCL
    I2CDelay();
    I2C_SDA = 1; //再拉高SDA
    I2CDelay();
}
/* I2C总线写操作，dat-待写入字节，返回值-从机应答位的值 */
bit I2CWrite(unsigned char dat)
{
    bit ack;  //用于暂存应答位的值
    unsigned char mask;  //用于探测字节内某一位值的掩码变量

    for (mask=0x80; mask!=0; mask>>=1) //从高位到低位依次进行
    {
        if ((mask&dat) == 0)  //该位的值输出到SDA上
            I2C_SDA = 0;
        else
            I2C_SDA = 1;
        I2CDelay();
        I2C_SCL = 1;          //拉高SCL
        I2CDelay();
        I2C_SCL = 0;          //再拉低SCL，完成一个位周期
    }
    I2C_SDA = 1;   //8位数据发送完后，主机释放SDA，以检测从机应答
    I2CDelay();
    I2C_SCL = 1;   //拉高SCL
    ack = I2C_SDA; //读取此时的SDA值，即为从机的应答值
    I2CDelay();
    I2C_SCL = 0;   //再拉低SCL完成应答位，并保持住总线

    return (~ack); //应答值取反以符合通常的逻辑：
                   //0=不存在或忙或写入失败，1=存在且空闲或写入成功
}
/* I2C总线读操作，并发送非应答信号，返回值-读到的字节 */
unsigned char I2CReadNAK()
{
    unsigned char mask;
    unsigned char dat;

    I2C_SDA = 1;  //首先确保主机释放SDA
    for (mask=0x80; mask!=0; mask>>=1) //从高位到低位依次进行
    {
        I2CDelay();
        I2C_SCL = 1;      //拉高SCL
        if(I2C_SDA == 0)  //读取SDA的值
            dat &= ~mask; //为0时，dat中对应位清零
        else
            dat |= mask;  //为1时，dat中对应位置1
        I2CDelay();
        I2C_SCL = 0;      //再拉低SCL，以使从机发送出下一位
    }
    I2C_SDA = 1;   //8位数据发送完后，拉高SDA，发送非应答信号
    I2CDelay();
    I2C_SCL = 1;   //拉高SCL
    I2CDelay();
    I2C_SCL = 0;   //再拉低SCL完成非应答位，并保持住总线

    return dat;
}
/* I2C总线读操作，并发送应答信号，返回值-读到的字节 */
unsigned char I2CReadACK()
{
    unsigned char mask;
    unsigned char dat;

    I2C_SDA = 1;  //首先确保主机释放SDA
    for (mask=0x80; mask!=0; mask>>=1) //从高位到低位依次进行
    {
        I2CDelay();
        I2C_SCL = 1;      //拉高SCL
        if(I2C_SDA == 0)  //读取SDA的值
            dat &= ~mask; //为0时，dat中对应位清零
        else
            dat |= mask;  //为1时，dat中对应位置1
        I2CDelay();
        I2C_SCL = 0;      //再拉低SCL，以使从机发送出下一位
    }
    I2C_SDA = 0;   //8位数据发送完后，拉低SDA，发送应答信号
    I2CDelay();
    I2C_SCL = 1;   //拉高SCL
    I2CDelay();
    I2C_SCL = 0;   //再拉低SCL完成应答位，并保持住总线

    return dat;
}

eeprom.c

#include <reg52.h>

extern void I2CStart();
extern void I2CStop();
extern unsigned char I2CReadACK();
extern unsigned char I2CReadNAK();
extern bit I2CWrite(unsigned char dat);

/* E2读取函数，buf-数据接收指针，addr-E2中的起始地址，len-读取长度 */
void E2Read(unsigned char *buf, unsigned char addr, unsigned char len)
{
    do {                       //用寻址操作查询当前是否可进行读写操作
        I2CStart();
        if (I2CWrite(0x50<<1)) //应答则跳出循环，非应答则进行下一次查询
        {
            break;
        }
        I2CStop();
    } while(1);
    I2CWrite(addr);            //写入起始地址
    I2CStart();                //发送重复启动信号
    I2CWrite((0x50<<1)|0x01);  //寻址器件，后续为读操作
    while (len > 1)            //连续读取len-1个字节
    {
        *buf++ = I2CReadACK(); //最后字节之前为读取操作+应答
        len--;
    }
    *buf = I2CReadNAK();       //最后一个字节为读取操作+非应答
    I2CStop();
}
/* E2写入函数，buf-源数据指针，addr-E2中的起始地址，len-写入长度 */
void E2Write(unsigned char *buf, unsigned char addr, unsigned char len)
{
    while (len > 0)
    {
        //等待上次写入操作完成
        do {                       //用寻址操作查询当前是否可进行读写操作
            I2CStart();
            if (I2CWrite(0x50<<1)) //应答则跳出循环，非应答则进行下一次查询
            {
                break;
            }
            I2CStop();
        } while(1);
        //按页写模式连续写入字节
        I2CWrite(addr);           //写入起始地址
        while (len > 0)
        {
            I2CWrite(*buf++);     //写入一个字节数据
            len--;                //待写入长度计数递减
            addr++;               //E2地址递增
            if ((addr&0x07) == 0) //检查地址是否到达页边界，24C02每页8字节，
            {                     //所以检测低3位是否为零即可
                break;            //到达页边界时，跳出循环，结束本次写操作
            }
        }
        I2CStop();
    }
}

做个俗人挺好，狮子不留恋过往

关注

7
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
6
评论
基于51单片机的电子密码锁设计

本设计采用STC89C52单片机为主控芯片，通过软件程序组成电子密码锁系统，能够实现：（1）密码输入错误，蜂鸣器报警，累计三次，系统锁死。(2) 密码为6-10位，可以随意更改。(3) 采用矩阵按键输入和红外输入两种。(4) 通过LCD1602液晶显示。(5) 有开锁指示灯及蜂鸣器警示音。(6) 具有模糊识别功能。
复制链接

扫一扫