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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机密码锁程序 存储在I2C 密码掉电不丢失
返回列表 发新帖
查看: 1787|回复: 1
打印 上一主题 下一主题
收起左侧

51单片机密码锁程序 存储在I2C 密码掉电不丢失

[复制链接]
跳转到指定楼层
楼主
ID:1134911 发表于 2024-12-19 19:43 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
设计内容：
1、密码存储在I2C器件中，实现密码掉电不丢失。
2、电路板一上电四个数码管显示“-“
3、实现数字键0-9和功能键的设计:
4、四个功能键:
(1)密码输入
(2)退出
(3)密码修改:当密码密码修改键按下，若输入密码正确后，按下此键时，将修改的密码进行存储。输入密码正确显示”8888“
输入失败显示”HHHH“

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

单片机源程序如下:
  1. #include <reg51.h>
  2. #include <intrins.h>
  3. #include <string.h>

  5. typedef unsigned char u8;
  6. typedef unsigned int u16;

  8. #define SMG_PORT P0
  9. #define KEY_MATRIX_PORT  P1
  10. #define AT24C02_ADDRESS  0xA0

  12. u8 gsmg_code[] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f,0x40,0x76};//0-9 "-" "H"
  13. u8 e_mima[4] = {1, 2, 3, 4}; // 初始密码是1234
  14. u8 read_mima[4];
  15. u8 entered_password[4];  // 存储用户输入的密码
  16. u8 input_index = 0;
  17. u8 key = 0;
  18. u8 wei=0;
  19. u8 panduan=0;//判断密码是否正确
  20. u8 state=0;
  21. u8 xiugai=0;
  22. u8 wdata=0;
  23. u8 show_h=0;

  25. sbit led=P2^7;
  26. sbit LSA = P2^2;
  27. sbit LSB = P2^3;
  28. sbit LSC = P2^4;

  30. sbit sda=P2^0;  
  31. sbit scl=P2^1;

  33. u8 chushi = 1;

  35. //@11.0592MHz
  36. void Delay10ms()
  37. {
  38.     unsigned char i, j;
  39.     i = 108;
  40.     j = 145;
  41.     do
  42.     {
  43.         while (--j);
  44.     } while (--i);
  45. }

  47. //@11.0592MHz
  48. void delay_us(unsigned int us)
  49. {
  50.     unsigned int i;
  51.     while(us--)
  52.     {
  53.         i = 11;  // 11 是根据 11.0592MHz 晶振频率调整的数值
  54.         while (--i);
  55.     }
  56. }

  58. void delayms(u16 x)
  59. {
  60. u8 i;
  61. while(x--)
  62. {
  63.   for(i=150;i>0;i--);
  64. }
  65. }


  68. void nop()
  69. {
  70.         _nop_();
  71.         _nop_();
  72. }
  73. /////////24C02读写驱动程序////////////////////
  74. void delay1(unsigned int m)
  75. {        unsigned int n;
  76.           for(n=0;n<m;n++);
  77. }

  79. void init()  //24c02初始化子程序
  80. {
  81.         scl=1;
  82.         nop();
  83.         sda=1;
  84.         nop();
  85. }

  87. void start()        //启动I2C总线
  88. {
  89.         sda=1;
  90.         nop();
  91.         scl=1;
  92.         nop();
  93.         sda=0;
  94.         nop();
  95.         scl=0;
  96.         nop();
  97. }

  99. void stop()         //停止I2C总线
  100. {
  101.         sda=0;
  102.         nop();
  103.         scl=1;
  104.         nop();
  105.         sda=1;
  106.         nop();
  107. }

  109. void writebyte(unsigned char j)  //写一个字节
  110. {
  111.         unsigned char i,temp;
  112.            temp=j;
  113.            for (i=0;i<8;i++)
  114.    {
  115.            temp=temp<<1;
  116.            scl=0;
  117.            nop();
  118.            sda=CY;                //temp左移时，移出的值放入了CY中
  119.            nop();
  120.            scl=1;                //待sda线上的数据稳定后，将scl拉高
  121.            nop();
  122.    }
  123.    scl=0;
  124.    nop();
  125.    sda=1;
  126.    nop();
  127. }

  129. unsigned char readbyte()   //读一个字节
  130. {
  131.    unsigned char i,j,k=0;
  132.    scl=0; nop(); sda=1;
  133.    for (i=0;i<8;i++)
  134.    {  
  135.                 nop(); scl=1; nop();
  136.               if(sda==1)
  137.                 j=1;
  138.               else
  139.                 j=0;
  140.               k=(k<<1)|j;
  141.                   scl=0;
  142.         }
  143.            nop();
  144.         return(k);
  145. }

  147. void clock()         //I2C总线时钟
  148. {
  149.    unsigned char i=0;
  150.    scl=1;
  151.    nop();
  152.    while((sda==1)&&(i<255))
  153.              i++;
  154.    scl=0;
  155.    nop();
  156. }

  158. ////////从24c02的地址address中读取一个字节数据/////
  159. unsigned char read24c02(unsigned char address)
  160. {
  161.    unsigned char i;
  162.    start();
  163.    writebyte(0xa0);
  164.    clock();
  165.    writebyte(address);
  166.    clock();
  167.    start();
  168.    writebyte(0xa1);
  169.    clock();
  170.    i=readbyte();
  171.    stop();
  172.    delay1(10);
  173.    return(i);
  174. }

  176. //////向24c02的address地址中写入一字节数据info/////
  177. void write24c02(unsigned char address,unsigned char info)
  178. {
  179.    start();
  180.    writebyte(0xa0);
  181.    clock();
  182.    writebyte(address);
  183.    clock();
  184.    writebyte(info);
  185.    clock();
  186.    stop();
  187.    delay1(50);
  188. }

  190. u8 key_matrix_ranks_scan(void)
  191. {
  192.     u8 key_value = 0;
  193.     KEY_MATRIX_PORT = 0xf7; //第一列为低电平
  194.     if (KEY_MATRIX_PORT!= 0xf7) //有按键按下
  195.     {
  196.         Delay10ms();
  197.         switch(KEY_MATRIX_PORT)
  198.         {
  199.             case 0x77: key_value = 1; break; //S1按下时
  200.             case 0xb7: key_value = 4; break;
  201.             case 0xd7: key_value = 7; break;
  202.             case 0xe7: key_value = 10; break;
  203.         }
  204.     }
  205.     while(KEY_MATRIX_PORT!= 0xf7); //等待释放，当按键按下时KEY值不等于0xf7，一直循环，当按键释放时，KEY等于0xf7，跳出循环

  207.     KEY_MATRIX_PORT = 0xfb; //第二列为低电平
  208.     if (KEY_MATRIX_PORT!= 0xfb) //有按键按下
  209.     {
  210.         Delay10ms();
  211.         switch(KEY_MATRIX_PORT)
  212.         {
  213.             case 0x7b: key_value = 2; break;
  214.             case 0xbb: key_value = 5; break;
  215.             case 0xdb: key_value = 8; break;
  216.             case 0xeb:/* key_value = 11;*/ break;
  217.         }
  218.     }
  219.     while(KEY_MATRIX_PORT!= 0xfb);

  221.     KEY_MATRIX_PORT = 0xfd; //第三列为低电平
  222.     if (KEY_MATRIX_PORT!= 0xfd) //有按键按下
  223.     {
  224.         Delay10ms();
  225.         switch(KEY_MATRIX_PORT)
  226.         {
  227.             case 0x7d: key_value = 3; break;
  228.             case 0xbd: key_value = 6; break;
  229.             case 0xdd: key_value = 9; break;
  230.             case 0xed:/* key_value = 12; */break;
  231.         }
  232.     }
  233.     while(KEY_MATRIX_PORT!= 0xfd);

  235.     KEY_MATRIX_PORT = 0xfe; //第四列为低电平
  236.     if (KEY_MATRIX_PORT!= 0xfe)
  237.     {
  238.         Delay10ms();
  239.         switch(KEY_MATRIX_PORT)
  240.         {
  241.             case 0x7e: key_value = 13; break; //S1按键按下时
  242.             case 0xbe: key_value = 14; break;
  243.             case 0xde: key_value = 15; break;
  244.             case 0xee: key_value = 16; break;
  245.         }
  246.     }
  247.     while(KEY_MATRIX_PORT!= 0xfe);

  249.     return key_value;
  250. }

  252. // 显示单个数字到指定的数码管位
  253. void display_on_smg(u8 num, u8 pos)
  254. {
  255.     switch (pos)
  256.     {
  257.         case 1: LSC = 1; LSB = 1; LSA = 1; break; // 第1位
  258.         case 2: LSC = 1; LSB = 1; LSA = 0; break; // 第2位
  259.         case 3: LSC = 1; LSB = 0; LSA = 1; break; // 第3位
  260.         case 4: LSC = 1; LSB = 0; LSA = 0; break; // 第4位
  261.     }
  262.     SMG_PORT = 0x00;
  263.     SMG_PORT = gsmg_code[num];
  264.                 delay_us(5);
  265.                 SMG_PORT = 0x00;
  266. }


  269. void clear_display(void)
  270. {
  271.     LSC = 1; LSB = 0; LSA = 0;
  272.     SMG_PORT = 0x00; // 清空显示
  273. }

  275. void show_8888(void)
  276. {
  277.   display_on_smg(8,1);
  278.         display_on_smg(8,2);
  279.         display_on_smg(8,3);
  280.         display_on_smg(8,4);
  281. }

  283. void show_HHHH(void)
  284. {
  285.   display_on_smg(11,1);
  286.         display_on_smg(11,2);
  287.         display_on_smg(11,3);
  288.         display_on_smg(11,4);
  289. }

  291. void show____(void)
  292. {
  293.         display_on_smg(10,1);
  294.         display_on_smg(10,2);
  295.         display_on_smg(10,3);
  296.         display_on_smg(10,4);
  297. }

  299. //输入密码
  300. void import_ss()
  301. {
  302.         u8 i;
  303.         for (i = 0; i < 4; i++)
  304.         {
  305.                         e_mima[i] = read_mima[i];
  306.         }
  307.   if (key!= 0 && key!=13 && key!=14 && key!=15 && key!=16)
  308.         {
  309.                 wei++;
  310.                 entered_password[input_index] = key-1;
  311.                 input_index++;
  312.                 if (input_index >= 4)
  313.                 {
  314.                         input_index = 0;
  315.                 }
  316.         }
  317.         if(wei==1)
  318.         {
  319.           display_on_smg(10, 1);
  320.   }
  321.         else if(wei==2)
  322.         {
  323.           display_on_smg(10, 1);
  324.                 display_on_smg(10, 2);
  325.         }
  326.         else if(wei==3)
  327.         {
  328.           display_on_smg(10, 1);
  329.                 display_on_smg(10, 2);
  330.                 display_on_smg(10, 3);
  331.         }
  332.         else if(wei==4)
  333.         {
  334.                 display_on_smg(10, 1);
  335.                 display_on_smg(10, 2);
  336.                 display_on_smg(10, 3);
  337.                 display_on_smg(10, 4);
  338.                 panduan=1;
  339.                 wei=0;
  340.         }
  341.         if(panduan==1)
  342.         {
  343.                 if(panduan==1)
  344.                 {
  345.                         // 比较密码
  346.                         if (entered_password[0] == e_mima[0] && entered_password[1] == e_mima[1] && entered_password[2] == e_mima[2] && entered_password[3] == e_mima[3])
  347.                         {
  348.                                 show_8888();
  349.                                 led=0;
  350.                         }
  351.                         else
  352.                         {
  353.                                 show_HHHH();
  354.                                 led=1;
  355.                         }
  356.                 }
  357.         }
  358. }
  359. // 密码修改
  360. void xiugai_ss(void)
  361. {
  362.         u8 i,j;
  363.         
  364.         for (i = 0; i < 4; i++)
  365.         {
  366.                         e_mima[i] = read_mima[i];
  367.         }
  368.     if (key!= 0 && key!= 13 && key!= 14 && key!= 15 && key!= 16)
  369.     {
  370.         entered_password[input_index] = key - 1;
  371.         input_index++;
  372.         if (input_index >= 4)
  373.         {
  374.             if (state == 0)
  375.             {
  376.                 // 输入原密码阶段
  377.                 if (entered_password[0] == e_mima[0] && entered_password[1] == e_mima[1] && entered_password[2] == e_mima[2] && entered_password[3] == e_mima[3])
  378.                 {
  379.                     state = 1; // 原密码正确，进入输入新密码状态
  380.                     input_index = 0;
  381.                     clear_display();
  382.                                                                           led=0;
  383.                                                                         show_h=0;
  384.                 }
  385.                 else
  386.                 {
  387.                     show_h=1;
  388.                     state = 0;
  389.                     input_index = 0;
  390.                 }
  391.             }
  392.             else if (state == 1)
  393.             {
  394.                 // 输入新密码阶段
  395.                 if (input_index == 4 )
  396.                 {
  397.                                                                           // 输入新密码阶段
  398.                 if (input_index == 4)
  399.                 {
  400.                     state = 2; // 输入新密码完成，进入确认状态
  401.                     input_index = 0;
  402.                 }
  403.                 }
  404.             }
  405.         }
  406.     }
  407.     // 显示已输入的密码
  408.     for (j = 0; j < input_index; j++)
  409.     {
  410.         display_on_smg(10, j + 1);
  411.     }
  412.                 if (state == 2 && key == 16)
  413.     {
  414.                         led=1;
  415.         // 确认修改密码
  416.         for (i = 0; i < 4; i++)
  417.         {
  418.            e_mima[i] = entered_password[i];
  419.                                  }
  420.                                 wdata=1;
  421.                                 show_8888();
  422.         state = 0;
  423.         input_index = 0;
  424.         chushi = 1;
  425.         xiugai = 0;
  426.         show____(); // 修改完成后返回初始界面显示
  427.     }
  428. }


  431. void main()
  432. {
  433.         u8 i;
  434.         led=1;
  435.         init();        //初始化24C02
  436.         // 上电从 24C02 读取数据
  437.         for (i = 0; i < 4; i++)
  438.         {
  439.                 read_mima[i] = read24c02(i);
  440.                 delayms(3);
  441.         }
  442.     while(1)
  443.     {
  444.                         // 上电从 24C02 读取数据
  445.                         for (i = 0; i < 4; i++)
  446.                         {
  447.                                 read_mima[i] = read24c02(i);
  448.                                 delayms(3);
  449.                         }
  450.                         if(wdata==1)
  451.                         {
  452.                           write24c02(0, entered_password[0]); // 将修改后的密码发送给 24C02
  453.                                 delayms(3);
  454.         write24c02(1, entered_password[1]);
  455.                                 delayms(3);
  456.                                 write24c02(2, entered_password[2]);
  457.                                 delayms(3);
  458.                                 write24c02(3, entered_password[3]);
  459.                                 delayms(3);
  460.                                 wdata=0;
  461.                         }
  462.                         if(show_h==1)
  463.                         {
  464.                           show_HHHH();
  465.                         }
  466.                         
  467.         key = key_matrix_ranks_scan();
  468.         if (key == 13)//输入键
  469.         {
  470.                                         chushi = 0;
  471.                                         panduan=0;
  472.                                         clear_display();
  473.         }
  474.                                 if(key==14)//退出键
  475.                                 {
  476.                                   chushi=1;
  477.                                 }
  478.                                 if(key==15)//密码修改
  479.                                 {
  480.                                         show_h=0;
  481.                                         chushi=2;
  482.                                         panduan=0;
  483.                                   clear_display();
  484.                                 }
  485.                                 if(key==16)
  486.                                 {
  487.                                         xiugai=1;
  488.                                 }
  489.                                 
  490.                                 if(chushi==1)
  491.                                 {
  492.                                         show____();
  493.                                         led=1;
  494.                                 }
  495.         else if (chushi == 0)
  496.         {
  497.            import_ss();
  498.         }
  499.                                 else if(chushi==2)
  500.                                 {
  501.                                   xiugai_ss();
  502.                                 }
  503.     }
  504. }
复制代码

仿真程序.7z (222.12 KB, 下载次数: 0)
本主题由 admin 执行 审核通过

评分

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

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶1 踩踩
回复

使用道具 举报

沙发
ID:433219 发表于 2025-1-22 09:10 | 只看该作者
mcu 有 IAP功能，当eeprom 可省略iic的24c
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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