普中51单片机，问题求解

HTIAN

1. 
   
2. 
   
3. #include "reg52.h"                       
   
4. 
   
5. typedef unsigned int u16;          
   
6. typedef unsigned char u8;
   
7. 
   
8. #define GPIO_DIG P0
   
9. #define GPIO_KEY P1
   
10. 
    
11. sbit LSA=P2^2;                //38译码器引脚
    
12. sbit LSB=P2^3;
    
13. sbit LSC=P2^4;
    
14. 
    
15. u8 KeyValue;        //
    
16. 
    
17. 
    
18. u8 code smgduan[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
    
19.                                         0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};//0~F码表
    
20. u8 show[2]={0,0};//存储两个矩阵键盘数据的数列
    
21. void delay(u16 i)
    
22. {
    
23.         while(i--);       
    
24. }
    
25. 
    
26. 
    
27. void KeyDown(void)//键盘扫描程序
    
28. {
    
29.         char a=0;
    
30.         u8 i;
    
31.         GPIO_KEY=0x0f;
    
32.         if(GPIO_KEY!=0x0f)//检测是否按下
    
33.         {
    
34.                 for(i;i<=1;i++)
    
35.                 {
    
36.                         delay(1000);//消抖
    
37.                         if(GPIO_KEY!=0x0f)
    
38.                         {       
    
39.                                 //??????
    
40.                                 GPIO_KEY=0X0F;
    
41.                                 switch(GPIO_KEY)
    
42.                                 {
    
43.                                         case(0X07):        KeyValue=0;break;
    
44.                                         case(0X0b):        KeyValue=1;break;
    
45.                                         case(0X0d): KeyValue=2;break;
    
46.                                         case(0X0e):        KeyValue=3;break;
    
47.                                 }
    
48.                                 //??????
    
49.                                 GPIO_KEY=0XF0;
    
50.                                 switch(GPIO_KEY)
    
51.                                 {
    
52.                                         case(0X70):        KeyValue=KeyValue;break;
    
53.                                         case(0Xb0):        KeyValue=KeyValue+4;break;
    
54.                                         case(0Xd0): KeyValue=KeyValue+8;break;
    
55.                                         case(0Xe0):        KeyValue=KeyValue+12;break;
    
56.                                 }
    
57.                                 if((a<50)&&(GPIO_KEY!=0xf0))         //
    
58.                                 {
    
59.                                         delay(100);
    
60.                                         a++;
    
61.                                         i++;
    
62.                                        
    
63.                                 }
    
64.                         }
    
65.                 }
    
66.         }
    
67. 
    
68. }
    
69. 
    
70. void main()
    
71. {       
    
72.         u8 q=0;
    
73.         while(1)
    
74.         {
    
75.                 if(q=0)
    
76.                 {
    
77.                         LSA=0;
    
78.                         LSB=0;
    
79.                         LSC=0;
    
80.                         KeyDown();
    
81.                         show[0]=smgduan[KeyValue];
    
82.                         GPIO_DIG=show[0];
    
83.                         q=1;
    
84.                         delay(10);
    
85.                         if(q=1)
    
86.                         {
    
87.                                 LSA=1;
    
88.                                 LSB=0;
    
89.                                 LSC=0;
    
90.                                 KeyDown();
    
91.                                 show[1]=smgduan[KeyValue];
    
92.                                 GPIO_DIG=show[1];
    
93.                                 q=2;
    
94.                                 delay(10);
    
95.                                 while(q=2)//重复输出
    
96.                                 {
    
97.                                         LSA=0;
    
98.                                         LSB=0;
    
99.                                         LSC=0;
    
100.                                         GPIO_DIG=show[0];
     
101.                                         delay(100);
     
102.        
     
103.                                         LSA=1;
     
104.                                         LSB=0;
     
105.                                         LSC=0;
     
106.                                         GPIO_DIG=show[1];
     
107.                                         delay(1000);
     
108.        
     
109.                                         GPIO_KEY=0x0f;//检测是否有新的输入
     
110.                                         if(GPIO_KEY!=0x0f)
     
111.                                         {
     
112.                                                 q=0;
     
113.                                                 show[0]=0;
     
114.                                                 show[1]=0;               
     
115.                                         }
     
116.                                        
     
117.                                 }
     
118.                         }
     
119.                 }         
     
120.         }
     
121. }

复制代码

我想实现第一按矩阵键盘在数码管上第8位显示数字，第二次按矩阵键盘在第7 位数码管上显示数字，有以上代码，
怎么能检测到第一次输入和第二次输入并重复显示，我在板子上下载程序只有一个数码管亮，

七星瞭望

你可以这么样：比如在矩阵键盘上按第一个按键然后直接段选位选，你第二个键重新定段选位选，你这个程序的段选位选美又改变所以只是在一个位置改变数值

裤裆里面有杀气

不建议在开发板上实验，其他模块也会占用IO口的