数码管只显示四位0，而且按键无反应，应该是单片机程序逻辑上的问题

下面是原程序

1. #include"math.h"
   
2. #include "reg51.h"
   
3. #define uchar unsigned char
   
4. uchar key_temp,key=0,i,j,k,t=0;
   
5. uchar a=0,b=0,c=0,d=0;
   
6. unsigned long qian,hou;
   
7. uchar table[10]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
   
8. static unsigned char state_key=0;
   
9. static unsigned char state_dis=0;
   
10. 
    
11. 
    
12. void keyscan()
    
13. {
    
14.         switch(state_key)
    
15. {
    
16.         case 0:
    
17.          key_temp=(P1&0x0f);
    
18.          if(key_temp!=0x0f)
    
19.          t=0;
    
20.          state_key=1;
    
21.    break;
    
22.         case 1:
    
23.                 if(t>=10)
    
24.                 {
    
25.                 if(key_temp==(P1&0x0f))
    
26.                 {
    
27.                   if(P1^0==0)
    
28.                                 key=1;
    
29.                         if(P1^1==0)
    
30.                                 key=2;
    
31.                         if(P1^2==0)
    
32.                                 key=3;
    
33.                         if(P1^3==0)
    
34.                                 key=4;
    
35.                 }
    
36.                 state_key=2;
    
37.                 }
    
38.                   
    
39.                   else
    
40.                         state_key=0;
    
41.                         break;        
    
42.                
    
43.         case 2:
    
44.                 if(key_temp==(P1&0x0f))
    
45.                 {
    
46.                 state_key=0;
    
47.                 break;
    
48.                 }
    
49.                 key=0;//default:break;
    
50. }
    
51. 
    
52. }
    
53. 
    
54. void keyaction()
    
55. {
    
56. switch(key)
    
57. {
    
58.         case 1:break;
    
59.         case 2:i=0;
    
60.                      i++;
    
61.                if(i>9)
    
62.                break;
    
63.         case 3:j=0;
    
64.                                  if(j<=3)
    
65.                                         j++;
    
66.                                  switch(j)
    
67.                                          {
    
68.                                                  case 0:P3=0xfe;i++;break;
    
69.                                                  case 1:P3=0xfd;i++;break;
    
70.                                                  case 2:P3=0xfb;i++;break;
    
71.                                                  case 3:P3=0xf7;i++;break;
    
72.                                          }
    
73.                                          break;
    
74.         case 4: k=0;
    
75.                       k++;
    
76.                                         if(k==1)
    
77.                                         hou=hou+qian;
    
78.           qian=0;
    
79.           if(k==2)
    
80.           hou=hou+qian;
    
81.           qian=0;
    
82.           k=0;
    
83.                                         break;                                       
    
84. }
    
85. }
    
86. void display()
    
87. {
    
88. switch(j)
    
89. {
    
90.         case 0:P2=table[a];break;
    
91.         case 1:P2=table[b][b];break;
    
92.         case 2:P2=table[c];break;
    
93.         case 3:P2=table[d];break;
    
94. }
    
95. }
    
96. 
    
97. 
    
98. void display0()
    
99. {
    
100. 
     
101.         switch(state_dis)
     
102. {
     
103.         case 0:a=i;b=0;c=0;d=0;break;
     
104.         case 1:b=i;c=0;d=0;break;
     
105.         case 2:c=i;d=0;break;
     
106.         case 3:d=i;break;
     
107. }
     
108. display();
     
109. }
     
110. 
     
111. 
     
112. 
     
113. void time0init()
     
114. {
     
115. TMOD=0x01;
     
116.         TH0=-50000/256;
     
117.          TL0=-50000%256;
     
118.           EA=1;
     
119.            ET0=1;
     
120.             TR0=1;
     
121. }
     
122. 
     
123. 
     
124. 
     
125. void time0()interrupt 1
     
126. {
     
127. TH0=-50000/256;
     
128. TL0=-50000%256;
     
129. t++;
     
130.                 if(state_dis<=3)
     
131.                         state_dis++;
     
132.                 else
     
133.                   state_dis=0;
     
134. }
     
135. 
     
136. 
     
137. 
     
138. 
     
139. void main()
     
140. {
     
141.         time0init();
     
142.   while(1)
     
143.         {
     
144.          keyscan();
     
145.          keyaction();
     
146.          display0();
     
147.          switch(j)
     
148.          {
     
149.                  case 0:qian=a;break;
     
150.                  case 1:qian=a+b*10;break;
     
151.                  case 2:qian=a+b*10+c*100;break;
     
152.                  case 3:qian=a+b*10+c*100+d*1000;break;
     
153.          }
     
154.         a=0;
     
155.         b=0;
     
156.         c=0;
     
157.         d=0;
     
158. 
     
159.         }
     
160. }

复制代码

数码管只显示四位0，而且按键无反应，应该是逻辑上的问题，实在找不到，求大神！

这源程序明显被阉割过

定时器及中断好像没问题，按键和显示程序认真检查一下，这两者其中一个出问题都会导致显示0而没有其它动作。

wc86110 发表于 2019-5-30 06:52
这源程序明显被阉割过

这是我自己写的程序，通过3位按钮使用计算器

可以自己调试一下， main函数里先把数码管用延时的方式都显示一遍，没有问题再调试按键。刚开始还要多看别人的代码

1、keyaction()函数中
case 2:i=0;
                     i++;
               if(i>9)
               break;
        case 3:j=0;
                                 if(j<=3)
                                        j++;
这样的处理逻辑，每次主函数进入这个函数后，P1^1或者P1^2在按下时，走case 2或case 3的分支，i和j永远都是从0开始，加一次变成1，永远不会有2以后的数字出现？你确定是需要做成这样的逻辑？
2、display()函数中case 1:P2=table[b][b];break;，这个table[b][b]是什么意思？
3、keyscan函数中
case 0:
         key_temp=(P1&0x0f);
         if(key_temp!=0x0f)
         t=0;
         state_key=1;
的处理，无论是否有按钮按下，state_key=1;都会被执行，下次进入case 1的分支，你确定这个逻辑正确？不是应该有按钮按下了，下次才进入case 1，判断是那个按钮按下吗？是不是改成
if(key_temp!=0x0f) {
         t=0;
         state_key=1;
}更合理一些？
按照你现在的扫描逻辑，即使没有按钮按下，case 0，case 1，case 2也会按照顺序全都走一遍！

另外自己的程序，无论是变量的声明，还是代码，都没有注释，即使现在你能看懂。过段时间你再看未必能明白。既然编程，一定要养成写注释的良好习惯。

楼上都是乱猜的，这种最基础最基础的东西都是错的怎么帮你？？？
                case 1:
                        if(t>=10)
                        {
                                if(key_temp==(P1&0x0f))
                                {
                                        if(P1^0==0)？？？？？？？？？？
                                                key=1;
                                        if(P1^1==0)？？？？？？？？？？
                                                key=2;
                                        if(P1^2==0)？？？？？？？？？
                                                key=3;
                                        if(P1^3==0)？？？？？？？？？
                                                key=4;
                                }
                                state_key=2;
                        }
                        else
                        state_key=0;
                        break;