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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 请问一下这个单片机程序的初始密码是多少，从哪个地方可 ...
返回列表 发新帖
查看: 910|回复: 2
打印 上一主题 下一主题
收起左侧

请问一下这个单片机程序的初始密码是多少，从哪个地方可以找出初始密码。

[复制链接]
跳转到指定楼层
楼主
ID:701114 发表于 2020-3-6 17:33 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1. #include<reg52.h>
  2. #define uint  unsigned int
  3. #define uchar unsigned char


  6. extern uchar keyscan();             //扫描按键                                 
  7. extern void write_c(uchar command); //lcd写命令                          
  8. extern void write_d(uchar date);    //lcd写数据                                 
  9. extern void Lcd_init();                    //lcd初始化
  10. extern void setposition(uchar x,uchar y)        ;
  11. extern void writebyte(uchar x,uchar y,uchar dat);                              
  12. extern void writenbyte(uchar x,uchar y,uchar *p);
  13. extern void WriteSet(uchar add, uchar dat);  //数据写入24c08的具体地址         
  14. extern unsigned char ReadSet(uchar set_addr); //从24c08的具体地址读出数据                                               
  15. sbit beep=P2^0;                                                                         //蜂鸣器         
  16. sbit  led=P3^0;                                                                       
  17. bit  takmo,right,set,input,flag;
  18. uchar i,j,use,temp,m,money,b,c;


  21. uchar code wel1[]={" welcome to the"};
  22. uchar code wel2[]={"ATM system"};
  23. uchar code new[]={"input new keys:"};
  24. uchar code yu_e[]={"   yu e is: "};


  27. uchar code note1[]={"Input your key"};
  28. uchar code note2[]={"key:"};
  29. uchar code note3[]={"set:"};
  30. uchar code note4[]={"your key is   "};
  31. uchar code note5[]={"  what can I   "};
  32. uchar code note6[]={"   do for you   "};
  33. uchar code note7[]={"  check the key "};
  34. uchar code note8[]={"and try it again"};
  35. uchar code note9[]={"thanks  use"};
  36. uchar code note10[]={" goodbye"};
  37. uchar code note11[]={"how much do you"};
  38. uchar code note12[]={"need:"};
  39. uchar code note13[]={"   not enough"};
  40. uchar code note14[]={"    processing "};
  41. uchar code note15[]={"  please wait...  "};
  42. uchar code note16[]={" your money is"};
  43. uchar code note17[]={"remember new key"};
  44. uchar code right0[]={" right!"};
  45. uchar code error0[]={" wrong!"};
  46. uchar code setname[]={"    set ok!"};
  47. uchar code setname1[]={"  set error!"};


  50. /******************************************************************
  51. 延时函数
  52. **********************************************************************/      
  53.                                                                                                                                                                                          
  54. void delay(uint x)
  55. {
  56.         uint y;
  57.         for(;x!=0;x--)
  58.                 for(y=110;y!=0;y--);
  59. }
  60. void delay0(uchar x)                             
  61. {  uchar i;
  62.    while(x--)
  63.    {for (i = 0; i<13; i++);}
  64. }
  65. /******************************************************************
  66. 声音函数
  67. **********************************************************************/
  68. void beepon()                                
  69. {  uchar i;
  70.   for (i=0;i<180;i++)
  71.   {delay0(5);
  72.    beep=!beep;                     
  73.   }
  74.    beep=1;                     
  75.    delay(20);                  
  76. }
  77. /*******************************************************************
  78. 灯闪,代表操作成功
  79. ********************************************************************/
  80. void  light()
  81. { uchar n;
  82.    for(n=0;n<=2;n++)
  83.    {
  84.    led=0;
  85.    delay(1000);
  86.    led=1;
  87.    delay(1000);
  88.    }
  89. }
  90. /******************************************************************
  91. 显示余额函数
  92. **********************************************************************/
  93. showmoney()
  94. {        if(money>use)
  95.    {
  96.     money-=use;
  97.         use=0;
  98.     write_c(0x01);
  99.     writenbyte(0,0,note14);
  100.         writenbyte(1,0,note15);
  101.         delay(5000);
  102.     write_c(0x01);
  103.     writenbyte(0,0,yu_e);
  104.     setposition(1,0);
  105.         write_d(money+0x30);
  106.     write_d(0+0x30);
  107.         write_d(0+0x30);
  108.         WriteSet(6,money);
  109.         light();


  112.         }
  113.         else
  114.         {
  115.           write_c(0x01);
  116.           write_c(0x0c);
  117.       writenbyte(0,0,note16);
  118.           writenbyte(1,0,note13);
  119.         }
  120. }
  121. /*********************************************************************
  122. 比较函数：用来确定密码正误
  123. *********************************************************************/
  124. bit check(uchar p[],uchar q[])
  125. {  uchar n,k=0;      
  126.    for(n=0;n<6;n++)
  127.    {  if(p[n]==q[n])
  128.        k++;}
  129.    if(k==6)
  130.    return 1;
  131.    else return 0;
  132. }
  133. /*******************************************************************
  134. 初始化函数
  135. ******************************************************************/
  136.   void  init()
  137. {         
  138.            takmo=0;right=0;set=0;input=1;flag=0;        
  139.                Lcd_init();
  140.                setposition(0,0);
  141.             for(i=0;wel1!='\0';i++)          //开机界面
  142.              {
  143.                  write_d(wel1);
  144.                  beepon();
  145.                  }         
  146.            setposition(1,3);
  147.             for(i=0;wel2!='\0';i++)
  148.              {write_d(wel2);
  149.                   beepon();
  150.                  }
  151.         delay(2000);                                                  
  152.                 write_c(0x01);                                 


  155.            writenbyte(0,1,note1);  //提示输入密码
  156.            writenbyte(1,0,note2);  //显示key
  157.            write_c(0x0f);               //光标闪烁
  158.            setposition(1,4);           //第二行第五个位置开始键入密码
  159.        i=0;     
  160. }


  163. /*********************************************************************  
  164. 主函数：确定不同按键组合功能
  165. ***********************************************************************/
  166. void main()
  167. {        
  168.     uchar key_buff[6];                 //输入缓冲
  169.     uchar new_key[6] ;                 //密码设置缓冲区
  170.     uchar original_key[6];                   //密码读出缓冲区
  171.         WriteSet(6,9);                    
  172.         init();
  173.     while(1)
  174.         {             for(b=0;b<6;b++)      //24c08里面取出正确的密码                                                  
  175.                {
  176.                  original_key=ReadSet(b);
  177.                  delay(5);
  178.                }
  179.         temp=keyscan();         //扫描键盘                                                   
  180.            if(temp>=0&&temp<=9)
  181.                   {   beepon();
  182.                  if(input)
  183.                   {
  184.                    key_buff[i++]=temp;
  185.                    write_d('*');
  186.                   }
  187.                  else if(set)
  188.                   {
  189.                    new_key[i++]=temp;
  190.                    write_d('*');
  191.                   }
  192.                  else if(takmo)
  193.                   {
  194.                                    i++;
  195.                    write_d(temp+0x30);
  196.                    use=10*use+temp;
  197.                   }
  198.                                  else{;}   
  199.               }
  200.            else if(temp==10)                   //取卡                  
  201.                  {
  202.                              beepon();
  203.                  write_c(0x01);
  204.                                  write_c(0x0c);
  205.                  writenbyte(0,3,note9);
  206.                  writenbyte(1,3,note10);
  207.                  delay(3000);
  208.                  init();
  209.              }
  210.       
  211.         else if(temp==11)                                //取钱
  212.             {      
  213.                  if(right)
  214.                {
  215.                               beepon();
  216.                           takmo=1;
  217.                   write_c(0x01);
  218.                                   write_c(0x0f);
  219.                   writenbyte(0,0,note11);
  220.                   writenbyte(1,0,note12);
  221.                }
  222.                            else{beepon();}
  223.             }
  224.         else if(temp==12)                           //设置新密码
  225.           {                              
  226.                if(right)
  227.                    {beepon();  
  228.               set=1;
  229.                   write_c(0x01);
  230.                           write_c(0x0f);
  231.               writenbyte(0,0,new);
  232.               setposition(1,0);
  233.               }
  234.                            else{beepon();}
  235.           }


  238.            else if(temp==13)
  239.            {
  240.                 if(right)
  241.                {
  242.                              beepon();
  243.                  write_c(0x01);
  244.                                  money=ReadSet(6);        
  245.                  showmoney();           //显示余额
  246.                 }
  247.                                 else{beepon();}
  248.            }  
  249.        else if(temp==14)                                 //确认
  250.            {  
  251.                         beepon();           
  252.                 if(input)
  253.                 {   
  254.                                        if(i!=6)
  255.                                     {   i=0;
  256.                         write_c(0x01);
  257.                                                 write_c(0x0c);
  258.                         writenbyte(0,2,note4);
  259.                         writenbyte(1,4,error0);
  260.                         delay(3000);
  261.                         write_c(0x01);
  262.                         writenbyte(0,0,note7);
  263.                         writenbyte(1,0,note8);
  264.                                             delay(3000);
  265.                                             init();
  266.                                                 ;
  267.                                          }
  268.                                         else
  269.                                         { flag=check(key_buff,original_key);
  270.                                           if(flag==1)
  271.                       {  
  272.                         i=0;
  273.                         right=1;
  274.                         input=0;
  275.                         write_c(0x01);
  276.                                                 write_c(0x0c);
  277.                         writenbyte(0,3,note4);
  278.                         writenbyte(1,4,right0);
  279.                         delay(3000);
  280.                         write_c(0x01);
  281.                         writenbyte(0,1,note5);
  282.                         writenbyte(1,0,note6);
  283.                        }                                       
  284.                      else
  285.                       {      
  286.                         i=0;
  287.                         write_c(0x01);
  288.                                                 write_c(0x0c);
  289.                         writenbyte(0,2,note4);
  290.                         writenbyte(1,4,error0);
  291.                         delay(3000);
  292.                         write_c(0x01);
  293.                         writenbyte(0,0,note7);
  294.                         writenbyte(1,0,note8);
  295.                                             delay(3000);
  296.                                             init();
  297.                                                 ;
  298.                       }
  299.                                          }
  300.                                }               
  301.                   
  302.                  else if(set)
  303.                      {  if(i==6)
  304.                                            {
  305.                          set=0;
  306.                          write_c(0x01);
  307.                                                  write_c(0x0c);
  308.                          writenbyte(0,0,setname);
  309.                                                  writenbyte(1,0,note17);
  310.                                   for(c=0;c<6;c++)
  311.                          {
  312.                            WriteSet(c,new_key[c]);
  313.                            delay(100);  
  314.                           }
  315.                             c=0;
  316.                                                 }
  317.                                                 else
  318.                                                 {
  319.                                                    set=0;
  320.                                                    i=0;
  321.                                                    write_c(0x01);
  322.                                                    write_c(0x0c);
  323.                            writenbyte(0,0,setname1);
  324.                                                  }
  325.                      }
  326.                 else if(takmo)
  327.                      {  
  328.                                             money=ReadSet(6);
  329.                         takmo=0;
  330.                         showmoney();      
  331.                      }
  332.                 else
  333.                   {beepon();}
  334.              }                           
  335.            else  if(temp==15)                                   //清除
  336.               {
  337.                                beepon();   
  338.                    if(input&&i>=1)
  339.                     {
  340.                                             writebyte(1,4+(--i),' ');
  341.                                                 setposition(1,4+i);
  342.                                         }
  343.                    else if(set&&i>=1)
  344.                     {
  345.                                             writebyte(1,0+(--i),' ');
  346.                                                 setposition(1,0+i);
  347.                                         }
  348.                    else if(takmo&&i>=1)
  349.                     {
  350.                                             writebyte(1,5+(--i),' ');
  351.                                             setposition(1,5+i);
  352.                                         }
  353.                    else
  354.                     {;}           
  355.               }
  356.           else {;}         
  357.     }
  358. }


  361.    #include<reg52.h>
  362. #define uint unsigned int
  363. #define uchar unsigned char
  364. void delayms(uint z)
  365. {
  366.         uint x,y;
  367.         for(x=z;x>0;x--)
  368.                 for(y=110;y>0;y--);
  369. }








  378. /*********************************************************************  
  379. * 函 数 名: keyscan
  380. * 功能描述: 键盘扫描返回值
  381. ***********************************************************************/


  384. uchar keyscan()
  385. {     uchar num=16,temp;
  386.                         P1=0xfe;
  387.                         temp=P1;
  388.                         temp=temp&0xf0;
  389.                         while(temp!=0xf0)
  390.                                 {
  391.                                         delayms(5);
  392.                                         temp=P1;
  393.                                         temp=temp&0xf0;
  394.                                         while(temp!=0xf0)
  395.                                         {
  396.                                                 temp=P1;
  397.                                         switch(temp)
  398.                                                 {
  399.                                                         case 0xee:num=0;
  400.                                                                 break;
  401.                                                         case 0xde:num=1;
  402.                                                                 break;
  403.                                                         case 0xbe:num=2;
  404.                                                                 break;
  405.                                                         case 0x7e:num=3;
  406.                                                                 break;
  407.                                                 }
  408.                                         while(temp!=0xf0)
  409.                                                 {
  410.                                                         temp=P1;
  411.                                                         temp=temp&0xf0;
  412.                                                 }
  413.                                         }
  414.                                 }






  421.                         P1=0xfd;
  422.                         temp=P1;
  423.                         temp=temp&0xf0;
  424.                         while(temp!=0xf0)
  425.                                 {
  426.                                         delayms(5);
  427.                                         temp=P1;
  428.                                         temp=temp&0xf0;
  429.                                         while(temp!=0xf0)
  430.                                         {
  431.                                                 temp=P1;
  432.                                         switch(temp)
  433.                                                 {
  434.                                                         case 0xed:num=4;
  435.                                                                 break;
  436.                                                         case 0xdd:num=5;
  437.                                                                 break;
  438.                                                         case 0xbd:num=6;
  439.                                                                 break;
  440.                                                         case 0x7d:num=7;
  441.                                                                 break;
  442.                                                 }
  443.                                         while(temp!=0xf0)
  444.                                                 {
  445.                                                         temp=P1;
  446.                                                         temp=temp&0xf0;
  447.                                                 }
  448.                                         }
  449.                                 }
















  466.                         P1=0xfb;
  467.                         temp=P1;
  468.                         temp=temp&0xf0;
  469.                         while(temp!=0xf0)
  470.                                 {
  471.                                         delayms(5);
  472.                                         temp=P1;
  473.                                         temp=temp&0xf0;
  474.                                         while(temp!=0xf0)
  475.                                         {
  476.                                                 temp=P1;
  477.                                         switch(temp)
  478.                                                 {
  479.                                                         case 0xeb:num=8;
  480.                                                                 break;
  481.                                                         case 0xdb:num=9;
  482.                                                                 break;
  483.                                                         case 0xbb:num=10;
  484.                                                                 break;
  485.                                                         case 0x7b:num=11;
  486.                                                                 break;
  487.                                                 }
  488.                                         while(temp!=0xf0)
  489.                                                 {
  490.                                                         temp=P1;
  491.                                                         temp=temp&0xf0;
  492.                                                 }
  493.                                         }
  494.                                 }




  499.                         P1=0xf7;
  500.                         temp=P1;
  501.                         temp=temp&0xf0;
  502.                         while(temp!=0xf0)
  503.                                 {
  504.                                         delayms(5);
  505.                                         temp=P1;
  506.                                         temp=temp&0xf0;
  507.                                         while(temp!=0xf0)
  508.                                         {
  509.                                                 temp=P1;
  510.                                         switch(temp)
  511.                                                 {
  512.                                                         case 0xe7:num=12;
  513.                                                                 break;
  514.                                                         case 0xd7:num=13;
  515.                                                                 break;
  516.                                                         case 0xb7:num=14;
  517.                                                                 break;
  518.                                                         case 0x77:num=15;
  519.                                                                 break;
  520.                                                 }
  521.                                         while(temp!=0xf0)
  522.                                                 {
  523.                                                         temp=P1;
  524.                                                         temp=temp&0xf0;
  525.                                                 }
  526.                                         }
  527.                                 }
  528. return num;


  531. }
  532. #include<reg52.h>
  533. #define uchar  unsigned char
  534. #define uint   unsigned int


  537. sbit RS=P2^5;
  538. sbit RW=P2^6;
  539. sbit EN=P2^7;


  542. void delaymms()
  543. {
  544.    unsigned char i,j;      
  545.          for(i=0;i<10;i++)
  546.           for(j=0;j<33;j++)
  547.            ;                 
  548. }
  549. void delays(uint n)
  550. {
  551.    uint i;
  552.         for(i=0;i<n;i++)
  553.            delaymms();
  554. }
  555. void write_c( uchar x )
  556. {
  557.    RS=0;
  558.    RW=0;
  559.    EN=0;
  560.    P0=x;
  561.    delays(5);
  562.    EN=1;
  563.    delays(5);
  564.    EN=0;
  565. }
  566. void write_d( uchar x )
  567. {
  568.    RS=1;
  569.    RW=0;
  570.    EN=0;
  571.    P0=x;
  572.    delays(5);
  573.    EN=1;
  574.    delays(5);
  575.    EN=0;   
  576. }

  578.   void setposition(uchar x,uchar y)
  579.   {
  580.      if(x==0)
  581.             write_c( 0x80+y );
  582.          else
  583.             write_c( 0xc0+y );
  584.   }
  585.   void writebyte(uchar x,uchar y,uchar dat)
  586.   {
  587.      setposition( x,y);
  588.              write_d( dat );
  589.    }
  590. void writenbyte(uchar x,uchar y,uchar *p)
  591.    {
  592.       setposition( x,y);
  593.           while(*p)
  594.           {
  595.              write_d( *p++ );
  596.            }
  597.     }
  598. void Lcd_init(void)
  599. {
  600.         write_c( 0x01 );
  601.         write_c( 0x38 );
  602.         write_c( 0x0c );
  603.         write_c( 0x06 );
  604.   }
  605.   #include <reg52.h>        //  包含51单片机寄存器定义的头文件
  606. #include <intrins.h>      //包含_nop_()函数定义的头文件
  607. #define        OP_READ        0xa1                // 器件地址以及读取操作,0xa1即为1010 0001B
  608. #define        OP_WRITE 0xa0                // 器件地址以及写入操作,0xa1即为1010 0000B
  609. sbit SCL=P3^5;         //将串行时钟总线SCL位定义在为P3.4引脚
  610. sbit SDA=P3^6;          //将串行数据总线SDA位定义在为P3.5引脚     
  611. /*****************************************************
  612. 函数功能：延时1ms
  613. ***************************************************/
  614. void delay1ms()
  615. {
  616.    unsigned char i,j;      
  617.          for(i=0;i<10;i++)
  618.           for(j=0;j<33;j++)
  619.            ;                 
  620. }


  623. /*****************************************************
  624. 函数功能：延时若干毫秒
  625. 入口参数：n
  626. ***************************************************/
  627. void delaynms(unsigned char n)
  628. {
  629.    unsigned char i;
  630.         for(i=0;i<n;i++)
  631.            delay1ms();
  632. }
  633. /***************************************************
  634. 函数功能：开始数据传送
  635. ***************************************************/
  636. void start()
  637. // 开始位
  638. {
  639.         SDA = 1;    //SDA初始化为高电平“1”
  640.    SCL = 1;    //开始数据传送时，要求SCL为高电平“1”
  641.         _nop_();     //等待一个机器周期
  642.         _nop_();     //等待一个机器周期
  643.         _nop_();     //等待一个机器周期
  644.         _nop_();     //等待一个机器周期
  645.         _nop_();     //等待一个机器周期
  646.         SDA = 0;    //SDA的下降沿被认为是开始信号
  647.         _nop_();     //等待一个机器周期
  648.         _nop_();     //等待一个机器周期
  649.         _nop_();     //等待一个机器周期
  650.         _nop_();     //等待一个机器周期
  651.         _nop_();     //等待一个机器周期
  652.         SCL = 0;    //SCL为低电平时，SDA上数据才允许变化(即允许以后的数据传递）  
  653. }
  654. /***************************************************
  655. 函数功能：结束数据传送
  656. ***************************************************/
  657. void stop()// 停止位
  658. {
  659.         SDA = 0;     //SDA初始化为低电平“0”        _n
  660.         SCL = 1;     //结束数据传送时，要求SCL为高电平“1”
  661.         _nop_();     //等待一个机器周期
  662.         _nop_();     //等待一个机器周期
  663.         _nop_();     //等待一个机器周期
  664.         _nop_();     //等待一个机器周期
  665.         _nop_();     //等待一个机器周期
  666.         SDA = 1;    //SDA的上升沿被认为是结束信号
  667.         _nop_();     //等待一个机器周期
  668.         _nop_();     //等待一个机器周期
  669.         _nop_();     //等待一个机器周期
  670.         _nop_();     //等待一个机器周期
  671.         _nop_();     //等待一个机器周期
  672.         SDA=0;
  673.         SCL=0;
  674. }
  675. /***************************************************
  676. 函数功能：检测应答位
  677. ***************************************************/


  680. bit Ask()                  //检测应答
  681. {
  682.       bit ack_bit;        //储存应答位
  683.         SDA = 1;         // 发送设备（主机）应在时钟脉冲的高电平期间(SCL=1)释放SDA线，
  684.                         //以让SDA线转由接收设备(AT24Cxx)控制
  685.         _nop_();        //等待一个机器周期
  686.         _nop_();        //等待一个机器周期
  687.         SCL = 1;       //根据上述规定，SCL应为高电平
  688.         _nop_();       //等待一个机器周期
  689.         _nop_();       //等待一个机器周期
  690.         _nop_();       //等待一个机器周期
  691.         _nop_();       //等待一个机器周期
  692.         _nop_();       //等待一个机器周期  
  693.         ack_bit = SDA; //接受设备（AT24Cxx)向SDA送低电平，表示已经接收到一个字节
  694.                        //若送高电平，表示没有接收到，传送异常 结束发送
  695.         SCL = 0;       //SCL为低电平时，SDA上数据才允许变化(即允许以后的数据传递）
  696.         return  ack_bit;                        // 返回AT24Cxx应答位






  703. }
  704. /***************************************************
  705. 函数功能：从AT24Cxx读取数据
  706. 出口参数：x
  707. ***************************************************/
  708. unsigned char ReadData()
  709. // 从AT24Cxx移入数据到MCU
  710. {
  711.         unsigned char i;
  712.         unsigned char x;   //储存从AT24Cxx中读出的数据
  713.         for(i = 0; i < 8; i++)
  714.         {
  715.                 SCL = 1;                //SCL置为高电平
  716.                 x<<=1;                  //将x中的各二进位向左移一位
  717.                 x|=(unsigned char)SDA;  //将SDA上的数据通过按位“或“运算存入x中
  718.                 SCL = 0;                        //在SCL的下降沿读出数据
  719.         }
  720.         return(x);                //将读取的数据返回
  721. }
  722. /***************************************************
  723. 函数功能：向AT24Cxx的当前地址写入数据
  724. 入口参数：y (储存待写入的数据）
  725. ***************************************************/
  726. //在调用此数据写入函数前需首先调用开始函数start(),所以SCL=0
  727. void WriteCurrent(unsigned char y)
  728. {
  729.         unsigned char i;
  730.         for(i = 0; i < 8; i++)                // 循环移入8个位
  731.         {
  732.             SDA = (bit)(y&0x80);   //通过按位“与”运算将最高位数据送到S
  733.                                                   //因为传送时高位在前，低位在后
  734.                 _nop_();            //等待一个机器周期   
  735.            SCL = 1;            //在SCL的上升沿将数据写入AT24Cxx      
  736.            _nop_();            //等待一个机器周期
  737.           _nop_();             //等待一个机器周期      
  738.                
  739.                   SCL = 0;            //将SCL重新置为低电平，以在SCＬ线形成传送数据所需的８个脉冲
  740.                 y <<= 1;           //将y中的各二进位向左移一位
  741.                
  742.         }
  743. }
  744. /***************************************************
  745. 函数功能：向AT24Cxx中的指定地址写入数据
  746. 入口参数：add (储存指定的地址）；dat(储存待写入的数据）
  747. ***************************************************/
  748. void WriteSet(unsigned char add, unsigned char dat)
  749. // 在指定地址addr处写入数据WriteCurrent
  750. {
  751.         start();               //开始数据传递
  752.         WriteCurrent(OP_WRITE);  //选择要操作的AT24Cxx芯片，并告知要对   其写入数据
  753.          Ask();
  754.         WriteCurrent(add);       //写入指定地址
  755.         Ask();
  756.         WriteCurrent(dat);       //向当前地址（上面指定的地址）写入数据
  757.         Ask();
  758.         stop();                //停止数据传递
  759.         delaynms(5);               //1个字节的写入周期为1ms, 最好延时1ms以上
  760. }
  761. /***************************************************
  762. 函数功能：从AT24Cxx中的当前地址读取数据
  763. 出口参数：x (储存读出的数据）
  764. ***************************************************/
  765. unsigned char ReadCurrent()
  766. {
  767.         unsigned char x;
  768.         start();               //开始数据传递
  769.         WriteCurrent(OP_READ);   //选择要操作的AT24Cxx芯片，并告知要读其数据
  770.         Ask();
  771.         x=ReadData();         //将读取的数据存入x
  772.         stop();                //停止数据传递
  773.         return x;              //返回读取的数据
  774. }
  775. /***************************************************
  776. 函数功能：从AT24Cxx中的指定地址读取数据
  777. 入口参数：set_addr
  778. 出口参数：x
  779. ***************************************************/
  780. unsigned char ReadSet(unsigned char set_addr)
  781. // 在指定地址读取
  782. {
  783.         start();                      //开始数据传递
  784.         WriteCurrent(OP_WRITE);       //选择要操作的AT24Cxx芯片，并告知要对其写入数据
  785.         Ask();
  786.         WriteCurrent(set_addr);       //写入指定地址
  787.         Ask();
  788.         return(ReadCurrent());        //从指定地址读出数据并返回
  789. }
复制代码

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

使用道具 举报

沙发
ID:648281 发表于 2020-3-6 22:15 | 只看该作者
你好！初始密码保存在 24C08 存储器里面
回复

使用道具 举报

板凳
ID:235200 发表于 2020-3-7 01:55 | 只看该作者
这已经告诉了你密码
for(b=0;b<6;b++)      //24c08里面取出正确的密码                                                  
   {
       original_key=ReadSet(b);
        delay(5);
     }
读出放在uchar original_key[6]; 这个数组中(程序中未用数组估计不对),新存储器读出结果是FFFFFFFFFFFF
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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