按键扫描程序取密码的问题

sunrise41

按键扫描程序取密码的问题 [复制链接]

for循环取6次Key_scan()的返回值

1. for(i=0;i<6;i++)
   
2. {
   
3.         secret[i]=Key_scan();
   
4.         delayms(200);
   
5. }/code]
   
6. 
   
7. 矩阵键盘扫描函数
   
8. [code]uchar Key_scan()
   
9. {
   
10.         unsigned int temp,key;
    
11.     while(1)
    
12.     {
    
13. //////////////////第一行///////////////////////////
    
14.         P3=0xfe;
    
15.         temp=P3;
    
16.         temp=temp&0xf0;
    
17.         if(temp!=0xf0)
    
18.         {
    
19.             delayms(10);
    
20.             if(temp!=0xf0)
    
21.             {
    
22.                 temp=P3;
    
23.                 switch(temp)
    
24.                 {
    
25.                     case 0xee:
    
26.                         key=0;
    
27.                                                 return 0x00;
    
28.                                                 //
    
29.                         break;
    
30.                     case 0xde:
    
31.                         key=1;
    
32.                                                 return 0x01;
    
33.                         //
    
34.                         break;
    
35.                     case 0xbe:
    
36.                         key=2;
    
37.                                                 return 0x02;
    
38.                         //
    
39.                         break;
    
40.                     case 0x7e:
    
41.                         key=3;
    
42.                                                 return 0x03;
    
43.                         //
    
44.                         break;
    
45.                 }
    
46.                 while(temp!=0xf0)
    
47.                 {
    
48.                     temp=P3;
    
49.                     temp=temp&0xf0;
    
50.                     //
    
51.                 }
    
52.                 //////////////
    
53.             }
    
54.         }
    
55. //////第二行//////
    
56.         P3=0xfd;
    
57.         temp=P3;
    
58.         temp=temp&0xf0;
    
59.         if(temp!=0xf0)
    
60.         {
    
61.             delayms(10);
    
62.             if(temp!=0xf0)
    
63.             {
    
64.                 temp=P3;
    
65.                 switch(temp)
    
66.                 {
    
67.                     case 0xed:
    
68.                         key=4;
    
69.                                                 return 0x04;
    
70.                         //
    
71.                         break;
    
72.                     case 0xdd:
    
73.                         key=5;
    
74.                                                 return 0x05;
    
75.                         //
    
76.                         break;
    
77.                     case 0xbd:
    
78.                         key=6;
    
79.                                                 return 0x06;
    
80.                         //
    
81.                         break;
    
82.                     case 0x7d:
    
83.                         key=7;
    
84.                                                 return 0x07;
    
85. 
    
86.                         //
    
87.                         break;
    
88.                 }
    
89.                 while(temp!=0xf0)
    
90.                 {
    
91.                     temp=P3;
    
92.                     temp=temp&0xf0;
    
93.                     //
    
94.                 }
    
95.                 ///////
    
96.             }
    
97.         }
    
98. //////////////////////第三行////////////////////
    
99.         P3=0xfb;
    
100.         temp=P3;
     
101.         temp=temp&0xf0;
     
102.         if(temp!=0xf0)
     
103.         {
     
104.             delayms(10);
     
105.             if(temp!=0xf0)
     
106.             {
     
107.                 temp=P3;
     
108.                 switch(temp)
     
109.                 {
     
110.                     case 0xeb:
     
111.                         key=8;
     
112.                                                 return 0x08;
     
113.                         //
     
114.                         break;
     
115.                     case 0xdb:
     
116.                         key=9;
     
117.                                                 return 0x09;
     
118.                         //
     
119.                         break;
     
120.                     case 0xbb:
     
121.                         key=10;
     
122.                                                 return 0x0A;
     
123.                         //
     
124.                         break;
     
125.                     case 0x7b:
     
126.                         key=11;
     
127.                                                 return 0x0B;
     
128.                         //
     
129.                         break;
     
130.                 }
     
131.                 while(temp!=0xf0)
     
132.                 {
     
133.                     temp=P3;
     
134.                     temp=temp&0xf0;
     
135.                     //
     
136.                 }
     
137.                 ///////
     
138.             }
     
139.         }
     
140. /////////////////////////第四行////////////////////
     
141.         P3=0xf7;
     
142.         temp=P3;
     
143.         temp=temp&0xf0;
     
144.         if(temp!=0xf0)
     
145.         {
     
146.             delayms(10);
     
147.             if(temp!=0xf0)
     
148.             {
     
149.                 temp=P3;
     
150.                 switch(temp)
     
151.                 {
     
152.                     case 0xe7:
     
153.                         key=12;
     
154.                                                 return 0x0C;
     
155.                         //
     
156.                         break;
     
157.                     case 0xd7:
     
158.                         key=13;
     
159.                                                 return 0x0D;
     
160.                         //
     
161.                         break;
     
162.                     case 0xb7:
     
163.                         key=14;
     
164.                                                 return 0x0E;
     
165.                         //
     
166.                         break;
     
167.                     case 0x77:
     
168.                         key=15;
     
169.                                                 return 0x0F;
     
170.                         //
     
171.                         break;
     
172.                 }
     
173.                 while(temp!=0xf0)
     
174.                 {
     
175.                     temp=P3;
     
176.                     temp=temp&0xf0;
     
177.                     //
     
178.                 }
     
179.                 ///////
     
180.             }
     
181.         }
     
182.     }
     
183. 
     
184. }
     

