设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › DIY简单的电子密码锁，可以外加改装为密码箱，用于送女 ...
返回列表 发新帖
查看: 4058|回复: 1
收起左侧

DIY简单的电子密码锁，可以外加改装为密码箱，用于送女朋友礼物的容器！

[复制链接]
ID:188940 发表于 2020-5-24 09:26 | 显示全部楼层 |阅读模式
今天给大家介绍一款业余制作的电子密码锁，有PCB、原理图、仿真图（前期用，后期直接上PCB板）。此程序没有做用外部存储器，所以不支持修改密码，我后续有时间慢慢在改进加上去，然后在添加指纹识别模块，有时间再继续更新。毕竟是业余时间做的，可能在有些方面不是很完善，希望大家都来观摩观摩，出出建议。
一、功能介绍：
1、输入8位密码，即可开锁。
2、输入9次纯数字，显示错误，并红灯提醒。
3、没有输入完8位密码，按下确认键，提醒错误并红灯提醒。
4、密码输入错误三次，锁定键盘并且蜂鸣器提醒5秒左右。
5、输入错误可以退格、清零。
6、1602显示模块会有60秒定时显示，没操作键盘50秒后，清楚数据，并且闪红灯提醒。
7、1602显示模块会有输入位数显示，提醒输入密码。
8、程序有密码数值存储在数组，可用于显示等操作。（制作礼品盒的时候可用）
9、本PCB，设计有外部存储器24C02的硬件位置，方便后期可添加！

二、PCB提醒

1、本次上传的PCB的1602的1.2引脚正负极已经调整过来（实物PCB的1.2脚反了，当时没注意，都烧坏了一块1602··········其他没有问题）。
2、我这里还有一版的PCB，硬件设计的请移步我的另一个贴，上面有更正的硬件说明。http://www.51hei.com/bbs/dpj-183892-1.html

三、最后说几句
1、有电子相关专业（专科）的同学们，可以用这个作为毕业设计，应该问题不大。
2、自己用动手能力的朋友，可以自己改成简易的电子密码箱，用来装礼物，给自己的朋友或者女朋友都可以。个人感觉还挺不错，感兴趣的朋友可以尝试，我有空了你也会做一个这样的。
3、我的一些实物视频可以去我的抖音上看，抖音号：5946BNYZD。
4、哔哩哔哩视频：https://www.bilibili.com/video/BV1QK411W7w9/

制作出来的实物图如下：

实物图二

实物图二

实物图一

实物图一

两版电路板

