标题: 请问一下这个单片机程序的初始密码是多少，从哪个地方可以找出初始密码。 [打印本页]

---

作者: 24132    时间: 2020-3-6 17:33
标题: 请问一下这个单片机程序的初始密码是多少，从哪个地方可以找出初始密码。

1. #include<reg52.h>
   
2. #define uint  unsigned int
   
3. #define uchar unsigned char
   
4. 
   
5. 
   
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;
    
19. 
    
20. 
    
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: "};
    
25. 
    
26. 
    
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!"};
    
48. 
    
49. 
    
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();
     
110. 
     
111. 
     
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);                                 
     
153. 
     
154. 
     
155.            writenbyte(0,1,note1);  //提示输入密码
     
156.            writenbyte(1,0,note2);  //显示key
     
157.            write_c(0x0f);               //光标闪烁
     
158.            setposition(1,4);           //第二行第五个位置开始键入密码
     
159.        i=0;     
     
160. }
     
161. 
     
162. 
     
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.           }
     
236. 
     
237. 
     
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. }
     
359. 
     
360. 
     
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. }
     
370. 
     
371. 
     
372. 
     
373. 
     
374. 
     
375. 
     
376. 
     
377. 
     
378. /*********************************************************************  
     
379. * 函 数 名: keyscan
     
380. * 功能描述: 键盘扫描返回值
     
381. ***********************************************************************/
     
382. 
     
383. 
     
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.                                 }
     
415. 
     
416. 
     
417. 
     
418. 
     
419. 
     
420. 
     
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.                                 }
     
450. 
     
451. 
     
452. 
     
453. 
     
454. 
     
455. 
     
456. 
     
457. 
     
458. 
     
459. 
     
460. 
     
461. 
     
462. 
     
463. 
     
464. 
     
465. 
     
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.                                 }
     
495. 
     
496. 
     
497. 
     
498. 
     
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;
     
529. 
     
530. 
     
531. }
     
532. #include<reg52.h>
     
533. #define uchar  unsigned char
     
534. #define uint   unsigned int
     
535. 
     
536. 
     
537. sbit RS=P2^5;
     
538. sbit RW=P2^6;
     
539. sbit EN=P2^7;
     
540. 
     
541. 
     
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. }
     
577. 
     
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. }
     
621. 
     
622. 
     
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. ***************************************************/
     
678. 
     
679. 
     
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应答位
     
697. 
     
698. 
     
699. 
     
700. 
     
701. 
     
702. 
     
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. }

复制代码

---

作者: 51hei**1140    时间: 2020-3-6 22:15
你好！初始密码保存在 24C08 存储器里面

---

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

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1