复制代码

本意是用for循环6次取得Key_scan()的返回值，然后赋值给数组secret

现在假如i=0的时候，你按下按键，secret[0]得到了Key_scan()的返回值，但如果长时间不按按键，secret=Key_scan();中的i并不会一直等于1。也就是说，secret[1]或者secret[2]并没有正确得到Key_scan()的返回值（很可能是个随机值）

这样使用for循环想正确取6次Key_scan()的返回值的功能就不可以实现，请问如何才能6次正确取得Key_scan()的返回值

上面的问题或许可以这样说
当没有按键按下的时候，这句Key_scan()并没有返回值，secret=Key_scan();这句也就没有执行完成，i也就应该一直等于1（假如按了一次按键），然后停在这里（因为扫描函数里也有while(1))，等待有按键按下，但事实是没有这样，请教为什么

xiukiss

这段程序貌似没什么问题，不过楼主可以尝试一下，把

        P3=0xf7;
        temp=P3;
        temp=temp&0xf0;
        if(temp!=0xf0)
        {
            delayms(10);
            if(temp!=0xf0)
            {
                temp=P3;
                switch(temp)
                {
                    case 0xe7:
                        key=12;
                        return 0x0C;
                        //
                        break;
                    case 0xd7:
                        key=13;
                        return 0x0D;
                        //
                        break;
                    case 0xb7:
                        key=14;
                        return 0x0E;
                        //
                        break;
                    case 0x77:
                        key=15;
                        return 0x0F;
                        //
                        break;
                }
                while(temp!=0xf0)
                {
                    temp=P3;
                    temp=temp&0xf0;
                    //
                }
                ///////
            }
        }
里的红字部分，替换成能够表现出现象的代码，例如亮灯。四个扫描都替换掉，最好是一行对应一个灯。然后跑起来看看效果怎么样。当然，如果能在线执行设置断点的话，就更方便了

cqwangsf

以前用51做过这样的程序，挺好玩的！！

zyandll123

可以在按键扫描函数里面，按键扫描的后面，将键值赋给数组，那么就肯定不会出错。

顺便说说，假如你真的要在mian里的for中赋值，那么你的按键扫描函数不应该有个while死循环，而这个循环应该在main中，mian中的死循环，每次做的事，就是按键扫描，假如有按键，立标志，保存键值，然后清标志，再循环回去，重新扫描按键，，，，，，

至于为什么你现在的代码实现不了这个功能，我就没有细看，因为你的程序架构有问题。查问题比较吃力。

liyanping

帮你顶

young_758

我都是这样的，
用SCAN_KEY只读取键值，
用old_key 和now_key做当前值和过去值，
如果两个值不相等，则计数清零，old_key=now_key;
如果相等则计数加一，到了6次（根据灵敏度调节）判断键值为何，然后动作！

SUMIDAsz

void main(void)//主函数
{
       
        unsigned char key, j ,k, s;
        wei1=0;
        wei2=0;
        wei3=0;
        wei4=0;
        wei5=0;
        wei6=0; //初始化位选，只让最后一位数码管显示

        while(1)
          {
                   if(key_certain()== 1)                //确定键被按下后，扫描是那个键被按下
                   {   
                    P1=0xfe;                                //送第一行为低电平
                        k=0xfe;                                        //保留这次扫描数值，备移位用
                    for(j=0;j<4;j++)                //四次扫描处理
                    {       
              s=P1&0xf0;                        //屏蔽低四位，取高四位，根据s数值确定那一列，根据扫描的j行确定行数，
                          switch(s)
                                {
                                        case 0xe0: key=4*j+0; break;        //第1列
                                            case 0xd0: key=4*j+1; break;        //第2列
                                         case 0xb0: key=4*j+2; break;        //第3列
                                         case 0x70: key=4*j+3; break;        //第4列
                                         default:        break;
                                }
                          k=(k<<1)|0x01;                //循环扫描，
                          P1=k;                                        //每次仅向一行送0扫描
             }//for
                   }//
               
          P0=tab[key];                                //数据送数码管显示数据口
                wei1=1;                                                        //选中片选

                delay(10);
        }//while
}

kevin77065638

观膜
回复内容太短了！

lylnk

用条件语句控制取键值可以实现！