两版电路板
单片机源程序如下:
  1. #include<reg51.h>
  2. #define         uchar unsigned        char
  3. #define uint unsigned int

  5. uchar code szjianzhibiao[]={0x77,0x7b,0x7d,
  6.                              0xb7,0xbb,0xbd,   //矩阵数字键盘键值
  7.                                                  0xd7,0xdb,0xdd,
  8.                                                          0xeb};

  10. uchar code gnjianzhibiao[]={0x7e,0xbe,0xde,          //矩阵功能键盘键值
  11.                                                          0xee,0xed,0xe7};
  12.                                                           
  13. uchar code           mima[]={0x77,0x7d,0x77,0xb7,  //设定的密码
  14.                              0x77,0x7d,0x77,0xb7};

  16. uchar code table[]="HOLLE!  User";
  17. uchar code table1[]="Password";
  18. uchar code table2[]="********";
  19. uchar code table3[]="  error!";
  20. uchar code table4[]="  OK!   ";
  21. uchar code table5[]="        ";         //抹除输入痕迹的空字符串
  22. uchar code table6[]="0123456789";
  23. uchar code table7[]="012345";
  24. //uchar code table8[]="you did it! Do you think I will love you? no! What I love is not you,but all of you! I will love you forever!";
  25. uchar code table9[]="  You did it!   ";
  26. uchar code table10[]="     Good!      ";
  27. uchar code table11[]="The gift belongs";
  28. uchar code table12[]="    to you.     ";
  29. uchar code table13[]="   I love you   ";
  30. uchar code table14[]="    forever!    ";

  32. sbit  green=P3^2;  //绿灯
  33. sbit  blue=P3^3;  //蓝灯
  34. sbit  red=P3^4;  //红灯
  35. sbit  bao=P1^3; //蜂鸣器
  36. sbit  jdq=P3^7; //继电器
  37. sbit  en=P1^2; //定义LCD1602使能端
  38. sbit  rw=P1^1;//定义LCD1602读/写选择端
  39. sbit  rs=P1^0;//定义LCD1602数据/命令选择端

  41. uchar T1_NUM=0,T1_NUM1=0,T0_NUM=0,T0_NUM1=0;
  42. uchar j=0,k=0,h=0,y=0,l=0,z=0,flag=0,flag1=0,flag2=0,p=0,d=0;

  44. void delay (uchar del)
  45. {
  46.     uint i,j;
  47.         for(i=0;i<del;i++)                   //延时程序
  48.            for(j=0;j<130;j++)
  49.            ;

  51. }


  54. void lcd_wcom(uchar com)
  55. {       rs=0;            //选择指令寄存器      
  56.         rw=0;            //选择写      
  57.         P0=com;            //把命令字送入P0      
  58.         delay(10);
  59.                 en=0;
  60.                 delay(10);            //延时一小会儿，让1602准备接收数据      
  61.         en=1;
  62.                 delay(10);          //使能线电平变化，命令送入1602的8位数据口      
  63.         en=0;  
  64. }
  65. void lcd_wdat(uchar dat)        //1602写数据函数        
  66. {      
  67.         rs=1;        //选择数据寄存器      
  68.         rw=0;        //选择写      
  69.         P0=dat;        //把要显示的数据送入P2      
  70.         delay(10);
  71.                 en=0;
  72.                 delay(10);       //延时一小会儿，让1602准备接收数据      
  73.         en=1;
  74.         delay(10);         //使能线电平变化，数据送入1602的8位数据口  
  75.         en=0;
  76. }
  77. void lcd_init()  
  78. {      
  79. lcd_wcom(0x38);       //8位数据，双列，5*7字形            
  80. lcd_wcom(0x0c);      //开启显示屏，关光标，光标不闪烁      
  81. lcd_wcom(0x06);    //显示地址递减，即写一个数据后，显示位置右移一位      
  82. lcd_wcom(0x01);    //清屏
  83. }
  84. void xianshi()  
  85. {
  86. uchar n,m=0;                              
  87. lcd_wcom(0x80+0x02);   //显示地址上排第三位            
  88. for(m=0;m<12;m++)     //将table[]中的数据依次写入1602显示  
  89. {               
  90. lcd_wdat(table[m]);                        
  91. delay(5);     
  92. }
  93. lcd_wcom(0x80+0x40);//显示地址为0xc4,即下排第1位     
  94. for(n=0;n<8;n++)   //将table1[]中的数据依次写入1602显示     
  95.   {                  
  96.   lcd_wdat(table1[n]);            
  97.   delay(5);      
  98.   }
  99. }

  101. void xianshi1(uchar s)  
  102. {
  103. uchar m;                              
  104. lcd_wcom(0x80+0x48);   //显示地址上排第九位，显示输入的*号         
  105. for(m=0;m<s;m++)     //将table[]中的数据依次写入1602显示      
  106. {               
  107. lcd_wdat(table2[m]);                        
  108. delay(1);     
  109. }
  110. }

  112. void xianshi2()  
  113. {
  114. uchar m;                              
  115. lcd_wcom(0x80+0x48);   //显示地址上排第九位，显示OK           
  116. for(m=0;m<8;m++)     //将table[]中的数据依次写入1602显示      
  117. {               
  118. lcd_wdat(table4[m]);                        
  119. delay(100);     
  120. }
  121. }

  123. void xianshi3()  
  124. {
  125. uchar m;                              
  126. lcd_wcom(0x80+0x48);   //显示地址上排第九位，显示error            
  127. for(m=0;m<8;m++)     //将table[]中的数据依次写入1602显示      
  128. {               
  129. lcd_wdat(table3[m]);                        
  130. delay(100);     
  131. }
  132. }


  135. void xianshi5()
  136. {
  137. uchar m=0;                              
  138. lcd_wcom(0x80+0x48);   //显示地上排第九位，清除显示                             
  139. for(m=0;m<8;m++)     //将table[]中的数据依次写入1602显示      
  140. {               
  141. lcd_wdat(table5[m]);                        
  142. delay(1);     
  143. }   
  144. }

  146. void xianshi6()
  147. {
  148. uchar m=0;
  149. lcd_wcom(0x80+0x00);                              
  150. for(m=0;m<16;m++)         
  151. {               
  152. lcd_wdat(table9[m]);                        
  153. delay(100);     
  154. }
  155. delay(100);

  157. lcd_wcom(0x80+0x40);                                
  158. for(m=0;m<16;m++)           
  159. {               
  160. lcd_wdat(table10[m]);                        
  161. delay(100);     
  162. }
  163. delay(100);

  165. lcd_wcom(0x80+0x00);                                
  166. for(m=0;m<16;m++)           
  167. {               
  168. lcd_wdat(table11[m]);                        
  169. delay(100);     
  170. }
  171. delay(100);

  173. lcd_wcom(0x80+0x40);                                
  174. for(m=0;m<16;m++)           
  175. {               
  176. lcd_wdat(table12[m]);                        
  177. delay(100);
  178. }
  179. delay(100);

  181. lcd_wcom(0x80+0x00);                                
  182. for(m=0;m<16;m++)           
  183. {               
  184. lcd_wdat(table13[m]);                        
  185. delay(100);   
  186. }
  187. delay(100);
  188.   
  189. lcd_wcom(0x80+0x40);                                
  190. for(m=0;m<16;m++)           
  191. {               
  192. lcd_wdat(table14[m]);                        
  193. delay(100);   
  194. }
  195. delay(100);   
  196. }

  198. void jishuqi( )
  199. {
  200.     TMOD=0x10;
  201.         TH1=(65536-40000)/256;
  202.         TL1=(65536-40000)%256;         //定时器T1，设置40ms
  203.         ET1=1;
  204.         EA=1;
  205.         TR1=1;
  206.                
  207. }

  209. void time1() interrupt 3
  210. {
  211.     TH1=(65536-40000)/256;
  212.         TL1=(65536-40000)%256;
  213.         T1_NUM++;
  214.         if(T1_NUM==25)              //定时1S
  215.         {
  216.           T1_NUM=0;
  217.           T1_NUM1++;  
  218.           p++;
  219.           lcd_wcom(0x80+0x0f);           //显示个位秒
  220.       lcd_wdat(table6[p]);          
  221.           }
  222.         if(T1_NUM1==5)                           //定时5S
  223.         {
  224.          T1_NUM1=0;
  225.         if(flag==1)                                  
  226.            {
  227.                 red=~red;
  228.             bao=1;                                  //红灯状态反转
  229.             flag=0;
  230.                 TR1=0;
  231.                 lcd_wcom(0x80+0x0e);
  232.       lcd_wdat(table6[d]);                  //显示十位秒
  233.            }
  234.           }
  235.           if(p==10)
  236.            {
  237.            p=0;                                        //计时秒开始
  238.            d++;
  239.            if(d==6)                                //计时分开始
  240.            d=0;
  241.            }

  243. }

  245. void jishuqi1( )
  246. {
  247.     TMOD=0x10;
  248.         TH0=(65536-40000)/256;
  249.         TL0=(65536-40000)%256;                 //定时器T1
  250.         ET0=1;
  251.         EA=1;
  252.         TR0=1;
  253.        
  254.                        
  255. }

  257. void time0() interrupt 1
  258. {
  259.     TH0=(65536-50000)/256;
  260.         TL0=(65536-50000)%256;          //设置50ms
  261.         T0_NUM++;
  262.         if(T0_NUM==100)                          //定时1S（正常来说T0_NUM应该=20就是1S，由于有误差，所以设置为100）
  263.         {
  264.           
  265.            T0_NUM=0;                         
  266.            T0_NUM1++;
  267.            l++;
  268.            if(l==10)
  269.            {
  270.            l=0;                                        //个位定时
  271.            z++;
  272.            if(z==6)                                //十位定时
  273.            z=0;
  274.            }
  275.            if(j-1!=flag2)           //每1S检测是否有按键按下
  276.            flag1=1;                           //没有按下，则赋值为1；
  277.           
  278.           
  279.         }
  280.         if(T0_NUM1==50)                   //定时50S
  281.         {
  282.            T0_NUM1=0;
  283.                      if(flag1>0&&flag1==1)         //按键没有按下
  284.                   {
  285.                   flag1=0;                                 //清零
  286.                   if(j==flag2&&P2==0xf0) //按键未操作且键盘按下次数未增加
  287.                    {
  288.                     red=0;
  289.                         delay(30);
  290.                         red=1;                                //超过50S未动作，清除数据并且清屏
  291.                     xianshi5();
  292.                         j=0;
  293.                         k=0;
  294.                    }
  295.                   }       
  296.         }
  297.          
  298.    
  299.    
  300. }

  302. void key ()
  303. {
  304.     uchar lie,jianzhi,szjianhao,szjianpan1,gnjianhao,caijimima[7],szjianhao2[7],sign,i;
  305.           if(flag==1)
  306.            {
  307.            xianshi3();
  308.            delay(100);        //锁定键盘并且报警
  309.            xianshi5();
  310.           
  311.            }
  312.           else
  313.           {
  314.           P2=0xf0;
  315.           if(P2!=0xf0)
  316.            {                                  //按键去抖动
  317.            delay(10);
  318.            if(P2!=0xf0)
  319.             {
  320.                 j=j+1; //数字按键计数
  321.                 k=k+1; //功能按键计数
  322.                 lie=P2;
  323.                 P2=0x0f;
  324.                 jianzhi=lie|P2;
  325.                  for(i=0;i<10;i++)
  326.                   {
  327.                    if(jianzhi==szjianzhibiao[i])
  328.                     {
  329.                           szjianhao=szjianzhibiao[i];                 //对比数字按键
  330.                           szjianpan1=i;                                                 //具体按键数字保存起来，可作用数码管显示，此可以不用理会
  331.                           sign=0;                                                         //是数字按键按下标记
  332.                           break;
  333.                         }
  334.                   }
  335.                   for(i=0;i<6;i++)
  336.                    {
  337.                     if(jianzhi==gnjianzhibiao[i])
  338.                      {
  339.                           gnjianhao=i;                                                //对比功能按键
  340.                           sign=1;                                                        //是功能按键按下标记
  341.                           break;
  342.                          }
  343.                         }
  344.                         while(P2!=0x0f);
  345.                         delay(10);
  346.                        
  347.            }
  348.            if(sign==0)                                                           //数字按键按下判断
  349.                         {
  350.                          bao=0;
  351.                  delay(30);                                                  //蜂鸣器提示音
  352.                  bao=1;
  353.                          if(j==9)                                                 //连续九次输入数字按键
  354.               {
  355.                                 xianshi3();
  356.                                 delay(30000);
  357.                                 xianshi5();
  358.                 j=0;
  359.                                 k=0;                                                 //错误提示、报警并且清除数据
  360.                                 red=0;
  361.                                 delay(150);
  362.                                 red=1;
  363.                                 for(i=0;i<8;i++)
  364.                    caijimima[i]=0;
  365.                           }
  366.              else
  367.               {
  368.             
  369.                            for(i=j-1;i<j;i++)
  370.                 {
  371.                   caijimima[i]=szjianhao;                //正确输入并且暂存储密码
  372.                                   szjianhao2[i]=szjianpan1;                //具体按键数字保存起来，可作用数码管显示，此可以不用理会
  373.                                   green=0;
  374.                                   delay(150);
  375.                                   green=1;

  377.                 }
  378.                                 xianshi1(i);
  379.               }
  380.                          }
  381.                         if(sign==1)                                                   //功能按键判断
  382.                         {
  383.                          flag1=0;
  384.                          if(gnjianhao==3) //确认键判断
  385.               {                          
  386.                if(k==9)
  387.                 {
  388.                  for(i=0;i<8;i++)
  389.                                  {
  390.                                   if(mima[i]==caijimima[i])
  391.                                    {
  392.                                    h=h+1; //对比计数
  393.                                    }
  394.                                    else
  395.                                     {
  396.                                       h=1;
  397.                                       break;
  398.                                     }
  399.                                   }
  400.                                   
  401.                                  
  402.                                   if(h==8)          //密码正确
  403.                                    {
  404.                                      k=0;
  405.                                      j=0;
  406.                                      h=0;
  407.                                          blue=0;
  408.                                          delay(150);
  409.                                          blue=1;
  410.                                          for(i=0;i<8;i++)
  411.                                            caijimima[i]=0;
  412.                                            xianshi2();
  413.                                            delay(10000);
  414.                                            xianshi5();                                //开锁
  415.                                            jdq=0;
  416.                                            delay(100);
  417.                                            jdq=1;
  418.                                            lcd_wcom(0x01);
  419.                                            xianshi6();
  420.                                            lcd_wcom(0x01);
  421.                                            xianshi();

  423.                                           
  424.                                      
  425.                                   }

  427.                                   if(h==1)           //密码错误
  428.                                    {
  429.                                      bao=0;
  430.                                          delay(200);
  431.                                          bao=1;
  432.                                          y++;            //密码错误次数标记
  433.                                          h=0;
  434.                                          k=0;
  435.                                          j=0;
  436.                                          red=0;
  437.                                          delay(150);
  438.                                          red=1;
  439.                                          for(i=0;i<8;i++)
  440.                                            caijimima[i]=0;
  441.                                            xianshi3();
  442.                                            delay(30000);
  443.                                            xianshi5();
  444.                                            if(y==3)                  
  445.                                             {
  446.                                                   y=0;
  447.                                                   red=0;
  448.                                       flag=1;                 //三次密码错误，锁定键盘参数赋值
  449.                                                   bao=0;
  450.                               jishuqi();        //锁定10S计数开始
  451.                                             }
  452.                                          
  453.                                    }
  454.                 }
  455.                else
  456.                             {
  457.                                   k=0;
  458.                                   j=0;
  459.                                   xianshi3();//请继续输入8位完整密码后在按确认键！
  460.                                   delay(30000);
  461.                                   xianshi5();
  462.                                
  463.                                 }
  464.                }

  466.               if(gnjianhao==2) //清零键判断
  467.                {
  468.                 for(i=0;i<7;i++)
  469.                  {
  470.                    caijimima[i]=0;
  471.                  }
  472.                                  lcd_wcom(0x01);
  473.                                  xianshi();
  474.                                  k=0;
  475.                                  j=0;
  476.                }

  478.               if(gnjianhao==1) //退格键判断
  479.                {
  480.                 if(k==1&&j==1)
  481.                  {
  482.                                   xianshi3();//错误，请输入8位完整密码！
  483.                                   delay(30000);
  484.                                   xianshi5();
  485.                                
  486.                                    red=0;
  487.                                    delay(200);
  488.                                    red=1;
  489.                                    delay(200);
  490.                                    red=0;
  491. ……………………

  493. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
简单电子密码锁.7z (962.95 KB, 下载次数: 32)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:188940 发表于 2020-5-24 09:32 | 显示全部楼层
我这里还有几块的PCB，有需要的，可以免费给，邮费几块钱就可以拿到手。
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表