标题: 8051单片机电子密码锁防盗系统的仿真设计(12864显示) [打印本页]
作者: wxqn123    时间: 2018-5-11 20:26
标题: 8051单片机电子密码锁防盗系统的仿真设计(12864显示)
字模方式：
{0x00,0x02,0x82,0x82,0x82,0x82,0x82,0xFE,0x82,0x82,0x82,0x82,0x82,0x02,0x00,0x00},
{0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x7F,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00},/*"王",0*/
//取模方式为
//（1）点阵格式：阴码
//（2）取模走向：逆向
//（3）取模方式：列行式
//（4）c51格式
//（5）点阵：16*16
//取模软件为PCtolCD2002完美版

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:
  1. /*
  2. 题目：基于8051单片机的电子密码锁防盗系统的设计
  3. 作者：yarcl（原名：肖志）
  4. 注意：本文件包含LCDINIT.H和OWNMATH.C文件，LCDINIT.H主要是包含位定义，全局变量，函数声明等
  5.           而OWNMATH.C文件主要是包含12864液晶显示屏的写数据、写指令函数。
  6.           本程序当中最核心的程序部分应该是键盘扫描函数，读者可以细细品味其中的优点，在此不作叙述！
  7.           对了，修改密码的函数是采用中断方式1的模式进行的，大家也可以细细品味。
  8. */
  9. #include < reg52.h > //包含头文件
  10. #include "LcdInit.h" //包含本地文件LcdInit.h
  11. #include "ownmath.c" //包含本地文件ownmath.c

  13. static uchar mima[6] = {1,2,3,7,8,9}; //存入的密码
  14. uchar shuru[6];                                        //将输入的密码存入到shuru这个数组当中去

  16. //函数声明
  17. uchar key_scan();

  19. //字模数据(依次顺序为“居民小区：请输入密码：位数重新”)
  20. uchar code data_shuju[15][32] = {
  21. 0x00,0x00,0xFE,0x92,0x92,0x92,0x92,0x92,0xF2,0x92,0x92,0x92,0x9E,0x80,0x80,0x00,
  22. 0x40,0x30,0x0F,0x00,0xFC,0x44,0x44,0x44,0x47,0x44,0x44,0x44,0xFC,0x00,0x00,0x00,/*"居",0*/

  24. …………
  25. …………限于本文篇幅 余下代码请从51黑下载附件…………

  27. 0x40,0x40,0x80,0xF0,0x80,0x40,0x40,0x00,0x02,0x02,0x01,0x0F,0x01,0x02,0x02,0x00,/*"*",10*/
  28. };

  30. //消去液晶显示屏的某些数字或者字母的显示
  31. uchar code disappear_char[1][16] = {
  32. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,/*" ",0*/
  33. };
  34. //消去液晶显示屏的某些汉字的显示
  35. uchar code disappear_hanzi[1][32] = {
  36. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,/*" ",0*/
  37. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  38. };

  40. /***************************************************************
  41. 名称：进入主函数时的初始化函数
  42. 功能：进行12864液晶显示屏的初始化
  43.           并且显示居民小区和请输入密码的提示字符
  44.           对门锁的初始化作用，P32口的低电平
  45. ***************************************************************/
  46. void init_main() {
  47.         Lcd_Initial();                            //对12864液晶显示屏的初始化作用
  48.         number = 0;                                   //密码存储，显示位置，各方面清零
  49.         P32 = 0;                                   //进行电磁铁的初始关闭作用
  50.         //显示居民小区：
  51.         Lcd_Character_16X16( 1, 0, 0,data_shuju[0]);
  52.         Lcd_Character_16X16( 1, 0, 16,data_shuju[1]);
  53.         Lcd_Character_16X16( 1, 0, 32,data_shuju[2]);
  54.         Lcd_Character_16X16( 1, 0, 48,data_shuju[3]);
  55.         Lcd_Character_16X16( 1, 0, 64,data_shuju[4]);
  56.         //显示请输入密码：
  57.         Lcd_Character_16X16( 1, 4, 0,data_shuju[5]);
  58.         Lcd_Character_16X16( 1, 4, 16,data_shuju[6]);
  59.         Lcd_Character_16X16( 1, 4, 32,data_shuju[7]);
  60.         Lcd_Character_16X16( 1, 4, 48,data_shuju[8]);
  61.         Lcd_Character_16X16( 1, 4, 64,data_shuju[9]);
  62.         Lcd_Character_16X16( 1, 4, 80,data_shuju[10]);

  64.         EA = 1;                                           //总中断打开
  65.         EX1 = 1;                                   //外部中断1打开
  66.         IT1 = 0;                                   //外部中断1工作方式，为低电平触发，IT1 = 1为下降沿触发
  67. }

  69. /***************************************************************
  70. 函数：主函数
  71. 功能：综合各个函数的作用
  72. 注意：进入主函数的时候，首先开启初始化函数功能
  73. ***************************************************************/
  74. void main() {
  75.         init_main();                           //初始化主函数之前的所有操作
  76.         while(1) {                                   //进入无限循环当中
  77.                 key_scan();                           //进行键盘扫描函数
  78.         }
  79.         //clear_screen();
  80. }

  82. /*********************************************************************
  83. 函数：键盘扫描函数
  84. 功能：集成了输入密码，显示密码个数，清除密码，
  85.           显示密码正确与错误各种功能的集成函数
  86.           可称为本函数的核心函数之一
  87. 键盘扫描方式：采用的翻转法的键盘扫描，可以减少扫描代码的数量
  88. 注意：本函数采用的是带有返回值，不带参数的函数，所以在函数的
  89.           末尾一定要加入return keyscan；这个语句
  90. **********************************************************************/
  91. uchar key_scan()
  92. {                                                                                  //函数开始
  93.    unsigned char k=0,p1_h=0,p1_l=0;                  //翻转法的定义k为选择分支作用，
  94.    uchar Mark;                                                                                  //p1_h是选择分支的高四位,p1_l是选择分支的低四位
  95.    char keyscan = 0, i = 0, j = 0;                  //记录输入的数据是数值，然后将其送入到shuru所代表的数组当中去
  96.                                                                                      //i的作用记录输入的数据是否是6位数据，防止超出所存储的数组的空间
  97.                                                                                   //j的作用是用来加强功能键“确认”的作用
  98. /*************************/
  99.         P1 = 0xf0;                                  //翻转法先给P1口送数据
  100.         k = P1;                                          //然后赋值给k
  101.         if(k != 0xf0)                                  //判断k是否是0xf0，如果不是，进入内部执行相应的程序
  102.         {
  103.                 delayms(50);                          //延时，防抖动
  104.                 k = P1;                                  //重新赋值
  105.                 if(k != 0xf0)                          //确定是否k不等于0xf0
  106.                 {
  107.                         number++;                  //number用于确定后面的在12864中的输出位置和密码存储的位置
  108.                         p1_h = P1;                  //将P1的高四位赋值给p1_h
  109.                         P1 = 0x0f;                  //然后将0x0f赋值给P1口，翻转，确定低四位，赋值给p1_l
  110.                         p1_l = P1;                  //将P1口的值赋给p1_l（是小写的字母l，不是数字1）

  112.                         k = p1_h|p1_l;                  //将高四位和低四位相或，然后赋值给k
  113.                         if (k == 0XE7) {          //此判断是为了确定是否是确认按键，如果是，直接进入确定程序
  114.                                 j = 1;        
  115.                         }

  117.                         if(number == 7)                  //此判断是为了确定输入的是否是6个数字，防止多输入或者少输入
  118.                         {
  119.                                 if (k != 0XB7) {  //这个是判断是否是清除按键，
  120.                                         number = 0;
  121.                                 }
  122.                         }

  124.                         while (p1_l == P1);          //这个是松手检测，防止长时间按在按键上，使输入的数据重复
  125.                         if (number > 0||j == 1){  
  126.                                 switch(k)          //条件分支语句
  127.                                 {
  128.                                         case 0XD7: keyscan = 0;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[0]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  129.                                         case 0XEE: keyscan = 1;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[1]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  130.                                         case 0XDE: keyscan = 2; Lcd_Character_16X8( 1, 6, 8*number,shuzi[2]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  131.                                         case 0XBE: keyscan = 3; Lcd_Character_16X8( 1, 6, 8*number,shuzi[3]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  132.                                         case 0XED: keyscan = 4;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[4]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  133.                                         case 0XDD: keyscan = 5;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[5]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  134.                                         case 0XBD: keyscan = 6; Lcd_Character_16X8( 1, 6, 8*number,shuzi[6]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  135.                                         case 0XEB: keyscan = 7;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[7]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  136.                                         case 0XDB: keyscan = 8;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[8]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  137.                                         case 0XBB: keyscan = 9; Lcd_Character_16X8( 1, 6, 8*number,shuzi[9]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  138.                                         case 0XE7: number = 0;
  139.                                                            for(i = 0; i < 6; i++)
  140.                                                                         if (mima[i] != shuru[i])//对比原始密码和输入密码
  141.                                                                         {
  142.                                                                                 Mark++;
  143.                                                                                 //该if语句是用来判断密码Mark的错误次数，一旦达到3次，
  144.                                                                                 //就进入到while循环当中，并且P30口 = 0；蜂鸣器响，直至单片机复位才可消失
  145.                                                                                 if (3 == Mark) {
  146.                                                                                         P30 = 0;
  147.                                                                                         Lcd_Character_16X8( 1, 6, 8*1,disappear_char[0]);
  148.                                                                                         Lcd_Character_16X8( 1, 6, 8*2,disappear_char[0]);
  149.                                                                                         Lcd_Character_16X8( 1, 6, 8*3,disappear_char[0]);
  150.                                                                                         Lcd_Character_16X8( 1, 6, 8*4,disappear_char[0]);
  151.                                                                                         Lcd_Character_16X8( 1, 6, 8*5,disappear_char[0]);
  152.                                                                                         Lcd_Character_16X8( 1, 6, 8*6,disappear_char[0]);
  153.                                                                                         while(1);
  154.                                                                                 }
  155.                                                                                 //密码错误
  156.                                                                                 Lcd_Character_16X16( 1, 6, 64,mistake[0]);
  157.                                                                                 Lcd_Character_16X16( 1, 6, 80,mistake[1]);
  158.                                                                                 Lcd_Character_16X16( 1, 6, 96,mistake[2]);
  159.                                                                                 Lcd_Character_16X16( 1, 6, 112,mistake[3]);
  160.                                                                                 //消除密码显示
  161.                                                                                 delayms(1000);
  162.                                                                                 Lcd_Character_16X8( 1, 6, 8*1,disappear_char[0]);
  163.                                                                                 Lcd_Character_16X8( 1, 6, 8*2,disappear_char[0]);
  164.                                                                                 Lcd_Character_16X8( 1, 6, 8*3,disappear_char[0]);
  165.                                                                                 Lcd_Character_16X8( 1, 6, 8*4,disappear_char[0]);
  166.                                                                                 Lcd_Character_16X8( 1, 6, 8*5,disappear_char[0]);
  167.                                                                                 Lcd_Character_16X8( 1, 6, 8*6,disappear_char[0]);
  168.                                                                                 //消除密码错误汉字显示
  169.                                                                                 Lcd_Character_16X16( 1, 6, 64,disappear_hanzi[0]);
  170.                                                                                 Lcd_Character_16X16( 1, 6, 80,disappear_hanzi[0]);
  171.                                                                                 Lcd_Character_16X16( 1, 6, 96,disappear_hanzi[0]);
  172.                                                                                 Lcd_Character_16X16( 1, 6, 112,disappear_hanzi[0]);
  173.                                                                                 break;                                                                                                
  174.                                                                         }
  175.                                                                         if(i == 6)        //确认密码是否是正确的，通过i值
  176.                                                                         {
  177.                                                                                 //输入密码正确
  178.                                                                                 Lcd_Character_16X16( 1, 6, 64,mistake[0]);
  179.                                                                                 Lcd_Character_16X16( 1, 6, 80,mistake[1]);
  180.                                                                                 Lcd_Character_16X16( 1, 6, 96,mistake[4]);
  181.                                                                                 Lcd_Character_16X16( 1, 6, 112,mistake[5]);
  182.                                                                                 delayms(1000);                //延时
  183.                                                                                 //消除密码显示位
  184.                                                                                 Lcd_Character_16X8( 1, 6, 8*1,disappear_char[0]);
  185.                                                                                 Lcd_Character_16X8( 1, 6, 8*2,disappear_char[0]);
  186.                                                                                 Lcd_Character_16X8( 1, 6, 8*3,disappear_char[0]);
  187.                                                                                 Lcd_Character_16X8( 1, 6, 8*4,disappear_char[0]);
  188.                                                                                 Lcd_Character_16X8( 1, 6, 8*5,disappear_char[0]);
  189.                                                                                 Lcd_Character_16X8( 1, 6, 8*6,disappear_char[0]);
  190.                                                                                 //消除密码正确显示位
  191.                                                                                 Lcd_Character_16X16( 1, 6, 64,disappear_hanzi[0]);
  192.                                                                                 Lcd_Character_16X16( 1, 6, 80,disappear_hanzi[0]);
  193.                                                                                 Lcd_Character_16X16( 1, 6, 96,disappear_hanzi[0]);
  194.                                                                                 Lcd_Character_16X16( 1, 6, 112,disappear_hanzi[0]);
  195.                                                                                 P32 = 1;
  196.                                                                                 delayms(2000);
  197.                                                                                 P32 = 0;
  198.                                                                         }
  199.                                                                 break;         
  200.                                         case 0XB7: keyscan = 10;number--;Lcd_Character_16X8( 1, 6, 8*number,disappear_char[0]);number--;break;
  201.                                         //这个是用来清除输错的密码，然后重新输入新的位数的密码
  202.                                         default: break;
  203.                                 /*        case 0XE7: return(4);break;
  204.                                         case 0XDE: return(5);break;
  205.                                         case 0XDD: return(6);break;
  206.                                         case 0XDB: return(7);break;
  207.                                         case 0XD7: return(8);break;
  208.                                         case 0XBE: return(9);break;
  209.                                         case 0XBD: return(10);break;
  210.                                         case 0XBB: return(11);break;
  211.                                         case 0XB7: return(12);break;
  212.                                         case 0X7E: return(13);break;
  213.                                         case 0X7D: return(14);break;
  214.                                         case 0X7B: return(15);break;
  215.                                         case 0X77: return(16);break;
  216.                                         default:  return(0);break;        */
  217.                                 }
  218.                         }
  219.                         
  220.                 }
  221.         }
  222.         return keyscan;                                //函数返回的参数
  223. }

  225. //修改密码函数
  226. /*
  227. 名称：修改密码函数
  228. 功能：如果需要进行密码的修改，可以调用此函数
  229. 注意：本函数可以采用中断，或者外部按键的方式，密码存储在ROM中
  230. */
  231. void external_mima() interrupt 2{
  232.         unsigned char k=0,p1_h=0,p1_l=0;                         //翻转法的定义k为选择分支作用，
  233.            unsigned char Mark = 0;                                                                                            //p1_h是选择分支的高四位,p1_l是选择分支的低四位
  234.            char keyscan = 0, i = 0, j = 0, h = 0;                //记录输入的数据是数值，然后将其送入到shuru所代表的数组当中去
  235.                                                                                                      //i的作用记录输入的数据是否是6位数据，防止超出所存储的数组的空间
  236.                                                                                                   //j的作用是用来加强功能键“确认”的作用
  237. nihao:        number = 0;                                                            //采用了goto语句，实现了错误输入密码后的重新输入
  238.         //清除“居民小区：”显示
  239.         Lcd_Character_16X16( 1, 0, 0,disappear_hanzi[0]);
  240.         Lcd_Character_16X16( 1, 0, 16,disappear_hanzi[0]);
  241.         Lcd_Character_16X16( 1, 0, 32,disappear_hanzi[0]);
  242.         Lcd_Character_16X16( 1, 0, 48,disappear_hanzi[0]);
  243.         Lcd_Character_16X16( 1, 0, 64,disappear_hanzi[0]);
  244.         //清除“请输入密码：”显示
  245.         Lcd_Character_16X16( 1, 4, 0,disappear_hanzi[0]);
  246.         Lcd_Character_16X16( 1, 4, 16,disappear_hanzi[0]);
  247.         Lcd_Character_16X16( 1, 4, 32,disappear_hanzi[0]);
  248.         Lcd_Character_16X16( 1, 4, 48,disappear_hanzi[0]);
  249.         Lcd_Character_16X16( 1, 4, 64,disappear_hanzi[0]);
  250.         Lcd_Character_16X16( 1, 4, 80,disappear_hanzi[0]);
  251.         //显示“请输入6位数密码”显示
  252.         Lcd_Character_16X16( 1, 4, 0,data_shuju[5]);
  253.         Lcd_Character_16X16( 1, 4, 16,data_shuju[6]);
  254.         Lcd_Character_16X16( 1, 4, 32,data_shuju[7]);
  255.         Lcd_Character_16X8( 1,  4, 48,shuzi[6]);
  256.         Lcd_Character_16X16( 1, 4, 56,data_shuju[11]);
  257.         Lcd_Character_16X16( 1, 4, 72,data_shuju[8]);
  258.         Lcd_Character_16X16( 1, 4, 88,data_shuju[9]);
  259.         Lcd_Character_16X16( 1, 4, 104,data_shuju[10]);
  260.                 while(1) {
  261.                 P1 = 0xf0;                                  //翻转法先给P1口送数据
  262.                 k = P1;                                          //然后赋值给k
  263.                 if(k != 0xf0)                                  //判断k是否是0xf0，如果不是，进入内部执行相应的程序
  264.                 {
  265.                         delayms(5);                          //延时，防抖动
  266.                         k = P1;                                  //重新赋值
  267.                         if(k != 0xf0)                          //确定是否k不等于0xf0
  268.                         {
  269.                                 number++;                  //number用于确定后面的在12864中的输出位置和密码存储的位置
  270.                                 p1_h = P1;                  //将P1的高四位赋值给p1_h
  271.                                 P1 = 0x0f;                  //然后将0x0f赋值给P1口，翻转，确定低四位，赋值给p1_l
  272.                                 p1_l = P1;                  //将P1口的值赋给p1_l（是小写的字母l，不是数字1）
  273.         
  274.                                 k = p1_h|p1_l;                  //将高四位和低四位相或，然后赋值给k
  275.                                 if (k == 0XE7) {          //此判断是为了确定是否是确认按键，如果是，直接进入确定程序
  276.                                         j = 1;        
  277.                                 }
  278.         
  279.                                 if(number == 7)                  //此判断是为了确定输入的是否是6个数字，防止多输入或者少输入
  280.                                 {
  281.                                         if (k != 0XB7) {  //这个是判断是否是清除按键，
  282.                                                 number = 0;
  283.                                         }
  284.                                 }
  285.         
  286.                                 while (p1_l == P1);          //这个是松手检测，防止长时间按在按键上，使输入的数据重复
  287.                                 if (number > 0||j == 1){  
  288.                                         switch(k)          //条件分支语句
  289.                                         {        
  290.                                                 case 0XD7: keyscan = 0;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[0]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);mima[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  291.                                                 case 0XEE: keyscan = 1;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[1]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);mima[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  292.                                                 case 0XDE: keyscan = 2; Lcd_Character_16X8( 1, 6, 8*number,shuzi[2]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);mima[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  293.                                                 case 0XBE: keyscan = 3; Lcd_Character_16X8( 1, 6, 8*number,shuzi[3]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);mima[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  294.                                                 case 0XED: keyscan = 4;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[4]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);mima[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  295.                                                 case 0XDD: keyscan = 5;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[5]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);mima[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  296.                                                 case 0XBD: keyscan = 6; Lcd_Character_16X8( 1, 6, 8*number,shuzi[6]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);mima[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  297.                                                 case 0XEB: keyscan = 7;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[7]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);mima[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  298.                                                 case 0XDB: keyscan = 8;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[8]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);mima[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  299.                                                 case 0XBB: keyscan = 9; Lcd_Character_16X8( 1, 6, 8*number,shuzi[9]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);mima[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  300.                                                 case 0XE7: number = 0;break;
  301.                                                 case 0XB7: keyscan = 10;number--;Lcd_Character_16X8( 1, 6, 8*number,disappear_char[0]);number--;break;
  302.                                                 //这个是用来清除输错的密码，然后重新输入新的位数的密码
  303.                                         }
  304.                                 }
  305.                                 
  306.                         }
  307.                         }
  308.                         if (k == 0XE7) break;
  309.                 }
  310.                 //消除“请输入6位数密码”显示
  311.                 Lcd_Character_16X16( 1, 4, 0,disappear_hanzi[0]);
  312.                 Lcd_Character_16X16( 1, 4, 16,disappear_hanzi[0]);
  313.                 Lcd_Character_16X16( 1, 4, 32,disappear_hanzi[0]);
  314.                 Lcd_Character_16X8( 1,  4, 48,disappear_char[0]);
  315.                 Lcd_Character_16X16( 1, 4, 56,disappear_hanzi[0]);
  316.                 Lcd_Character_16X16( 1, 4, 72,disappear_hanzi[0]);
  317.                 Lcd_Character_16X16( 1, 4, 88,disappear_hanzi[0]);
  318.                 Lcd_Character_16X16( 1, 4, 104,disappear_hanzi[0]);
  319.                 Lcd_Character_16X16( 1, 4, 120,disappear_hanzi[0]);
  320.                 //消除密码显示
  321.                 Lcd_Character_16X8( 1, 6, 8*1,disappear_char[0]);
  322.                 Lcd_Character_16X8( 1, 6, 8*2,disappear_char[0]);
  323.                 Lcd_Character_16X8( 1, 6, 8*3,disappear_char[0]);
  324.                 Lcd_Character_16X8( 1, 6, 8*4,disappear_char[0]);
  325.                 Lcd_Character_16X8( 1, 6, 8*5,disappear_char[0]);
  326.                 Lcd_Character_16X8( 1, 6, 8*6,disappear_char[0]);
  327.                 //重新装初值
  328.                 number = 0;
  329.                    //显示“请重新输入密码：”
  330.                 Lcd_Character_16X16( 1, 4, 0,data_shuju[5]);
  331.                 Lcd_Character_16X16( 1, 4, 16,data_shuju[13]);
  332.                 Lcd_Character_16X16( 1, 4, 32,data_shuju[14]);
  333.                 Lcd_Character_16X16( 1, 4, 48,data_shuju[6]);
  334.                 Lcd_Character_16X16( 1, 4, 64,data_shuju[7]);
  335.                 Lcd_Character_16X16( 1, 4, 80,data_shuju[8]);
  336.                 Lcd_Character_16X16( 1, 4, 96,data_shuju[9]);
  337.                 Lcd_Character_16X16( 1, 4, 112,data_shuju[10]);
  338.                 while(1) {
  339.                 P1 = 0xf0;                                  //翻转法先给P1口送数据
  340.                 k = P1;                                          //然后赋值给k
  341.                 if(k != 0xf0)                                  //判断k是否是0xf0，如果不是，进入内部执行相应的程序
  342.                 {
  343.                         delayms(5);                          //延时，防抖动
  344.                         k = P1;                                  //重新赋值
  345.                         if(k != 0xf0)                          //确定是否k不等于0xf0
  346.                         {
  347.                                 number++;                  //number用于确定后面的在12864中的输出位置和密码存储的位置
  348.                                 p1_h = P1;                  //将P1的高四位赋值给p1_h
  349.                                 P1 = 0x0f;                  //然后将0x0f赋值给P1口，翻转，确定低四位，赋值给p1_l
  350.                                 p1_l = P1;                  //将P1口的值赋给p1_l（是小写的字母l，不是数字1）
  351.         
  352.                                 k = p1_h|p1_l;                  //将高四位和低四位相或，然后赋值给k
  353.                                 if (k == 0XE7) {          //此判断是为了确定是否是确认按键，如果是，直接进入确定程序
  354.                                         j = 1;        
  355.                                 }
  356.         
  357.                                 if(number == 7)                  //此判断是为了确定输入的是否是6个数字，防止多输入或者少输入
  358.                                 {
  359.                                         if (k != 0XB7) {  //这个是判断是否是清除按键，
  360.                                                 number = 0;
  361.                                         }
  362.                                 }
  363.         
  364.                                 while (p1_l == P1);          //这个是松手检测，防止长时间按在按键上，使输入的数据重复
  365.                                 if (number > 0||j == 1){  
  366.                                         switch(k)          //条件分支语句
  367.                                         {
  368.                                                 case 0XD7: keyscan = 0;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[0]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  369.                                                 case 0XEE: keyscan = 1;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[1]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  370.                                                 case 0XDE: keyscan = 2;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[2]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  371.                                                 case 0XBE: keyscan = 3; Lcd_Character_16X8( 1, 6, 8*number,shuzi[3]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  372.                                                 case 0XED: keyscan = 4;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[4]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  373.                                                 case 0XDD: keyscan = 5;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[5]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  374.                                                 case 0XBD: keyscan = 6; Lcd_Character_16X8( 1, 6, 8*number,shuzi[6]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  375.                                                 case 0XEB: keyscan = 7;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[7]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  376.                                                 case 0XDB: keyscan = 8;        Lcd_Character_16X8( 1, 6, 8*number,shuzi[8]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  377.                                                 case 0XBB: keyscan = 9; Lcd_Character_16X8( 1, 6, 8*number,shuzi[9]);delayms(1000);Lcd_Character_16X8( 1, 6, 8*number,shuzi[10]);shuru[number-1] = keyscan;break;                //keyscan是用来确定输入的数据，number是用来确定输入的位置，shuru【】是用来放置密码
  378.                                                 case 0XE7: number = 0;
  379.                                                                    for(i = 0; i < 6; i++)
  380.                                                                                 if (mima[i] != shuru[i])//对比原始密码和输入密码
  381.                                                                                 {
  382.                                                                                         //密码错误
  383.                                                                                         Lcd_Character_16X16( 1, 6, 64,mistake[0]);
  384.                                                                                         Lcd_Character_16X16( 1, 6, 80,mistake[1]);
  385.                                                                                         Lcd_Character_16X16( 1, 6, 96,mistake[2]);
  386.                                                                                         Lcd_Character_16X16( 1, 6, 112,mistake[3]);
  387.                                                                                         //消除密码显示位
  388.                                                                                         Lcd_Character_16X8( 1, 6, 8*1,disappear_char[0]);
  389.                                                                                         Lcd_Character_16X8( 1, 6, 8*2,disappear_char[0]);
  390.                                                                                         Lcd_Character_16X8( 1, 6, 8*3,disappear_char[0]);
  391.                                                                                         Lcd_Character_16X8( 1, 6, 8*4,disappear_char[0]);
  392.                                                                                         Lcd_Character_16X8( 1, 6, 8*5,disappear_char[0]);
  393.                                                                                         Lcd_Character_16X8( 1, 6, 8*6,disappear_char[0]);
  394.                                                                                         //消除密码错误显示位
  395.                                                                                         Lcd_Character_16X16( 1, 6, 64,disappear_hanzi[0]);
  396.                                                                                         Lcd_Character_16X16( 1, 6, 80,disappear_hanzi[0]);
  397.                                                                                         Lcd_Character_16X16( 1, 6, 96,disappear_hanzi[0]);
  398.                                                                                         Lcd_Character_16X16( 1, 6, 112,disappear_hanzi[0]);
  399. ……………………

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

所有资料51hei提供下载:
电子密码锁.rar (100.15 KB, 下载次数: 64)




作者: dengyifenzhong    时间: 2018-5-17 09:24
不错，收藏了，共享万岁
作者: 小小斑鸠    时间: 2018-8-28 13:29
谢谢大佬，已收藏



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1